Control Inalámbrico de Coche Robot Arduino con HC-05, NRF24L01 y HC-12

En este tutorial aprenderemos a controlar inalámbricamente el coche robot Arduino que construimos en el video anterior. Te mostraré tres métodos diferentes de control inalámbrico: usando el módulo Bluetooth HC-05, el transceptor NRF24L01 y el módulo inalámbrico de largo alcance HC-12, así como el control mediante smartphone y una aplicación Android personalizada. Puedes ver el video o leer el tutorial escrito.

Ya tengo tutoriales sobre cómo conectar y usar cada uno de estos módulos con Arduino, así que si necesitas más detalles puedes consultarlos. Los enlaces están en el artículo.

Control del coche robot Arduino usando módulo HC-05 Bluetooth

Comenzamos con la comunicación Bluetooth, para lo que necesitamos dos módulos HC-05 que deben configurarse como maestro y esclavo.

Control Inalámbrico de Coche Robot Arduino con HC-05, NRF24L01 y HC-12

Podemos hacerlo fácilmente usando comandos AT. Configuré el joystick como maestro y el coche robot como esclavo. Esquema completo del circuito:

Componentes necesarios:

Módulo Bluetooth HC-05 ………….…
Módulo Joystick ………………………….
Baterías 18650 …………………………..
Cargador de baterías 18650…………………
Controlador L298N ……………………………..
Motor DC de alto torque 12V …………
Placa Arduino ……………………………

Código fuente

Usaremos el mismo código del tutorial anterior, donde controlamos el coche robot directamente con el joystick, y haremos algunas modificaciones.

Código HC-05 Maestro (Joystick):

/* Control inalámbrico coche robot Arduino con HC-05 Bluetooth
== DISPOSITIVO MAESTRO - Joystick ==
by Dejan Nedelkovski, www.HowToMechatronics.com */
int xAxis, yAxis;

void setup() {
  Serial.begin(38400); // Velocidad de comunicación por defecto del módulo Bluetooth
}

void loop() {
  xAxis = analogRead(A0); // Leer eje X del joystick
  yAxis = analogRead(A1); // Leer eje Y del joystick
  // Enviar valores por puerto serial al dispositivo esclavo HC-05
  Serial.write(xAxis/4); // Dividir por 4 para convertir 0-1023 a 0-255 (1 byte)
  Serial.write(yAxis/4);
  delay(20);
}

El código en el dispositivo maestro (joystick) es simple. Leemos los valores X e Y del joystick, que regulan la velocidad de los motores, y los enviamos por el puerto serial al dispositivo esclavo HC-05. Los valores analógicos del joystick (0-1023) se convierten a 0-255 dividiéndolos por 4.

Hacemos esto porque ese rango (0-255) puede enviarse por Bluetooth como 1 byte, más fácil de recibir en el otro lado (el coche robot).

En el lado receptor, si el puerto serial ha recibido los 2 bytes (valores X e Y), usando Serial.read() los leemos:

// Código del coche robot Arduino
// Leer datos entrantes del joystick o dispositivo maestro Bluetooth
while (Serial.available() >= 2) {
  x = Serial.read();
  delay(10);
  y = Serial.read();
}

Ahora convertimos los valores de vuelta al rango 0-1023, adecuado para el código de control de motores:

// Código del coche robot Arduino
// Convertir de rango 0-255 a 0-1023 para control de motores
xAxis = x*4;
yAxis = y*4;

Nota: Al subir el código, desconecta los pines RX y TX del Arduino.

Código completo HC-05 Esclavo (Coche robot):

/* Control inalámbrico coche robot Arduino con HC-05 Bluetooth
== DISPOSITIVO ESCLAVO - Coche robot Arduino ==
by Dejan Nedelkovski, www.HowToMechatronics.com */
#define enA 9
#define in1 4
#define in2 5
#define enB 10
#define in3 6
#define in4 7
int xAxis, yAxis;
unsigned int x = 0;
unsigned int y = 0;
int motorSpeedA = 0;
int motorSpeedB = 0;

