Toma el control de las funciones de poder de Lego

Acerca de este proyecto

¿Tienes uno de esos increíbles modelos de Lego Power Functions con motores eléctricos y servomotores? En este tutorial te mostraré cómo puedes controlar tu modelo Lego con tu Arduino y un mínimo de componentes electrónicos. Explicaré los circuitos y la programación en detalle para que este tutorial sea fácil de entender para los principiantes. El modelo de Lego que tendrás que construir tú mismo (si no tienes un hijo), no te ayudaré con eso.

También aprenderemos a usar el inventor de la aplicación MIT para programar nuestra propia aplicación de control remoto para Android. ¡Pronto tendrás tu propio vehículo de exploración Lego Mars en tu patio trasero!

Este es mi primer proyecto Arduino y mi hijo tiene un hermoso modelo de automóvil Lego Technic (9398 4X4 Crawler) con Lego Power Functions:un servomotor Lego para la dirección y dos motores L Lego para conducir. Me permitió usar el automóvil para este proyecto (siempre que no cortara ningún cable de motor). Aquí, probamos el prototipo terminado:

Comprensión del cableado de Power Functions

Primero, compre algunos cables de extensión de Lego Power Functions (artículo 8886 en la tienda web de Lego). A continuación, córtelos (en serio). Haremos algunos cables de "ruptura" que tienen ladrillos de Lego en un extremo y alfileres en el otro. Suelde los pines en o similar. Aquí está el cableado explicado:

GND significa Tierra, que es el terminal negativo (-) del paquete de baterías (ánodo). C1 y C2 pueden cambiar la polaridad para hacer que los motores y los servos cambien de dirección. TechnicRobot ha realizado un bonito vídeo que explica todo en detalle. (ADVERTENCIA:usted está haciendo esto bajo su propia responsabilidad. ¡No seré responsable si arruina algo!) Para el conector del servo de Lego, necesita soldar las clavijas a los cuatro cables. Puede utilizar el enchufe gris claro. Para el cable de alimentación que conecta la caja de la batería con la placa de prueba, solo necesitamos +9 Voltios y GND, pero debe usar el enchufe gris oscuro (porque necesita un conector macho):

Para el cable del motor, solo necesitamos conectar C1 y C2 y puede usar un enchufe gris claro. (Estudie los esquemas para obtener más detalles).

Controlar un motor Lego con el chip L293D

Queremos control de velocidad variable para nuestros motores de CC y control de posición para nuestro servo Lego. Esto se logra mediante la modulación de ancho de pulso (PWM). El lenguaje de programación de Arduino hace que PWM sea fácil de usar; simplemente llame a analogWrite (pin, dutyCycle), donde dutyCycle es un valor de 0 a 255. Los pines PWM están marcados con ~ en su arduino.

Los pines de salida de Arduino son de 5 voltios y máx. 30 mA, mientras que los motores Lego necesitan 9 voltios y tiran más de 100 mA cada uno. Necesitamos algún tipo de "dispositivo de conmutación" en el medio. También queremos poder hacer funcionar los motores de CC en ambas direcciones. Estas funciones se resuelven mediante un llamado puente H. Usaremos el L293D, que contiene dos puentes H en un chip integrado, lo que significa que podemos conectar los motores Lego (M) en paralelo a un lado y el servo Lego (S) al otro lado del chip. (Si desea controlar los dos motores de forma independiente, necesitará un segundo L293D). El servo Lego también debe estar conectado a GND y Lego +9 Volt.

El chip mantiene a Lego +9 Volt y Arduino +5 Volt completamente separados. ¡Nunca los conecte entre sí o dañará algo! Pero debe conectar todas las líneas de tierra juntas y con los pines de tierra L293D.

Desde nuestro Arduino, usaremos el pin 9 para controlar la velocidad del motor y los pines 2 y 5 para controlar la dirección de rotación. El servo Lego se controla como un motor:conectamos el pin 3 para la posición y los pines 6 y 8 para la dirección (izquierda o derecha).

