Arduino : U 3 E 29

Ejercicio 29: Ruta codificada

El robot sigue una trayectoria predefinida.

Novedades hardware	Novedades software
	Codificación de trayectorias en cadenas

Requisitos: Chasis del robot, circuito de potencia

Planteamiento: Va a trazar la letra M

Presentación de: Codificación manual de trayectorias.

Vamos a usar una cadena para guardar la secuencia de movimientos, que identificamos con números:

0 para avanzar
1para retroceder
2 para girar a la derecha
3 para girar a la izquierda

Usaremos condicionales para asignar a cada uno de esos valores una función que realice el movimiento.

Las funciones que realizan el movimiento constan del procedimiento básico para el movimiento y un delay con un valor que determina la duración del movimiento. Si corresponden a un desplazamiento el delay toma el valor de la variable “dist”. Si corresponden a un giro la variable es “ang”.

Luego cada función que corresponde a un movimiento tiene como argumento el valor de la variable “dist” o el valor de la variable “ang”. Las duraciones están guardadas en las cadenas distancias[ ] y angulos[ ], de forma que la posición de cada valor corresponde a la posición del movimiento correspondiente.

Las variables “dist” y “ang” se actualizan tomando los valores de las cadenas distancias[ ] y angulos[ ] cuando la iteración del bucle for principal va recorriendo las sucesivas posiciones de las cadenas.

Los condicionales seleccionan qué función corresponde (y, por tanto, qué movimiento) y la función toma el valor actualizado de su variable.

Variantes:

Prueba a codificar otras letras y haz que tu robot escriba una palabra.
Haz un recorrido de ida y vuelta, con el robot retrocediendo sobre sus pasos y con el robot girando para recorrer el camino de vuelta mientras avanza.
Añade un cuarto valor (4) que represente estar parado e incluye tiempos de parada en tu recorrido. (Si tu robot no puede parase, ponlo a dar un nº completo de vueltas).

CODIGO FUENTE

 Copyright (C) 2006  Juan Carlos Alonso de Mena
 This program is free software; you can redistribute it and/or modify it under the terms
 of the GNU General Public License as published by the Free Software Foundation;
 See the GNU General Public License for more details?

Motor dc y circuito con par Darlington y relé de doble conmutador configurado como un inversor de giro:

 int motori =6;
 int motord =8;
 int n=0;
 int m=0;
 //int unidist=800;
 //int uniang=3200;
 int movimientos[]={0,2,0,3,0,2,0};               //cadena en la que el nº indica el tipo de movimiento y la posición el orden
 int distancias[]={4000,0,1500,0,1500,0,4000};    //distancias en los avences y retrocesos, nótense los 0 para los giros
 int angulos[]={0,3200*3/8,0,3200/4,0,3200*3/8,0};//valores de los giros relativos a la vuelta completa,
                                                  //nótense los 0 para los desplazamientos
 int dist=0;
 int ang=0;
 void setup(){
   pinMode(motori,OUTPUT);
   pinMode(motord,OUTPUT);
   pinMode(13,OUTPUT); 
 }
 void avanza(){
   digitalWrite(motori,LOW);
   digitalWrite(motord,LOW);
 }
 void retrocede(){
   digitalWrite(motord,HIGH);
   digitalWrite(motori,HIGH);
 }  
 void giraderecha(){
   digitalWrite(motord,HIGH);
   digitalWrite(motori,LOW); 
 }
 void giraizquierda(){
   digitalWrite(motord,LOW);
   digitalWrite(motori,HIGH);
 }
 void adelante(int dist){        //función que hace avanzar una distancia guardada en la variable dist
   avanza();
   delay(dist);
 }
 void atras(int dist){           //función que hace retroceder una distancia   guardada en la variable dist
   retrocede();
   delay(dist);
 }   
 void derecha(int ang){          //función que hace girar a la derecha un valor guardado en la variable ang
   giraderecha();
   delay(ang);
 } 
 void izquierda(int ang){        //función que hace girar a la izquierda un valor guardado en la variable ang
   giraizquierda();
   delay(ang);
 }
 void loop(){
   digitalWrite(13,HIGH);        //se enciende un LED para indicar que comienza
   delay(3000);
   digitalWrite(13,LOW);
   for(m=0;m<7;m++){             //iteración que recorre las cadenas de movimientos, distancias y ángulos a la vez
     dist=distancias[m];         //variable que recoje el valor de la cadena para entregarla a la función
     ang=angulos[m];
     if(movimientos[m]==0){      //según el valor de la cadena tenemos un movimiento u otro
       adelante(dist);
     }
     if(movimientos[m]==1){
       atras(dist);
     }
     if(movimientos[m]==2){
       derecha(ang);
     }
     if(movimientos[m]==3){
       izquierda(ang);
     }
   }
   while(m>=7){                  //cuando ha terminado se pone a dar vueltas
    giraderecha();
   }
 }

