Plataforma móvil con 2 servos controlada por un joystick y Arduino

Vamos a montar una torreta con dos servos que nos ayudarán a desplazarla en un ángulo de 180º, en el eje horizontal y en el vertical. Utilizaremos un joystick para mover los pequeños motores.

Podremos utilizar la plataforma móvil para añadir una cámara, un sensor de distancia, un láser, un lanzamisiles, o para mover una placa solar… Hay multitud de utilidades que se nos pueden ocurrir para utilizar la plataforma. Básicamente, montaremos una plataforma móvil de 2-DOF que nos permitirá orientar un sensor.

Material necesario:

• Placa Arduino o similar.
• 2 Servos, modelo micro servo SG90, en nuestro caso.
• Joystick.
• Soporte servo PAN-TILT, (es el soporte móvil).
• Protoboard.
• Cables.
• Tornillos.
• Soporte o caja de zapatos para colocar la base móvil.

Montar el soporte móvil con los servos

Pasos necesarios para su montaje:

Primer paso: utilizamos las piezas de sujeción que llevan los servos para unirlos a la plataforma, para ello tendremos que adaptar las piezas recortándolas y atornillándolas.

Adaptar las piezas y atornillar

Segundo paso: encajamos uno de los servos en la cruceta inferior y atornillamos.

Tercer paso: unimos la cruceta que hemos formado con la base inferior.

Paso cuarto: unimos la base superior con el segundo servo y encajamos en la cruceta.

Por último, montar el esquema: el servo 2, corresponde al movimiento horizontal, es el de la parte inferior, y el servo 1, es el superior, y realiza el movimiento en vertical:

El servo1 que es el que vamos a utilizar para el movimento vertical, eje y, (es el superior de la torreta) lo unimos con el pin 5 digital de Arduino.

Para el movimento horizontal, eje x, utilizamos el servo 2. Es el de la parte inferior de la torreta y está unido con el pin digital 6 de Arduino.

Para la alimentación de los servos se utilizan 4 pilas de tipo AA, no olvidar conectar a tierra, (cable azul de la imagen).

El joystick está conectado:

• GND, cable azul a tierra.
• VCC, corresponde con la alimentación, cable rojo
• VRx, cable amarillo, está unido al pin analógico A0.
• VRy, cable naranja, está unido al pin analógico A1.

Para fijar la torreta se ha atornillado la base sobre una caja, y el joystick también se ha fijado como se puede ver en la imagen inferior.

Mover la base móvil con el joystick

El primer objetivo es que la base se mueva cuando desplacemos la palanca del joystick. Incluimos la librería Servo.h y creamos dos constantes indicando los pines que hemos unido al joystick para controlar el eje x, pinX, y el eje y, pinY.

#include "Servo.h"  // librería para poder controlar el servo
const int pinX = A0;
const int pinY = A1;

Necesitaremos dos nuevas variables para guardar la lectura del movimiento del joystick, X e Y.

int X = 0;
int Y = 0;

Creamos dos objetos servo y dos variables para guardar los grados de movimiento que se van a aplicar a cada servo.

Servo servo1;   // Crea un objeto servo
int grados1 = 0; // GRADOS DEL SERVO 1
Servo servo2;
int grados2 = 0; // GRADOS DEL SERVO 1

En la función setup(), inicializamos la comunicación serial y vinculamos cada servo a un pin digital de la placa Arduino.

void setup() {
   Serial.begin(9600);
   servo1.attach(5);
   servo2.attach(6);
}

El siguiente paso, es crear la función loop(). Primero, debemos saber si la palanca del joystick se mueve, leemos los valores del eje X e Y, con una pausa en medio para estabilizar las lecturas:

X = analogRead(pinX);
delay(10);
Y = analogRead(pinY);

Seguidamente, traducimos las lecturas a valores entre 0 y 180 grados para girar los servos:

grados1 = map(X, 0, 1023, 180, 0);
grados2 = map(Y, 0, 1023, 0, 180);