void setup() {
  pinMode(enA, OUTPUT);
  pinMode(enB, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
  Serial.begin(38400); // Velocidad de comunicación por defecto del módulo Bluetooth
}

void loop() {
  // Valor por defecto - sin movimiento cuando el joystick está en el centro
  x = 510 / 4;
  y = 510 / 4;
  // Leer datos entrantes del joystick o dispositivo maestro Bluetooth
  while (Serial.available() >= 2) {
    x = Serial.read();
    delay(10);
    y = Serial.read();
  }
  delay(10);
  // Convertir de rango 0-255 a 0-1023 para control de motores
  xAxis = x*4;
  yAxis = y*4;
  // Eje Y para control adelante/atrás
  if (yAxis < 470) {
    // Motor A atrás
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    // Motor B atrás
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    // Convertir lecturas Y descendentes (470 a 0) en PWM 0-255
    motorSpeedA = map(yAxis, 470, 0, 0, 255);
    motorSpeedB = map(yAxis, 470, 0, 0, 255);
  } else if (yAxis > 550) {
    // Motor A adelante
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    // Motor B adelante
    digitalWrite(in3, LOW);
    digitalWrite(in4, HIGH);
    // Convertir lecturas Y ascendentes (550 a 1023) en PWM 0-255
    motorSpeedA = map(yAxis, 550, 1023, 0, 255);
    motorSpeedB = map(yAxis, 550, 1023, 0, 255);
  } else {
    motorSpeedA = 0;
    motorSpeedB = 0;
  }
  // Eje X para control izquierda/derecha
  if (xAxis < 470) {
    int xMapped = map(xAxis, 470, 0, 0, 255);
    // Girar izquierda - reducir motor izquierdo, aumentar derecho
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    if (motorSpeedA < 0) motorSpeedA = 0;
    if (motorSpeedB > 255) motorSpeedB = 255;
  }
  if (xAxis > 550) {
    int xMapped = map(xAxis, 550, 1023, 0, 255);
    // Girar derecha - reducir motor derecho, aumentar izquierdo
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    if (motorSpeedA > 255) motorSpeedA = 255;
    if (motorSpeedB < 0) motorSpeedB = 0;
  }
  // Evitar zumbido a bajas velocidades (ajustar según tus motores)
  if (motorSpeedA < 70) motorSpeedA = 0;
  if (motorSpeedB < 70) motorSpeedB = 0;
  analogWrite(enA, motorSpeedA);
  analogWrite(enB, motorSpeedB);
}

Control con Smartphone y App Android personalizada

Veamos cómo controlar el coche robot con una app Android personalizada. El esquema del coche es el mismo que el ejemplo anterior, con el HC-05 en modo esclavo.

Usando MIT App Inventor crearemos nuestra app. Básicamente simula un joystick hecho con dos imágenes (image sprites).

En los bloques de la app, al arrastrar el sprite del joystick, la bola se mueve a la posición del dedo y enviamos los valores X e Y por Bluetooth al Arduino. Estos valores se reciben igual que antes con Serial.read().

// Leer datos entrantes de la app Android smartphone
while (Serial.available() >= 2) {
  x = Serial.read();
  delay(10);
  y = Serial.read();
}

Además, convertimos los valores X e Y recibidos del smartphone al rango 0-1023. Estos valores dependen del tamaño del canvas; en mi app eran de 60 a 220, que convertí con map():

// Asegurar valores correctos
if (x > 60 && x < 220) {
  xAxis = map(x, 220, 60, 1023, 0); // Convertir valores smartphone X a 0-1023
}
if (y > 60 && y < 220) {
  yAxis = map(y, 220, 60, 0, 1023); // Convertir valores smartphone Y a 0-1023
}

Cuando se suelta el sprite, la bola vuelve al centro y se envían valores para detener el coche. Puedes descargar la app e imágenes en el artículo web.

Descargas disponibles:

Arduino_Robot_Car_Joystick_App.apk

1 archivo(s) 1.62 MB Descargar Control Inalámbrico de Coche Robot Arduino con HC-05, NRF24L01 y HC-12

Arduino_Robot_Car_Joystick_App_aia_file

1 archivo(s) 171.20 KB Descargar Control Inalámbrico de Coche Robot Arduino con HC-05, NRF24L01 y HC-12

Imágenes Joystick App

1 archivo(s) 44.36 KB Descargar

Código completo Arduino (Esclavo con app):

/* Control inalámbrico coche robot Arduino con HC-05 Bluetooth y app Android
== DISPOSITIVO ESCLAVO - Coche robot Arduino ==
by Dejan Nedelkovski, www.HowToMechatronics.com */
#define enA 9
#define in1 4
#define in2 5
#define enB 10
#define in3 6
#define in4 7
int xAxis, yAxis;
int x = 0;
int y = 0;
int motorSpeedA = 0;
int motorSpeedB = 0;

void setup() {
  pinMode(enA, OUTPUT);
  pinMode(enB, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
  Serial.begin(38400); // Velocidad de comunicación por defecto del módulo Bluetooth
}

void loop() {
  // Valor por defecto - sin movimiento cuando el joystick está en el centro
  xAxis = 510;
  yAxis = 510;
  // Leer datos entrantes de la app Android smartphone
  while (Serial.available() >= 2) {
    x = Serial.read();
    delay(10);
    y = Serial.read();
  }
  delay(10);
  // Asegurar valores correctos
  if (x > 60 && x < 220) {
    xAxis = map(x, 220, 60, 1023, 0);
  }
  if (y > 60 && y < 220) {
    yAxis = map(y, 220, 60, 0, 1023);
  }
  // Eje Y para control adelante/atrás
  if (yAxis < 470) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    motorSpeedA = map(yAxis, 470, 0, 0, 255);
    motorSpeedB = map(yAxis, 470, 0, 0, 255);
  } else if (yAxis > 550) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    digitalWrite(in3, LOW);
    digitalWrite(in4, HIGH);
    motorSpeedA = map(yAxis, 550, 1023, 0, 255);
    motorSpeedB = map(yAxis, 550, 1023, 0, 255);
  } else {
    motorSpeedA = 0;
    motorSpeedB = 0;
  }
  // Eje X para control izquierda/derecha
  if (xAxis < 470) {
    int xMapped = map(xAxis, 470, 0, 0, 255);
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    if (motorSpeedA < 0) motorSpeedA = 0;
    if (motorSpeedB > 255) motorSpeedB = 255;
  }
  if (xAxis > 550) {
    int xMapped = map(xAxis, 550, 1023, 0, 255);
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    if (motorSpeedA > 255) motorSpeedA = 255;
    if (motorSpeedB < 0) motorSpeedB = 0;
  }
  // Evitar zumbido a bajas velocidades
  if (motorSpeedA < 70) motorSpeedA = 0;
  if (motorSpeedB < 70) motorSpeedB = 0;
  analogWrite(enA, motorSpeedA);
  analogWrite(enB, motorSpeedB);
}

