Te mostraré tres métodos diferentes de control inalámbrico, usando el módulo Bluetooth HC-05, el módulo transceptor NRF24L01 y el módulo inalámbrico de largo alcance HC-12, así como también usando un teléfono inteligente y una aplicación de Android hecha a medida. Puede ver el siguiente video o leer el tutorial escrito a continuación para obtener más detalles.

Ya tengo tutoriales sobre cómo conectar y usar cada uno de estos módulos con la placa Arduino, así que si necesitas más detalles siempre puedes consultarlos. Los enlaces a cada uno de ellos se pueden encontrar a continuación en el artículo.

Control de coche robot Arduino mediante módulo Bluetooth HC-05

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

Podemos hacer eso fácilmente usando comandos AT, y configuro el joystick para que sea un maestro y el coche robot Arduino para que sea un esclavo. Aquí está el esquema del circuito completo para este ejemplo:

Componentes necesarios 

• Módulo Bluetooth HC-05
• Módulo de joystick
• Baterías 18650
• Cargador de batería 18650
• Controlador L298N
• Motor de CC de alto par de 12 V
• Arduino UNO
• Arduino NANO
• Resistencia 1k y 2k
• Cables para conectar
• Protoboard

Código fuente

/
int xAxis, yAxis;
configuración vacía () {  
  De serie. comenzar ( 38400 ) ; // Tasa de comunicación predeterminada del módulo Bluetooth
}
bucle vacío () {  
  xAxis = analogRead ( A0 ) ; // Leer Joysticks eje X
  yAxis = analogRead ( A1 ) ; // Leer Joysticks eje Y
  
  // Enviar los valores a través del puerto serie al dispositivo Bluetooth esclavo HC-05
  De serie. escribir ( xAxis / 4 ) ; // Dividir por 4 para convertir de 0-1023 a 0-256, rango (1 byte)
  De serie. escribir ( yAxis / 4 ) ;
  retraso ( 20 ) ;
}

El código en el dispositivo maestro o el joystick es bastante simple. Solo necesitamos leer los valores X e Y del joystick, que en realidad regulan la velocidad de los motores, y enviarlos a través del puerto serie al dispositivo Bluetooth esclavo HC-05. Podemos notar aquí que los valores analógicos del joystick de 0 a 1023 se convierten en valores de 0 a 255 al sumergirlos en 4.

Hacemos esto porque ese rango, de 0 a 255, se puede enviar, a través del dispositivo Bluetooth, como 1 byte, que es más fácil de aceptar en el otro lado, o en el automóvil robot Arduino.

Entonces aquí, si el serial ha recibido los 2 bytes, los valores X e Y, usando la función Serial.read () los leeremos a ambos.

// Código del coche robot Arduino
// Leer los datos entrantes del Joystick o del dispositivo Bluetooth maestro
  while ( Serial. disponible () > = 2 ) {   
    x = Serie. leer () ;
    retraso ( 10 ) ;
    y = Serie. leer () ;
  }

Ahora solo tenemos que volver a convertir los valores al rango de 0 a 1023, adecuado para el código de control del motor a continuación, que ya explicamos cómo funciona en el video anterior.

// Código del coche robot Arduino
// Convierta de nuevo el rango 0-255 a 0-1023, adecuado para el código de control del motor a continuación
eje x = x * 4;
yAxis = y * 4;

Solo una nota rápida de que al cargar el código, debemos desconectar los pines RX y TX de la placa Arduino.

Código de esclavo HC-05 completo:

 /
