Robot Sanduino – Control con funciones

El uso de funciones en los lenguajes de programación es fundamental para escribir programas más compactos y legibles. Por ejemplo, para un robot Sanduino que hace lo siguiente de forma repetida:

  • Avanza 2 segundos
  • Retrocede 1 segundo
  • Avanza 1 segundo
  • Retrocede 2 segundos

Se puede tener el siguiente programa:

/* Programa: Sanduino_avretro.ino
   Autor: Julio Sandria (Enero 2015)
   Requiere: Robot Sanduino A01, con puente H
   y Arduino UNO conectados.
   Mueve el motor izquierdo con pines 6 y 7
   Mueve el motor derecho con pines 8 y 9
*/

void setup() {
  pinMode(6,OUTPUT);
  pinMode(7,OUTPUT);
  pinMode(8,OUTPUT);
  pinMode(9,OUTPUT);
}

void loop() {
  // Robot avanza 2 segundos
  digitalWrite(6,HIGH);
  digitalWrite(7,LOW);
  digitalWrite(8,HIGH);
  digitalWrite(9,LOW);
  delay(2000);
  
  // Robot retrocede 1 segundos
  digitalWrite(6,LOW);
  digitalWrite(7,HIGH);
  digitalWrite(8,LOW);
  digitalWrite(9,HIGH);
  delay(1000);

  // Robot avanza 1 segundos
  digitalWrite(6,HIGH);
  digitalWrite(7,LOW);
  digitalWrite(8,HIGH);
  digitalWrite(9,LOW);
  delay(2000);
  
  // Robot retrocede 2 segundos
  digitalWrite(6,LOW);
  digitalWrite(7,HIGH);
  digitalWrite(8,LOW);
  digitalWrite(9,HIGH);
  delay(2000);  
}

Se puede hacer un programa más compacto y que hace lo mismo usando las funciones avanza() y retrocede():

/* Programa: Sanduino_avretrof.ino
   Autor: Julio Sandria (Enero 2015)
   Requiere: Robot Sanduino A01, con puente H
   y Arduino UNO conectados.
   Mueve el motor izquierdo con pines 6 y 7
   Mueve el motor derecho con pines 8 y 9
*/

void setup() {
  pinMode(6,OUTPUT);
  pinMode(7,OUTPUT);
  pinMode(8,OUTPUT);
  pinMode(9,OUTPUT);
}

void loop() {
  avanza(2000);
  retrocede(1000);
  avanza(1000);
  retrocede(2000); 
}

void avanza(int tiempo) {
  digitalWrite(6,HIGH);
  digitalWrite(7,LOW);
  digitalWrite(8,HIGH);
  digitalWrite(9,LOW);
  delay(tiempo);
}

void retrocede(int tiempo) {  
  digitalWrite(6,LOW);
  digitalWrite(7,HIGH);
  digitalWrite(8,LOW);
  digitalWrite(9,HIGH);
  delay(tiempo);
}

En la función loop se hacen las llamadas siguientes:

  avanza(2000);
  retrocede(1000);
  avanza(1000);
  retrocede(2000);

Observa que esto prácticamente se puede leer así: avanza 2000, retrocede 1000, avanza 1000, retrocede 2000 (los tiempos en milisegundos). Esto es mucho más fácil de leer y entender que el contenido de loop() del primer programa.

Después de la función loop() están las definiciones de las funciones avanza() y retrocede().

Robot Sanduino – Busca negro

El programa siguiente, hace que el robot Sanduino avance mientras detecta el suelo blanco. Cuando en el suelo detecta el color negro se detiene.

/* Programa: SanduinoBuscaNegro.ino
   Autor:    Julio Sandria (Enero 2015)
             Taller de Robótica 2015
   Robot Sanduino usando un sensor de luz 
*/

int pinSensorLuz = 2;
int valorSensorLuz = 0;
int tAvanza = 50;
int tAlto = 40;

void setup() {
  pinMode(pinSensorLuz,INPUT);
  pinMode(6,OUTPUT);
  pinMode(7,OUTPUT);
  pinMode(8,OUTPUT);
  pinMode(9,OUTPUT);
  delay(3000);
}

void loop() {
  valorSensorLuz = digitalRead(pinSensorLuz);

  if( valorSensorLuz == 0 ) avanza(tAvanza);

  alto(tAlto);
}

/* Se define la función avanza()
   ms = tiempo en milisegundos */