En la parte superior de nuestro programa, definimos los pines de Arduino usados ​​como constantes. Además, definimos algunas variables que usaremos para controlar los motores:

  // Pines de salida digital de control del motor definidos como constantes globalesconst int controlPin1A =2; const int controlPin2A =5; const int ENablePin =9; // Pines de salida digital de servocontrol definidos como constantes globales const int controlPin3A =6; const int controlPin4A =8; const int servoENablePin =3; // Variables globales de control del motor:int motorSpeed ​​=0; // Velocidad del motor 0..255int motorDirection =1; // Adelante (1) o reverso (0) // Variables globales de control de servo:int dirección =0; // Posición del servo 0..255int directionDirection =0; // Izquierda (0) y Derecha (1)  

En la configuración, definimos estos pines como salidas con el comando pinmode () y luego los configuramos a 0 Voltios con digitalWrite ().

  void setup () {// otras cosas .... // Declarar pines de salida digital:pinMode (controlPin1A, OUTPUT); // 1A pinMode (controlPin2A, SALIDA); // 2A pinMode (ENablePin, SALIDA); // EN1,2 pinMode (controlPin3A, SALIDA); // 3A pinMode (controlPin4A, SALIDA); // 4A pinMode (servoENablePin, SALIDA); // EN3,4 digitalWrite (ENablePin, LOW); // motor apagado digitalWrite (servoENablePin, LOW); // centrado en la dirección}  

Ahora necesitamos entender cómo el chip L293D controla la dirección de rotación de los motores. Tenemos que suministrar las siguientes señales (alta ==5 voltios; baja ==0 voltios):

• EN1,2 1A 2A

• Alto Alto Bajo El motor gira a la izquierda (Adelante; motorDirection ==1)

• Alto Bajo Alto El motor gira a la derecha (Reversa; motorDirection ==0)

• EN3,4 3A 4A

• Alto Alto Bajo Servo gira a la izquierda (directionDirection ==0)

• Alto Bajo Alto Servo gira a la derecha (directionDirection ==1)

Está bien. Estamos listos para escribir una subrutina que lea las variables globales de dirección y velocidad / posición y controle los motores y servo:

  void SetMotorControl () {if (motorDirection ==1) // Adelante {digitalWrite (controlPin1A, HIGH); digitalWrite (controlPin2A, BAJO); } else // Reverse {digitalWrite (controlPin1A, LOW); digitalWrite (controlPin2A, ALTO); } analogWrite (ENablePin, motorSpeed); // Velocidad si (direcciónDirección ==0) // Izquierda {digitalWrite (controlPin3A, HIGH); digitalWrite (controlPin4A, BAJO); } else // Derecha {digitalWrite (controlPin3A, LOW); digitalWrite (controlPin4A, ALTO); } analogWrite (servoENablePin, dirección); // Posición del servo}  

Aplicación simple de RC para Android con joystick

A continuación, creemos una aplicación de Android sencilla para controlar el modelo. (Si primero desea probar la aplicación terminada:la he puesto a su disposición en Google Play Store. Aquí está el enlace:Arduino RC car bluetooth).

Usaremos la aplicación MIT inventor 2. MIT App Inventor es una innovadora introducción para principiantes a la programación y creación de aplicaciones. Mark Friedman de Google y el profesor del MIT Hal Abelson codirigieron el desarrollo de App Inventor. Funciona como un servicio web administrado por el personal del Centro de aprendizaje móvil del MIT.

En su teléfono Android, vaya a Google Play e instale la aplicación MIT AI2 Companion. En su computadora, abra el enlace a mi aplicación RC en el navegador Firefox o Chrome (Internet Explorer no es compatible). Deberá iniciar sesión con su dirección de gmail y crear una cuenta para ver el código fuente. Si abre la aplicación complementaria en su teléfono, puede ver el código fuente en el navegador, realizar cambios y probarlo inmediatamente en su teléfono.

En el navegador, ahora verá la vista de diseñador de la aplicación:

En la parte inferior, vemos la almohadilla naranja con la bola azul del joystick. Ahora cambie a la vista Bloques para ver el programa. El corazón del programa es un bloque de cuándo que realiza un seguimiento de los movimientos de su dedo tocando y arrastrando la bola azul del joystick:

La posición de su dedo se registra en las dos variables actualX y currentY y se utiliza para calcular los valores de las dos variables dirección y velocidad (rango:-100..0 .. + 100). Primero, el programa verifica si su dedo está fuera de la almohadilla y limita los valores a +/- 100. Si el dedo está dentro de la almohadilla, el programa calcula los valores de dirección y velocidad . A continuación, el programa genera una cadena de comandos de la forma:

El comando comienza con "RC" para control remoto (la idea es que en el futuro, es posible que desee tener más comandos) seguido de una coma. Luego enviamos los valores de dirección y velocidad . El carácter de nueva línea ('\ n') al final del comando es una señal para Arduino de que el comando está completo. Esta cadena de comandos se envía por bluetooth al Arduino. Para su referencia, la cadena también se muestra en la pantalla.

Leyendo comandos bluetooth en el Arduino

Para leer las cadenas de comandos de Bluetooth, necesitamos conectar un módulo Bluetooth HC-05. Eche un vistazo a su módulo:

El mío tiene 6 pines. Solo necesitamos cuatro pines. VCC es voltaje de suministro (positivo) y GND es tierra. El módulo tolera un voltaje de suministro de 6 voltios, lo que significa que podemos conectarlo al pin de alimentación arduino de 5 voltios. TXD y RXD son las señales en serie. Tenemos que cruzar las líneas y conectar TXD a arduino RXD (pin 0) y viceversa. Tenga cuidado: Dice NIVEL:3,3 V, lo que significa que el RXD no puede estar conectado directamente al arduino TXD de 5 V (pin 1). Tenemos que construir un divisor de voltaje con tres resistencias de 1 kOhm para producir un voltaje de salida que es 2/3 de 5 V (ver esquemas). Por otro lado, la señal TXD de 3.3V se puede conectar directamente a Arduino RXD. El Arduino reconocerá 3.3 voltios como ALTO.

Como los pines 0 y 1 se comparten con el puerto USB de su Arduino, tendrá que desconectar las señales RXD y TXD del pin 0 y 1 mientras carga el programa a través de USB en la placa. La carga no funcionará si no desconecta los cables.

A continuación, debe emparejar el módulo HC-05 con su dispositivo Android. Encienda el Bluetooth; iniciar la aplicación; presione "Conexión Bluetooth"; haz que tu teléfono sea visible y busca un dispositivo llamado HC-05 o similar. Seleccione el dispositivo. Se le pedirá un código. Presione "1234". Cuando regrese a la pantalla del joystick, debe indicar "conectado" en verde.

Ahora, veamos el código:

  // Tamaño del búfer en serie:calcular en función del tamaño de entrada máximo esperado para un comando INPUT_SIZE + 1]; // matriz de tipo char (C-string) // leer Serial hasta que la nueva línea o el búfer se llene o se agote el tiempo de espera. tamaño de byte =Serial.readBytesUntil ('\ n', input, INPUT_SIZE); // Agrega el 0 final para finalizar la cadena C input [size] =0; // Cadena dividida que tiene la forma:"RC, dirección, velocidad, \ n \ 0" char * command =strtok (input, ","); // comando (RC) // RCsteering en Rango:-100 (izquierda) .. 0 .. 100 (derecha) char * RCsteering =strtok (NULL, ","); // RCspeed en el rango:-100 (velocidad máxima de retroceso) .. 0 .. 100 (máxima velocidad de avance) char * RCspeed =strtok (NULL, ","); int iRCsteering =atoi (RCsteering); // convierte la cadena en un entero int iRCspeed =atoi (RCspeed); // convierte la cadena en un entero // el resto del programa}  

La cadena enviada por la aplicación de Android se lee en una construcción de cadena especial:una cadena C con terminación nula. (El carácter 0 le dice al programa que ha llegado al final de la cadena). Esto se hace usando la función Serial.readBytesUntil ('\ n', input, ...), que lee desde la interfaz serial (bluetooth) hasta que obtiene un carácter de nueva línea ('\ n'). De esa forma, seguimos leyendo bytes hasta que tengamos un comando completo en entrada :

Una forma muy eficaz de procesar entradas es la función de token de cadena, que corta la cadena en partes utilizando una coma como delimitador. La primera llamada a strtok () devuelve "RC". Las partes subsiguientes del comando se leen pasando NULL a strtok (). Los valores devueltos se almacenan en RCsteering y RCspeed . Estas variables son en realidad indicadores de posiciones en entrada . La función atoi () los convierte finalmente en enteros. Ahora tenemos:

Ya casi hemos terminado. Tenemos que multiplicar estos valores por 2.55 antes de pasarlos a nuestra rutina SetMotorControl () (Recuerde que la velocidad del motor estaba en el rango 0..255). ¡Estudie el resto del programa en la sección CÓDIGO, construya el circuito y pruebe su modelo Lego controlado a distancia!

¿Qué sigue?

Ahora que tiene un Arduino controlando su modelo de Lego, es posible que desee utilizar ese modelo como plataforma robótica:agregue algunos sensores de ping ultrasónicos, programe su propia lógica para evitar obstáculos y cree su propio robot Mars rover autónomo. O agregue más comandos al control remoto y más funciones al modelo. Pero primero, encuentre un método para que Arduino descubra que el modelo se ha salido del alcance de la conexión bluetooth y detenga el modelo. Cuéntame tu solución.

Muy pronto, descubrirá que una placa de prototipos y cables sueltos no son una buena idea para un modelo en movimiento. Consiga un protector de motor adafruit con conectores de bloque de terminales grandes y vuelva a cablear y reprogramar. Esto también liberará señales digitales que puede usar como entradas en su lugar. También puede considerar un protector de sensor para una mejor conexión de sus sensores.

¡Cuéntame de tus proyectos actuales!

 / * Lego Powerfunctions modelo de coche controlado por bluetooth Arduino Uno controla motores y servo Control remoto con aplicación de Android desarrollada con la aplicación MIT Inventor 2 Circuito:* Comunicación en serie (usa Uno pin 0,1) Módulo Bluetooth conectado (tiene que desconectarse al cargar el programa a través de USB) * L293D con motor (usa pines digitales Uno 2,5,9) * L293D con servo (usa pines digitales Uno 6,8,3) * /// Bibliotecas usadas:#include  // Biblioteca de interfaz de periféricos en serie # include  // contiene la función strtok:dividir la cadena en tokens // Tamaño de búfer en serie:calcular en función del tamaño de entrada máximo esperado para un comando a través de la interfaz de serie bluetooth # definir INPUT_SIZE 30 / / Pines de salida digital de control de motor definidos como constantes globales (tracción en las 4 ruedas con 2 motores Lego):const int controlPin1A =2; // Entrada del controlador L293D 1A en el pin no 2 http://www.ti.com/lit/ds/symlink/l293.pdf conectado al pin de salida digital Arduino 2const int controlPin2A =5; // Entrada del controlador L293D 2A en el pin no 7 conectado al pin de salida digital Arduino 5const int ENablePin =9; // Entrada L293D ENable (1,2) en el pin no 1 conectado al pin 9 de salida digital Arduino // Pines de salida digital de servocontrol definidos como constantes globales (Servo dirección con 1 servo Lego):const int controlPin3A =6; // Entrada del controlador L293D 3A en el pin no 10 conectado al pin de salida digital Arduino 6const int controlPin4A =8; // Entrada del controlador L293D 4A en el pin no 15 conectado a la salida digital de Arduino pin 8 const int servoENablePin =3; // Entrada L293D ENable (3,4) en el pin no 9 conectado al pin de salida digital 3 de Arduino // Variables globales de control del motor:int motorSpeed ​​=0; // Velocidad del motor 0..255int motorDirection =1; // Adelante (1) o reverso (0) // Variables globales de control de servo:int dirección =0; // Posición del servo 0..255int directionDirection =0; // Izquierda (0) y Derecha (1) void setup () {Serial.begin (9600); // inicializar la comunicación serial Serial.setTimeout (1000); // Tiempo de espera de 1000 ms // Declarar pines de salida digital:pinMode (controlPin1A, OUTPUT); // 1A pinMode (controlPin2A, SALIDA); // 2A pinMode (ENablePin, SALIDA); // EN1,2 pinMode (controlPin3A, SALIDA); // 3A pinMode (controlPin4A, SALIDA); // 4A pinMode (servoENablePin, SALIDA); // EN3,4 digitalWrite (ENablePin, LOW); // motor apagado digitalWrite (servoENablePin, LOW); // centrado en la dirección} void loop () {// Obtiene el siguiente comando del bluetooth en serie (agrega 1 byte para el 0 final) char input [INPUT_SIZE + 1]; // matriz de tipo char (cadena C) con terminación nula (https://www.arduino.cc/en/Reference/String) tamaño de byte =Serial.readBytesUntil ('\ n', input, INPUT_SIZE); // leer Serial hasta que la nueva línea o el búfer se llene o se agote el tiempo de espera // Agregue el 0 final para finalizar la cadena C input [size] =0; // Leer comando que es una cadena C de la forma:"RC, RCsteering, RCspeed, \ n \ 0" (termina con un carácter de nueva línea y un nulo) char * command =strtok (input, ","); // ignorar el comando por ahora (RC para control remoto es el único comando enviado por la aplicación por el momento) char * RCsteering =strtok (NULL, ","); // luego viene RCsteering que está en el rango:-100 (izquierda) .. 0 .. 100 (derecha) char * RCspeed =strtok (NULL, ","); // luego viene RCspeed que está en el Rango:-100 (velocidad máxima de retroceso) .. 0 .. 100 (máxima velocidad de avance) int iRCsteering =atoi (RCsteering); // convierte la cadena RCsteering en un entero iRCsteering int iRCspeed =atoi (RCspeed); // convierte la cadena RCspeed en un número entero iRCspeed // Establece las variables de control del motor y del servo if (iRCsteering> 0) steeringDirection =1; // girar a la derecha si iRCsteering =1..100 else directionDirection =0; // girar a la izquierda si iRCsteering =-100..0 direction =int (2.55 * abs (iRCsteering)); // Posición del servo 0..255 basada en el comando 0..100 if (iRCspeed> 0) motorDirection =1; // Pon el coche en avance si iRCspeed =1..100 else motorDirection =0; // Ponga el coche en reversa si iRCspeed =-100..0 motorSpeed ​​=int (2.55 * abs (iRCspeed)); // Establecer la velocidad 0..255 en base al comando 0..100 SetMotorControl (); // ajustar la dirección y velocidad del motor} void SetMotorControl () / * L293 lógica:EN1,2 1A 2A HHL El motor gira a la izquierda (Adelante; motorDirection ==1) HLH El motor gira a la derecha (Reversa; motorDirection ==0) EN3,4 3A 4A HHL El servo gira a la izquierda (dirección de dirección ==0) HLH El servo gira a la derecha (dirección de dirección ==1) Velocidad del motor:señal PWM en EN1,2 (490 Hz; valor de salida digital 0..255 para velocidad del motor) Posición del servo:señal PWM encendida EN3,4 (490 Hz; valor de salida digital 0..255 para la posición; 0 es recto) * / {if (motorDirection ==1) // Adelante {digitalWrite (controlPin1A, HIGH); digitalWrite (controlPin2A, BAJO); } else // Reverse {digitalWrite (controlPin1A, LOW); digitalWrite (controlPin2A, ALTO); } analogWrite (ENablePin, motorSpeed); // Velocidad si (direcciónDirección ==0) // Izquierda {digitalWrite (controlPin3A, HIGH); digitalWrite (controlPin4A, BAJO); } else // Derecha {digitalWrite (controlPin3A, LOW); digitalWrite (controlPin4A, ALTO); } analogWrite (servoENablePin, dirección); // Posición del servo}