#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;
configuración vacía () {  
  pinMode ( enA, SALIDA ) ;
  pinMode ( enB, SALIDA ) ;
  pinMode ( in1, SALIDA ) ;
  pinMode ( entrada2 , SALIDA ) ;
  pinMode ( in3, SALIDA ) ;
  pinMode ( in4, SALIDA ) ;
  De serie. comenzar ( 38400 ) ; // Tasa de comunicación predeterminada del módulo Bluetooth
}
bucle vacío () {  
  // Valor predeterminado: sin movimiento cuando el joystick permanece en el centro
  x = 510/4;
  y = 510/4;
  // Leer los datos entrantes del Joystick o del dispositivo Bluetooth maestro
  while ( Serial. disponible () > = 2 ) {   
    x = Serie. leer () ;
    retraso ( 10 ) ;
    y = Serie. leer () ;
  }
  retraso ( 10 ) ;
  // Convierta de nuevo el rango 0-255 a 0-1023, adecuado para el código de control del motor a continuación
  eje x = x * 4;
  yAxis = y * 4;
  // Eje Y utilizado para control hacia adelante y hacia atrás
  si ( yAxis < 470 ) {  
    // Pon el motor A hacia atrás
    digitalWrite ( in1, HIGH ) ;
    digitalWrite ( in2 , LOW ) ;
    // Pon el motor B hacia atrás
    digitalWrite ( in3, HIGH ) ;
    digitalWrite ( in4, BAJO ) ;
    // Convierta las lecturas decrecientes del eje Y para retroceder de 470 a 0 en un valor de 0 a 255 para la señal PWM para aumentar la velocidad del motor
    motorSpeedA = map ( yAxis, 470, 0, 0, 255 ) ;
    motorSpeedB = map ( yAxis, 470, 0, 0, 255 ) ;
  }
  else if ( yAxis > 550 ) {   
    // Pon el motor A hacia adelante
    digitalWrite ( in1, LOW ) ;
    digitalWrite ( in2 , HIGH ) ;
    // Pon el motor B hacia adelante
    digitalWrite ( in3, BAJO ) ;
    digitalWrite ( in4, HIGH ) ;
    // Convierta las lecturas crecientes del eje Y para avanzar de 550 a 1023 en un valor de 0 a 255 para la señal PWM para aumentar la velocidad del motor
    motorSpeedA = map ( yAxis, 550, 1023, 0, 255 ) ;
    motorSpeedB = map ( yAxis, 550, 1023, 0, 255 ) ;
  }
  // Si el joystick permanece en el medio, los motores no se mueven
  else { 
    motorSpeedA = 0;
    motorSpeedB = 0;
  }
  // Eje X utilizado para control izquierdo y derecho
  si ( xAxis < 470 ) {  
    // Convertir las lecturas decrecientes del eje X de 470 a 0 en un valor creciente de 0 a 255
    int xMapped = map ( xAxis, 470, 0, 0, 255 ) ;
    // Mover a la izquierda: disminuir la velocidad del motor izquierdo, aumentar la velocidad del motor derecho
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Confine el rango de 0 a 255
    si ( motorSpeedA < 0 ) {  
      motorSpeedA = 0;
    }
    if ( motorSpeedB > 255 ) {  
      motorSpeedB = 255;
    }
  }
  si ( xAxis > 550 ) {  
    // Convertir las lecturas crecientes del eje X de 550 a 1023 en valores de 0 a 255
    int xMapped = map ( xAxis, 550, 1023, 0, 255 ) ;
    // Mover a la derecha - disminuir la velocidad del motor derecho, aumentar la velocidad del motor izquierdo
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    // Confine el rango de 0 a 255
    if ( motorSpeedA > 255 ) {  
      motorSpeedA = 255;
    }
    si ( motorSpeedB < 0 ) {  
      motorSpeedB = 0;
    }
  }
  // Evite los zumbidos a bajas velocidades (ajuste de acuerdo con sus motores. Mis motores no podían comenzar a moverse si el valor de PWM estaba por debajo del valor de 70)
  si ( motorSpeedA < 70 ) {  
    motorSpeedA = 0;
  }
  si ( motorSpeedB < 70 ) {  
    motorSpeedB = 0;
  }
  analogWrite ( enA, motorSpeedA ) ; // Enviar señal PWM al motor A
  analogWrite ( enB, motorSpeedB ) ; // Enviar señal PWM al motor B
}

Control del coche robot Arduino mediante un teléfono inteligente y una aplicación de Android personalizada

A continuación, veamos cómo podemos controlar nuestro coche robot Arduino utilizando una aplicación de Android personalizada . El esquema del circuito del automóvil robot es exactamente el mismo que el del ejemplo anterior, con el modo Bluetooth HC-05 configurado como dispositivo esclavo.

Por otro lado, utilizando la aplicación en línea MIT App Inventor , crearemos nuestra propia aplicación para Android, y así es como se ve.

