Manufactura industrial
Internet industrial de las cosas | Materiales industriales | Mantenimiento y reparación de equipos | Programación industrial |
home  MfgRobots >> Manufactura industrial >  >> Manufacturing Technology >> Proceso de manufactura

Controlar un robot Roomba con Arduino y un dispositivo Android

Componentes y suministros

Roomba Create2
× 1
Arduino UNO
× 1
Interruptor de botón SparkFun de 12 mm
× 1

Aplicaciones y servicios en línea

MJRoBot BT Remote Control - Aplicación para Android

Acerca de este proyecto

Como uno de los ganadores del Concurso de Robótica Instructables 2016, recibí como premio un iRobot Roomba Create2. Es una plataforma excelente y muy asequible para el desarrollo de robótica, que cuesta alrededor de 200 dólares estadounidenses. Create 2 permite una variedad de métodos de programación. Para empezar, lo usé con un Arduino y una aplicación de Android para mover el robot. En este primer tutorial, exploraré cómo conectar el Arduino con el Roomba a través del puerto serie y cómo controlar sus motores, LEDS y sonido. En proyectos futuros, exploraré sus sensores y también usaré una Raspberry Pi para conectar el Roomba a Internet.

A continuación, un video que muestra mis primeros resultados programando un robot Roomba:

Paso 1:lista de materiales

  • iRobot Create2
  • Arduino UNO
  • Módulo Bluetooth HC-06
  • Botón pulsador

Paso 2:el Roomba Create2

El Roomba es un robot de accionamiento diferencial, con 2 ruedas y una rueda delantera. Su velocidad sube a 500 mm / sy se le puede ordenar que vaya hacia arriba o hacia atrás.

Para la señalización podemos contar con cuatro display de 7 segmentos y 5 leds (ver figura):

  • Limpio
  • Spot
  • Muelle
  • Advertencia / Verificación
  • Suciedad / escombros

Como sensores internos, tenemos entre otros:

  • Detector de acantilados (4 al frente)
  • Detectores de golpes (2 al frente)
  • Codificadores de rueda

Para la programación, se debe utilizar el documento:iRobot® Create® 2 Open Interface (OI). El Roomba se puede programar en 3 modos:

Modo pasivo:

  • Al enviar el comando de Inicio o cualquiera de los comandos del modo de limpieza (por ejemplo, Spot, Clean, Seek Dock), el OI ingresa al modo Pasivo. Cuando el OI está en modo pasivo, puede solicitar y recibir datos del sensor usando cualquiera de los comandos del sensor, pero no puede cambiar los parámetros de comando actuales para los actuadores (motores, parlantes, luces, controladores de lado bajo, salidas digitales) a otra cosa. .

Modo seguro:le da el control total de Roomba, con la excepción de las siguientes condiciones relacionadas con la seguridad:

  • Cargador enchufado y encendido.
  • Detección de caída de rueda (en cualquier rueda).
  • Detección de un acantilado mientras avanza (o retrocede con un radio de giro pequeño, menos de un radio de robot).
  • Si ocurre una de las condiciones de seguridad mencionadas anteriormente mientras el OI está en modo seguro, Roomba detiene todos los motores y vuelve al modo pasivo.

Modo completo:

  • Le brinda control completo sobre Roomba, todos sus actuadores y todas las condiciones relacionadas con la seguridad que están restringidas cuando el OI está en modo seguro, ya que el modo completo apaga las características de seguridad del cargador interno, caída de rueda y acantilado .

Paso 3:la conexión en serie

Para la comunicación entre Roomba y Arduino, se utilizará el puerto serie. De forma predeterminada, Roomba se comunica a 115.200 baudios, pero para comunicarse con Arduino, lo cambiaremos a 19.200.

