Creando un tren con juguetes y un arduino – Parte 2

Ayer compré un tren de juguete y le puse motor, pilas e interruptor. Hoy estuve trabajando en una “pista” (no logré hacer vías, se resbalaba el plástico de las ruedas). Y luego, en una barrera automática.

Para trabajar sobre una superficie que pueda cambiar de lugar (para liberar la mesa), usé unas baldosas grandes que tengo en casa. En ellas fui pegando distintas cosas para guiar el tren, empezando por un tapacanto de melamina que tenía guardado:

Después de varias pruebas llegué a la solución pegando precintos mediante cinta de papel, pero podrían usarse muchas otras soluciones.

Una vez que el trencito ya funcionaba correctamente armé la barrera con el Arduino:

¿Qué se necesita?

  • Placa Arduino
  • Protoboard (placa de prueba / placa sin soldaduras)
  • Cables
  • Servo motor
  • Sensor ultrasónico (distancia)
  • Optativo: un buzzer, batería de 9v y conector Plug Jack para conectarlo al Arduino y usar la barrera sin la computadora

Conexiones

Lo ideal para hacer este montaje es ya haber utilizado por separado cada uno de los tres elementos: el servo motor, el buzzer y el sensor de distancia / ultrasónico.

  • El servo: va conectado al pin 9, a tierra y a VCC (aquí explicación sobre cómo conectar un servo)
    • cable anaranjado: va a un pin de tipo PWD (los de la tilde de la eñe), en este caso al 9
    • cable color marrón: GND (tierra)
    • cable color rojo: +5v
  • El sensor ultrasónico:
    • VCC – a 5v
    • TRIG – al pin 12
    • ECHO – al pin 13
    • GND – a gnd
  • El buzzer
    • Pin 10 (el positivo)
    • GND (el negativo)
Esquema de conexiones armado en Tinkercad (simulador de circuitos)
Esquema de conexiones armado en Tinkercad (simulador de circuitos)

Programa

Aquí comparto el código utilizado para que la barrera se levante cuando el sensor ultrasónico detecta algo cerca:

#include <Servo.h>
#define PIN_TRIG 12
#define PIN_ECO 13
int buzzer = 10;

int tones[ ] = {261, 277, 294, 311, 330, 349, 370, 392, 415, 440,466, 494};
                //DO, DO#, RE, RE#, MI, FA, FA#, SOL, SOL#, A, A#, B
                //Estas son las frecuencias que corresponden a cada nota, para usar en el buzzer
Servo myservo;
int pos = 0;
void setup() {
  Serial.begin (9600);
  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECO, INPUT);
  pinMode(buzzer, OUTPUT);
  myservo.attach(9);
}

void loop() {
//Este fragmento de código es para tomar la información del sensor ultrasónico HC-SR04
long duracion, distancia;
digitalWrite(PIN_TRIG, LOW);
delayMicroseconds(2);
digitalWrite(PIN_TRIG, HIGH);
delayMicroseconds(10);
digitalWrite(PIN_TRIG, LOW);

duracion=pulseIn(PIN_ECO, HIGH);
distancia=(duracion/2)/29;
//Aquí hacemos que la distancia se muestre en el "Monitor Serial"
Serial.println(distancia);
//Acá ponemos una condición: si la distancia es menor a doce cm, que suene el buzzer y se baje la barrera
if (distancia < 12) {
  //suena el buzzer en la frecuencia indicada por la matriz que está en 
        tone(buzzer, tones[8]);
        delay(50);
        noTone(buzzer);    
        delay(50);
        tone(buzzer, tones[8]);
        delay(50);
        noTone(buzzer);    
        delay(50);
  for (pos = 130; pos >= 0; pos -= 1) { // Lleva la variable pos desde 130 grados hasta 0, de uno en uno
    myservo.write(pos);              // pone el servo en la posición indicada por la variable pos
    delay(15);                       // espera 15ms 
  }      
  delay(1000);
  for (pos = 0; pos <= 130; pos += 1) { // lleva la variable pos desde 0 hasta 130
    myservo.write(pos);              // pone el servo en la posición indicada por la variable pos
    delay(15);                       // espera 15ms
  }
  
        
}
}