void avanza(int ms) {
  digitalWrite(6,HIGH);
  digitalWrite(7,LOW);
  digitalWrite(8,HIGH);
  digitalWrite(9,LOW);
  delay(ms);
}

/* Se define la función alto()
   ms = tiempo en milisegundos */
void alto(int ms) {
  digitalWrite(6,LOW);
  digitalWrite(7,LOW);
  digitalWrite(8,LOW);
  digitalWrite(9,LOW);
  delay(ms);
}

Copia el programa en el software Adruino y cárgalo a la tarjeta Arduino del Robot Sanduino. El robot debe tener conectado el sensor de luz izquierdo al pin 2 de Arduino.

Prueba el robot colocándolo en una superficie blanca o clara y déjalo avanzar hacia un superficie negra u obscura.

Observa el uso de las funciones avanza() y alto(), las cuales permiten unir cierta funcionalidad que siempre se repite.

De este ejemplo se deriva el programa para el Robot Sanduino Seguidor de línea.

Rotob Sanduino seguidor de línea

En el siguiente video se muestra el Robot Sanduino A01 seguidor de línea.

El programa siguiente, es la versión inicial para lograr que el robot siga la línea como se muestra en el video.

/* Programa: SanduinoSigueLinea.ino
   Autor:    Julio Sandria (Enero 2015)
             Taller Robótica 2015
   Robot Sanduino seguidor de línea 
   con dos sensores de luz             
*/

int pinSensorLuzI = 2;
int pinSensorLuzD = 4;
int valorSensorLuzI = 0;
int valorSensorLuzD = 0;
int tAvanza = 50;
int tGiro = 50;
int tAlto = 50;

void setup() {
  pinMode(pinSensorLuzI,INPUT);
  pinMode(pinSensorLuzD,INPUT);
  pinMode(6,OUTPUT);
  pinMode(7,OUTPUT);
  pinMode(8,OUTPUT);
  pinMode(9,OUTPUT);
  delay(3000);
}

void loop() {
  valorSensorLuzI = digitalRead(pinSensorLuzI);
  valorSensorLuzD = digitalRead(pinSensorLuzD);

  if( valorSensorLuzI == 0 && valorSensorLuzD == 0 ) {
    avanza(tAvanza); 
  } 
  
  if( valorSensorLuzI == 1 ) {
    izquierda(tGiro);
  } 
  
  if( valorSensorLuzD == 1 ) {
    derecha(tGiro);
  }  
  
  alto(tAlto);
}

void avanza(int ms) {
  digitalWrite(6,HIGH);
  digitalWrite(7,LOW);
  digitalWrite(8,HIGH);
  digitalWrite(9,LOW);
  delay(ms);
}

void retrocede(int ms) {
  digitalWrite(6,LOW);
  digitalWrite(7,HIGH);
  digitalWrite(8,LOW);
  digitalWrite(9,HIGH);
  delay(ms);  
}

void izquierda(int ms) {
  digitalWrite(6,HIGH);
  digitalWrite(7,LOW);
  digitalWrite(8,LOW);
  digitalWrite(9,HIGH);
  delay(ms);  
}

void derecha(int ms) {
  digitalWrite(6,LOW);
  digitalWrite(7,HIGH);
  digitalWrite(8,HIGH);
  digitalWrite(9,LOW);
  delay(ms);
}

void alto(int ms) {
  digitalWrite(6,LOW);
  digitalWrite(7,LOW);
  digitalWrite(8,LOW);
  digitalWrite(9,LOW);
  delay(ms);
}

Copia el programa en el software Arduino y cárgalo a la tarjeta Arduino del Robot Sanduino A01.

¿Quieres aumentar la velocidad del robot? Prueba cambiando poco a poco las variables tAvanza, tGiro y tAlto.

 

Robot Sanduino – Sensor ultrasónico

El robot Sanduino A01 está equipado con un sensor ultrasónico HC-SR04 como el de la figura siguiente.

sensor-ultrasonico-hc-sr04_3

Para usar este sensor debes descargar la librería NewPing que está en esta dirección: http://playground.arduino.cc/Code/NewPing.

Es un archivo comprimido en formato zip que debes descomprimir, y la carpeta NewPing copiarla a la carpeta Arduino\libraries que debe estar en tu carpeta Documentos.

Este sensor lo puedes probar con el siguiente programa.

/* Programa: SensorUltrasonico.ino
 Autor: Julio Sandria (Enero 2015)
 Taller Robótica 2015 
*/