Básicamente, la aplicación simula un joystick, cuya apariencia está formada por dos imágenes o sprites de imágenes.

Si echamos un vistazo a los bloques de esta aplicación, podemos ver que cuando se arrastra el sprite del joystick, la imagen de la bola del joystick se mueve a la ubicación actual de nuestro dedo, y al mismo tiempo enviamos la X e Y valores a través del Bluetooth al automóvil Arduino.

Estos valores son aceptados por Arduino de la misma manera que en el ejemplo anterior, usando la función Serial.read.

// Leer los datos entrantes de la aplicación de Android para teléfonos inteligentes
  while ( Serial. disponible () > = 2 ) {   
    x = Serie. leer () ;
    retraso ( 10 ) ;
    y = Serie. leer () ;
  }

Lo que debemos hacer adicionalmente aquí es convertir los valores X e Y recibidos del teléfono inteligente en el rango de 0 a 1023, adecuado para el código de control del motor a continuación. Estos valores dependen del tamaño del lienzo, y los valores X e Y que obtenía de mi aplicación eran de 60 a 220, que con la función map () los convertí fácilmente.

// Se asegura de que recibamos los valores actuales
  si ( x > 60 y x < 220 ) {  
    xAxis = mapa ( x, 220, 60, 1023, 0 ) ; // Convierta los valores X e Y del teléfono inteligente al rango 0-1023, motor adecuado para el código de control del motor a continuación
  }
  if ( y > 60 & y < 220 ) {  
    yAxis = mapa ( y, 220, 60, 0, 1023 ) ;
  }

En los bloques de la aplicación, también podemos ver que cuando se retoca el sprite de la imagen, la bola del joystick vuelve al centro del lienzo y se envían los valores adecuados al automóvil para que deje de moverse. Puede encontrar y descargar esta aplicación en el artículo del sitio web, así como las dos imágenes del joystick para que pueda crear la suya propia o modificar esta aplicación.

Código completo de Arduino:

/
#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;
configuración vacía () {  
  pinMode ( enA, SALIDA ) ;
  pinMode ( enB, SALIDA ) ;
  pinMode ( in1, SALIDA ) ;
  pinMode ( entrada2 , SALIDA ) ;
  pinMode ( in3, SALIDA ) ;
  pinMode ( in4, SALIDA ) ;
  De serie. comenzar ( 38400 ) ; // Tasa de comunicación predeterminada del módulo Bluetooth
}
bucle vacío () {  
  // Valor predeterminado: sin movimiento cuando el joystick permanece en el centro
  xAxis = 510;
  yAxis = 510;
  // Leer los datos entrantes de la aplicación de Android para teléfonos inteligentes
  while ( Serial. disponible () > = 2 ) {   
    x = Serie. leer () ;
    retraso ( 10 ) ;
    y = Serie. leer () ;
  }
  retraso ( 10 ) ;
  
  // Se asegura de que recibamos los valores actuales
  si ( x > 60 y x < 220 ) {  
    xAxis = mapa ( x, 220, 60, 1023, 0 ) ; // Convierta los valores X e Y del teléfono inteligente al rango 0-1023, motor adecuado para el código de control del motor a continuación
  }
  if ( y > 60 & y < 220 ) {  
    yAxis = mapa ( y, 220, 60, 0, 1023 ) ;
  }
  // Eje Y utilizado para control hacia adelante y hacia atrás
  si ( yAxis < 470 ) {  
    // Pon el motor A hacia atrás
    digitalWrite ( in1, HIGH ) ;
    digitalWrite ( in2 , LOW ) ;
    // Pon el motor B hacia atrás
    digitalWrite ( in3, HIGH ) ;
    digitalWrite ( in4, BAJO ) ;
    // Convierta las lecturas decrecientes del eje Y para retroceder de 470 a 0 en un valor de 0 a 255 para la señal PWM para aumentar la velocidad del motor
    motorSpeedA = map ( yAxis, 470, 0, 0, 255 ) ;
    motorSpeedB = map ( yAxis, 470, 0, 0, 255 ) ;
  }
  else if ( yAxis > 550 ) {   
    // Pon el motor A hacia adelante
    digitalWrite ( in1, LOW ) ;
    digitalWrite ( in2 , HIGH ) ;
    // Pon el motor B hacia adelante
    digitalWrite ( in3, BAJO ) ;
    digitalWrite ( in4, HIGH ) ;
    // Convierta las lecturas crecientes del eje Y para avanzar de 550 a 1023 en un valor de 0 a 255 para la señal PWM para aumentar la velocidad del motor
    motorSpeedA = map ( yAxis, 550, 1023, 0, 255 ) ;
    motorSpeedB = map ( yAxis, 550, 1023, 0, 255 ) ;
  }
  // Si el joystick permanece en el medio, los motores no se mueven
  else { 
    motorSpeedA = 0;
    motorSpeedB = 0;
  }
  // Eje X utilizado para control izquierdo y derecho
  si ( xAxis < 470 ) {  
    // Convertir las lecturas decrecientes del eje X de 470 a 0 en un valor creciente de 0 a 255
    int xMapped = map ( xAxis, 470, 0, 0, 255 ) ;
    // Mover a la izquierda: disminuir la velocidad del motor izquierdo, aumentar la velocidad del motor derecho
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Confine el rango de 0 a 255
    si ( motorSpeedA < 0 ) {  
      motorSpeedA = 0;
    }
    if ( motorSpeedB > 255 ) {  
      motorSpeedB = 255;
    }
  }
  si ( xAxis > 550 ) {  
    // Convertir las lecturas crecientes del eje X de 550 a 1023 en valores de 0 a 255
    int xMapped = map ( xAxis, 550, 1023, 0, 255 ) ;
    // Mover a la derecha - disminuir la velocidad del motor derecho, aumentar la velocidad del motor izquierdo
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    // Confine el rango de 0 a 255
    if ( motorSpeedA > 255 ) {  
      motorSpeedA = 255;
    }
    si ( motorSpeedB < 0 ) {  
      motorSpeedB = 0;
    }
  }
  // Evite los zumbidos a bajas velocidades (ajuste de acuerdo con sus motores. Mis motores no podían comenzar a moverse si el valor de PWM estaba por debajo del valor de 70)
  si ( motorSpeedA < 70 ) {  
    motorSpeedA = 0;
  }
  si ( motorSpeedB < 70 ) {  
    motorSpeedB = 0;
  }
  analogWrite ( enA, motorSpeedA ) ; // Enviar señal PWM al motor A
  analogWrite ( enB, motorSpeedB ) ; // Enviar señal PWM al motor B
}

Control inalámbrico del coche robot Arduino mediante el módulo transceptor NRF24L01

Ahora podemos pasar al siguiente método, el control inalámbrico del coche robot Arduino utilizando los módulos transceptores NRF24L01 .

Aquí está el esquema del circuito. Podemos notar que estos módulos usan la comunicación SPI, por lo que en comparación con el ejemplo anterior, tuve que mover los pines Habilitar A y Habilitar B del controlador L298N a los pines número 2 y 3 de la placa Arduino.

Código fuente

Para este ejemplo, necesitamos instalar la biblioteca RF24. De manera similar al ejemplo anterior, después de definir algunos pines y configurar el módulo como transmisor, leemos los valores X e Y del joystick y los enviamos al otro módulo NRF24L01 en el carro robot Arduino.

Primero, podemos notar que las lecturas analógicas son cadenas, que usando la función cadena.toCharArray () se colocan en una matriz de caracteres. Luego, usando la función radio.write () enviamos los datos de la matriz de caracteres al otro módulo.

Código del transmisor:

 /
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
Radio RF24 ( 8, 9 ) ; // CE, CSN
dirección de byte constante [ 6 ] = "00001" ;
char xyData [ 32 ] = "" ;
String xAxis, yAxis;
configuración vacía () {  
  De serie. comenzar ( 9600 ) ;
  radio. empezar () ;
  radio. openWritingPipe ( dirección ) ;
  radio. setPALevel ( RF24_PA_MIN ) ;
  radio. stopListening () ;
}
bucle vacío () {  
  
  xAxis = analogRead ( A0 ) ; // Leer Joysticks eje X
  yAxis = analogRead ( A1 ) ; // Leer Joysticks eje Y
  // valor X
  xAxis. toCharArray ( xyData, 5 ) ; // Coloca la Cadena (Valor X) en una matriz de caracteres
  radio. escribir ( & xyData, sizeof ( xyData )) ; // Envía los datos de la matriz (valor X) al otro módulo NRF24L01
  // valor Y
  yAxis. toCharArray ( xyData, 5 ) ;
  radio. escribir ( & xyData, sizeof ( xyData )) ;
  retraso ( 20 ) ;
}