Creando un tren con juguetes y un arduino – Parte 1

Ayer fui al supermercado y vi que vendían un trencito y sus vagones. Me compré algunos, porque ya venía pensando en crear un trencito con una barrera y más cosas interesantes.

Locomotora y vagones de juguetes comprados en el supermercado
Locomotora y vagones de juguetes compradas en el supermercado

Busqué entre todas mis cajitas de “cosas que me servirían para robótica” y elegí un motorreductor, un interruptor, y un portapilas para dos pilas doble A.

También puede hacerse con un motor DC pero seguramente sería bastante más complicado armarlo porque el motorreductor amarillo clásico de Arduino ya viene con dos ruedas que encajan perfectamente. Yo soldé varias conexiones, pero también puede utilizarse cinta de papel (se desarma a cada rato, por eso es mejor soldar, pero no es imprescindible si no se sabe cómo hacerlo).

Del portapilas salen dos cables. Uno se suelda al motor y el otro al interruptor. Y se agrega otro cable desde el interruptor hasta el motor.
Portapila con un cable soldado al interruptor, y el otro suelto, que se conecta al motor. Del interruptor sale otro cable que se conecta al otro extremo del motor.
Portapila, interruptor y motor ya soldados. Para mantener el equilibrio, le agregué dos rueditas del tren original, sostenidas con un palito de brochette.
Portapila, interruptor y motor ya soldados. Para mantener el equilibrio, le agregué dos rueditas del tren original, sostenidas con un palito de brochette. Todo pegado con cinta de papel para el prototipo. Si funciona, trabajo en emprolijar y hacer más firmes los armados.

Sensor de humedad para tierra: HW-080

Para un proyecto en escuelas secundarias, me compré unos sensores HW-080, que miden la humedad de la tierra. Estas sondas pueden utilizarse solas y devolverán un valor binario, o con un módulo para convertir en analógicos los valores. Yo las compré con el módulo:

Sonda y módulo analógico
Sonda + módulo para convertir los valores en analógicos

Los pude utilizar en menos de cinco minutos gracias a este post de madnesselectronics.com donde obtuve el siguiente código:

#define sensor A0
void setup(){
    pinMode(sensor, INPUT);
    Serial.begin(9600);
  }
 void loop(){
 //Se hace la lectura analoga del pin A0 (sensor) y se pasa por la funcion map() para ajustar los valores leidos a los porcentajes que queremos utilizar   
int valorHumedad = map(analogRead(sensor), 0, 1023, 100, 0);
Serial.print("Humedad: ");
Serial.print(valorHumedad);
Serial.println("%"); 
delay(100);
  }

Las conexiones, en el caso de los sensores que yo adquirí, no tienen ninguna indicación. ¡Está todo en chino! Por lo tanto, sólo me quedó imitar la posición de la guía del enlace:

El resultado: al insertar en una maceta con tierra el sensor, veremos en el monitor serie el porcentaje de humedad.

Mover un servo motor utilizando el celular

En la entrada anterior expliqué cómo conectar el Módulo Bluetooth HC-06 al arduino y enviar mensajes desde el celular a través de una app llamada Bluetooth SPP.

Modo Control

Hasta ahora lo utilizamos en modo “terminal”. Ya podemos pasar al modo “Control” de la aplicación (en el menú de hamburguesa – las tres rayitas)

Comenzamos investigando qué recibe el Arduino cuando tocamos cada tecla. Para ello, abrimos el monitor serie y pulsamos los botones. Recibe una A, una B, una C, una D y cuando soltamos, una Z.

Por lo tanto, modificamos el programa para que nos avise qué recibe cada vez que tocamos una flecha. Vamos a pedirle que cuando se oprime el botón hacia arriba nos devuelva “Arriba”, y eso mismo con todos los botones:

void setup()  
 {
   Serial.begin(9600);
 }
 void loop() 
 {
   if (Serial.available())
   {
     char dato=Serial.read();
     Serial.print("Dato recibido: ");
     Serial.println(dato);
     if (dato=='B') {
       Serial.println("Abajo");
     }
        if (dato=='A') {
       Serial.println("Arriba");
     }
        if (dato=='C') {
       Serial.println("Izquierda");   
     }
        if (dato=='D') {
       Serial.println("Derecha");
     }
   }
 }

Y el resultado, al tocar las flechas:

Conectando el Servo Motor Tower Pro Micro Servo 9g

Si nunca utilizaste el servo motor, comenzá por aprender a utilizarlo, por ejemplo, con esta entrada: Servo motor 9g Tower Pro

Ahora vamos a hacer esas mismas conexiones, repasando:

  • cable anaranjado: va a un pin de tipo PWD (los de la tilde de la eñe)
  • cable color marrón: GND (tierra)
  • cable color rojo: +5v

El problema es que tenemos el pin de +5v ocupado por el módulo HC-06, así que vamos a tener que conectar el módulo de Bluetooth y el Servo a una breadboard / placa de pruebas, y de allí sacar un cable para el pin de Arduino llamado +5v

Ahora le agregamos unas líneas a nuestro programa, para que se mueva el servo motor al presionar los botones:

#include <Servo.h>
 
Servo myservo;   

void setup()  
 {
   Serial.begin(9600);
   myservo.attach(9);
 }

void loop() 
 {
   if (Serial.available())
   {
     char dato=Serial.read();
     Serial.print("Dato recibido: ");
     Serial.println(dato);
     if (dato=='B') {
       Serial.println("Abajo");
       myservo.write(90);
         delay(15); 
     }
        if (dato=='A') {
       Serial.println("Arriba");
       myservo.write(0);
         delay(15); 
     }
        if (dato=='C') {
       Serial.println("Izquierda"); 
       myservo.write(180);  
     }
        if (dato=='D') {
       Serial.println("Derecha");
       myservo.write(45);
     }
   }
 }

Como el servo no gira 360 grados, los botones no lo mandan exactamente arriba, abajo, derecha, izquierda. Ya mejoraremos eso en otra entrada.

Módulo Bluetooth en Arduino

Hace mucho tiempo me compré un kit de domótica que no llegué a usar. Hoy que tengo un ratito me puse a probar el módulo Bluetooth HC-06 (el que tiene cuatro pines).

Las conexiones se realizan de la siguiente manera:

  • VCC va a 5v
  • GND a GND
  • TX al pin RX (el 0 en mi Arduino)
  • RX al pin TX (el 1 en mi Arduino)

Muy importante: cuando TX y RX están conectados, Arduino da error al descargar el programa. Eso significa que si lo utilizamos de esta manera necesitamos desconectar ambos pines y resetear la placa cada vez que vamos a descargar código al arduino. Esto se resuelve utilizando la librería SoftwareSerial para conectar otros pines.

Tomé el primer código del sitio naylampmechatronics.com

void setup()  
{
  Serial.begin(9600);
}

void loop() 
{
  if (Serial.available())
  {
    char dato=Serial.read();
    Serial.print("Dato recibido: ");
    Serial.println(dato);
  }
}

Conectar el celular al Bluetooth HC-06

Lo primero que hay que hacer es instalarse una app, por ejemplo Bluetooth SPP.

Me costó muchísimo esta parte. No lograba entender lo que estaba ocurriendo. Según se explica en varios posteos, en el módulo bluetooth HC-06:

  • La luz roja titilando significa que está visible pero no conectado
  • La luz roja encendida fija significa que la conexión se estableció

Lo que a mí me funcionó es lo siguiente:

  • Encender el bluetooth del celular y poner “buscar”. No me aparecía ninguno de los nombres que figuran en los distintos posteos, así que probé conectarme a uno que aparecía y se conectó (con el pin 0000, también podría ser 1234). Aún así la luz seguía titilando, por eso mi confusión.
  • En la aplicación de celular (Bluetooth SPP en mi caso), poner “Conectar”. Recién allí deja de titilar la luz del HC-06