Control inalámbrico con módulo transceptor NRF24L01

Pasamos al siguiente método: control inalámbrico con módulos transceptores NRF24L01.

Esquema del circuito. Estos módulos usan comunicación SPI, así que moví los pines Enable A y B del L298N a los pines 2 y 3 del Arduino.

Código fuente

Necesitamos instalar la librería RF24. Similar al ejemplo anterior, tras definir pines y configurar el módulo como transmisor, leemos X e Y del joystick y los enviamos al otro NRF24L01 en el coche robot.

Las lecturas analógicas son Strings, que con string.toCharArray() pasamos a array de caracteres. Luego con radio.write() enviamos el array.

Código Transmisor (Joystick):

/* Control inalámbrico coche robot Arduino con NRF24L01
== Transmisor - Joystick ==
by Dejan Nedelkovski, www.HowToMechatronics.com
Librería: TMRh20/RF24, https://github.com/tmrh20/RF24/ */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(8, 9); // CE, CSN
const byte address[6] = "00001";
char xyData[32] = "";
String xAxis, yAxis;

void setup() {
  Serial.begin(9600);
  radio.begin();
  radio.openWritingPipe(address);
  radio.setPALevel(RF24_PA_MIN);
  radio.stopListening();
}

void loop() {
  xAxis = analogRead(A0);
  yAxis = analogRead(A1);
  // Valor X
  xAxis.toCharArray(xyData, 5);
  radio.write(&xyData, sizeof(xyData));
  // Valor Y
  yAxis.toCharArray(xyData, 5);
  radio.write(&xyData, sizeof(xyData));
  delay(20);
}

