Contrôler un robot Roomba avec Arduino et un appareil Android

Applications et services en ligne

À propos de ce projet

En tant que l'un des gagnants du concours de robotique Instructables 2016, j'ai reçu comme prix un iRobot Roomba Create2. C'est une plate-forme formidable et très abordable pour le développement de la robotique, qui coûte environ 200 $ US. Create 2 permet une variété de méthodes de programmation. Pour commencer, je l'ai utilisé avec un Arduino et une application Android pour déplacer le robot. Dans ce premier tutoriel, j'explorerai comment connecter l'Arduino au Roomba via le port série et comment commander ses moteurs, ses LED et son son. Sur un futur projet, j'explorerai ses capteurs et utiliserai également un Raspberry Pi pour connecter le Roomba à Internet.

Ci-dessous, une vidéo montrant mes premiers résultats en programmant un robot Roomba :

Étape 1 :Nomenclature

• iRobot Create2

• Arduino UNO

• Module Bluetooth HC-06

• Bouton poussoir

Étape 2 :le Roomba Create2

Le Roomba est un robot à entraînement différentiel, avec 2 roues et une roulette avant. Sa vitesse va jusqu'à 500 mm/s et peut être commandée pour aller vers le haut ou vers l'arrière.

Pour la signalisation, on peut compter avec quatre afficheurs 7 segments et 5 LED (voir figure) :

• Nettoyer

• Spot

• Dock

• Avertissement/Vérification

• Saleté/Débris

Comme capteurs internes, nous avons entre autres :

• Détecteur de falaise (4 en façade)

• Détecteurs de chocs (2 à l'avant)

• Encodeurs de roue

Pour la programmation, le document :iRobot® Create® 2 Open Interface (OI) doit être utilisé. Le Roomba peut être programmé en 3 modes :

Mode passif :

• Lors de l'envoi de la commande Démarrer ou de l'une des commandes du mode de nettoyage (par exemple, Spot, Clean, Seek Dock), l'OI passe en mode passif. Lorsque l'OI est en mode passif, vous pouvez demander et recevoir des données de capteur à l'aide de l'une des commandes de capteur, mais vous ne pouvez pas modifier les paramètres de commande actuels pour les actionneurs (moteurs, haut-parleur, lumières, pilotes bas côté, sorties numériques) à autre chose .

Mode sans échec :vous donne le contrôle total de Roomba, à l'exception des conditions de sécurité suivantes :

• Chargeur branché et alimenté.

• Détection d'une chute de roue (sur n'importe quelle roue).

• Détection d'une falaise en avançant (ou en reculant avec un petit rayon de braquage, moins d'un rayon de robot).

• Si l'une des conditions de sécurité ci-dessus se produit alors que l'OI est en mode sans échec, Roomba arrête tous les moteurs et revient en mode passif.

Mode complet :

• Vous donne un contrôle complet sur Roomba, tous ses actionneurs et toutes les conditions liées à la sécurité qui sont restreintes lorsque l'OI est en mode sans échec, car le mode complet éteint la falaise, la chute des roues et les fonctions de sécurité du chargeur interne .

Étape 3 :La connexion série

Pour la communication entre le Roomba et Arduino, le port série sera utilisé. Par défaut, Roomba communique à 115 200 bauds, mais pour communiquer avec Arduino, nous le basculerons à 19 200.

Il existe 2 manières de définir le débit en bauds du Roomba :

• Lorsque vous éteignez Roomba, continuez à maintenir le bouton Clean/Power enfoncé une fois que la lumière s'est éteinte. Après environ 10 secondes, Roomba joue une mélodie de notes descendantes. Roomba communiquera à 19 200 bauds jusqu'à ce que le processeur perde la puissance de la batterie ou que le débit en bauds soit explicitement modifié via l'OI.

• Utilisez la broche de changement de débit en bauds (broche 5 sur le connecteur Mini-DIN) pour modifier le débit en bauds du Roomba. Après avoir allumé Roomba, attendez 2 secondes, puis appuyez sur le Baud Rate Change à trois reprises. Chaque impulsion doit durer entre 50 et 500 millisecondes. Roomba communiquera à 19 200 bauds jusqu'à ce que le processeur perde la puissance de la batterie ou que le débit en bauds soit explicitement modifié via l'OI.

Le schéma ci-dessus montre comment l'Arduino doit être connecté au connecteur Mini-DIN du Roomba

Étape 4 :Démarrage de Roomba

La première chose à faire lors de la programmation d'un Roomba est de :

• "Réveillez" le robot

