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.

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

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

Robot Sanduino A01
Robot Sanduino A01

El Robot Sanduino A01 es un paquete básico de robótica educativa basado en Arduino. 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 distancia infrarrojos (ó 2 sensores de contacto), 1 sensor de distancia ultrasónico, 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.

Dónde comprar

El Robot Sanduino A01 lo puedes adquirir en RobotSA.

Guía de armado y programación

 

Programación de Robots Lego Mindstorms NXT con Java. Tema 3 Java para NXT

Esta presentación, corresponde a uno de los temas tratados en el Curso de Robótica a nivel licenciatura impartido por el autor en el Tecnológico de Monterrey Campus Zacatecas.

Este tema enfatiza la programación orientada a objetos con Java para los robots Lego Mindstorms NXT. Se ilustra la creación de clases, objetos e interfaces. Se ejemplifica la herencia, el uso de métodos, tipos de datos y arreglos en Java, así como el control de flujo de programas y el manejo de excepciones. Todo esto aplicado en un robot móvil Lego.

Clase CarBot

importlejos.nxt.*;
public class CarBotextends Thread implements ManioBot {
  public void avanza() {
    Motor.B.forward(); Motor.C.backward(); pausa(500);
  }
  public void derecha() {
    Motor.B.backward(); Motor.C.backward(); pausa(500);
  }
  public void frena() {
    Motor.B.stop(); Motor.C.stop();
  }
  private void pausa(intmSegundos) {
    try {
      Thread.sleep(mSegundos);
    } catch(InterruptedExceptione) {}
  }
}

Presentation · February 2010
DOI: 10.13140/RG.2.2.24016.30721
Disponible en https://www.researchgate.net/publication/317302716.

Para detalles básicos sobre los robots Lego Mindstorms NXT y la instalación del software necesario para programarlos en Java, ver la siguiente entrada:

Prototipo de robot Lego futbolista programado en Java

En este documento se presenta un prototipo de robot futbolista construido con el paquete Lego Mindstirms Robotics Invention System 2.0 y programado en Java usando lejos. En este artículo se presenta una introducción a los robots futbolistas y la construcción inicial y programación básica del robot Lego futbolista (RoLeF).

Technical Report · February 2007
DOI: 10.13140/RG.2.2.10156.67208