Arduino Blink Monitor ejemplo – encender y apagar LEDs

¿Cómo encender y apagar LEDs externos a Arduino? ¿Y cómo monitorear (ver) qué está haciendo Arduino?

arduino-blink-demoEste programa hace que Arduino encienda y apague el LED conectado al PIN 13. Está basado en el ejemplo Blink de Arduino.

/* Programa: BlinkMonitor.ino
   Modificado por: Julio Sandria - 28-Sep-2016
   Enciende un LED dos segundos y lo apaga un segundo, repetidamente.
   También muestra un texto en el Monitor Serie.  
*/

// la función setup se ejecuta una vez cuando se oprime reset o 
// enciende la tarjeta Arduino
void setup() {
  // inicializar pin digital 13.
  pinMode(13, OUTPUT);
  Serial.begin(9600);
  Serial.println("Iniciando BlinkMonitor... por Julio Sandria...");
  delay(1000);
}

// la función loop se repite siempre que tenga energía la tarjeta
void loop() {
  digitalWrite(13, HIGH);   // Enciende el led
  Serial.print("LED 13 encendido... ");
  delay(2000);              // Espera dos segundos
  digitalWrite(13, LOW);    // Apaga el led
  Serial.println("apagado.");
  delay(1000);              // Espera un segundo
}

Monitor Serie

Arduino puede comunicarse mediante un puerto serial a otros dispositivos o computadora conectada con cable USB. La opción Herramientas | Monitor Serie abre la ventana donde se puede imprimir textos desde Arduino, usando comunicación serial.

arduino-monitor-serie-2

Esta funcionalidad es la que se demuestra en este ejercicio. Por ejemplo, en la función setup(), de las dos líneas:

Serial.begin(9600);
Serial.println("Iniciando BlinkMonitor... por Julio Sandria...");

la primera (Serial.begin) inicializa la comunicación serial entre Arduino y la computadora, a una velocidad de 9600 bps (bits por segundo), la segunda (Serial.println) imprime una línea con el texto “Iniciando BlinkMonitor… por Julio Sandria…”. Para más información ver el sitio web de Arduino:  https://www.arduino.cc/en/Reference/Serial.

Conectar un led al pin 13 de Arduino

Además de encender el led que Arduino tiene integrado junto al pin 13, puedes conectar otro Led como se ilustra en la siguiente figura. Después de hacer las conexiones, conecta Arduino a la computadora para ejecutar el programa.

arduino-blink-demo

Conectar dos leds

Como segundo ejercicio, conecte un segundo led a Arduino, como se muestra en la figura siguiente, y cambie la programación para que el led rojo se encienda cuando el led verde se apague y viceversa.

arduino-2-leds-ejemplo

Bluetooth HC-06 para comunicación Android y Arduino

Mtro. Julio César Sandria Reynoso

Resumen

En este artículo mostramos cómo usar una tarjeta bluetooth HC-06 para establecer una comunicación inalámbrica entre un celular o tableta con Android y Arduino UNO. Se muestra el diagrama de conexión entre las tarjetas Arduino y HC-06. Se proporciona el programa que debe cargarse en Arduino para recibir la comunicación por bluetooth. Se indica qué programa debe descargarse del Play Store e instalarse en el dispositivo Android. Y finalmente se describe cómo realizar la conexión entre ambos dispositivos, y qué datos recibe Arduino para mostrarlos en un Monitor Serie.

Material

  • Tarjeta Arduino UNO
  • Tarjeta Bluetooth HC-06
  • 4 cables macho-hembra
  • Celular o tableta con Android
  • Computadora con software Arduino

Diagrama

Con los cables hembra-macho, conecta las tarjeta Arduino UNO y HC-06 como se muestra en el diagrama siguiente:

Arduino_UNO-HC-06 v2

Una vez conectadas entre si ambas tarjetas, conecta Arduino UNO a la computadora mediante el cable USB. De esta forma, la tarjeta bluetooth CH-06 recibe energía e inmediatamente está disponible para conectarse con un dispositivo bluetooth.

Aplicación en Android