Motor dc y circuito con driver integrado 293D:

 int activai=8;
 int activad=13;
 int motord1=9;
 int motord2=10;
 int motori1=11;
 int motori2=12;
 int puls=2;
 int n=0;
 int m=0;
 //int unidist=1200;
 //int unigrado=5200;
 int movimientos[]={0,2,0,3,0,2,0};                //cadena en la que el nº indica el  tipo de movimiento y la posición el orden 
 int distancias[]={6000,0,2500,0,2500,0,6000};     //distancias en los avences y  retrocesos, nótense los 0 para los giros
 int angulos[]={0,5200*3/8,0,5200/4,0,5200*3/8,0}; //valores de los giros relativos a la vuelta completa, 
                                                   //nótense los 0 para los desplazamientos
 int dist=0;
 int ang=0;
 void para(){                                         
   digitalWrite(activai,LOW);
   digitalWrite(activad,LOW);
 }
 void setup(){
   pinMode(motori1,OUTPUT);
   pinMode(motori2,OUTPUT);
   pinMode(motord1,OUTPUT);
   pinMode(motord2,OUTPUT);
   pinMode(activai,OUTPUT);
   pinMode(activad,OUTPUT);
   pinMode(puls,INPUT);  
   while(digitalRead(puls)==LOW){  //espera a que se pulse para comenzar
     para();
   }   
 }
 void avanza(){
   digitalWrite(motori1,HIGH);
   digitalWrite(motori2,LOW);
   digitalWrite(motord1,HIGH);
   digitalWrite(motord2,LOW); 
 }
 void retrocede(){
   digitalWrite(motori1,LOW);
   digitalWrite(motori2,HIGH);
   digitalWrite(motord1,LOW);
   digitalWrite(motord2,HIGH);
 }  
 void giraderecha(){
   digitalWrite(motori1,HIGH);
   digitalWrite(motori2,LOW);
   digitalWrite(motord1,LOW);
   digitalWrite(motord2,HIGH);
 }
 void giraizquierda(){
   digitalWrite(motord1,HIGH);
   digitalWrite(motord2,LOW);
   digitalWrite(motori1,LOW);
   digitalWrite(motori2,HIGH);
 }
 void adelante(int dist){          //función que hace avanzar una distancia guardada en la variable dist
   avanza();
   delay(dist);
 }
 void atras(int dist){             //función que hace retroceder una distancia guardada en la   variable dist
   retrocede();
   delay(dist);
 }  
 void derecha(int ang){            //función que hace girar a la derecha un valor guardado en la   variable ang
   giraderecha();
   delay(ang);
 } 
 void izquierda(int ang){          //función que hace girar a la izquierda un valor guardado en  la variable ang
   giraizquierda();
   delay(ang); 
 }
 void loop(){
   digitalWrite(activai,HIGH);     //activamos los motores
   digitalWrite(activad,HIGH);
   for(m=0;m<7;m++){               //iteración que recorre las cadenas de movimientos, distancias y ángulos a la vez
     dist=distancias[m];           //variables que recojen los valores de las cadenas para entregarlos a las funciones
     ang=angulos[m];
     if(movimientos[m]==0){        //según el valor de la cadena tenemos un movimiento u otro
       adelante(dist);
     }
     if(movimientos[m]==1){
       atras(dist);
     }
     if(movimientos[m]==3){
       izquierda(ang);
     }
     if(movimientos[m]==2){
       derecha(ang);
     }
   }
   if(m>=7){
     while(digitalRead(puls)==LOW){//cuando ha terminado se para
      para();
     }
   }
 }

