Robot Arduino con controlador PS2 (Joystick PlayStation 2)

Acerca de este proyecto

En este tutorial, le mostraré cómo usar un joystick inalámbrico de PlayStation 2 (PS2) para pilotar un tanque robótico. Se utilizó una placa Arduino Uno en el núcleo de este proyecto. Recibe comandos del controlador inalámbrico y establece la velocidad de los motores. También se pueden usar otras placas de desarrollo (NodeMCU, Firebeetle, etc.), y los principios presentados en este tutorial se pueden aplicar en otros modelos de robots y dispositivos.

Anteriormente diseñé un tanque robótico controlado por Blynk. Se conecta a una red Wi-Fi y recibe comandos del servidor Blynk. Se utilizó un teléfono inteligente con la aplicación Blynk como control remoto y se utilizaron diferentes métodos de entrada:botones, barras deslizantes e incluso el acelerómetro del teléfono inteligente. Puede encontrar más información sobre este proyecto aquí:https://www.hackster.io/igorF2/wi-fi-controlled-robot-using-wemos-d1-esp8266-and-blynk-464198

También hice algunos experimentos con comandos de voz. Puede ser útil si desea controlar un robot de forma remota sin usar sus manos, o si desea que sea accesible para alguien con movimientos limitados. Uno podría pensar en una silla de ruedas robótica controlada por voz, por ejemplo. Se utilizó un kit robótico de bricolaje, junto con algunas de mis herramientas favoritas:Adafruit.io, IFTTT y Arduino IDE. Instrucciones completas aquí:

https://www.hackster.io/igorF2/wi-fi-voice-controlled-robot-using-google-assistant-79802c

Puedes utilizar diferentes kits o incluso diseñar tus propios robots utilizando materiales sencillos, sin necesidad de utilizar herramientas complejas como impresoras 3D y máquinas de corte por láser. Puede encontrar un ejemplo en uno de mis tutoriales anteriores:

https://www.hackster.io/igorF2/widc-wi-fi-controlled-fpv-robot-8f1e09

Paso 1:herramientas y materiales

En este proyecto se utilizaron las siguientes herramientas:

• Soldador y alambre (enlace / enlace). Los motores de CC ya venían con cables soldados a sus terminales ... Pero eventualmente se romperá y es posible que deba resolverlo. Así que considere tener un buen soldador y alambre a mano.
• Lámina de espuma EVA (u otro material no conductor). El chasis del robot que utilicé en este proyecto está hecho de aluminio y las placas de circuito están instaladas en estas partes metálicas. Utilicé una capa de lámina de espuma entre las tablas y la placa de metal para evitar posibles cortocircuitos.
• Cinta de doble cara . Se utilizó para pegar las láminas de espuma a las placas de circuito y para la instalación del modo H-Bridge.
• Tijeras , para cortar algunos rectángulos de láminas de espuma.

Usé las siguientes partes de hardware para mi proyecto:

• Placa de desarrollo basada en Arduino Uno (enlace / enlace / enlace / enlace). Se utiliza como controlador principal del robot. Es realmente fácil de usar y programar con Arduino IDE, ideal para principiantes en electrónica y programación.

• Módulo de puente en H de doble canal L298N (enlace / enlace / enlace / enlace). Este módulo permite que las señales de 3.3V de Wemos (o un Arduino) se amplifiquen a los 12V necesarios para los motores.

• Tanque de chasis de robot de bricolaje (Enlace). Este increíble kit tiene todo lo que necesitas para construir un tanque:dos motores de CC, engranajes, orugas, pernos, tuercas, etc. ¡Ya viene con las herramientas necesarias para ensamblar el chasis, lo cual es ideal para principiantes!

• Control remoto inalámbrico PS2 (Enlace). Este controlador de videojuego puede enviar comandos de forma inalámbrica a un receptor, que puede interactuar con un microcontrolador mediante comunicación en serie.

• 18650 baterías de 3,7 V (x3) (enlace / enlace). Solía ​​alimentar todo el circuito. Este tanque utiliza motores de 12V. Usé tres baterías de 3.7V en serie para alimentarlas.

• Soporte de batería 3S 18650 (enlace / enlace / enlace). Puede contener tres baterías 18650 en serie y se puede colocar fácilmente en la parte posterior del tanque.

• Cargador de batería 18650 (enlace / enlace). Sus baterías eventualmente se agotarán. Cuando eso suceda, un cargador de batería vendrá a su rescate.
• Jerséis (enlace / enlace). Usé 6 puentes macho-hembra para señales entre el puente H y el Wemos, y 2 puentes macho-macho para 5V y Gnd. Es posible que necesite más si planea agregar algunos sensores.
• Cable USB tipo B . Lo necesitará para cargar su código. La mayoría de las placas ya vienen con su propio cable.

Los enlaces anteriores son solo una sugerencia de dónde puede encontrar los elementos utilizados en este tutorial (y tal vez apoyar mis futuros tutoriales). No dude en buscarlos en otro lugar y comprarlos en su tienda local o en línea favorita.

Paso 2:Montaje del robot

La primera parte de este proyecto fue el montaje de la estructura del robot.

En proyectos anteriores desarrollé la estructura de mi propio robot, utilizando materiales de fácil acceso (sin necesidad de herramientas complejas, impresoras 3D o máquinas de corte por láser). Puede encontrar este proyecto en el enlace a continuación:

https://www.hackster.io/igorF2/widc-wi-fi-controlled-fpv-robot-8f1e09

Más tarde decidí darle una oportunidad a un kit robótico obtenido de una tienda en línea. Puede encontrar un enlace al chasis del robot en el siguiente enlace:http://bit.ly/2ycI8fP. Si estás buscando un kit, ¡creo que es una buena opción! Lo usé en otros dos tutoriales, como puede ver en los enlaces a continuación:

https://www.hackster.io/igorF2/wi-fi-controlled-robot-using-wemos-d1-esp8266-and-blynk-464198

https://www.hackster.io/igorF2/wi-fi-voice-controlled-robot-using-google-assistant-79802c

En un principio parecía que el montaje sería complejo o que me encontraría con problemas como la falta de piezas (dada la cantidad de piezas que componen el kit). ¡Pero este kit realmente me sorprendió! Todas las piezas me parecen de buena calidad, y varias piezas de repuesto acompañan al kit. Por lo tanto, un tornillo perdido debajo del banco de trabajo no imposibilitará la realización de su proyecto, que me pareció excelente (especialmente después de perder un par de tornillos).

Otro punto positivo es que todas las herramientas necesarias para montar el robot están incluidas en el kit (un par de llaves Allen y el destornillador). ¡Creo que esto hace que el kit sea excelente para principiantes que no tienen muchas herramientas!

Como aspecto negativo destacaría la falta de documentación. El ensamblador del robot

ual (un archivo de hoja de cálculo en chino) no es extremadamente fácil de usar y no hay muchos tutoriales en línea para ese tanque. ¡Entonces decidí documentar el proceso de ensamblaje de mi robot en el video de arriba! Otro punto de atención se refiere al material de la estructura del robot. La base está fabricada íntegramente en aluminio, lo que puede provocar algún cortocircuito si los pines de las placas de circuito impreso tocan el marco.

Hay otros kits en línea que puede utilizar. Incluso puede crear su propia estructura, como describí a continuación.

Paso 3:cableado del circuito

Se instaló un paquete de energía hecho de tres baterías 18650 en la parte posterior del robot. Proporciona 11,1 V (3 x 3,7 V) al robot. Eso es suficiente para alimentar los motores de 12 V CC.

Se utilizó un puente en H de doble canal L298N para el control de los motores. Recibe algunas señales de 5V de la placa Arduino y proporciona voltajes más altos para los motores. También permite que los motores funcionen en ambas direcciones, dependiendo de la combinación de esas señales de entrada.

Cada dispositivo se conectó de acuerdo con los esquemas.

Sigue una lista de los pines que necesitará conectar:​​

Entradas / salidas de Arduino Uno:

• Pin digital 3 => Pin ENA de puente H
• Pin digital 5 => Pin IN1 de puente H
• Pin digital 4 => Pin IN2 de puente H
• Pin digital 8 => Pin IN3 de puente H
• Pin digital 7 => Pin IN4 de puente H
• Pin digital 6 => Pin ENB de puente H
• Pin 5V => Pin 5V H-Bridge
• Pin de tierra => Pin de tierra de puente H
• Pin digital 10 => Pin 6 del receptor de PS2
• Pin digital 11 => Pin 2 del receptor de PS2
• Pin digital 12 => Pin 1 del receptor de PS2
• Pin digital 13 => Pin 7 del receptor de PS2
• Pin de 3.3V => Pin 5 del receptor de PS2
• Gnd pin => pin 4 del receptor de PS2

Entradas / salidas H-Bridge:

• Pin ENA => Pin digital 3 de Arduino
• Pin IN1 => Pin 5 digital Arduino
• Pin IN2 => Pin 4 digital Arduino
• Pin IN3 => Pin digital 8 de Arduino
• Pin IN4 => Pin digital 7 de Arduino
• Pin ENB => Pin digital 6 de Arduino
• Pin 5V => Pin Arduino 5V
• Pin de Gnd => Pin de Gnd de Arduino
• Gnd pin => Cable negativo de la batería
• Pin de 12V => Cable positivo de la batería
• OUT1 => Cable negativo del motor derecho
• OUT2 => Cable positivo del motor derecho
• OUT3 => Cable positivo del motor izquierdo
• OUT4 => Cable negativo del motor izquierdo

Receptor PS2:

• Pin 1 (datos) => Pin digital 12 de Arduino
• Pin 2 (comando) => Pin digital 11 de Arduino
• Pin 4 (tierra) => Pin Arduino Gnd
• Pin 5 (alimentación) => Pin Arduino 3.3V
• Pin 6 (atención) => Pin digital Arduino 10
• Pin 7 (reloj) => Pin digital 13 de Arduino

Paso 4:Configura el IDE de Arduino

Para este proyecto utilicé Arduino IDE para programar la placa Arduino.

1. Descargue e instale la última versión de Arduino IDE

Puede encontrar la última versión para Windows, Linux o MAC OSX en el sitio web de Arduino:https://www.arduino.cc/en/main/software

Descárguelo gratis, instálelo en su computadora y ejecútelo.

2. Añadiendo las bibliotecas

En este proyecto, uso la biblioteca Arduino PS2X.

Descargue la biblioteca en https://github.com/madsci1016/Arduino-PS2X. Descomprima el archivo y copie las carpetas a las bibliotecas / herramientas de Arduino IDE.

