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»).

 

Arduino desde cero (y sin teoría). Parte 1.

Cada vez que algún amigo, amiga o amigue comienza a usar Arduino yo me pongo a buscar tutoriales que vayan directo a la parte práctica, dejando para después la teoría. Creo fervientemente que la teoría viene como respuesta al «¿Por qué es así?», después de lograr algo a nivel práctico. Como no encuentro un tutorial así, decidí escribir el mío propio. Aquí va.

Primer paso: descargar el software

El software se descarga de este enlace: https://www.arduino.cc/en/Main/Software .

Descargar software para Windows o para Linux

Te va a ofrecer la posibilidad de colaborar con unos dólares, o de descargar el software gratis («Just download», es decir, «sólo descargar»)

Just Download

Una vez descargado el instalador, hay que ejecutarlo.

Segundo paso: conectar la placa

La placa Arduino Uno tiene un conector similar al de las impresoras («USB tipo A/B»). Simplemente conectamos el USB tipo A (el plano) a la computadora, y el más cuadradito (tipo B), al Arduino. Si todo sale bien, deben encenderse algunas luces.

Conector USB tipo B

Tercer paso: usar un programa de ejemplo para ver cómo titila un led

Ahora que nuestro Arduino está conectado, vamos a abrir un programa de ejemplo que hará titilar el led «Built-in», es decir, una luz que está incorporada a la placa.

Para ello vamos al menú Archivo / Ejemplos / Básicos / Blink

Abrir ejemplo titilar led

Ahora el programa está en la computadora, pero no en la placa Arduino. Para que el programa pase de la computadora a la placa, hay que pulsar el botón «Subir» (que para mí debería llamarse «descargar», pero bue…)

Descargar programa a la placa

Si esto da error, es porque hay que elegir la placa y el puerto en el menú Herramientas. La placa probablemente sea «Arduino Uno» (lo dice en la placa), y el puerto -si usás Windows- puede ser «Com 1» (en mi captura se ve un nombre diferente porque uso Linux):

Elegir la placa y el puerto

Lo que debe ocurrir ahora, al volver a «subir» el programa, es que la luz que tiene la placa comience a titilar, manteniéndose encendida por un segundo y apagada por un segundo.

Próxima práctica de Arduino: utilizar un led y la protoboard.

Para leer más sobre qué es Arduino, Hardware Libre, Software libre, recomiendo este post de Xataca.