Ejercicio 28: Polígonos

El robot traza polígonos regulares con un nº creciente de lados.

Novedades hardware	Novedades software
	Uso de algoritmos para generar trayectorias

Requisitos: Chasis del robot, circuito de potencia

Planteamiento: El robot va a recorrer, una tras otra, trayectorias con la forma de los diversos polígonos regulares.

Presentación de: Uso de algoritmos para producir trayectorias.

Este es un ejercicio en homenaje a la tortuga del LOGO.

¿Quién no ha dibujado polígonos regulares con REPITE?. Aquí la iteración la conduce el bucle for.

Definimos una función que tiene como argumento el nº de lados.

Si fijamos una distancia, (en este caso la longitud del perímetro del polígono, para mantener el recorrido acotado), podemos calcular los tiempos necesarios para recorrer las longitudes de los lados y girar los valores de los ángulos dividiendo el tiempo para el perímetro y el tiempo para un giro completo entre el nº de lados. Una iteración repite cada avance y cada giro el nº de veces que corresponde al nº de lados.

El bucle principal del programa llama a la función desde una iteración que varía su argumento para dar polígonos de nº creciente de lados.

La versión con relé no puede parar, así que lo hacemos girar entre figuras.

Las otras versiones tienen procedimientos para parar y los usamos entre figuras y al comienzo, cuando un bucle while mantiene parados los motores hasta que presionamos el pulsador (el final de carrera que usaremos para detectar colisiones más adelante).

Variantes:

• Atrévete con los polígonos estrellados.

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 led=13;
 int n=0;
 int unidist=800;
 int uniang=3200;
 int dist=0;
 int ang=0;
 int m=0;
 int c=0;
 int nlados=0;
 void setup(){
   pinMode(motori,OUTPUT);
   pinMode(motord,OUTPUT);
   pinMode(led,OUTPUT);
   dist=12*unidist;                 //tiempo que tarda en recorrer todo el  perímetro
 }
 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 vueltas()
   for(n=0;n<2;n++){
    giraderecha();
    delay(uniang);
   }
 }
 void poli(int nlados){             //función que calcula y aplica con desplazamientos y giros 
   for(m=0;m<nlados;m++){           //las distancias y ángulos para un nº de lados dado 
     avanza();                      //produce polígonos de igual perímetro (dist)
     delay(dist/nlados);            //tiempo que tarda en avanzar la distancia de un lado   
     giraderecha();                           
     delay(uniang/nlados);          //tiempo que tarda en girar el ángulo correspondiente
   }
 } 
 void listo(){                      //como no se para, que dé vueltas antes de cada figura

digitalWrite(led,HIGH);

  vueltas();
  digitalWrite(led,LOW);
 }
 void loop(){
   for(c=3;c<11;c++){               //iteración sobre el nº de lados
     listo();
     poli(c);
   }
 } 

• 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 unidist=1200;                
 int uniang=5600;                 
 int dist=0;
 int ang=0; 
 int n=0;
 int m=0;
 int nlados=0;
 void para(){                     //procedimiento que para ambos motores
   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 empezar
     para();
   }
   dist=12*unidist;    
 }
 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 poli(int nlados){           //función que calcula y aplica con  desplazamientos y giros 
   for(m=0;m<nlados;m++){         //las distancias y ángulos para un nº de lados dado
     avanza();                    //produce polígonos de igual perímetro (dist)
     delay(dist/nlados);          //tiempo que tarda en avanzar la distancia de un lado  
     giraderecha();                           
     delay(uniang/nlados);        //tiempo que tarda en girar el ángulo correspondiente
   }
 } 
 void loop(){
   for(n=3;n<11;n++){             //iteración sobre el nº de lados
     para();                      //espera un poco antes de cada figura
     delay(3000);
     digitalWrite(activai,HIGH);  //activa los motores
     digitalWrite(activad,HIGH);
     poli(n);
   }
 } 

• Motor paso a paso y circuito con driver integrado 74H245

 int vel2=5;         
 int vel=5;         
 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 uniang=4000;                 
 int dist=0;                      
 int ang=0;    
 int nlados=0;
 void para(){                        //procedimiento que para ambos motores
   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){
     para();                         //espera a que se pulse para empezar
   } 
 }
 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 poli(int nlados){              //función que calcula y aplica con   desplazamientos y giros 
   for(m=0;m<nlados;m++){            //las distancias y ángulos para un nº de lados dado
     avanza();                       //produce polígonos de igual perímetro (dist)
     delay(dist/nlados);             //tiempo que tarda en avanzar la distancia de un lado 
     giraderecha();                         
     delay(uniang/nlados);           //tiempo que tarda en girar el ángulo correspondiente
   }
 }
 void loop(){
   for(n=3;n<11;n++){                //iteración sobre el nº de lados
     para();                         //espera un poco antes de cada figura
     delay(3000);
     poli(n);
   }
 } 

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?.

Login