// Descargar NewPing: http://playground.arduino.cc/Code/NewPing
// Copia la carpeta NewPing en la carpeta ..\Arduino\libraries
#include <NewPing.h>

// PIN TRIGGER de sensor ultrasónico a PIN 11 de Arduino.
#define PIN_TRIGGER 11
// PIN ECHO de sensor ultrasónico a PIN 12 de Arduino:
#define PIN_ECHO 12
// Máxima distancia a medir en centímetros:
#define MAX_DISTANCIA 200 
// La distancia máxima del sensor es 400-500 cm. 

// La siguiente linea configura pines y distancia.
NewPing sonar(PIN_TRIGGER, PIN_ECHO, MAX_DISTANCIA);

int uS, distancia;

void setup() {
 // Abrir monitor serial a 9600 bauds/seg para ver resultados:
 Serial.begin(9600); 
}

void loop() {
 // Esperar 500ms entre pings (cerca de 20 pings/sec).
 // 29ms debe ser el menor tiempo entre pings.
 delay(500); 
 
 // Envía ping, obtiene tiempo ping en microsegundos (uS): 
 uS = sonar.ping();
 
 // Convertir tiempo ping a distancia.
 // (0 = distancia fuera de rango, no hay eco de ping).
 distancia = uS / US_ROUNDTRIP_CM; 
 
 Serial.print("Distancia: ");
 Serial.print(distancia); // Imprimir distancia 
 Serial.println("cm");
}

Copia el programa en el software Arduino y cárgalo a la tarjeta Arduino. Una vez cargado el programa y con la tarjeta aún conectada a la computadora, abre el Monitor Serial, en el cual podrás ver la lectura del sensor ultrasónico.

Acerca un objeto al sensor para verificar que esté funcionando apropiadamente.

Robot Sanduino – Sensores de luz

El robot Sanduino A01 está equipado con dos sensores de luz TCRT5000. Este sensor emite una luz infrarroja y detecta la cantidad de luz que se refleja en los objetos.

Sensor-de-luz-TCRT5000-300x200

Al colocar el emisor/receptor hacia el piso, puede detectar una línea negra colocada sobre un piso claro. Al usarlo así se le llama también sensor de línea. El emisor/receptor debe estar a una distancia aproximada de 5mm del piso y colocado como lo muestra la siguiente figura.

Sensores-de-linea-Sanduino-800x400

Cada sensor de luz tiene cuatro conectores, ambos sensores se deben conectar así en el robot Sanduino:

  • VCC – Al positivo del protoboard, que está conectado a 5V de Arduino.
  • GND – Al negativo del protoboard, que está conectado a GND de Arduino.

Para el sensor izquierdo:

  • DO (Data Output) – Al pin 2 de Arduino.
  • AO (Analog Output) – No lo usamos.

Para el sensor derecho:

  • DO (Data Output) – Al pin 4 de Arduino.
  • AO (Analog Output) – No lo usamos.

Con estas conexiones, se puede probar este programa ejemplo:

/* Programa: SensorLuz1.ino 
   Autor:    Julio Sandria (Enero 2015)
   Requiere un sensor de luz TCRT5000 conectado al
   pin 2 de Arduino.
*/

int pinSensorLuz1 = 2;
int valorSensorLuz1 = 0;
int valorSensorLuz1anterior = -1;

void setup() {
  pinMode(pinSensorLuz1,INPUT);
  Serial.begin(9600);
  Serial.println("Esperando 3 segundos...");
  delay(3000);
}

void loop() {
  valorSensorLuz1 = digitalRead(pinSensorLuz1);
  if( valorSensorLuz1 != valorSensorLuz1anterior ) {
    Serial.print( "valorSensorLuz1 = " );
    Serial.println( valorSensorLuz1 ); 
  }
  valorSensorLuz1anterior = valorSensorLuz1;
  delay(1000);
}

Copia el programa en el software Arduino y cárgalo a la tarjeta Arduino. Una vez cargado en Arduino, abre el Monitor Serial.

Observa lo que se muestra en el Monitor Serial cuando apuntas el sensor a una superficie clara y a una superficie obscura.

Robot Sanduino – Motores CD

El Robot Sanduino A01 usa dos motores de Corriente Directa (CD), los cuales se pueden conectar como se muestra en la siguiente figura.

SanduinoA01-MotoresCD

El puente H y la tarjeta Arduino UNO deben estar atornillados a la base superior del Robot Sanduino A01, usando un espaciador entre cada tarjeta de circuitos y la base superior, para evitar que las tarjetas se tuerzan al apretar los tornillos.