• Définir le mode (Sécurisé ou complet)

Nous pouvons le "réveiller" en envoyant une impulsion basse à la broche Mini-DIN 5 (détecter l'entrée de l'appareil) comme indiqué sur la fonction ci-dessous :

void wakeUp (void){ setWarningLED(ON); digitalWrite(ddPin, HAUT); retard (100); digitalWrite(ddPin, LOW); retard (500); digitalWrite(ddPin, HAUT); délai (2000);}  

Pour démarrer Roomba toujours 2 codes doivent être envoyés :"START" [128] et le mode, dans notre cas "SAFE MODE" [131]. Si vous souhaitez un "FULL MODE", le code [132] doit être envoyé à la place.

void startSafe(){ Roomba.write(128); //Démarrer Roomba.write(131); //Délai du mode sans échec (1000);}  

Étape 5 :Allumer les voyants et l'affichage

Allumer les LED

Comme décrit en introduction, Roomba dispose de 5 LED :

• Power/Clean (bicolore rouge/vert et intensité contrôlée)

• Spot (Vert, intensité fixe)

• Dock (Vert, intensité fixe)

• Avertissement/Vérification (Orange, intensité fixe)

• Saleté/Débris (Bleu, intensité fixe)

Toutes les LED peuvent être commandées à l'aide du code [139]. Pour contrôler la LED d'alimentation, vous devez envoyer deux octets de données à Roomba :"couleur" et "intensité".

Couleur :

• Vert =0

• Orange =128

• rouge=255

Intensité :

• Faible=0

• Max=255

La fonction setPowerLED (byte setColor, byte setIntensity) le fait :

void setDigitLEDs(octet chiffre1, octet chiffre2, octet chiffre3, octet chiffre4){ Roomba.write(163); Roomba.write(chiffre1) ; Roomba.write(chiffre2) ; Roomba.write(chiffre3) ; Roomba.write(digit4);} 

Par exemple, pour allumer la LED POWER de couleur orange à la moitié de son intensité, vous pouvez appeler la fonction ci-dessous :

setPowerLED (128, 128 ); 

Pour allumer les 4 LED restantes, les fonctions ci-dessous doivent être utilisées :

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

Toutes les fonctions ci-dessus ont un code similaire à celui-ci :

void setDebrisLED(bool enable){brisLED =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)intensity);}  

Fondamentalement, la différence sera la ligne :

debrisLED =activer ; 

qui doit être modifié en activant chacune des autres LED (spotLED, dockLED, warningLED ).

Envoi de messages à afficher

Roomba dispose de quatre écrans à 7 segments que vous pouvez utiliser pour envoyer des messages de deux manières différentes :

• Code [163] :LED de chiffres bruts (numériques)

• Code [164] :Chiffres LED ASCII (Approximation des lettres et codes spéciaux)

Afficher des nombres est très facile. Vous devez envoyer le code [163], en suivant les 4 chiffres à afficher. La fonction :setDigitLEDs(octet chiffre1, octet chiffre2, octet chiffre3, octet chiffre4) le fait pour vous :

void setDigitLEDs(octet chiffre1, octet chiffre2, octet chiffre3, octet chiffre4){ Roomba.write(163); Roomba.write(chiffre1) ; Roomba.write(chiffre2) ; Roomba.write(chiffre3) ; Roomba.write(digit4);}  

Par exemple, pour afficher "1, 2, 3, 4", vous devez appeler la fonction :

setDigitLEDs(1, 2, 3, 4) ; 

Avec le code [164], il est possible d'envoyer une approximation de l'ASCII. La fonction setDigitLEDFromASCII(byte digit, car letter) nous fait ceci :

void setDigitLEDFromASCII(byte digit, char letter){ switch (digit){ case 1 :digit1 =letter ; Pause; cas 2 :chiffre2 =lettre; Pause; cas 3 :chiffre3 =lettre; Pause; cas 4 :chiffre4 =lettre; Pause; } Roomba.write(164); Roomba.write(chiffre1) ; Roomba.write(chiffre2) ; Roomba.write(chiffre3) ; Roomba.write(digit4);}  

Pour simplifier, je crée une nouvelle fonction pour envoyer les 4 chiffres en même temps :

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

Par exemple, pour afficher "STOP", vous devez appeler la fonction :

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

Étape 6 :Déplacer le Roomba

Pour la mobilité, Roomba dispose de 2 moteurs CC indépendants qui peuvent être programmés pour fonctionner jusqu'à 500 mm/s. Plusieurs commandes peuvent être utilisées pour piloter le robot. Les principaux sont :

