Como montar un robot controlado por radiofrecuencia

Hoy en nuestro blog, explicamos como construir tu propio robot con Arduino y controlarlo por radiofrecuencia. Es un proyecto interesante, por que manejaremos radiofrecuencia, ademas de aprender a leer la información de un joystick y procesarla.

Componentes utilizados.

-2 placas Arduino UNO Rev3. Esta será la placa encargada de recibir la información procedente del modulo de RF y procesarla para hacer las gestiones necesarias. Además la segunda placa será responsable de leer lo que sucede en el joystick y enviar esa información atravez del modulo RF.(Más información aquí)

-Chasis robot 4WD. Sobre este chasis, montaremos toda la electrónica necesaria para manejar nuestro robot. (Más información aquí)

-2 Módulos RF NRF24L01. Con estos módulos comunicaremos el Arduino que tenemos en el mando con el Arduino del robot.(Más información aquí)

-Controlador de motores L298N. Este es el encargado de aportar potencia a las señales de procedentes de nuestro Arduino Uno para controlar los motores.(Más información aquí)

-Cables protoboard. Estos cables los usamos para conectar todos los componentes que componen nuestro robot.(Más información aquí)

Proceso operativo

-El primer paso para desarrollar nuestro proyecto es hacer un esquema que nos indique el modo de conexión de todos los componentes de nuestro robot. (Ver esquema)

-A continuación cableamos toda la electrónica tal y como nos indica el esquema de conexión.

-Escribimos y compilamos el código, que manejara el robot. (Ver código)

-El último paso es probar el robot y depurar el programa hasta conseguir que funcione como deseamos.

Esquema de conexión.

-En el siguiente esquema se representan las conexiones del control TX.

-En el siguiente esquema se representan las conexiones del robot RX.

Código.

Este primer código es el ecargado de manejar el mando de control de robot.

/**
 * A Mirf example to test the latency between two Ardunio.
 *
 * Pins:
 * Hardware SPI:
 * MISO -> 12
 * MOSI -> 11
 * SCK -> 13
 *
 * Configurable:
 * CE -> 10
 * CSN -> 9
 *
 * Note: To see best case latency comment out all Serial.println
 * statements not displaying the result and load 
 * 'ping_server_interupt' on the server.
 */

#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>

void setup(){
  Serial.begin(9600);
  Mirf.cePin = 10;                // Cambiamos el pin CE del standar ya que usamos un shield para el joystick que no concuerda los pines con la librería
  Mirf.csnPin = 9;                // Cambiamos el pin CSN del standar ya que usamos un shield para el joystick que no concuerda los pines con la librería
  Mirf.spi = &MirfHardwareSpi;    // Configuramos el SPI de Arduino por Hardware
  Mirf.init();                    // Inciamos el módulo de RF
  Mirf.setRADDR((byte *)"clie1"); // Indicamos la dirección para recibir datos
  Mirf.payload = 4;               // Indicamos el número de datos que se espera recibir
  Mirf.config();                  // Configuramos el módulo de RF 
}