Las líneas de colores que unen conectores representan cables, que no necesariamente son de los colores mostrados.

Con el siguiente programa, puedes probar que todo el sistema esté apropiadamente conectado.

/* Programa: Sanduino_Motores.ino
   Autor: Julio Sandria (Enero 2015)
   Requiere: Robot Sanduino A01, con puente H
   y Arduino UNO conectados.
   Mueve el motor izquierdo con pines 6 y 7
   Mueve el motor derecho con pines 8 y 9
*/

void setup() {
  pinMode(6,OUTPUT);
  pinMode(7,OUTPUT);
  pinMode(8,OUTPUT);
  pinMode(9,OUTPUT);
}

void loop() {
  // Robot avanza 2 segundos
  digitalWrite(6,HIGH);
  digitalWrite(7,LOW);
  digitalWrite(8,HIGH);
  digitalWrite(9,LOW);
  delay(2000);
  
  // Robot retrocede 2 segundos
  digitalWrite(6,LOW);
  digitalWrite(7,HIGH);
  digitalWrite(8,LOW);
  digitalWrite(9,HIGH);
  delay(2000);  
}

Carga el programa en la tarjeta Arduino UNO del robot.

NOTA: Asegúrate de conectar una fuente de energía al interruptor y otra fuente de energía a Arduino UNO.

Al iniciar el programa, el robot debe avanzar dos segundos. Si en lugar de esto el robot retrocede, entonces hay que cambiar la polaridad de los cables conectados a los motores y al puente H.

Si al iniciar el programa, el robot gira hacia un lado dos segundos, hay que invertir la polaridad de los cables del motor conectado hacia el lado que gira.

Blink – Encender y Apagar un LED con Arduino

¿Cómo controlar un LED con Arduino?

Arduino UNO y otros modelos de tarjetas Arduino, tienen incorporado un LED conectado al PIN 13, como se ilustra en la siguiente imagen, donde el LED está señalado en rojo.

arduinounor3frontsupledpin13

El programa siguiente hace que Arduino encienda y apague el LED conectado al PIN 13.

/* Programa: Blink.ino
   Modificado por: Julio Sandria
   Enciende un LED por dos segundos, y después
   lo apaga un segundo, repite esto siempre hasta
   que se apague Arduino
*/
void setup() {
  // inicializa el pin digital 13 como una salida
  // El pin 13 tiene un LED conectado en la
  // mayoria de las tarjetas Arduino
  pinMode(13,OUTPUT);
}
void loop() {
  // loop = bucle, ciclo
  // loop() se repite siempre hasta que se apague Arduino
  digitalWrite(13,HIGH);  // Enciende el LED
  delay(2000);            // Espera 2000 milisegundos (2 segundos)
  digitalWrite(13,LOW);   // Apaga el LED
  delay(1000);            // Espera 1 segundo
}

Este es solo un programa de ejemplo. Para controlar LEDs externos a Arduino consulta nuestra página: Arduino Blink Monitor Ejemplo.

Robot Sanduino A01 – Armado de chasis

El Robot Sanduino A01 consta de dos bases de acrílico. El primer paso es atornillar la base superior sobre la base inferior. Debe quedar como se ilustra en la foto siguiente.

Paso 1. Atornillar base superior sobre base inferior.Sanduino-A01-Chasis-Completo-500x500

Paso 2: Colocar soportes para motores e interruptor.

Sanduino-A01-Chasis-P2-1

Paso 3: Colocar motores, entre los soportes para motor.Sanduino-A01-Chasis-P2-2

Paso 4: Atornillar motores.Sanduino-A01-Chasis-P2-3

Paso 5: Colocar y atornillar rueda loca.
Sanduino-A01-Chasis-P2-5NOTA: El portapilas no se atornilla al chasis.

 

Robot Sanduino A01

El Robot Sanduino A01 es un paquete básico de robótica que incluye: 1 chasis de acrílico con motores y ruedas, 1 tarjeta Arduino UNO, 1  puente H dual, 1 protoboard, 2 sensores de línea, 2 sensores de contacto, 1 sensor de distancia, cables de conexión, tornillos y accesorios para su construcción. Requiere 8 baterías AA, no incluidas. Requiere desarmador plano y de cruz chicos, no incluidos.

Robot Sanduino A01
Robot Sanduino A01

Más información en http://robotsa.com/archivos/111.