Una vez establecida la conexión, ya podemos escribir en el celular y ver el resultado en el monitor serie (que se visualiza desde el menú Herramientas del Arduino IDE):

¡Bien! Ya estamos recibiendo contenido desde el celular al Arduino, y podemos verlo en el monitor serie.

En el próximo posteo voy a mostrar cómo manejar un servo motor a través de la app del celular, con Arduino y el módulo Bluetooth HC-06.

Cómo soldar

Como soy una persona que estudió educación pero a quien le apasionan los proyectos con tecnología, voy aprendiendo muchas cosas gracias a este tipo de videos que se encuentran en la web.

Es cierto que observé bastante a mi papá trabajando en su taller, pero además, gracias a este tipo de video que comparto, pude soldar algunos componentes de mis kits de Arduino.

Espero que a ustedes también les sean útiles estos consejos.

Primeros pasos con Arduino: Mi presentación para el Flisol

Comparto aquí la presentación que utilicé el día del Flisol 2019, en UNPAZ.

En el taller (de una hora de duración) mostré muy rápidamente cual es la estructura de la placa Arduino Uno, y utilizamos leds, un motor y un sensor de distancia.

También expliqué y practicamos el uso de la placa de pruebas o breadboard.


Estoy muy conforme con la manera en que voy aprendiendo a llevar adelante este tipo de talleres, ya que cada vez que una dificultad se repite, encuentro la manera de encarar ese contenido para saltear ese obstáculo.

Y esta vez me gustó mucho la manera en que expliqué el uso de la protoboard, con estos tres videos:

Intentos de hacer un robot bípedo

Con cuatro servomotores, un arduino Uno, una batería de 9v. y otros materiales (palitos de helado, pistola de silicona), estuve tratando de hacer un robot bípedo que camine. El armado es similar al de la mano robótica del post anterior.

Fui corrigiendo diferentes defectos, tanto de programación como de diseño

Después me concentré en que la robota Thelma llevara la placa arduino, la batería, la protoboard… era imposible con el diseño anterior. Así que todo cambió: patitas cortas (intenté varios modelos y finalmente me quedé con las patitas del servomotor) y cuerpo de tupper:

Manito robótica: controlar 4 servos en un Arduino Uno

Hace unos meses me compré cinco servomotores Tower Pro SG90 para hacer una manito. Recién tuve tiempo hoy de empezar a armar algo.

Cinco motores servo SG90

Si nunca usaste un servo, empezá por aprender a manejar un solo motor. Cada marca y modelo tiene diferentes colores de cables.

Atención: si lo conectás mal, el servo se quema. Yo ya quemé dos…

En el caso del Tower Pro SG90:

  • el cable naranja es de datos,
  • el rojo es positivo,
  • el marrón negativo.

Tenemos que conectar los cuatro servos a positivo, negativo (GND) y después el cable naranja de cada servo va a un pin PWM diferente.

Los pines PWM son los que tienen el símbolo ~

Fuentes de energía

Cuando usamos cuatro servos, es necesario agregar energía externa, ya que exigen más de lo que la placa Arduino puede darles. Yo conecté un portapilas de cada lado, y dos servos de cada lado:

Portapilas

  • Cable rojo al positivo, cable marrón al negativo.
  • Cable naranja de cada servo a un pin PWM diferente.

El código

Como siempre, comencé por abrir el archivo de ejemplo para manejar servos. Y después lo modifiqué.

Para poder pegar los motores con cinta de papel a una cajita, empecé con un programita que apunta los cuatro servos a la posición 0.

#include <Servo.h>

Servo myservo; // esto está en el programa de ejemplo, yo agregué los otros 
Servo myservo2;
Servo myservo3;
Servo myservo4;

void setup() {

myservo.attach(5); // un servo en cada pin
myservo2.attach(9);
myservo3.attach(10);
myservo4.attach(11);
}