En el lado receptor (coche robot), configuramos el módulo como receptor y recibimos con radio.read(). Luego con atoi() convertimos los datos recibidos a enteros para el control de motores.

// Código coche robot - ejemplo NRF24L01
if (radio.available()) {
  radio.read(&receivedData, sizeof(receivedData));
  xAxis = atoi(&receivedData[0]);
  delay(10);
  radio.read(&receivedData, sizeof(receivedData));
  yAxis = atoi(&receivedData[0]);
  delay(10);
}

Código Receptor (Coche robot):

/* Control inalámbrico coche robot Arduino con NRF24L01
== Receptor - Coche robot Arduino ==
by Dejan Nedelkovski, www.HowToMechatronics.com
Librería: TMRh20/RF24, https://github.com/tmrh20/RF24/ */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#define enA 2 // Nota: Pin 9 en video anterior (pin 10 usado para SPI NRF24L01)
#define in1 4
#define in2 5
#define enB 3 // Nota: Pin 10 en video anterior
#define in3 6
#define in4 7
RF24 radio(8, 9); // CE, CSN
const byte address[6] = "00001";
char receivedData[32] = "";
int xAxis, yAxis;
int motorSpeedA = 0;
int motorSpeedB = 0;

void setup() {
  pinMode(enA, OUTPUT);
  pinMode(enB, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
  Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setPALevel(RF24_PA_MIN);
  radio.startListening();
}

void loop() {
  if (radio.available()) {
    radio.read(&receivedData, sizeof(receivedData));
    xAxis = atoi(&receivedData[0]);
    delay(10);
    radio.read(&receivedData, sizeof(receivedData));
    yAxis = atoi(&receivedData[0]);
    delay(10);
  }
  // Control motores (igual que ejemplos anteriores)
  if (yAxis < 470) {
    digitalWrite(in1, HIGH); digitalWrite(in2, LOW);
    digitalWrite(in3, HIGH); digitalWrite(in4, LOW);
    motorSpeedA = map(yAxis, 470, 0, 0, 255);
    motorSpeedB = map(yAxis, 470, 0, 0, 255);
  } else if (yAxis > 550) {
    digitalWrite(in1, LOW); digitalWrite(in2, HIGH);
    digitalWrite(in3, LOW); digitalWrite(in4, HIGH);
    motorSpeedA = map(yAxis, 550, 1023, 0, 255);
    motorSpeedB = map(yAxis, 550, 1023, 0, 255);
  } else {
    motorSpeedA = 0; motorSpeedB = 0;
  }
  if (xAxis < 470) {
    int xMapped = map(xAxis, 470, 0, 0, 255);
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    if (motorSpeedA < 0) motorSpeedA = 0;
    if (motorSpeedB > 255) motorSpeedB = 255;
  }
  if (xAxis > 550) {
    int xMapped = map(xAxis, 550, 1023, 0, 255);
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    if (motorSpeedA > 255) motorSpeedA = 255;
    if (motorSpeedB < 0) motorSpeedB = 0;
  }
  if (motorSpeedA < 70) motorSpeedA = 0;
  if (motorSpeedB < 70) motorSpeedB = 0;
  analogWrite(enA, motorSpeedA);
  analogWrite(enB, motorSpeedB);
}

Control inalámbrico con transceptor de largo alcance HC-12

Último método: módulos transceptores HC-12 de largo alcance (hasta 1.8 km).

El esquema es casi igual al de HC-05, ya que usan el mismo método de comunicación serial.

Código fuente

El código del joystick es idéntico al de Bluetooth. Leemos valores analógicos y los enviamos con Serial.write().

Código Transmisor:

/* Control inalámbrico coche robot Arduino con HC-12 largo alcance
== Transmisor - Joystick ==
by Dejan Nedelkovski, www.HowToMechatronics.com */
int xAxis, yAxis;

void setup() {
  Serial.begin(9600); // Velocidad de comunicación por defecto
}

void loop() {
  xAxis = analogRead(A0);
  yAxis = analogRead(A1);
  Serial.write(xAxis/4); // Convertir 0-1023 a 0-255 (1 byte)
  Serial.write(yAxis/4);
  delay(20);
}

En el receptor, esperamos datos con while(), leemos con Serial.read() y convertimos de vuelta a 0-1023.

Código Receptor:

/* Control inalámbrico coche robot Arduino con HC-12 largo alcance
== Receptor - Coche robot Arduino ==
by Dejan Nedelkovski, www.HowToMechatronics.com */
#define enA 9
#define in1 4
#define in2 5
#define enB 10
#define in3 6
#define in4 7
int xAxis, yAxis;
int x = 0;
int y = 0;
int motorSpeedA = 0;
int motorSpeedB = 0;

void setup() {
  pinMode(enA, OUTPUT);
  pinMode(enB, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
  Serial.begin(9600); // Velocidad de comunicación por defecto
}

void loop() {
  // Valor por defecto - sin movimiento
  xAxis = 510;
  yAxis = 510;
  // Leer datos entrantes
  while (Serial.available() == 0) {}
  x = Serial.read();
  delay(10);
  y = Serial.read();
  delay(10);
  // Convertir 0-255 a 0-1023
  xAxis = x * 4;
  yAxis = y * 4;
  // Control motores (igual que ejemplos anteriores)
  if (yAxis < 470) {
    digitalWrite(in1, HIGH); digitalWrite(in2, LOW);
    digitalWrite(in3, HIGH); digitalWrite(in4, LOW);
    motorSpeedA = map(yAxis, 470, 0, 0, 255);
    motorSpeedB = map(yAxis, 470, 0, 0, 255);
  } else if (yAxis > 550) {
    digitalWrite(in1, LOW); digitalWrite(in2, HIGH);
    digitalWrite(in3, LOW); digitalWrite(in4, HIGH);
    motorSpeedA = map(yAxis, 550, 1023, 0, 255);
    motorSpeedB = map(yAxis, 550, 1023, 0, 255);
  } else {
    motorSpeedA = 0; motorSpeedB = 0;
  }
  if (xAxis < 470) {
    int xMapped = map(xAxis, 470, 0, 0, 255);
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    if (motorSpeedA < 0) motorSpeedA = 0;
    if (motorSpeedB > 255) motorSpeedB = 255;
  }
  if (xAxis > 550) {
    int xMapped = map(xAxis, 550, 1023, 0, 255);
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    if (motorSpeedA > 255) motorSpeedA = 255;
    if (motorSpeedB < 0) motorSpeedB = 0;
  }
  if (motorSpeedA < 70) motorSpeedA = 0;
  if (motorSpeedB < 70) motorSpeedB = 0;
  analogWrite(enA, motorSpeedA);
  analogWrite(enB, motorSpeedB);
}

Esto es todo para este tutorial. Preguntas en los comentarios.