• Code [137] :Drive ==> Doit envoyer +/- Vitesse en mm/s et +/- Rayon en mm

• Code [145] :Drive Direct ==> Doit envoyer la vitesse gauche/droite en mm/s (+ pour l'avant et - pour l'arrière)

• Code [146] :Drive PWM ==> Doit envoyer des données +/- PWM pour les roues gauche et droite

Vous trouverez ci-dessous le code de ces 3 options :

void drive(int speed, int radius){ clamp(velocity, -500, 500); //def vitesse max et min en mm/s clamp (rayon, -2000, 2000); //def rayon max et min en mm Roomba.write(137); Roomba.write(vitesse>> 8); Roomba.write(vitesse); Roomba.write(rayon>> 8); Roomba.write(rayon);}//----------------------------------------- ------------------------void driveWheels(int right, int left){ clamp(right, -500, 500); pince (gauche, -500, 500); Roomba.write(145); Roomba.write(à droite>> 8); Roomba.write (à droite) ; Roomba.write(gauche>> 8); Roomba.write(gauche); }//------------------------------------------------ ----------------void driveWheelsPWM(int rightPWM, int leftPWM){ clamp(rightPWM, -255, 255); pince (gauchePWM, -255, 255); Roomba.write(146); Roomba.write(rightPWM>> 8); Roomba.write(rightPWM); Roomba.write(leftPWM>> 8); Roomba.write(leftPWM);}  

Notez que la fonction "clamp" définit les valeurs maximales et minimales autorisées à entrer. Cette fonction est définie sur le fichier rombaDefines.h :

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

En utilisant le code ci-dessus, des fonctions plus simples peuvent être créées pour piloter Roomba :

/-------------------------------------------- --------------------void turnCW(vitesse courte non signée, degrés courts non signés){ drive(vitesse, -1); pince (vitesse, 0, 500); retard (6600); lecteur(0,0);}//----------------------------------------- ------------------------------------ void turnCCW(vitesse courte non signée, degrés courts non signés){ drive(vitesse, 1); pince (vitesse, 0, 500); retard (6600); lecteur(0,0);}//----------------------------------------- ----------------------- void driveStop(void){ drive(0,0);}//----------- -------------------------------------------------- --void driveLeft(int left){ driveWheels(left, 0);}//------------------------------- --------------------------------void driveRight(int right){ driveWheels(0, right);}

Notez que pour tourner en angle, l'argument "retard" doit être calculé spécifiquement pour une vitesse donnée. Ci-dessous quelques exemples qui peuvent être utilisés pour tester les moteurs :

turnCW (40, 180); // tourne dans le sens des aiguilles d'une montre à 180 degrés et stopdriveWheels (20, -20); // tourne driveLeft(20); // tourner à gauche

Pour tester les moteurs, il est bon d'ajouter un bouton poussoir externe (dans mon cas connecté à la broche Arduino 12), afin que vous puissiez télécharger le code sur Arduino, en démarrant le Roomba, mais en arrêtant l'exécution jusqu'à ce que le bouton poussoir soit enfoncé. Habituellement, pour les tests de moteurs, vous pouvez le faire dans la partie configuration du code.

À titre d'exemple, veuillez consulter le code Arduino simple ci-dessous (notez que le code utilise des fonctions et des définitions développées auparavant) :

#include "roombaDefines.h"#include // Roomba Create2 connectionint rxPin=10;int txPin=11;SoftwareSerial Roomba(rxPin,txPin);//------ -----------------------------------------------------configuration vide() { Roomba.begin (19200); pinMode(ddPin, SORTIE); pinMode(boutonPin, INPUT_PULLUP); // connecté à la broche Arduino 12 et utilisé pour le délai de "démarrage" (2000); se réveiller (); // Réveil Roomba startSafe(); // Démarrez Roomba en mode sans échec pendant que (digitalRead (buttonPin)) { } // attendez que le bouton soit enfoncé pour exécuter le code en continu turnCW (40, 180); //test de rotation du Roomba à 180 degrés dans le sens des aiguilles d'une montre et arrêt}//---------------------------------- ----------boucle vide() { }  

Étape 7 :Contrôler Roomba via Bluetooth

Pour terminer notre première partie du projet, installons un module Bluetooth (HC-06) sur notre Arduino. Le schéma ci-dessus montre comment procéder. Habituellement, le HC-06 est réglé en usine avec un débit en bauds de 9 600. Il est important que vous le changiez en 19 200 pour être compatible avec la vitesse de communication Arduino-Roomba. Vous pouvez le faire en envoyant une commande AT au module (AT+BAUD5 où "5" est le code pour 19 200).

Si vous avez le moindre doute sur le fonctionnement du HC-06, veuillez consulter mon tutoriel :Connecter des "trucs" via Bluetooth / Android / Arduino.

Pour contrôler le Roomba, nous utiliserons une application générique que j'ai développée pour contrôler les robots mobiles, à l'aide du MIT AppInventor 2:"MJRoBot BT Remote Control". L'application peut être téléchargée gratuitement sur la boutique Google via le lien :Application :MJRoBot BT Remote Control.

L'application dispose d'une interface simple, vous permettant d'envoyer des commandes au module BT à la fois en mode TEXTE ou directement via des boutons préprogrammés (à chaque pression d'un bouton, un caractère est envoyé) :