Hay 2 formas de configurar la velocidad en baudios de Roomba:

  • Mientras apaga Roomba, continúe presionando el botón Limpiar / Encendido después de que la luz se haya apagado. Después de unos 10 segundos, Roomba reproduce una melodía de tonos descendentes. Roomba se comunicará a 19.200 baudios hasta que el procesador pierda energía de la batería o la velocidad en baudios se cambie explícitamente por medio del OI.
  • Utilice el pin de cambio de velocidad en baudios (pin 5 en el conector Mini-DIN) para cambiar la velocidad en baudios de Roomba. Después de encender Roomba, espere 2 segundos y luego pulse el Baud Rate Change bajo tres veces. Cada pulso debe durar entre 50 y 500 milisegundos. Roomba se comunicará a 19200 baudios hasta que el procesador pierda energía de la batería o la velocidad en baudios se cambie explícitamente por medio del OI.

El diagrama anterior muestra cómo se debe conectar el Arduino al conector Roomba Mini-DIN

Paso 4:Iniciar Roomba

Lo primero que se debe hacer al programar un Roomba es:

  • "Despierta" al robot
  • Defina el modo (seguro o completo)

Podemos "despertarlo", enviando un pulso bajo al pin 5 Mini-DIN (detectar la entrada del dispositivo) como se muestra en la función a continuación:

  void wakeUp (void) {setWarningLED (ON); escritura digital (ddPin, ALTA); retraso (100); digitalWrite (ddPin, BAJO); retraso (500); escritura digital (ddPin, ALTA); retraso (2000);}  