Motor paso a paso y circuito con driver integrado 74H245

 int vel2=5;         
 int vel =5; 
 int tgiro =10;         
 int unoai = 8;         
 int unobi = 9;         
 int dosai = 10;         
 int dosbi = 11;        
 int unoad = 2;
 int unobd = 3;
 int dosad = 4;
 int dosbd = 5;
 int puls=7;
 int n=0;
 int m=0;
 //int unidist=900;
 //int unigrado=4000;
 int movimientos[]={0,2,0,3,0,2,0};                //cadena en la que el nº indica el tipo de movimiento y la posición el orden
 int distancias[]={4000,0,1500,0,1500,0,4000};     //distancias en los avences y retrocesos, nótense los 0 para los giros
 int angulos[]={0,4000*3/8,0,4000/4,0,4000*3/8,0}; //valores de los giros relativos a la vuelta completa, 
                                                   //nótense los 0 para los desplazamientos
 int dist=0;
 int ang=0;
 void para(){
   digitalWrite(unoai,LOW);
   digitalWrite(unoad,LOW);
   digitalWrite(unobi,LOW);
   digitalWrite(unobd,LOW);
   digitalWrite(dosai,LOW);
   digitalWrite(dosad,LOW);
   digitalWrite(dosbi,LOW);
   digitalWrite(dosbd,LOW);
 }
 void setup(){
   pinMode(unoai,OUTPUT);      
   pinMode(unobi,OUTPUT);
   pinMode(dosai,OUTPUT);
   pinMode(dosbi,OUTPUT);
   pinMode(unoad,OUTPUT);
   pinMode(unobd,OUTPUT);
   pinMode(dosad,OUTPUT);
   pinMode(dosbd,OUTPUT);
   pinMode(puls,INPUT);
   while(digitalRead(puls)==LOW){  //espera a que se pulse para comenzar
     para();
   } 
 }
 void avanza(){
   digitalWrite(unoai,HIGH);
   digitalWrite(unoad,HIGH);
   digitalWrite(unobi,LOW);
   digitalWrite(unobd,LOW);
   digitalWrite(dosai,HIGH);
   digitalWrite(dosad,HIGH);
   digitalWrite(dosbi,LOW);
   digitalWrite(dosbd,LOW);
   delay(vel);
   digitalWrite(unoai,LOW);
   digitalWrite(unoad,LOW);
   digitalWrite(unobi,HIGH);
   digitalWrite(unobd,HIGH);
   delay(vel);
   digitalWrite(dosai,LOW);
   digitalWrite(dosad,LOW);
   digitalWrite(dosbi,HIGH);
   digitalWrite(dosbd,HIGH);
   delay(vel);
   digitalWrite(unoai,HIGH);
   digitalWrite(unoad,HIGH);
   digitalWrite(unobi,LOW);  
   digitalWrite(unobd,LOW);  
   delay(vel);
 } 
 void retrocede(){
   digitalWrite(unoai,LOW);
   digitalWrite(unoad,LOW);
   digitalWrite(unobi,HIGH);
   digitalWrite(unobd,HIGH);
   digitalWrite(dosai,LOW);
   digitalWrite(dosad,LOW);
   digitalWrite(dosbi,HIGH);
   digitalWrite(dosbd,HIGH);
   delay(vel);
   digitalWrite(unoai,HIGH);  
   digitalWrite(unoad,HIGH);
   digitalWrite(unobi,LOW);
   digitalWrite(unobd,LOW);
   delay(vel);
   digitalWrite(dosai,HIGH);
   digitalWrite(dosad,HIGH);
   digitalWrite(dosbi,LOW);
   digitalWrite(dosbd,LOW);
   delay(vel);
   digitalWrite(unoai,LOW);
   digitalWrite(unoad,LOW);
   digitalWrite(unobi,HIGH);  
   digitalWrite(unobd,HIGH);  
   delay(vel);
 }   
 void giraizquierda(){
   digitalWrite(unoad,HIGH);
   digitalWrite(unoai,LOW);
   digitalWrite(unobd,LOW);
   digitalWrite(unobi,HIGH);
   digitalWrite(dosad,HIGH);
   digitalWrite(dosai,LOW);
   digitalWrite(dosbd,LOW);
   digitalWrite(dosbi,HIGH);
   delay(vel2);
   digitalWrite(unoad,LOW);
   digitalWrite(dosbi,LOW);
   digitalWrite(unobd,HIGH);
   digitalWrite(dosai,HIGH); 
   delay(vel2); 
   digitalWrite(dosad,LOW);
   digitalWrite(unobi,LOW);
   digitalWrite(dosbd,HIGH);
   digitalWrite(unoai,HIGH);
   delay(vel2);
   digitalWrite(unoad,HIGH);
   digitalWrite(dosbi,HIGH);
   digitalWrite(unobd,LOW); 
   digitalWrite(dosai,LOW); 
   delay(vel2);    
 }
 void giraderecha(){
   digitalWrite(unoai,HIGH);
   digitalWrite(unoad,LOW);
   digitalWrite(unobi,LOW);
   digitalWrite(unobd,HIGH);
   digitalWrite(dosai,HIGH);
   digitalWrite(dosad,LOW);
   digitalWrite(dosbi,LOW);
   digitalWrite(dosbd,HIGH);
   delay(vel2);
   digitalWrite(unoai,LOW);
   digitalWrite(dosbd,LOW);
   digitalWrite(unobi,HIGH);
   digitalWrite(dosad,HIGH);
   delay(vel2); 
   digitalWrite(dosai,LOW);
   digitalWrite(unobd,LOW);
   digitalWrite(dosbi,HIGH);
   digitalWrite(unoad,HIGH);
   delay(vel2);
   digitalWrite(unoai,HIGH);
   digitalWrite(dosbd,HIGH);
   digitalWrite(unobi,LOW); 
   digitalWrite(dosad,LOW); 
   delay(vel2);    
 }
 void adelante(int dist){          //función que hace avanzar una distancia guardada en la variable dist
   avanza();
   delay(dist); 
 }
 void atras(int dist){             //función que hace retroceder una distancia guardada en   la variable dist
   retrocede();
   delay(dist);
 }

}

 void derecha(int ang){            //función que hace girar a la derecha un valor guardado en la variable ang
   giraderecha();
   delay(ang);
 } 
 void izquierda(int ang){          //función que hace girar a la izquierda un valor guardado en la variable ang
   giraizquierda();
   delay(ang);
 }
 void loop(){
   digitalWrite(13,LOW);
   for(m=0;m<7;m++){
     dist=distancias[m];           //variables que recojen los valores de las cadenas para entregarlos a las funciones
     ang=angulos[m];
     if(movimientos[m]==0){        //según el valor de la cadena tenemos un movimiento u otro
       adelante(dist);
     }
     if(movimientos[m]==1){
       atras(dist);
     }
     if(movimientos[m]==3){
       izquierda(angulos[m]);
     }
     if(movimientos[m]==2){
       derecha(angulos[m]);
     }
   }
   if(m>=7){                       //cuando ha terminado se para
     while(digitalRead(puls)==LOW){
       para();
     }
   }
 }

Volver ?

  Copyright (c) 2006  Juan Carlos Alonso de Mena

  Permission is granted to copy, distribute and/or modify this document under the terms of 
 the GNU Free Documentation License, Version 1.2 or any later version published by the
 Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no
 Back-Cover Texts.  A copy of the license is included in the section entitled 
 GNU Free Documentation License?.

Edit Page \| Page History	Page last modified on October 09, 2006, at 02:42 PM	Recent Changes (All) \| Edit SideBar \| Admin
Powered by PmWiki