• w :Avant-propos

• s :En arrière

• d :Exact

• a :Gauche

• f :Arrêtez

• p :ON/OFF (non utilisé sur cette première partie)

• m :manuel/automatique (utilisé pour redémarrer Roomba si un obstacle comme une falaise est trouvé en mode sans échec)

• + :Vitesse +

• - :Vitesse -

Vous pouvez également envoyer d'autres commandes sous forme de texte si nécessaire. Il existe également une fenêtre de texte pour les messages reçus du module BT. Cette fonctionnalité est très importante lors de la phase de test, elle peut être utilisée de la même manière que le "Serial Monitor".

La boucle() une partie du code sera « l'écoute » du périphérique Bluetooth et, en fonction de la commande reçue, effectuera une action :

boucle vide() { checkBTcmd(); // vérifie si une commande est reçue de la télécommande BT manualCmd ();} 

La fonction checkBTcmd() est illustré ci-dessous :

void checkBTcmd() // vérifie si une commande est reçue de la télécommande BT { if (BT1.available()) { command =BT1.read(); BT1.flush(); } } 

Une fois la commande reçue, la fonction manualCmd() prendra les mesures appropriées :

void manualCmd(){ switch (commande) { case 'm':startSafe(); Serial.print("Roomba en mode sans échec"); BT1.print("Roomba BT Ctrl OK - Mode sans échec"); BT1.println('\n'); commande ='f'; playSound (3) ; Pause; cas 'f' :driveStop(); //éteindre les deux moteurs writeLEDs ('s', 't', 'o', 'p'); état =commande ; Pause; cas 'w' :entraînement (motorSpeed, 0); writeLEDs (' ', 'g', 'o', ' '); état =commande ; Pause; case 'd' :driveRight(motorSpeed); writeLEDs ('r', 'i', 'g', 'h'); Pause; cas 'a' :driveLeft(motorSpeed); writeLEDs ('l', 'e', ​​'f', 't'); Pause; cas 's' :lecteur (-motorSpeed, 0); writeLEDs ('b', 'a', 'c', 'k'); état =commande ; Pause; case '+':if (state =='w') { motorSpeed ​​=motorSpeed ​​+ 10; if (motorSpeed ​​> MAX_SPEED) { motorSpeed ​​=MAX_SPEED; } commande ='w'; } else {commande =état;} pause ; case '-':if (state =='w') { motorSpeed ​​=motorSpeed ​​- 10; } if (motorSpeed ​​ 

Étape 8 : Conclusion

Le code Arduino complet utilisé ici et les documents associés peuvent être trouvés sur mon GITHUB :Roomba_BT_Ctrl.

Veuillez noter que tous les actionneurs Roomba n'ont pas été commentés sur ce tutoriel. Il existe d'autres moteurs, utilisés pour le nettoyage, d'autres LED utilisées pour l'horaire, des boutons, des capteurs, etc.

Plusieurs des fonctions que j'ai créées sur mon programme étaient basées sur la bibliothèque Create 2 développée par Dom Amato. Vous pouvez télécharger la bibliothèque complète sur :https://github.com/brinnLabs/Create2 .

Mon intention ici était de rester simple et de vous donner une plate-forme de départ pour commencer à jouer avec Roomba. Dans le futur, je prétends publier d'autres tutos, utiliser un Raspberry-Pi, connecter le Roomba à internet, lire ses capteurs, etc.

Comme toujours, j'espère que ce projet pourra aider d'autres personnes à trouver leur chemin dans le monde passionnant de l'électronique et de la robotique !

Pour plus de projets, s'il vous plaît visitez mon blog (en portugais):

MJRoBot.org

Salutations du sud du monde !

Rendez-vous à mon prochain tutoriel !

Merci

Marcelo