Para iniciar Roomba siempre se deben enviar 2 códigos:"INICIO" [128] y el modo, en nuestro caso "MODO SEGURO" [131]. Si desea un "MODO COMPLETO", debe enviar el código [132] en su lugar.

  void startSafe () {Roomba.write (128); // Iniciar Roomba.write (131); // Retraso en modo seguro (1000);}  

Paso 5:encender los LED y la pantalla

Encendido de los LED

Como se describe en la introducción, Roomba tiene 5 LED:

  • Poder / Limpio (bicolor rojo / verde e intensidad controlada)
  • Spot (verde, intensidad fija)
  • Muelle (verde, intensidad fija)
  • Advertencia / verificación (naranja, intensidad fija)
  • Suciedad / escombros (azul, intensidad fija)

Todos los LED se pueden controlar mediante el código [139]. Para controlar el LED de encendido, debe enviar dos bytes de datos a Roomba:"color" e "intensidad".

Color:

  • Verde =0
  • Naranja =128
  • rojo =255

Intensidad:

  • Bajo =0
  • Max =255

La función setPowerLED (byte setColor, byte setIntensity) lo hace:

  void setDigitLEDs (byte digit1, byte digit2, byte digit3, byte digit4) {Roomba.write (163); Roomba.write (dígito1); Roomba.write (dígito2); Roomba.write (dígito3); Roomba.write (dígito4);}  

Por ejemplo, para encender el LED de ENCENDIDO con color naranja a la mitad de su intensidad, puede llamar a la función de la siguiente manera:

  setPowerLED (128, 128);  

Para encender los 4 LED restantes, se deben utilizar las siguientes funciones:

  setDebrisLED (ON); setDockLED (ON); setSpotLED (ACTIVADO); setWarningLED (ON);  

Todas las funciones anteriores tienen un código similar a este:

  void setDebrisLED (bool enable) {debrisLED =enable; Roomba.write (139); Roomba.write ((debrisLED? 1:0) + (spotLED? 2:0) + (dockLED? 4:0) + (warningLED? 8:0)); Roomba.write ((byte) color); Roomba.write ((byte) intensidad);}  

Básicamente, la diferencia será la línea:

  debrisLED =enable;  

que deben cambiarse habilitando cada uno de los demás LED ( spotLED, dockLED, warningLED ).

Envío de mensajes a la pantalla

Roomba tiene cuatro pantallas de 7 segmentos que puede usar para enviar mensajes de dos formas diferentes:

  • Código [163]:LED de dígitos sin formato (numérico)
  • Código [164]:LED de dígitos ASCII (Aproximación de letras y códigos especiales)

Mostrar números es muy fácil. Debe enviar el código [163], siguiendo los 4 dígitos que se visualizarán. La función: setDigitLEDs (byte digit1, byte digit2, byte digit3, byte digit4) hace esto por ti:

  void setDigitLEDs (byte digit1, byte digit2, byte digit3, byte digit4) {Roomba.write (163); Roomba.write (dígito1); Roomba.write (dígito2); Roomba.write (dígito3); Roomba.write (dígito4);}  

Por ejemplo, para mostrar "1, 2, 3, 4", debe llamar a la función:

  setDigitLEDs (1, 2, 3, 4);  

Con el código [164], es posible enviar aproximaciones de ASCII. La función setDigitLEDFromASCII (dígito de byte, letra de carácter) nos hace esto:

  void setDigitLEDFromASCII (dígito de byte, letra de carácter) {interruptor (dígito) {caso 1:dígito1 =letra; descanso; caso 2:dígito2 =letra; descanso; caso 3:dígito3 =letra; descanso; caso 4:dígito4 =letra; descanso; } Roomba.write (164); Roomba.write (dígito1); Roomba.write (dígito2); Roomba.write (dígito3); Roomba.write (dígito4);}  

Para simplificar, creo una nueva función para enviar los 4 dígitos al mismo tiempo:

  void writeLEDs (char a, char b, char c, char d) {setDigitLEDFromASCII (1, a); setDigitLEDFromASCII (2, b); setDigitLEDFromASCII (3, c); setDigitLEDFromASCII (4, d);}  

Por ejemplo, para mostrar "DETENER", debe llamar a la función:

  writeLEDs ('s', 't', 'o', 'p');  

Paso 6:Mover el Roomba

Para la movilidad, Roomba tiene 2 motores de CC independientes que se pueden programar para funcionar hasta 500 mm / s. Hay varios comandos que se pueden utilizar para conducir el robot. Los principales son:

  • Código [137]:Drive ==> Debe enviar +/- Velocidad en mm / sy +/- Radio en mm
  • Código [145]:Drive Direct ==> Debe enviar la velocidad izquierda / derecha en mm / s (+ para avance y - para retroceso)
  • Código [146]:Drive PWM ==> Debe enviar +/- datos PWM para las ruedas izquierda y derecha

A continuación se muestra el código para esas 3 opciones:

  void drive (int velocidad, int radio) {clamp (velocity, -500, 500); // def velocidad máxima y mínima en mm / s abrazadera (radio, -2000, 2000); // def radio máximo y mínimo en mm Roomba.write (137); Roomba.write (velocidad>> 8); Roomba.write (velocidad); Roomba.write (radio>> 8); Roomba.write (radio);} // ---------------------------------------- ----------------------- void driveWheels (int derecha, int izquierda) {abrazadera (derecha, -500, 500); abrazadera (izquierda, -500, 500); Roomba.write (145); Roomba.write (derecha>> 8); Roomba.write (derecha); Roomba.write (izquierda>> 8); Roomba.write (izquierda); } // ----------------------------------------------- ---------------- void driveWheelsPWM (int rightPWM, int leftPWM) {abrazadera (rightPWM, -255, 255); abrazadera (leftPWM, -255, 255); Roomba.write (146); Roomba.write (rightPWM>> 8); Roomba.write (rightPWM); Roomba.write (leftPWM>> 8); Roomba.write (leftPWM);}  

Tenga en cuenta que la función "sujetar" define los valores máximo y mínimo que se pueden ingresar. Esta función está definida en el archivo rombaDefines.h:

  #define clamp (value, min, max) (value  max? max:value)  

Usando el código anterior, se pueden crear funciones más simples para impulsar Roomba:

  / ------------------------------------------- -------------------- void turnCW (velocidad corta sin signo, grados cortos sin signo) {drive (velocidad, -1); abrazadera (velocidad, 0, 500); retraso (6600); unidad (0,0);} // ---------------------------------------- ----------------------- giro vacío CCW (velocidad corta sin signo, grados cortos sin signo) {drive (velocidad, 1); abrazadera (velocidad, 0, 500); retraso (6600); unidad (0,0);} // ---------------------------------------- ----------------------- void driveStop (void) {drive (0,0);} // ----------- -------------------------------------------------- --void driveLeft (int left) {driveWheels (left, 0);} // ------------------------------- -------------------------------- void driveRight (int right) {driveWheels (0, right);}  

Tenga en cuenta que para girar en ángulo, el argumento "retraso" debe calcularse específicamente para una velocidad determinada. A continuación, se muestran algunos ejemplos que se pueden utilizar para probar los motores:

  turnCW (40, 180); // gira 180 grados en el sentido de las agujas del reloj y detiene las ruedas motrices (20, -20); // girar driveLeft (20); // girando a la izquierda  

Para probar los motores, es bueno agregar un pulsador externo (en mi caso conectado al pin 12 de Arduino), para que puedas descargar el código a Arduino, iniciando el Roomba, pero deteniendo la ejecución hasta que se presione el pulsador. Por lo general, para las pruebas de motores, puede hacerlo en la parte de configuración del código.

Como ejemplo, consulte el código Arduino simple a continuación (tenga en cuenta que el código usa funciones y definiciones desarrolladas anteriormente):

  #include "roombaDefines.h" #include  // Roomba Create2 connectionint rxPin =10; int txPin =11; SoftwareSerial Roomba (rxPin, txPin); // ------ --------------------------------------- configuración vacía () {Roomba.begin (19200); pinMode (ddPin, SALIDA); pinMode (buttonPin, INPUT_PULLUP); // conectado al pin 12 de Arduino y utilizado para el retardo de "inicio" (2000); despierta (); // Activar Roomba startSafe (); // Iniciar Roomba en modo seguro mientras (digitalRead (buttonPin)) {} // esperar que se presione el botón para ejecutar de forma continua el código turnCW (40, 180); // prueba Roomba gira 180 grados en el sentido de las agujas del reloj y deténgase} // ----------------------------------- ---------- bucle vacío () {}  

Paso 7:controlar Roomba a través de Bluetooth

Para completar nuestra primera parte del proyecto, instalemos un módulo Bluetooth (HC-06) en nuestro Arduino. El diagrama de arriba muestra cómo hacerlo. Por lo general, el HC-06 viene de fábrica con una tasa de baudios de 9.600. Es importante que lo cambie a 19.200 para que sea compatible con la velocidad de comunicación Arduino-Roomba. Puede hacerlo enviando un comando AT al módulo (AT + BAUD5 donde "5" es el código para 19,200).

Si tiene alguna duda sobre cómo funciona el HC-06, consulte mi tutorial:Conexión de "cosas" a través de Bluetooth / Android / Arduino.

Para controlar el Roomba, usaremos una aplicación genérica que fue desarrollada por mí para controlar robots móviles, usando el MIT AppInventor 2:"MJRoBot BT Remote Control". La aplicación se puede descargar de forma gratuita desde la tienda de Google a través del enlace:Aplicación:MJRoBot BT Remote Control.

La aplicación tiene una interfaz simple, lo que le permite enviar comandos al módulo BT tanto en modo TEXTO como directamente a través de botones preprogramados (cada vez que se presiona un botón, se envía un carácter):

  • w:Foreward
  • s:al revés
  • d:Derecha
  • a:izquierda
  • f:detener
  • p:ON / OFF (no se utiliza en esta primera parte)
  • m:Manual / Automático (se utiliza para reiniciar Roomba si se encuentra un obstáculo como un acantilado en el modo seguro)
  • +:Velocidad +
  • -:Velocidad -

También puede enviar otros comandos como texto si es necesario. También hay una ventana de texto para los mensajes recibidos del módulo BT. Esta función es muy importante durante la fase de prueba, se puede utilizar de la misma forma que el "Monitor en serie".

El bucle () parte del código será "escuchar" el dispositivo bluetooth y, según el comando recibido, tomar una acción:

  void loop () {checkBTcmd (); // verifica si se recibe un comando del control remoto BT manualCmd ();}  

La función checkBTcmd () se muestra a continuación:

  void checkBTcmd () // verifica si se recibe un comando del control remoto BT {if (BT1.available ()) {command =BT1.read (); BT1.flush (); }}  

Una vez que se recibe un comando, la función manualCmd () tomará la acción apropiada:

  void manualCmd () {switch (comando) {case 'm':startSafe (); Serial.print ("Roomba en modo seguro"); BT1.print ("Roomba BT Ctrl OK - Modo seguro"); BT1.println ('\ n'); comando ='f'; playSound (3); descanso; caso 'f':driveStop (); // apaga ambos motores writeLEDs ('s', 't', 'o', 'p'); estado =comando; descanso; caso 'w':drive (motorSpeed, 0); writeLEDs ('', 'g', 'o', ''); estado =comando; descanso; caso 'd':driveRight (motorSpeed); writeLEDs ('r', 'i', 'g', 'h'); descanso; caso 'a':driveLeft (motorSpeed); writeLEDs ('l', 'e', ​​'f', 't'); descanso; case 's':drive (-motorSpeed, 0); writeLEDs ('b', 'a', 'c', 'k'); estado =comando; descanso; case '+':if (estado =='w') {motorSpeed ​​=motorSpeed ​​+ 10; if (motorSpeed> MAX_SPEED) {motorSpeed ​​=MAX_SPEED; } comando ='w'; } else {comando =estado;} romper; case '-':if (estado =='w') {motorSpeed ​​=motorSpeed ​​- 10; } if (motorSpeed ​​ 

Paso 8:Conclusión

El código completo de Arduino utilizado aquí y los documentos relacionados se pueden encontrar en mi GITHUB:Roomba_BT_Ctrl.

Tenga en cuenta que no todos los actuadores Roomba fueron comentados en este tutorial. Hay otros motores, que se utilizan para la limpieza, otros LED que se utilizan para el horario, botones, sensores, etc.

Varias de las funciones que creé en mi programa se basaron en la biblioteca Create 2 desarrollada por Dom Amato. Puede descargar la biblioteca completa en: https://github.com/brinnLabs/Create2 .

Mi intención aquí era mantener la sencillez y ofrecerles una plataforma de inicio para empezar a jugar con Roomba. En el futuro, pretendo publicar otros tutoriales, usar una Raspberry-Pi, conectar el Roomba a internet, leer sus sensores, etc.

Como siempre, espero que este proyecto pueda ayudar a otros a encontrar su camino en el apasionante mundo de la electrónica y la robótica.

Para más proyectos, visite mi blog (en portugués):

MJRoBot.org

¡Saludos desde el sur del mundo!

¡Nos vemos en mi próximo tutorial!

Gracias

Marcelo

Código

Github
https://github.com/Mjrovai/Roomba_BT_Ctrl

Proceso de manufactura

  1. Control de un efecto con sensores reales
  2. Cree un detector de incendios en minutos con Samsung SAMIIO, Arduino UNO y Raspberry Pi
  3. Cree su robot de transmisión de video controlado por Internet con Arduino y Raspberry Pi
  4. Control remoto universal usando Arduino, 1Sheeld y Android
  5. Obstáculos que evitan el robot con servomotor
  6. Termómetro portátil con dispositivo Android
  7. Control del servomotor con Arduino y MPU6050
  8. Control del brillo del LED usando Bolt y Arduino
  9. Módulo GPS u-blox LEA-6H 02 con Arduino y Python
  10. Reconocimiento y síntesis de voz con Arduino
  11. Controlar una matriz de LED con Arduino Uno