Por otro lado. en el coche robot Arduino, después de definir el módulo como receptor, aceptamos datos usando la función radio.read (). Luego, usando la función atoi (), convertimos los datos recibidos, o los valores X e Y del joystick, en valores enteros, que son adecuados para el código de control del motor a continuación.

// Código del coche robot Arduino - ejemplo NRF24L01
if ( radio. available ()) { // Si el módulo NRF240L01 recibió datos    
    radio. leer ( y datos recibidos, tamaño de (datos recibidos )) ; // Leer los datos y ponerlos en una matriz de caracteres
    xAxis = atoi ( y datos recibidos [ 0 ]) ; // Convertir los datos de la matriz de caracteres (valor X recibido) en un número entero
    retraso ( 10 ) ;
    radio. leer ( y datos recibidos, tamaño de (datos recibidos )) ;
    yAxis = atoi ( y datos recibidos [ 0 ]) ;
    retraso ( 10 ) ;
  }

Es así de simple, pero por supuesto, como ya dije, si necesita más detalles sobre cómo conectar y configurar los módulos, siempre puede consultar mi tutorial particular.

Código receptor:

/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#define enA 2 // Nota: Pin 9 en el video anterior (el pin 10 se usa para la comunicación SPI del NRF24L01)
#define in1 4
#define in2 5
#define enB 3 // Nota: Pin 10 en el video anterior
#define in3 6
#define in4 7
Radio RF24 ( 8, 9 ) ; // CE, CSN
dirección de byte constante [ 6 ] = "00001" ;
Char receivedData [ 32 ] = "" ;
int   xAxis, yAxis;
int motorSpeedA = 0;
int motorSpeedB = 0;
configuración vacía () {  
  pinMode ( enA, SALIDA ) ;
  pinMode ( enB, SALIDA ) ;
  pinMode ( in1, SALIDA ) ;
  pinMode ( entrada2 , SALIDA ) ;
  pinMode ( in3, SALIDA ) ;
  pinMode ( in4, SALIDA ) ;
  De serie. comenzar ( 9600 ) ;
  radio. comenzar () ;
  radio. openReadingPipe ( 0, dirección ) ;
  radio. setPALevel ( RF24_PA_MIN ) ;
  radio. startListening () ;
}
bucle vacío () {  
  if ( radio. available ()) { // Si el módulo NRF240L01 recibió datos    
    radio. leer ( y datos recibidos, tamaño de (datos recibidos )) ; // Leer los datos y ponerlos en una matriz de caracteres
    xAxis = atoi ( y datos recibidos [ 0 ]) ; // Convertir los datos de la matriz de caracteres (valor X recibido) en un número entero
    retraso ( 10 ) ;
    radio. leer ( y datos recibidos, tamaño de (datos recibidos )) ;
    yAxis = atoi ( y datos recibidos [ 0 ]) ;
    retraso ( 10 ) ;
  }
  
  // Eje Y utilizado para control hacia adelante y hacia atrás
  si ( yAxis < 470 ) {  
    // Pon el motor A hacia atrás
    digitalWrite ( in1, HIGH ) ;
    digitalWrite ( in2 , LOW ) ;
    // Pon el motor B hacia atrás
    digitalWrite ( in3, HIGH ) ;
    digitalWrite ( in4, BAJO ) ;
    // Convierta las lecturas decrecientes del eje Y para retroceder de 470 a 0 en un valor de 0 a 255 para la señal PWM para aumentar la velocidad del motor
    motorSpeedA = map ( yAxis, 470, 0, 0, 255 ) ;
    motorSpeedB = map ( yAxis, 470, 0, 0, 255 ) ;
  }
  else if ( yAxis > 550 ) {   
    // Pon el motor A hacia adelante
    digitalWrite ( in1, LOW ) ;
    digitalWrite ( in2 , HIGH ) ;
    // Pon el motor B hacia adelante
    digitalWrite ( in3, BAJO ) ;
    digitalWrite ( in4, HIGH ) ;
    // Convierta las lecturas crecientes del eje Y para avanzar de 550 a 1023 en un valor de 0 a 255 para la señal PWM para aumentar la velocidad del motor
    motorSpeedA = map ( yAxis, 550, 1023, 0, 255 ) ;
    motorSpeedB = map ( yAxis, 550, 1023, 0, 255 ) ;
  }
  // Si el joystick permanece en el medio, los motores no se mueven
  else { 
    motorSpeedA = 0;
    motorSpeedB = 0;
  }
  // Eje X utilizado para control izquierdo y derecho
  si ( xAxis < 470 ) {  
    // Convertir las lecturas decrecientes del eje X de 470 a 0 en un valor creciente de 0 a 255
    int xMapped = map ( xAxis, 470, 0, 0, 255 ) ;
    // Mover a la izquierda: disminuir la velocidad del motor izquierdo, aumentar la velocidad del motor derecho
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Confine el rango de 0 a 255
    si ( motorSpeedA < 0 ) {  
      motorSpeedA = 0;
    }
    si ( motorSpeedB > 255 ) { 
      motorSpeedB = 255;
    }
  }
  si ( eje x > 550 )  {
    // Convertir las lecturas crecientes del eje X de 550 a 1023 en valores de 0 a 255
    int xMapped = map ( xAxis, 550, 1023, 0, 255) ;
    // Mover a la derecha - disminuir la velocidad del motor derecho, aumentar la velocidad del motor izquierdo
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    // Confine el rango de 0 a 255
    if ( motorSpeedA > 255 ) {  
      motorSpeedA = 255;
    }
    si ( motorSpeedB < 0 ) {  
      motorSpeedB = 0;
    }
  }
  // Evite los zumbidos a bajas velocidades (ajuste de acuerdo con sus motores. Mis motores no podían comenzar a moverse si el valor de PWM estaba por debajo del valor de 70)
  si ( motorSpeedA < 70 ) {  
    motorSpeedA = 0;
  }
  si ( motorSpeedB < 70 ) {  
    motorSpeedB = 0;
  }
  analogWrite ( enA, motorSpeedA ) ; // Enviar señal PWM al motor A
  analogWrite ( enB, motorSpeedB ) ; // Enviar señal PWM al motor B
}