............

Ahora que su entorno de desarrollo está listo, ¡pasemos al siguiente paso!

Paso 5:Explicación de la biblioteca del controlador inalámbrico PS2

Un controlador inalámbrico PS2 es una gran herramienta para sus proyectos de robótica. Tiene una cantidad increíble de botones:20 pulsadores digitales y 2 sticks analógicos. De esta manera, hay infinitas posibilidades para controlar su robot.

Usé la biblioteca PS2X de Bill Porter (https://github.com/madsci1016/Arduino-PS2X) para conectar el controlador a una placa Arduino Uno.

Define una clase PS2X para el controlador, que contiene algunos métodos para leer entradas analógicas y digitales desde el joystick. Un objeto para esta clase se crea utilizando el siguiente código (antes o durante la instalación):

  PS2X ps2x;  

Una vez que se definió el objeto, debe vincularse a los pines de E / S de Arduino mediante la siguiente función:

  error =ps2x.config_gamepad (reloj, comando, atención, datos, presión ?, ¿retumbar?);  

Esta función puede devolver algunos errores si hay algún problema con las conexiones o con el controlador mismo.

Las principales funciones utilizadas desde la biblioteca son las de lectura de entradas digitales y analógicas. Para lectura y entrada digital, se utiliza el siguiente método:

  ps2x.Button (botón);  

¿En qué botón es el nombre del botón que se va a leer. Cada botón está mapeado de la siguiente manera:

Botones de dirección:

• PSB_PAD_UP =Botón arriba del pad direccional;
• PSB_PAD_DOWN =Botón abajo del pad direccional;
• PSB_PAD_LEFT =botón izquierdo del control direccional
• PSB_PAD_RIGHT =Botón derecho del control direccional

Botones de acción:

• PSB_GREEN o PSB_TRIANGLE =botón de triángulo verde
• PSB_RED o PSB_CIRCLE =botón de círculo rojo
• PSB_BLUE o PSB_CROSS =botón x azul
• PSB_PINK o PSB_SQUARE =​​botón cuadrado rosa

Activadores:

• PSB_L1 =botón de activación del lado izquierdo 1
• PSB_R1 =botón de activación del lado derecho 1
• PSB_L2 =botón de activación del lado izquierdo 2
• PSB_R2 =botón de activación del lado derecho 2

Palos:

• PSB_L3 =botón pulsador del joystick izquierdo (sí, puede presionar el joystick como si fuera un botón)
• PSB_R3 =botón pulsador del joystick derecho

Menú:

• PSB_SELECT =botón de selección
• PSB_START =botón de inicio

Para leer el valor analógico (con convertidor en un número entero entre 0 y 255) de los sticks use el siguiente método:

  ps2x.Analog (stick_axis);  

¿En qué stick_axis representa el palo y la dirección a leer, de la siguiente manera:

• PSS_LY =posición y del joystick izquierdo
• PSS_LX =posición x del joystick izquierdo
• PSS_RY =posición y del joystick derecho
• PSS_RX =posición x del joystick derecho

¡Con esas funciones básicas, estará listo para usar el controlador PS2 en su proyecto! En los siguientes pasos, muestro algunos ejemplos de bocetos de Arduino que combinan esos botones.

Paso 6:Boceto n. ° 1 - Botones del Dpad

Los videojuegos antiguos, como SEGA Master System y Mega Drive y Nintendo SNES, no tenían botones sensibles a la fuerza. Los botones de dirección eran solo botones de encendido / apagado. Para este primer ejemplo, quería emular el tipo de controles que uno tendría en los videojuegos antiguos de esas consolas.

Para este primer Sketch utilicé botones del Dpad como entradas al robot. El robot utilizó cada botón para realizar uno de los movimientos básicos:avanzar, girar a la derecha, girar a la izquierda o retroceder.

Esos botones tienen salidas binarias. De esta manera, el microcontrolador solo entenderá que se presionaron los botones, pero no comprenderá con qué fuerza se presionaron. De esta manera, una vez que se hace clic en un botón determinado, los motores funcionarán a máxima velocidad.

Si conectó todo de acuerdo con mis esquemas, tendrá las siguientes salidas:

• PSB_PAD_UP =avanzar
• PSB_PAD_DOWN =retroceder
• PSB_PAD_LEFT =girar a la izquierda
• PSB_PAD_RIGHT =girar a la derecha

Como dije antes, el motor se moverá a una velocidad fija. Al girar hacia la izquierda o hacia la derecha, los motores funcionarán en direcciones opuestas, por lo que el robot girará alrededor de su eje.

Código Arduino:

Descarga el código y ábrelo en Arduino IDE. Si usa el mismo pinout que usé, probablemente no tendrá que cambiar nada en el código (aunque podría ser necesario, si la orientación de los motores es diferente

Para cargar el código, seleccione la placa 'Arduino / Genuino Uno', seleccione el puerto COM correcto, conecte la placa en el puerto USB de su computadora y cargue el código.
Una vez completada la carga, desconecte el cable USB y coloque el baterías. El código comenzará a ejecutarse y la placa Arduino conectará automáticamente el joystick PS2. Abra el monitor serial en el primer uso y verifique el estado de la conexión. Si no se conecta con el joystick, hay algunas cosas que debe hacer:

• Reinicia la placa Arduino Uno. Pruébelo varias veces (para mí, generalmente funciona después del tercer reinicio);
• Verifique si el joystick está encendido (y con las baterías cargadas). El receptor tiene algunos LED que indicarán si el joystick estaba emparejado. También verifique si los pines RX y TX de Arduino parpadean cuando recibe nuevos comandos (y actualiza el estado en el puerto serie);
• Compruebe las conexiones ... puede que haya algún problema en los puentes entre los componentes.

Explicación del código:

En este proyecto solo tuve que usar la biblioteca PS2X_lib.h. Se agrega al principio del código.

  #include   

Defina los pines del Arduino conectados al puente h. Si usa las mismas conexiones que yo usé, tendrá la siguiente configuración. Si elige usar pines diferentes, actualice esta parte del código.

  // Se utilizan para establecer la dirección del controlador del puente. #define ENA 3 // ENA #define MOTORA_1 4 // IN3 #define MOTORA_2 5 // IN4 #define MOTORB_1 8 // IN1 #define MOTORB_2 7 // IN2 #define ENB 6 // ENB  

Algunas variables globales se declararon antes de la configuración ( p2sx , error , tipo y vibrar ). El primero es una instancia de la clase PS2X. El estado de error durante la conexión se almacenará en error entero. Tipo y vibrar indicará el tipo de controlador (controlador DualShock o GuitarHero) y si se supone que debe vibrar con un comando dado.

Lo primero que hice durante la instalación fue configurar el estado de los pines de E / S (como salida) y establecer los pines de habilitación en BAJO. De esta forma, desactivará ambos motores al arrancar y el robot no se moverá aleatoriamente mientras espera el resto del código.

  // Configurar pines de salida pinMode (ENA, OUTPUT); pinMode (MOTORA_1, SALIDA); pinMode (MOTORA_2, SALIDA); pinMode (ENB, SALIDA); pinMode (MOTORB_1, SALIDA); pinMode (MOTORB_2, SALIDA); // Deshabilitar ambos motores digitalWrite (ENA, 0); escritura digital (ENB, 0);  

Luego comencé la comunicación del puerto serie (útil para depurar el código). Elija una velocidad en baudios adecuada y establezca la misma velocidad en el monitor en serie.

  // Iniciar la comunicación en serie Serial.begin (57600);  

Finalmente, configura el objeto ps2x con los pines del Arduino que estaban conectados al receptor del joystick (reloj, comando, atención y datos respectivamente). Podría devolver un error (que se mostrará en el monitor de serie). El tipo de controlador también se mostrará (aunque probablemente ya sepa el tipo de controlador que tiene en sus manos en este momento:D).

  error =ps2x.config_gamepad (13,11,10,12, true, true); // configurar pines y configuraciones:GamePad (reloj, comando, atención, datos, presiones ?, ¿retumbar?) buscar error // Verificar error si (error ==0) {Serial.println ("Controlador encontrado, configurado exitosamente" ); } else if (error ==1) Serial.println ("No se encontró controlador, verifique el cableado o reinicie el Arduino"); else if (error ==2) Serial.println ("Controlador encontrado pero no aceptando comandos"); else if (error ==3) Serial.println ("El controlador se niega a ingresar al modo Presiones, puede que no lo admita"); // Compruebe el tipo de controlador type =ps2x.readType (); cambiar (tipo) {caso 0:Serial.println ("Tipo de controlador desconocido"); descanso; caso 1:Serial.println ("Controlador DualShock encontrado"); descanso; caso 2:Serial.println ("Controlador GuitarHero encontrado"); descanso; }  

Durante el ciclo principal, Arduino leerá cada botón del D-pad (ARRIBA, ABAJO, IZQUIERDA y DERECHA) y establecerá los diferentes valores para los pines de salida, para mover las ruedas. Después de un breve retraso, se inicia un nuevo ciclo.

La siguiente sección muestra cómo mover el robot hacia adelante si se presionó el botón ARRIBA. Los pines MOTORA_1 y MOTORA_2 definen la dirección de rotación del Motor A. ENA definirá si el movimiento está habilitado o no (motor ON / OFF). Observe que es una salida "analógica" (en realidad, una PWM). Su valor debe estar entre 0 y 1023. Esto modulará el PWM y cambiará el voltaje promedio en la salida del h-brigde (entre 0 y 12V). Si el voltaje promedio es demasiado bajo, el motor no podrá moverse en absoluto.

  // MOVER HACIA ADELANTE if (ps2x.Button (PSB_PAD_UP)) {digitalWrite (MOTORA_1, LOW); escritura digital (MOTORA_2, ALTA); escritura digital (MOTORB_1, ALTA); digitalWrite (MOTORB_2, BAJO); analogWrite (ENB, 1023); analogWrite (ENA, 1023); Serial.println ("Avanzar"); }  

* Usé salidas PWM para los pines ENA y ENB. De esta forma, 1023 representaría un pulso con la mayor longitud (pin siempre activado) y 0 la ausencia de pulsos (pin siempre desactivado). Si se usa un valor diferente (menor) aquí, se espera que los motores funcionen más lentamente, ya que el voltaje promedio en sus terminales será menor.

Paso 7:Boceto n. ° 2 - Stick analógico y botones digitales (L2 y R2)

En un momento dado, todas las consolas adoptaron joysticks con dos joysticks analógicos. Esas nuevas entradas permitieron entradas sensibles a la fuerza que crearon acciones de velocidad variable y se hicieron populares en todo tipo de videojuegos.

En este segundo ejemplo, quería usar un interruptor analógico para dirigir el tanque y un par de botones pulsadores como acelerador y frenos / marcha atrás. Este tipo de configuración es muy popular en muchos juegos de carreras, como Mario Kart, por ejemplo. Pulsa el botón R2 para acelerar el tanque, L2 para retroceder y establece la dirección del movimiento según la posición x del joystick izquierdo.

El tipo de kit robótico que utilicé no tiene mucha inercia (si el voltaje en los motores se establece en 0 V, no se mantendrá en movimiento por un tiempo). De esta forma, no hubo necesidad de definir un comando para frenar el robot.

La mayor parte del código ya se explicó en el paso anterior. Una diferencia es que definí dos variables que almacenan la velocidad de cada motor (de 0 a 1023).

  int motor_right_speed =0; 
 int motor_left_speed =0;  

En el bucle principal, Arduino leerá la posición x del joystick izquierdo. Recibirá un valor entre 0 y 255 y lo asignará entre -1023 y 1023.

Este valor se sumará (o restará) a la velocidad de cada motor, con el fin de crear una diferencia entre la velocidad de cada pista y hacer que el robot gire hacia la izquierda o hacia la derecha.

  int nJoyL =ps2x.Analog (PSS_LX); // leer joystick izquierdo nJoyL =map (nJoyL, 0, 255, 1023, -1023); motor_right_speed =1023; motor_left_speed =1023; if (nJoyL <0) {motor_right_speed =motor_right_speed + nJoyL; } if (nJoyL> 0) {motor_left_speed =motor_left_speed - nJoyL; }  

Si se presiona el botón R2, el tanque se moverá hacia adelante. De esta manera, el Arduino establece valores apropiados para los pines del motor. ENA y ENB crean salidas 'analógicas' para cada motor, con un valor proporcional a la velocidad deseada para cada motor (según la posición x del joystick izquierdo).

L2 hará algo similar, pero invierte la dirección del motor.

  if (ps2x.Button (PSB_R2)) {digitalWrite (MOTORA_1, LOW); escritura digital (MOTORA_2, ALTA); escritura digital (MOTORB_1, ALTA); digitalWrite (MOTORB_2, BAJO); analogWrite (ENA, motor_right_speed); analogWrite (ENB, motor_left_speed); } if (ps2x.Button (PSB_L2)) {digitalWrite (MOTORA_1, HIGH); escritura digital (MOTORA_2, BAJA); digitalWrite (MOTORB_1, BAJO); escritura digital (MOTORB_2, ALTA); analogWrite (ENA, motor_right_speed); analogWrite (ENB, motor_left_speed); } if (! ps2x.Button (PSB_L2) ​​&&! ps2x.Button (PSB_R2)) {analogWrite (ENA, 0); analogWrite (ENB, 0); }  

Si no se presionó ninguno de los botones, los motores se desactivarán.

Paso 8:Boceto n. ° 3:palancas analógicas izquierda y derecha (mando diferencial)

¡Esta es mi forma favorita de controlar el tanque (aunque no es óptima en términos de recursos)! ¡Me hace sentir como si estuviera controlando una máquina realmente grande con ambas manos!

En este código utilicé ambos palos para establecer la dirección y la velocidad de cada pista. El joystick izquierdo controlará el carril izquierdo y el joystick derecho controlará el carril derecho.

El código es casi el mismo que se describió anteriormente. Pero esta vez quería leer la posición y de ambos palos:

  int nJoyL =ps2x.Analog (PSS_LY); // leer joystick izquierdo int nJoyR =ps2x.Analog (PSS_RY); // leer joystick derecho nJoyL =map (nJoyL, 0, 255, 1023, -1023); nJoyR =mapa (nJoyR, 0, 255, -1023, 1023);  

Dependiendo de la posición de la palanca, el código establecerá los pines digitales para establecer la dirección de cada motor.

Usé un valor fijo en enable (1023), pero usaría un valor variable basado en el valor real del stick analógico. Definí una banda muerta (+ -50) en la que el microcontrolador desactivará los motores.

  // Realiza movimientos basados ​​en ambos sticks analógicos if (nJoyR> 50) {digitalWrite (MOTORA_1, HIGH); escritura digital (MOTORA_2, BAJA); analogWrite (ENA, 1023); } si (nJoyR <-50) {digitalWrite (MOTORA_1, LOW); escritura digital (MOTORA_2, ALTA); analogWrite (ENA, 1023); } si (abs (nJoyR) <50) {analogWrite (ENA, 0); }  

Paso 9:Boceto n. ° 4:solo joystick analógico izquierdo

En esta última aplicación Sketch utilicé un solo joystick para controlar el robot. Es optium en términos de uso de recursos (te quedarán muchos botones para configurar diferentes acciones), pero es bastante difícil de entender.

La velocidad de cada pista se define en función de las posiciones xey del joystick. De esta manera, es posible aplicar diferentes velocidades en cada pista y mover el robot con diferentes velocidades / direcciones. El código utilizado aquí se derivó del siguiente tutorial. ¡Compruébalo!

https://www.impulseadventure.com/elec/robot-differential-steering.html

Paso 10:Consideraciones finales

Me esforcé mucho en este proyecto, para que fuera lo más claro y educativo posible. Si te gustó, no olvides darle "Me gusta" y "compartirlo". ¡Tu apoyo es muy importante para mí! :D

Si aún no sigues mis tutoriales, ¡echa un vistazo a esos otros tutoriales sobre robótica! ¡Espero que les gusten!

https://www.hackster.io/igorF2/joy-robot-robo-da-alegria-bba54f

https://www.hackster.io/igorF2/widc-wi-fi-controlled-fpv-robot-8f1e09

https://www.hackster.io/igorF2/nunchuk-controlled-robotic-arm-with-arduino-b1c0fa

https://www.hackster.io/igorF2/wi-fi-browser-controlled-robotic-arm-89b63d

¡Considere apoyar mis proyectos futuros con una pequeña donación de Bitcoin! :D

Dirección de depósito de BTC:1FiWFYSjRaL7sLdr5wr6h86QkMA6pQxkXJ

Código

• Bosquejo n. ° 1
• Bosquejo n. ° 2
• Bosquejo n. ° 3
• Bosquejo n. ° 4

Boceto n. ° 1 Arduino

 // PS2 Tank por Igor Fonseca @ 2019 // Controla un tanque robótico usando un joystick PS2, usando botones D-pad // basado en un ejemplo usando la biblioteca PS2X por Bill Porter 2011 // Todo el texto anterior debe estar incluido en cualquier redistribución.// incluir bibliotecas # incluir  // Se utilizan para establecer la dirección del controlador del puente. # definir ENA 3 // ENA # definir MOTORA_1 4 // IN3 # definir MOTORA_2 5 // IN4 #define MOTORB_1 8 // IN1 # define MOTORB_2 7 // IN2 # define ENB 6 // ENBPS2X ps2x; // crea la clase de controlador PS2 // ahora mismo, la biblioteca NO admite controladores conectables en caliente, lo que significa que // siempre debes reiniciar tu Arduino después de conectar el controlador, // o llamar a config_gamepad (pines) nuevamente después de conectar el controlador. int error =0; byte type =0; byte vibrate =0; void setup () {// Configurar pines de salida pinMode (ENA, OUTPUT); pinMode (MOTORA_1, SALIDA); pinMode (MOTORA_2, SALIDA); pinMode (ENB, SALIDA); pinMode (MOTORB_1, SALIDA); pinMode (MOTORB_2, SALIDA); // Disable both motors digitalWrite(ENA,0); digitalWrite(ENB,0); // Start serial communication Serial.begin(57600); error =ps2x.config_gamepad(13,11,10,12, true, true); //setup pins and settings:GamePad(clock, command, attention, data, Pressures?, Rumble?) check for error // Check for error if(error ==0){ Serial.println("Found Controller, configured successful"); } else if(error ==1) Serial.println("No controller found, check wiring or reset the Arduino"); else if(error ==2) Serial.println("Controller found but not accepting commands"); else if(error ==3) Serial.println("Controller refusing to enter Pressures mode, may not support it."); // Check for the type of controller type =ps2x.readType(); switch(type) { case 0:Serial.println("Unknown Controller type"); descanso; case 1:Serial.println("DualShock Controller Found"); descanso; case 2:Serial.println("GuitarHero Controller Found"); descanso; }}// Main loopvoid loop(){ if(error ==1) //skip loop if no controller found return; else { //DualShock Controller ps2x.read_gamepad(false, vibrate); // disable vibration of the controller // Perform movements based on D-pad buttons // MOVE FORWARD if(ps2x.Button(PSB_PAD_UP)) { digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); analogWrite(ENB, 1023); analogWrite(ENA, 1023); Serial.println("Move forward"); } // TURN RIGHT if(ps2x.Button(PSB_PAD_RIGHT)){ digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); analogWrite(ENB, 1023); analogWrite(ENA, 1023); Serial.println("Turn right"); } // TURN LEFT if(ps2x.Button(PSB_PAD_LEFT)){ digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2,HIGH); analogWrite(ENB, 1023); analogWrite(ENA, 1023); Serial.println("Turn left"); } // MOVE BACK if(ps2x.Button(PSB_PAD_DOWN)){ digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2,HIGH); analogWrite(ENB, 1023); analogWrite(ENA, 1023); Serial.println("Move back"); } if (!ps2x.Button(PSB_PAD_DOWN) &&!ps2x.Button(PSB_PAD_UP) &&!ps2x.Button(PSB_PAD_RIGHT) &&!ps2x.Button(PSB_PAD_LEFT)) { analogWrite(ENB, 0); analogWrite(ENA, 0); } delay(50); } }

Sketch #2Arduino

// PS2 Tank by Igor Fonseca @2019// Controls a robotic tank using a PS2 joystick, using D-pad buttons// based on an example using the PS2X library by Bill Porter 2011// All text above must be included in any redistribution.// include libraries#include // These are used to set the direction of the bridge driver.#define ENA 3 //ENA#define MOTORA_1 4 //IN3#define MOTORA_2 5 //IN4#define MOTORB_1 8 //IN1#define MOTORB_2 7 //IN2#define ENB 6 //ENBint motor_right_speed =0;int motor_left_speed =0;PS2X ps2x; // create PS2 Controller Class//right now, the library does NOT support hot pluggable controllers, meaning //you must always either restart your Arduino after you conect the controller, //or call config_gamepad(pins) again after connecting the controller.int error =0; byte type =0;byte vibrate =0;void setup(){ // Configure output pins pinMode(ENA, OUTPUT); pinMode(MOTORA_1, OUTPUT); pinMode(MOTORA_2, OUTPUT); pinMode(ENB, OUTPUT); pinMode(MOTORB_1, OUTPUT); pinMode(MOTORB_2, OUTPUT); // Disable both motors digitalWrite(ENA,0); digitalWrite(ENB,0); // Start serial communication Serial.begin(57600); error =ps2x.config_gamepad(13,11,10,12, true, true); //setup pins and settings:GamePad(clock, command, attention, data, Pressures?, Rumble?) check for error // Check for error if(error ==0){ Serial.println("Found Controller, configured successful"); } else if(error ==1) Serial.println("No controller found, check wiring or reset the Arduino"); else if(error ==2) Serial.println("Controller found but not accepting commands"); else if(error ==3) Serial.println("Controller refusing to enter Pressures mode, may not support it."); // Check for the type of controller type =ps2x.readType(); switch(type) { case 0:Serial.println("Unknown Controller type"); descanso; case 1:Serial.println("DualShock Controller Found"); descanso; case 2:Serial.println("GuitarHero Controller Found"); descanso; }}// Main loopvoid loop(){ if(error ==1) //skip loop if no controller found return; else { //DualShock Controller ps2x.read_gamepad(false, vibrate); // disable vibration of the controller int nJoyL =ps2x.Analog(PSS_LX); // read left stick nJoyL =map(nJoyL, 0, 255, 1023, -1023); int motor_right_speed =1023; int motor_left_speed =1023; if (nJoyL <0) { motor_right_speed =motor_right_speed + nJoyL; } if (nJoyL> 0) { motor_left_speed =motor_left_speed - nJoyL; } if(ps2x.Button(PSB_R2)) { digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); analogWrite(ENA, motor_right_speed); analogWrite(ENB, motor_left_speed); } if(ps2x.Button(PSB_L2)) { digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2,HIGH); analogWrite(ENA, motor_right_speed); analogWrite(ENB, motor_left_speed); } if(!ps2x.Button(PSB_L2) &&!ps2x.Button(PSB_R2)) { analogWrite(ENA, 0); analogWrite(ENB, 0); } delay(50); } }

Sketch #3Arduino

// PS2 Tank by Igor Fonseca @2019// Controls a robotic tank using a PS2 joystick, using D-pad buttons// based on an example using the PS2X library by Bill Porter 2011// All text above must be included in any redistribution.// include libraries#include // These are used to set the direction of the bridge driver.#define ENA 3 //ENA#define MOTORA_1 4 //IN3#define MOTORA_2 5 //IN4#define MOTORB_1 8 //IN1#define MOTORB_2 7 //IN2#define ENB 6 //ENBPS2X ps2x; // create PS2 Controller Class//right now, the library does NOT support hot pluggable controllers, meaning //you must always either restart your Arduino after you conect the controller, //or call config_gamepad(pins) again after connecting the controller.int error =0; byte type =0;byte vibrate =0;void setup(){ // Configure output pins pinMode(ENA, OUTPUT); pinMode(MOTORA_1, OUTPUT); pinMode(MOTORA_2, OUTPUT); pinMode(ENB, OUTPUT); pinMode(MOTORB_1, OUTPUT); pinMode(MOTORB_2, OUTPUT); // Disable both motors digitalWrite(ENA,0); digitalWrite(ENB,0); // Start serial communication Serial.begin(57600); error =ps2x.config_gamepad(13,11,10,12, true, true); //setup pins and settings:GamePad(clock, command, attention, data, Pressures?, Rumble?) check for error // Check for error if(error ==0){ Serial.println("Found Controller, configured successful"); } else if(error ==1) Serial.println("No controller found, check wiring or reset the Arduino"); else if(error ==2) Serial.println("Controller found but not accepting commands"); else if(error ==3) Serial.println("Controller refusing to enter Pressures mode, may not support it."); // Check for the type of controller type =ps2x.readType(); switch(type) { case 0:Serial.println("Unknown Controller type"); descanso; case 1:Serial.println("DualShock Controller Found"); descanso; case 2:Serial.println("GuitarHero Controller Found"); descanso; }}// Main loopvoid loop(){ if(error ==1) //skip loop if no controller found return; else { //DualShock Controller ps2x.read_gamepad(false, vibrate); // disable vibration of the controller int nJoyL =ps2x.Analog(PSS_LY); // read left stick int nJoyR =ps2x.Analog(PSS_RY); // read right stick nJoyL =map(nJoyL, 0, 255, 1023, -1023); nJoyR =map(nJoyR, 0, 255, -1023, 1023); // Perform movements based on both analog sticks if(nJoyR>50) { digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); analogWrite(ENA, 1023); } if(nJoyR<-50) { digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); analogWrite(ENA, 1023); } if (abs(nJoyR)<50) { analogWrite(ENA, 0); } if(nJoyL>50) { digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); analogWrite(ENB, 1023); } if(nJoyL<-50) { digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2,HIGH); analogWrite(ENB, 1023); } if (abs(nJoyL)<50) { analogWrite(ENB, 0); } delay(50); } }

Sketch #4Arduino

// PS2 Tank by Igor Fonseca @2019// Controls a robotic tank using a PS2 joystick, using left analog stick// based on an example using the PS2X library by Bill Porter 2011// All text above must be included in any redistribution.// include libraries#include  //for v1.6// These are used to set the direction of the bridge driver.#define ENA 3 //ENA#define MOTORA_1 4 //IN3#define MOTORA_2 5 //IN4#define MOTORB_1 8 //IN1#define MOTORB_2 7 //IN2#define ENB 6 //ENBint motor_right_speed =0;int motor_left_speed =0;PS2X ps2x; // create PS2 Controller Class//right now, the library does NOT support hot pluggable controllers, meaning //you must always either restart your Arduino after you conect the controller, //or call config_gamepad(pins) again after connecting the controller.int error =0; byte type =0;byte vibrate =0;void setup(){ // Configure output pins pinMode(ENA, OUTPUT); pinMode(MOTORA_1, OUTPUT); pinMode(MOTORA_2, OUTPUT); pinMode(ENB, OUTPUT); pinMode(MOTORB_1, OUTPUT); pinMode(MOTORB_2, OUTPUT); // Disable both motors digitalWrite(ENA,0); digitalWrite(ENB,0); // Start serial communication Serial.begin(57600); error =ps2x.config_gamepad(13,11,10,12, true, true); //setup pins and settings:GamePad(clock, command, attention, data, Pressures?, Rumble?) check for error // Check for error if(error ==0){ Serial.println("Found Controller, configured successful"); } else if(error ==1) Serial.println("No controller found, check wiring or reset the Arduino"); else if(error ==2) Serial.println("Controller found but not accepting commands"); else if(error ==3) Serial.println("Controller refusing to enter Pressures mode, may not support it."); // Check for the type of controller type =ps2x.readType(); switch(type) { case 0:Serial.println("Unknown Controller type"); descanso; case 1:Serial.println("DualShock Controller Found"); descanso; case 2:Serial.println("GuitarHero Controller Found"); descanso; }}// Main loopvoid loop(){ if(error ==1) //skip loop if no controller found return; else { //DualShock Controller ps2x.read_gamepad(false, vibrate); // disable vibration of the controller int nJoyX =ps2x.Analog(PSS_LX); // read x-joystick int nJoyY =ps2x.Analog(PSS_LY); // read y-joystick nJoyX =map(nJoyX, 0, 255, -1023, 1023); nJoyY =map(nJoyY, 0, 255, 1023, -1023); // OUTPUTS int nMotMixL; // Motor (left) mixed output int nMotMixR; // Motor (right) mixed output // CONFIG // - fPivYLimt :The threshold at which the pivot action starts // This threshold is measured in units on the Y-axis // away from the X-axis (Y=0). A greater value will assign // more of the joystick's range to pivot actions. // Allowable range:(0..+127) float fPivYLimit =1023.0; // TEMP VARIABLES float nMotPremixL; // Motor (left) premixed output float nMotPremixR; // Motor (right) premixed output int nPivSpeed; // Pivot Speed float fPivScale; // Balance scale between drive and pivot // Calculate Drive Turn output due to Joystick X input if (nJoyY>=0) { // Forward nMotPremixL =(nJoyX>=0)? 1023.0 :(1023.0 + nJoyX); nMotPremixR =(nJoyX>=0)? (1023.0 - nJoyX) :1023.0; } else { // Reverse nMotPremixL =(nJoyX>=0)? (1023.0 - nJoyX) :1023.0; nMotPremixR =(nJoyX>=0)? 1023.0 :(1023.0 + nJoyX); } // Scale Drive output due to Joystick Y input (throttle) nMotPremixL =nMotPremixL * nJoyY/1023.0; nMotPremixR =nMotPremixR * nJoyY/1023.0; // Now calculate pivot amount // - Strength of pivot (nPivSpeed) based on Joystick X input // - Blending of pivot vs drive (fPivScale) based on Joystick Y input nPivSpeed =nJoyX; fPivScale =(abs(nJoyY)>fPivYLimit)? 0.0 :(1.0 - abs(nJoyY)/fPivYLimit); // Calculate final mix of Drive and Pivot nMotMixL =(1.0-fPivScale)*nMotPremixL + fPivScale*( nPivSpeed); nMotMixR =(1.0-fPivScale)*nMotPremixR + fPivScale*(-nPivSpeed); motor_left_speed =nMotMixL; motor_right_speed =nMotMixR; if (motor_right_speed> 50) { digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); } else if (motor_right_speed <-50) { digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2, HIGH); } else { digitalWrite(MOTORB_1, LOW); digitalWrite(MOTORB_2, LOW); } if (motor_left_speed> 50) { digitalWrite(MOTORA_1, LOW); digitalWrite(MOTORA_2, HIGH); } else if (motor_left_speed <-50) { digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); } else { digitalWrite(MOTORA_1, LOW); digitalWrite(MOTORA_2, LOW); } analogWrite(ENA, abs(motor_left_speed)); analogWrite(ENB, abs(motor_right_speed)); if (abs(motor_left_speed> 50) || abs(motor_left_speed> 50)) { Serial.println("Moving!"); } delay(50); } }

Esquemas

Sistema de información de semáforos Pedal de guitarra Arduino UNO