¡Saludos, estudiantes!.

¡En efecto!. Hoy vamos a acercarnos al control de servomotores mediante Arduino del modo más sencillo, eficiente y rápido que se me ocurre, y que consiste, simplemente, en conectar uno directamente a la tarjeta, volcar el código que os voy a dar, y ver el efecto que éste produce, para a continuación ir introduciendo modificaciones que nos ayuden a entender el algoritmo original.

¿Qué es un servomotor?

En primer lugar, ¿qué es un servo?. Un servomotor es un dispositivo alimentado por corriente continua que puede controlar de modo muy exacto o su posición (de 0º a 180º) o su velocidad (en revoluciones por minuto, rpm, en sentido horario o antihorario).

Los servomotores tienen tres pines de conexiones: alimentación (5 V, normalmente), tierra o GND y la patilla de señal, a través de la cual el sistema de control emitirá una señal PWM (Pulse Width Modulation, una sucesión de unos y ceros de periodo controlado que intentan emular el resultado de una señal analógica) que indicará al servomotor la posición o la velocidad que le corresponde alcanzar.

Sí, lo sé. Para aquél que entra en este mundillo por primera vez puede resultar algo complicado. Así que, si lo tenéis a bien, entremos directamente en harina con un montaje sencillísimo:

Conectamos nuestro primer servo: ¡Hola, mundo!

 Para empezar, conectaremos un servo a nuestra Arduino de manera directa (la patilla de señal, en el ejemplo, va al pin 6):

IMPORTANTE: el pin de señal de los servos que utilices debe conectarse siempre a pines que puedan realizar la función PWM, que son los que están señalizados con este letrero con con el signo ~ . Mientras que en una Arduino Mega puedes utilizar todas las patillas digitales, en la UNO, por ejemplo, sólo son válidoas la 3, 5, 6, 9,10 y 11.

¿Ya está?. ¡Qué rápido!. ¡Vuelca entonces este código!:

//Incluimos libreria
#include <Servo.h>
//Declaramos un servo
Servo miMotor;

void setup(){
//avisamos al código de que el servo está conectado al pin 6
miMotor.attach(6);
}
void loop(){
//Con la instruccion write indicamos la posición deseada, de 0 a 180
miMotor.write(90);
}

Como puedes ver, el código es cortito, pero tiene cuatro partes bien diferenciadas:

1. Incluimos OBLIGATORIAMENTE la librería <Servo.h> mediante la instrucción #include
2. Antes de entrar en la rutina setup(), declaramos una variable de tipo Servo a la que hemos llamado miMotor.
   
    
3. Dentro de setup(), mediante la instrucción attach indicamos que miMotor va conectado a la patilla 6
4. En loop() indicamos la posición (o posiciones, o velocidad, o velocidades) que queremos que miMotor vaya adquiriendo.

¡Primera propuesta de modificación: hagamos que el servo pase por tres posiciones (0º, 90º y 180º) con una frecuencia determinada, por ejemplo, 1 segundo!:

#include <Servo.h>

Servo miMotor;

void setup(){

miMotor.attach(6);
}
void loop(){
miMotor.write(0);
delay(1000);
miMotor.write(90);
delay(1000);
miMotor.write(180);
delay(1000);
}

Conexión de varios servomotores

¡Seguimos avanzando!. Según lo que te he explicado, puedes conectar tantos servomotores como patillas PWM ponga tu Arduino a tu disposición. ¡Conectemos ahora dos servos, uno a la patilla 6 y otro a la 9! :

(Aviso para navegantes). Aunque los servos no son motores de corriente continua normales, también tienen exigencias de corriente algo fuertecillas. Los servomotores de posición no dan tantos problemas, pero los de velocidad te darán problemas en cuanto quieras controlar dos o más a la vez, porque su consumo "obnubila"al microcontrolador y éste tiene tendencia a colgarse. La solución es alimentarlos con una fuente externa, distinta de la que alimenta nuestra tarjeta Arduino, procurando, eso sí, que las tierras sean comunes. Te pongo un ejemplo a continuación:

Un artículo muy clarificador al respecto es de nuestros amigos gallegos TECNOLOXIA.ORG, cuya lectura, disponible aquí o si pinchas en la imagen, te recomiendo para que comprendas el problema. A mí personalmente me gusto mucho, y aunque está en galego, su redacción es muy clara y cómoda de leer.

De todos modos, nosotros seguiremos alimentando ambos motores con nuestra Arduino, porque mi experiencia me dice que un par de servos de posición no suelen ofrecer problemas.

En cuanto al código que vamos a utilizar, es una adaptación del disponible en la IDE en los ejemplos, concretamente en el apartado Servo->Sweep. Lo que vamos a hacer es que AMBOS motores recorran simultáneamente el arco entre 0º y 180º, con un bucle for(). ¡Dentro código!.

/* Sweep
 by BARRAGAN <http://barraganstudio.com>
 This example code is in the public domain.

 modified 8 Nov 2013
 by Scott Fitzgerald
 modified 15 Mar 2017
 by Antonio Gómez
 http://www.arduino.cc/en/Tutorial/Sweep
*/

#include <Servo.h>

Servo motor1,motor2;


void setup() {
  motor.attach(6);
  motor2.attach(9);  
  }

void loop() {
  for (pos = 0; pos <= 180; pos += 1) { 
    motor1.write(pos);
    motor2.write(pos);              
    delay(15);                     
    }
  for (pos = 180; pos >= 0; pos -= 1) {
    motor1.write(pos);             
    motor2.write(pos);
    delay(15);                       
  }
}

Si te fijas, sigue siendo un trabajo en cuatro fases: incluír librería->declarar servos y ponerles nombre->Indicar en setup() qué pines de señal utilizar mediante attach()->Mover los servos en loop() mediante write().

¿Ya lo has probado?. ¿A QUE MOLA?.

Moviendo un servomotor mediante la posición de un potenciómetro

Para nuestra última práctica, os dejo un esquema de conexiones tan sencillo como los anteriores: un potenciómetro (resistencia variable) conectado a Vcc, GND y A0, y un servo conectado al pin de señales 6:

Nuestro objetivo, en esta ocasión, es controlar la posición del servo haciendo girar la rueda del potenciómetro. Para ello, conectaremos dicho potenciómetro a la entrada A0 de nuestro convertidor A/D, de modo que obtendremos una señal entre 0 y 1023. Como queremos convertir dicho valor a otro equivalente dentro del rango 0º-180º, nos valdremos de la instrucción map(). Además, para poder seguir el proceso, os dejo abierto en el código el monitor serie para que podáis ver en cada momento la señal registrada por el potenciómetro y la enviada al motor. ¡Dentro código!

#include<Servo.h>
Servo motor;
int valorLeido,valorEscrito;
void setup(){
Serial.begin(9600);
motor.attach(6);
}
void loop(){
valorLeido=analogRead(A0);
valorEscrito=map(valorLeido,0,1023,0,180);
Serial.print("Valor leido: ");
Serial.print(valorLeido);
Serial.print("\t");
Serial.print("Valor Escrito: ");
Serial.println(valorEscrito);
motor.write(valorEscrito);
delay(50);
}

En este video, puedes ver el resultado de esta práctica:

¡Y ya está!. A partir de aquí, podéis hacer mil cosas con lo aprendido. Por ejemplo, hace algunos años un alumno mío asoció la velocidad de los servos de un robot a la distancia detectada por un sensor de ultrasonidos, y podía ¡CONTROLAR EL MOVIMIENTO DEL ROBOT MOVIENDO LA MANO COMO UN JEDI!. ¡Dentro vídeo!:

Para acabar, os dejo un último video que recoge, a grandes rasgos, todo lo explicado hoy (por si os resulta interesante):

¡Y yo creo que eso es todo por hoy!. ¡Espero que os haya resultado útil!. ¡Hacedme llegar (por favor) vuestras opiniones, preguntas, críticas e inquietudes a través de los comentarios, de Twitter (@antoniotecnocr, recuerda) o del canal de Youtube!. ¡Gracias por llegar hasta aquí!. ¡Por favor comparte todo lo que aprendas!. ¡Sed felices!. ¡Siempre creciendo!. ¡Siempre aprendiendo!. ¡Cultura maker!