Control inalámbrico del coche robot Arduino con transceptor de largo alcance HC-12

Para el último método de control inalámbrico del coche robot Arduino, utilizaremos los módulos transceptores de largo alcance HC-12 . Estos módulos pueden comunicarse entre sí con distancias de hasta 1,8 km.

El esquema del circuito de este ejemplo es casi el mismo que el de los módulos Bluetooth HC-05, ya que utilizan el mismo método para comunicarse con el Arduino, a través del puerto serie.

Código fuente

El código del Joystick es exactamente el mismo que el de la comunicación Bluetooth. Simplemente leemos los valores analógicos del joystick y los enviamos al otro módulo usando la función Serial.write ().

Código del transmisor:

/
int xAxis, yAxis;
configuración vacía () {  
  De serie. comenzar ( 9600 ) ; // Tasa de comunicación predeterminada del módulo Bluetooth
}
bucle vacío () {  
  xAxis = analogRead ( A0 ) ; // Leer Joysticks eje X
  yAxis = analogRead ( A1 ) ; // Leer Joysticks eje Y
  
  // Enviar los valores a través del puerto serie al dispositivo Bluetooth esclavo HC-05
  De serie. escribir ( xAxis / 4 ) ; // Dividir por 4 para convertir de 0-1023 a 0-256, rango (1 byte)
  De serie. escribir ( yAxis / 4 ) ;
  retraso ( 20 ) ;
}

Por otro lado, con el bucle while () esperamos hasta que lleguen los datos, luego los leemos usando la función Serial.read () y los convertimos nuevamente en el rango de 0 a 1023, adecuado para el código de control del motor a continuación.

Código receptor:

/
#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;
configuración vacía () {  
  pinMode ( enA, SALIDA ) ;
  pinMode ( enB, SALIDA ) ;
  pinMode ( in1, SALIDA ) ;
  pinMode ( entrada2 , SALIDA ) ;
  pinMode ( in3, SALIDA ) ;
  pinMode ( in4, SALIDA ) ;
  De serie. comenzar ( 9600 ) ; // Tasa de comunicación predeterminada del módulo Bluetooth
}
bucle vacío () {  
  // Valor predeterminado: sin movimiento cuando el joystick permanece en el centro
  xAxis = 510;
  yAxis = 510;
  // Leer los datos entrantes del 
  while ( Serial. disponible () == 0 ) {}  
  x = Serie. leer () ;
  retraso ( 10 ) ;
  y = Serie. leer () ;
  retraso ( 10 ) ;
  // Convierta de nuevo el rango 0-255 a 0-1023, adecuado para el código de control del motor a continuación
  eje x = x * 4;
  yAxis = y * 4;
  // Eje Y utilizado para control hacia adelante y hacia atrás
  si ( yAxis < 470 ) {  
    // Pon el motor A hacia atrás
    digitalWrite ( in1, HIGH ) ;
    digitalWrite ( in2 , LOW ) ;
    // Pon el motor B hacia atrás
    digitalWrite ( in3, HIGH ) ;
    digitalWrite ( in4, BAJO ) ;
    // Convierta las lecturas decrecientes del eje Y para retroceder de 470 a 0 en un valor de 0 a 255 para la señal PWM para aumentar la velocidad del motor
    motorSpeedA = map ( yAxis, 470, 0, 0, 255 ) ;
    motorSpeedB = map ( yAxis, 470, 0, 0, 255 ) ;
  }
  else if ( yAxis > 550 ) {   
    // Pon el motor A hacia adelante
    digitalWrite ( in1, LOW ) ;
    digitalWrite ( in2 , HIGH ) ;
    // Pon el motor B hacia adelante
    digitalWrite ( in3, BAJO ) ;
    digitalWrite ( in4, HIGH ) ;
    // Convierta las lecturas crecientes del eje Y para avanzar de 550 a 1023 en un valor de 0 a 255 para la señal PWM para aumentar la velocidad del motor
    motorSpeedA = map ( yAxis, 550, 1023, 0, 255 ) ;
    motorSpeedB = map ( yAxis, 550, 1023, 0, 255 ) ;
  }
  // Si el joystick permanece en el medio, los motores no se mueven
  else { 
    motorSpeedA = 0;
    motorSpeedB = 0;
  }
  // Eje X utilizado para control izquierdo y derecho
  si ( xAxis < 470 ) {  
    // Convertir las lecturas decrecientes del eje X de 470 a 0 en un valor creciente de 0 a 255
    int xMapped = map ( xAxis, 470, 0, 0, 255 ) ;
    // Mover a la izquierda: disminuir la velocidad del motor izquierdo, aumentar la velocidad del motor derecho
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Confine el rango de 0 a 255
    si ( motorSpeedA < 0 ) {  
      motorSpeedA = 0;
    }
    if ( motorSpeedB > 255 ) {  
      motorSpeedB = 255;
    }
  }
  si ( xAxis > 550 ) {  
    // Convertir las lecturas crecientes del eje X de 550 a 1023 en valores de 0 a 255
    int xMapped = map ( xAxis, 550, 1023, 0, 255 ) ;
    // Mover a la derecha - disminuir la velocidad del motor derecho, aumentar la velocidad del motor izquierdo
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    // Confine el rango de 0 a 255
    if ( motorSpeedA > 255 ) {  
      motorSpeedA = 255;
    }
    si ( motorSpeedB < 0 ) {  
      motorSpeedB = 0;
    }
  }
  // Evite los zumbidos a bajas velocidades (ajuste de acuerdo con sus motores. Mis motores no podían comenzar a moverse si el valor de PWM estaba por debajo del valor de 70)
  si ( motorSpeedA < 70 ) {  
    motorSpeedA = 0;
  }
  si ( motorSpeedB < 70 ) {  
    motorSpeedB = 0;
  }
  analogWrite ( enA, motorSpeedA ) ; // Enviar señal PWM al motor A
  analogWrite ( enB, motorSpeedB ) ; // Enviar señal PWM al motor B
}

howtomechatronics.com