void loop(){
  uint8_t datos[Mirf.payload];    // Creamos un array con el tamaño de los datos que recibe el modulo RF
  int valor[2];                   // Variables que son modificadas según valor del joystick
  double calculos[3];             // Estas variables la usamos para calcular la velocidad que debe mandar, según posición del mando
  int vector;                     // Variable que calcula un vectos y nos dice la distancia a la que está el joystick del centro
  
  valor[0]=(analogRead(0)/2.01)-253;  // Leemos el ADC y calculamos para que de aproximadamente uno +-255 de máximo
  valor[1]=(analogRead(1)/2.01)-246;  // Leemos el ADC y calculamos para que de aproximadamente uno +-255 de máximo
  if(valor[0] >255){valor[0]=255;} if(valor[0] < -255){valor[0]=-255;}  // Nos aseguramos que no sobrepase los +255 y os -255
  if(valor[1] >255){valor[1]=255;} if(valor[1] < -255){valor[1]=-255;}  // Nos aseguramos que no sobrepase los +255 y os -255
  
  calculos[0]=valor[0];  // Copiamos los valores las variables calculo para su posterior procesamiento
  calculos[1]=valor[1];  // Copiamos los valores las variables calculo para su posterior procesamiento

  calculos[3]=sqrt((calculos[0]*calculos[0])+(calculos[1]*calculos[1]));  // Calculamos la distancia a la que está el joystick del centro 
  if(valor[0] < 0){calculos[3] *= -1;}                                    // Si es menor que 0, lo ponemos en negativo ya que el cálculo anterior no lo hace
  
  if(calculos[3] > 255){calculos[3]=255;}         // Nos aseguramos que no sea mayor que 255
  if(calculos[3] < -255){calculos[3]=-255;}       // Nos aseguramos que no sea menor que -255
  vector=calculos[3];                             // Pasamos el valor calculado que lleva decimales a una variable de 16 bit y eliminamos los decimales para enviarla posteriormente
  valor[1]=(analogRead(1)/5.11)-100;              // Volvemos a leer el joystick (Eje X) para que nos de un valor de +-100 que es lo que usa la librería del robot en el giro
  if(valor[1] > 99){valor[1]=99;}                 // Nos aseguramos que no sea mayor que 99 ya que 100 el robot lo entiende como giro sobre su propio eje
  if(valor[1] < -99){valor[1]=-99;}               // Nos aseguramos que no sea menor que -99 ya que -100 el robot lo entiende como giro sobre su propio eje
  
  datos[2]=vector>>8;        // Dividimos el vector que son 16bit en dos variables de 8 bit (2 byte) 
  datos[3]=vector;           // Dividimos el vector que son 16bit en dos variables de 8 bit (2 byte) 
  datos[0]=valor[1]>>8;      // Dividimos la variable valor que son 16bit en dos variables de 8 bit (2 byte)
  datos[1]=valor[1];         // Dividimos la variable valor que son 16bit en dos variables de 8 bit (2 byte)
  
  Mirf.setTADDR((byte *)"serv1");  // Configuramos la dirección a donde vamos a enviar los datos
  Mirf.send(datos);                // Enviamos los datos 
  while(Mirf.isSending()){}        // Esperamos que termine la emisión
  
  Serial.print("Vector: ");   // Enviamos los datos por terminal para depurar el control
  Serial.print(" ");          // Enviamos los datos por terminal para depurar el control
  Serial.print(vector);       // Enviamos los datos por terminal para depurar el control
  Serial.print(" ");          // Enviamos los datos por terminal para depurar el control
  Serial.print("Valor 0 ");   // Enviamos los datos por terminal para depurar el control
  Serial.print(valor[0]);     // Enviamos los datos por terminal para depurar el control
  Serial.print(" ");          // Enviamos los datos por terminal para depurar el control
  Serial.print("Valor 1 ");   // Enviamos los datos por terminal para depurar el control
  Serial.println(valor[1]);   // Enviamos los datos por terminal para depurar el control
  
  
  

Este siguiente código es el encargado de recibir la información del mando de control y gestionarla para hacer que el robot se mueva.

// Incluimos la librería de los motores
#include <LEANTEC_ControlMotor.h>
// Configuramos los pines que vamos a usar
ControlMotor control(2,3,4,9,5,6); // MotorDer1,MotorDer2,MotorIzq1,MotorIzq2,PWM_Derecho,PWM_Izquierdo
int led = 10;
int memoled= 0;
/**
 * An Mirf example which copies back the data it recives.
 *
 * Pins:
 * Hardware SPI:
 * MISO -> 12
 * MOSI -> 11
 * SCK -> 13
 *
 * Configurable:
 * CE -> 8
 * CSN -> 7
 *
 */
 
#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>

unsigned long time=0;    // Variable para controlar el tiempo entre dato y dato
int valor[2];            // Variable para almacenar la dirección y la velocidad

//----------------------------- Configuramos Ardunio ---------------------------------------
//------------------------------------------------------------------------------------------
void setup(void){
  pinMode(led, OUTPUT);
  Serial.begin(9600);
  Mirf.spi = &MirfHardwareSpi;    // Configuramos el SPI de Arduino por Hardware
  Mirf.init();                    // Inciamos el módulo de RF
  Mirf.setRADDR((byte *)"serv1"); // Indicamos la dirección para recibir datos
  Mirf.payload = 4;               // Indicamos el número de datos que se espera recibir
  Mirf.config();                  // Configuramos el módulo de RF
  time=0;                         // Ponemos a 0 el tiempo
}
//--------------------------- Arrancamos el programa ---------------------------------------
//------------------------------------------------------------------------------------------
void loop(void)
{
  byte datos[Mirf.payload];      // Buffer para almacenar los datos

  if(!Mirf.isSending() && Mirf.dataReady()){ // Esperamos recibir un dato
    Mirf.getData(datos);       // Copiamos al buffer los datos recibidos
    time = millis();           // Almacenamos el tiempo en la variable
    valor[0]=(datos[0]<<8)+datos[1];  // Como lo que recibimos son 4 byte (2 variables de 16bit) tenemos que unirla
    valor[1]=(datos[2]<<8)+datos[3];  // Como lo que recibimos son 4 byte (2 variables de 16bit) tenemos que unirla
    Serial.print("Robot ");    // Línea para ver en el terminal que recibe el robot
    Serial.print(valor[0]);    // Línea para ver en el terminal que recibe el robot
    Serial.print(" ");         // Línea para ver en el terminal que recibe el robot
    Serial.println(valor[1]);  // Línea para ver en el terminal que recibe el robot
    if(memoled<25)
    {digitalWrite(led, LOW);}
    if((memoled>25)&&(memoled<35))
    {digitalWrite(led, HIGH);}
    if(memoled>35)
    {memoled=0;}
    memoled++;
  
  }
  
  if ( ( millis() - time ) > 1000 ) {   // Comprobamos si desde la última vez que recibimos un dato hasta ahora ha pasado mas de 1 seg
    control.Motor(0,0);                 // Si ha pasado mas de 1 seg, paramos le robot ya que no hay recepción de datos
    Serial.println("Error de recepcion de datos"); // Línea para ver en el terminal que recibe el robot  
    delay(500);     // Paramos 0,5 seg el robot
    digitalWrite(led, HIGH);
  }
  else{                                 // Si todo está correcto y estamos recibiendo datos, seguimos
    control.Motor(valor[1], valor[0]);  // Pasamos los datos al control de motores.
  }
  
}

Imágenes del proyecto.

-En la siguiente imagen vemos el robot ya montado, con una cámara instalada en su parte superior.

Video del robot funcionando