void loop() {

myservo.write(0); // todos los servos van a la posición 0
myservo2.write(0);
myservo3.write(0);
myservo4.write(0);
delay(5000);}

apuntar los motores

Recién cuando pude poner los cuatro servos en la posición cero, los pegué en una cajita de cartón. Los dedos los hice con “limpiapipas” (alambre forrado, se usa en manualidades)

Ahora sólo queda programar el movimiento:

#include <Servo.h>

Servo myservo; // crear un objeto servo para cada motor
Servo myservo2;
Servo myservo3;
Servo myservo4;

void setup() {

myservo.attach(5); // declarar el pin en que se conecta cada servo
myservo2.attach(9);
myservo3.attach(10);
myservo4.attach(11);
}

void loop() {

myservo.write(0); // pongo todos los dedos en 0
myservo2.write(0);
myservo3.write(0);
myservo4.write(0);
delay(5000); // espero cinco segundos
myservo.write(90); // pongo todos los dedos en 90º
myservo2.write(90);
myservo3.write(90);
myservo4.write(90);
delay(1500); // espero un segundo y medio
myservo.write(180); // pongo todos los servos en 180º
myservo2.write(180);
myservo3.write(180);
myservo4.write(180);
delay(1500); // espero un segundo y medio

}

Este es el primer resultado:

En un segundo intento utilicé palitos de helado. Y armé una estructura de tres dedos, dos de ellos con una articulación (ahora con cinco servos).

Como los pares de pilas anteriores parecían insuficientes, ahora puse todos los motores en la misma fila y le conecté una batería de 9v.

conexionesBateria de 9v conectada a los servos

El resultado me gusta más que en la prueba anterior:

Acá con unos movimientos más suaves (usando bucles for para cada movimiento):

Arduino desde cero. Parte 2.

En la entrada anterior, expliqué cómo descargar el IDE de Arduino (“Integrated Development Environment”, es decir “Entorno de Desarrollo Integrado”). Después conectamos la placa Arduino y descargamos un ejemplo que hace titilar una luz led que está integrada a la placa.

Ahora vamos a empezar a entender un poco del programa que descargamos. Vemos tres secciones:

  • La primera parte, que se ve toda de color gris comienza con /* y termina con */. Todo eso se llama “comentarios”, y es un texto en inglés que explica de qué se trata el programa. Lo podemos eliminar para aclarar el panorama.

Todo lo que figure entre /* y */ va a ser ignorado por Arduino, así que podemos escribir algo allí que no va a influir en nada:

/* Eliminamos los comentarios en inglés pero podemos escribir algo en castellano */

Otra forma de escribir comentarios es comenzar con doble barra:

// Esto es un comentario, sirve para poner anotaciones para uno mismo

  • Después viene un segundo bloque que comienza con “void setup()”. Todo lo que figura entre llaves { } dentro de “void setup()”, son órdenes que se van a ejecutar una sola vez al comienzo del programa. En este caso hay dos renglones. Un comentario en inglés, que lo eliminamos, y una orden que es “PinMode”. En un rato la analizamos.

void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}

  • Por último el bloque “void loop()”. Todo lo que viene entre llaves después de “void loop()” se ejecutará en bucle, una y otra vez, hasta que desenchufemos el Arduino.

void loop() {
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(100);
}

digitalWrite(LED_BUILTIN, HIGH); Encender el led integrado a la placa (“led built-in”). La orden significa “escribir en un pin digital el valor 1”. Un pin digital puede valer 1 o 0. O lo que es lo mismo, “high” o “low” (“encendido” o “apagado”).
delay(1000); Esperar un segundo (mil milisegundos)
digitalWrite(LED_BUILTIN, LOW); Apagar el led “built-in”
delay(1000); Esperar un segundo (mil milisegundos)

Entonces, vamos a hacer unos cambios al programa para entenderlo más.

Donde dice:

delay(1000)

Vamos a poner otros números:

delay(500)

delay(2000)