Se utiliza la función map() para transformar los valores dentro del rango que deseamos. El eje x, es el servo inferior (2), se moverá hacia la izquierda si las lecturas son mayores de 90º, y si son menores de 90º, hará un movimiento hacia la derecha. El servo 1, el superior, es el encargado del eje y, movimiento vertical, se moverá hacia arriba cuando es menor de 90º y moverá la plataforma superior hacia abajo cuando sea mayor de 90º. Todo esto depende de cómo hayamos colocado el joystick respecto a los servos y a la plataforma.

Por último, hacemos que nos muestre X e Y por el monitor serial, y procedemos a girar los servos:

Serial.print("X:" );
Serial.println(grados1);
Serial.print("Y:" );
Serial.println(grados2);

servo1.write(grados1);
servo2.write(grados2);
delay(40);

Código completo:

#include "Servo.h"  // librería para poder controlar el servo
const int pinX = A0;
const int pinY = A1;
int X = 0;
int Y = 0;

Servo servo1;   // Crea un objeto servo
int grados1 = 0; // GRADOS DEL SERVO 1
Servo servo2;
int grados2 = 0; // GRADOS DEL SERVO 1
 
void setup() {
   Serial.begin(9600);
   servo1.attach(5);
   servo2.attach(6);
}
 
void loop() {
   //leer valores
   X = analogRead(pinX);
   delay(10);
   Y = analogRead(pinY);
   
   grados1 = map(X, 0, 1023, 180, 0);
   grados2 = map(Y, 0, 1023, 0, 180);

   Serial.print("X:" );
   Serial.println(grados1);
   Serial.print("Y:" );
   Serial.println(grados2);

   servo1.write(grados1);
   servo2.write(grados2);
   delay(40);
}

Plataforma móvil que guarda su posición

En el código anterior, la plataforma móvil vuelve a su posición original si dejamos de mantener la palanca del joystick. Si, por el contrario, lo que nos interesa es que la plataforma mantenga su posición y que se mueva a una velocidad constante:

Comprobemos el código inferior.

#include "Servo.h"  // librería para poder controlar el servo
const int pinX = A0;
const int pinY = A1;
int X = 0;
int Y = 0;
int velocidad = 10;

Servo servo1;   // Crea un objeto servo1
Servo servo2;
// posición inicial
int grados1 = 90; // GRADOS DEL SERVO 1
int grados2 = 0; // GRADOS DEL SERVO 2
 
void setup() {
   servo1.attach(5); // eje horizontal
   servo2.attach(6); // eje vertical
   servo1.write (grados1);  // ubicamos el servo en su posición inicial
   servo2.write (grados2); 
}
 
void loop() {
   //leer valores
   X = analogRead(pinX);
   delay(10);
   Y = analogRead(pinY);

   if (X > 700){ // derecha
    grados1 = grados1 - velocidad;
    if(grados1 < 0) grados1 = 0;
   }
   if (X < 400){ // izquierda
    grados1 = grados1 + velocidad;
    if(grados1 > 180) grados1 = 180;
   }
   if (Y > 700){  // hacia abajo
    grados2 = grados2 + velocidad;
    if(grados2 > 150) grados2 = 150;
   }
   if (Y < 400){ // hacia arriba
    grados2 = grados2 - velocidad;
    if(grados2 < 0) grados2 = 0;
   }

   servo1.write(grados1);
   servo2.write(grados2);
   delay(40);  // Esperamos
}

Explicación del código:

Se ha añadido una nueva variable denominada velocidad, es la que va hacer que los servos se muevan más rápido o más despacio, si su valor es 1 se moverá de grado en grado.

if (X > 700){ // derecha
  grados1 = grados1 - velocidad;
  if(grados1 < 0) grados1 = 0;
}

En la función loop() comprobamos hacia dónde estamos moviendo la palanca del joystick. Sabemos que los valores analógicos que nos proporciona Arduino en x e y, pueden ser de 0 a 1023, donde 511 es el valor medio, para asegurarnos de que se está moviendo hacia la derecha, comprobamos que la lectura sea mayor de 700 en el eje x, en este caso se resta a la posición que tenemos en la variable grados1 la variable velocidad; seguidamente, se comprueba que no sea menor de 0, esto es para que no nos pueda dar una posición menor de 0º.

Realizamos el mismo proceso para el movimiento hacia la izquierda, para subir y para bajar.