En Android vamos a usar la aplicación Bluetooth RC Controller, la cual puedes descargar del Play Store de Google.

Bluetooth RC Controller Med

Una vez instalada la aplicación en tu dispositivo móvil, conéctala mediante bluetooth al HC-06, el cual se muestra con dicho nombre entre los dispositivos bluetooth. El password por default es 1234.

La tarjeta HC-06 tiene un led rojo que se enciende cuando recibe energía. Este led parpadea cuando la tarjeta aún no está conectada a otro dispositivo bluetooth. Cuando se conecta, el led queda encendido permanentemente.

Programa en Arduino

Copia el siguiente código y pégalo en el Software Arduino. Cárgalo a tu tarjeta Arduino UNO.

/*
 * Autor Julio Sandria // Feb 14, 2015 ver 1
 * Programa: bluetooth_sanduino_v1.ino
 * Proyecto: Bluetooth HC-06 para comunicación Android y Arduino
 * Mas información en: www.robotica.sandria.org
 *
 * Conexiones:
 * Arduino UNO pin 10 a pin TXD de HC-06
 * Arduino UNO pin 11 a pin RXD de HC-06
 * Arduino UNO pin 5V a pin VCC de HC-06
 * Arduino UNO pin GND a pin GND de HC-06
 */

// Incluimos librería para comunicación serial con Arduino
#include "SoftwareSerial.h"

// Declaramos objeto BT1 para comunicación serial por bluetooth
// usando pines 10 para recibir y 11 para transmitir
SoftwareSerial BT1(10,11); // RX, TX

int estado;

void setup() {
  // Iniciamos comunicación serial por USB
  Serial.begin(9600);
  // Iniciamos comunicación serial por bluetooth
  BT1.begin(9600);
  // Damos tiempo para iniciar comunicación
  delay(500); 
  Serial.println("Iniciando bluetooth_sanduino_v1.ino...");
  if(BT1.available())
    Serial.println("BT1 disponible");
}

void loop() {
  if (BT1.available()) {
    // Si hay disponible comunicación bluetooth...
    estado = BT1.read();
    if( estado != 83 ) // Default de Bluetooth RC Controller
      Serial.println(estado);
  } else {
    // Si no hay disponible comunicación bluetooth...
    Serial.println("BT1 NO disponible");
  }  
  delay(50);
}

Una vez cargado el programa en la tarjeta Arduino y con el cable USB conectando Arduino con la computadora, en el software Arduino abre el Monitor Serie, para ver lo que está pasando en la tarjeta Arduino.

Monitor_Serie_bluetooth_sanduino_v1

Si no se conectaron bien el móvil Android y el HC-06, en el Monitor Serie debe mostrarse el mensaje “BT1 NO disponible”. Si se conectaron correctamente, se mostrará el mensaje “BT1 disponible”.

Una vez conectados entre si Android y Arduino, oprime los botones de movimiento de carro de la aplicación Bluetooth RC controller. Al hacer esto, en el Monitor Serie se mostrarán números que corresponden a los botones oprimidos de la siguiente manera:

  • 70: Forward: Avanzar
  • 66: Backward: Retroceder
  • 76: Left: Izquierda
  • 82: Right: Derecha

De hecho, cada número corresponde al código ASCII de la primera letra de la palabra en inglés.

En el siguiente artículo, veremos cómo controlar por bluetooth el robot Sanduino con un dispositivo móvil Android.

Enlaces relacionados

Sensor infrarrojo (IR) TSOP1100

El sensor infrarrojo de la serie TSOP1100 tiene un receptor miniaturizado diseñado para sistemas de control remoto infrarrojo. Documentación técnica: Sensor-IR-TSOP1100.

Sensor-IR-TSOP1100

Jairo Herrera muestra el uso de este sensor con una tarjeta Arduino UNO y un control remoto en la página Arduino + Sensor IR + Ctrl Remoto.

En robótica, se puede usar este sensor para enviarle comandos a un robot mediante un control remoto o con cualquier otro dispositivo que emita una señal infrarroja, por ejemplo, la pelota IR usada con robots futbolistas en RoboCupJunior Soccer.

 

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.