Y cada vez que hacemos un cambio, probamos usar el botón “subir” para pasar ese programa a la placa. Recordemos que hay dos “delay”. El primero es el tiempo que espera el led estando encendido, y el segundo el tiempo que espera apagado.

Conectando un led

Ahora vamos a conectar un led, dejando de utilizar el “built-in”.

Antes de hacer cualquier conexión, desenchufamos la placa (siempre).

Cada led (“diodo emisor de luz”) tiene una pata más larga y una más corta. La pata más larga se llama “ánodo” y es la positiva. La pata corta “cátodo” y es la pata negativa.

Como primer experimento, vamos a conectar el LED en el pin 13. Es decir, la pata larga del LED en el pin 13, y la pata corta en “tierra” (GND, “ground”).

Led conectado en el pin 13Aclaración importantísima: el pin 13 es el único que tiene resistencia propia. En todos los demás pines no podemos conectar un led directamente porque se quema.

Si volvemos a conectar la placa (que ya tiene cargado el programa anterior) vamos a ver que el led que conectamos en el pin 13 titila igual que el led integrado a la placa (built-in). Esto es porque el led built-in y el pin 13 están interconectados.

Utilización de un led en otro pin

Para conectar un led en cualquier otro pin digital (los que están numerados y no comienzan con A), por ejemplo el pin número 8, deberíamos agregar una resistencia. ¿Por qué? Porque la resistencia impide que el LED reciba más electricidad de la que puede soportar. Se usa para que el componente no se queme.

Por lo tanto, deberíamos hacer algo como esto (los negros son cables):

Led y resistencia

Pero claro, sería muy incómodo realizar estas soldaduras y que después no funcione el circuito. Entonces, en lugar de soldar, utilizamos una placa de pruebas.

Entendiendo la protoboard

La protoboard es la placa de pruebas que viene generalmente acompañando a la placa Arduino. Se trata de una superficie con agujeritos donde podemos ver unos números, un signo + y un signo –

¿Para qué sirve? Para poder hacer circuitos de prueba, sin necesidad de soldar las conecciones.

Para entender cómo se usa, hay que saber que los agujeritos están conectados entre sí. Pero no todos con todos:

  • Las dos filas que tienen el signo + y el signo – tienen todos sus agujeritos conectados entre sí.
  • Las columnitas que están numeradas, tienen cinco agujeritos interconectados.

Entonces, para repetir el esquema anterior tenemos que conectar:

  • La pata larga del LED en la misma columnita que el cable que se conecta al pin número 8
  • La pata corta del LED en la misma columnita que una pata de la resistencia
  • La otra pata de la resistencia en la misma columnita que el cable que lleva a GND (cualquier GND, ya que todos son iguales).

Conectar un led mediante la protoboard

Es decir, no importa en qué columnita conectamos cada cosa, lo importante es que estén en la misma columna las cosas que deben ir interconectadas. Aquí lo muestro con líneas rojas:

Conexiones del led en la protoboard

El programa

Hasta ahora teníamos un programa que encendía y apagaba el led conectado en el pin 13, y el led “built-in” a la vez. Ahora lo vamos a modificar para que encienda y apague el led conectado en el pin digital número 8. Para eso, cada vez que dice “led_builtin”, lo cambiamos por el número 8:

void setup() {
    pinMode(8, OUTPUT);
}

void loop() {
digitalWrite(8, HIGH);
delay(1000);
digitalWrite(8, LOW);
delay(100);
}

Lo descargamos (con el botón “subir”) y… ¡Listo! El led conectado en el pin número 8 está titilando.

PinMode

Algo que quedó “para después”, fue el comando “pinMode” que está en void setup():

void setup() {
pinMode(8, OUTPUT);
}

Esa línea de código lo que le indica al Arduino es que determinado pin va a estar en modo salida (“output”). En este caso sería el pin número 8, va a salir información (encender o apagar el led).

Si tuviésemos un botón conectado en ese pin, le diríamos que será un pin de entrada (“input”).