Een Roomba-robot besturen met Arduino en Android-apparaat

Over dit project

Als een van de winnaars van de Instructables Robotics Contest 2016 ontving ik als prijs een iRobot Roomba Create2. Het is een geweldig en zeer betaalbaar platform voor de ontwikkeling van robotica, dat ongeveer $ 200 kost. Create 2 maakt een verscheidenheid aan programmeermethoden mogelijk. Om te beginnen gebruikte ik het met een Arduino en een Android-app om de robot te verplaatsen. In deze eerste tutorial zal ik onderzoeken hoe de Arduino via de seriële poort met de Roomba kan worden verbonden en hoe de motoren, LEDS en geluid te bedienen. Bij toekomstige projecten zal ik de sensoren ervan verkennen en ook een Raspberry Pi gebruiken om de Roomba met internet te verbinden.

Hieronder een video die mijn eerste resultaten toont bij het programmeren van een Roomba-robot:

Stap 1:Stuklijst

• iRobot Create2

• Arduino UNO

• Bluetooth-module HC-06

• Drukknop

Stap 2:De Roomba Create2

De Roomba is een differentieel aangedreven robot, met 2 wielen en een voorwiel. Zijn snelheid gaat tot 500 mm/s en kan worden opgedragen om omhoog of achteruit te gaan.

Voor signalisatie kunnen we rekenen op vier 7 segmenten display en 5 LED's (zie afbeelding):

• Schoon

• Plek

• Dock

• Waarschuwing/controle

• Vuil/puin

Als interne sensoren hebben we onder andere:

• Klifdetector (4 vooraan)

• Bump detectoren (2 voor)

• Wiel-encoders

Voor het programmeren moet het document:iRobot® Create® 2 Open Interface (OI) worden gebruikt. De Roomba kan in 3 standen worden geprogrammeerd:

Passieve modus:

• Bij het verzenden van het Start-commando of een van de opdrachten voor de reinigingsmodus (bijv. Spot, Clean, Seek Dock), gaat de OI naar de passieve modus. Wanneer de OI zich in de passieve modus bevindt, kunt u sensorgegevens opvragen en ontvangen met behulp van een van de sensoropdrachten, maar u kunt de huidige opdrachtparameters voor de actuatoren (motoren, luidspreker, lichten, low-side drivers, digitale uitgangen) niet wijzigen in iets anders .

Veilige modus:geeft u volledige controle over Roomba, met uitzondering van de volgende veiligheidsgerelateerde voorwaarden:

• Oplader aangesloten en ingeschakeld.

• Detectie van een wieldruppel (op elk wiel).

• Detectie van een klif tijdens het vooruit bewegen (of achteruit bewegen met een kleine draaicirkel, minder dan één robotradius).

• Als een van de bovenstaande veiligheidsgerelateerde omstandigheden zich voordoet terwijl de OI zich in de veilige modus bevindt, stopt Roomba alle motoren en keert terug naar de passieve modus.

Volledige modus:

• Geeft u volledige controle over Roomba, al zijn aandrijvingen en alle veiligheidsgerelateerde voorwaarden die beperkt zijn wanneer de OI zich in de veilige modus bevindt, aangezien de volledige modus de klif, wiel-drop en interne oplader-veiligheidsfuncties uitschakelt .

Stap 3:De seriële verbinding

Voor communicatie tussen de Roomba en Arduino wordt de seriële poort gebruikt. Roomba communiceert standaard op 115.200 baud, maar om met Arduino te kunnen communiceren, schakelen we dit over naar 19.200.

Er zijn 2 manieren om de baudrate van Roomba in te stellen:

• Terwijl u Roomba uitschakelt, blijft u de Clean/Power-knop ingedrukt houden nadat het lampje is uitgegaan. Na ongeveer 10 seconden speelt Roomba een deuntje van dalende toonhoogtes. Roomba communiceert met 19.200 baud totdat de processor de batterijvoeding verliest of de baudrate expliciet wordt gewijzigd door middel van de OI.

• Gebruik de baudrate-wijzigingspen (pin 5 op de mini-DIN-connector) om de baudrate van Roomba te wijzigen. Wacht na het inschakelen van Roomba 2 seconden en pulseer vervolgens de Baud Rate Change-laag drie keer. Elke puls moet tussen de 50 en 500 milliseconden duren. Roomba communiceert op 19200 baud totdat de processor de batterij verliest of de baudrate expliciet wordt gewijzigd door middel van de OI.

Het bovenstaande diagram laat zien hoe de Arduino moet worden aangesloten op de Roomba Mini-DIN-connector

Stap 4:Roomba starten

Het eerste dat moet worden gedaan bij het programmeren van een Roomba is:

• Maak de robot wakker

• Definieer de modus (veilig of volledig)

We kunnen het "wekken" door een lage puls naar Mini-DIN pin 5 (detecteer apparaatinvoer) te sturen, zoals weergegeven in de onderstaande functie:

void wakeUp (void){ setWarningLED(ON); digitalWrite(ddPin, HOOG); vertraging (100); digitalWrite(ddPin, LAAG); vertraging (500); digitalWrite(ddPin, HOOG); vertraging(2000);}  

Om Roomba te starten moeten altijd 2 codes worden verzonden:"START" [128] en de modus, in ons geval "SAFE MODE" [131]. Als u een "VOLLEDIGE MODUS" wilt, moet in plaats daarvan de code [132] worden verzonden.

void startSafe(){ Roomba.write(128); //Start Roomba.write (131); //Veilige modus vertraging (1000);}  

Stap 5:De LED's en het display inschakelen

De LED's inschakelen

Zoals beschreven bij de introductie, heeft Roomba 5 LED's:

• Power/Clean (tweekleurig rood/groen en gecontroleerde intensiteit)

• Spot (groen, vaste intensiteit)

• Dock (groen, vaste intensiteit)

• Waarschuwing/controle (oranje, vaste intensiteit)

• Vuil/vuil (blauw, vaste intensiteit)

Alle LED's kunnen worden aangestuurd met code [139]. Om de Power-LED te bedienen, moet u twee databytes naar Roomba sturen:"kleur" en "intensiteit".

Kleur:

• Groen =0

• Oranje =128

• rood=255

Intensiteit:

• Laag=0

• Max=255

De functie setPowerLED (byte setColor, byte setIntensity) doet het:

void setDigitLEDs(byte digit1, byte digit2, byte digit3, byte digit4){ Roomba.write(163); Roomba.write(cijfer1); Roomba.write(cijfer2); Roomba.write(cijfer3); Roomba.write(digit4);} 

Om bijvoorbeeld de POWER-LED met oranje kleur op de helft van zijn intensiteit in te schakelen, kunt u de onderstaande functie oproepen:

setPowerLED (128, 128); 

Om de overige 4 LED's AAN te zetten, moeten de balgfuncties worden gebruikt:

setDebrisLED(AAN);setDockLED(AAN); setSpotLED(AAN); setWarningLED(AAN); 

Alle bovenstaande functies hebben een code die lijkt op deze:

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

In wezen is het verschil de regel:

debrisLED =inschakelen; 

die moeten worden gewijzigd om elk van de andere LED's in te schakelen (spotLED, dockLED, warningLED ).

Berichten verzenden om weer te geven

Roomba heeft vier 7 Segment Displays die u kunt gebruiken om op twee verschillende manieren berichten te verzenden:

• Code [163]:Cijfer-LED's onbewerkt (numeriek)

• Code [164]:Cijfer-LED's ASCII (benadering van letters en speciale codes)

Cijfers weergeven is heel eenvoudig. U moet de code [163] verzenden, na de 4 cijfers die moeten worden weergegeven. De functie:setDigitLEDs(byte digit1, byte digit2, byte digit3, byte digit4) doet dit voor u:

void setDigitLEDs(byte digit1, byte digit2, byte digit3, byte digit4){ Roomba.write(163); Roomba.write(cijfer1); Roomba.write(cijfer2); Roomba.write(cijfer3); Roomba.write(digit4);}  

Om bijvoorbeeld "1, 2, 3, 4" weer te geven, moet u de functie aanroepen:

setDigitLEDs(1, 2, 3, 4); 

Met code [164] is het mogelijk om een ​​benadering van ASCII te verzenden. De functie setDigitLEDFromASCII(byte digit, char letter) doet dit met ons:

void setDigitLEDFromASCII(byte digit, char letter){ switch (digit){ case 1:digit1 =letter; pauze; geval 2:cijfer2 =letter; pauze; geval 3:cijfer3 =letter; pauze; geval 4:cijfer4 =letter; pauze; } Roomba.write(164); Roomba.write(cijfer1); Roomba.write(cijfer2); Roomba.write(cijfer3); Roomba.write(digit4);}  

Om het eenvoudiger te maken, heb ik een nieuwe functie gemaakt om de 4 cijfers tegelijkertijd te verzenden:

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

Om bijvoorbeeld "STOP" weer te geven, moet u de functie oproepen:

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

Stap 6:De Roomba verplaatsen

Voor mobiliteit heeft Roomba 2 onafhankelijke gelijkstroommotoren die kunnen worden geprogrammeerd om tot 500 mm/sec te lopen. Er zijn verschillende commando's die kunnen worden gebruikt om de robot te besturen. De belangrijkste zijn:

• Code [137]:Aandrijving ==> Moet +/- Snelheid in mm/s en +/- Radius in mm verzenden

• Code [145]:Drive Direct ==> Moet snelheid links/rechts verzenden in mm/s (+ voor vooruit en - voor achteruit)

• Code [146]:Drive PWM ==> Moet +/- PWM-gegevens verzenden voor linker- en rechterwielen

Hieronder staat de code voor die 3 opties:

void drive(int snelheid, int radius){ clamp(velocity, -500, 500); //def max en min snelheid in mm/s klem (straal, -2000, 2000); //def max en min straal in mm Roomba.write (137); Roomba.write(snelheid>> 8); Roomba.write(snelheid); Roomba.write(straal>> 8); Roomba.write(straal);}//---------------------------------------- ----------------------- ongeldige aandrijfwielen (int rechts, int links) {klem (rechts, -500, 500); klem (links, -500, 500); Roomba.write(145); Roomba.write(rechts>> 8); Roomba.write(rechts); Roomba.write(links>> 8); Roomba.write(links); }//----------------------------------------------- ---------------- ongeldige driveWheelsPWM (int rechtsPWM, int linksPWM) {klem (rechtsPWM, -255, 255); klem (linksPWM, -255, 255); Roomba.write(146); Roomba.write(rightPWM>> 8); Roomba.write(rightPWM); Roomba.write(linksPWM>> 8); Roomba.write(leftPWM);}  

Merk op dat de "klem"-functie de maximum- en minimumwaarden definieert die mogen worden ingevoerd. Deze functie is gedefinieerd in het bestand rombaDefines.h:

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

Met behulp van de bovenstaande code kunnen eenvoudigere functies worden gemaakt om Roomba rond te rijden:

/------------------------------------------- -------------------- ongeldige turnCW (unsigned korte snelheid, unsigned korte graden) {drive (snelheid, -1); klem (snelheid, 0, 500); vertraging (6600); schijf(0,0);}//---------------------------------------- ----------------------- ongeldige draai CCW (onondertekende korte snelheid, niet-ondertekende korte graden) {drive (snelheid, 1); klem (snelheid, 0, 500); vertraging (6600); schijf(0,0);}//---------------------------------------- -----------------------void driveStop(void){ drive(0,0);}//----------- -------------------------------------------------- --void driveLeft(int links){ driveWheels(links, 0);}//------------------------------- --------------------------------void driveRight(int rechts){ driveWheels(0, right);}  

Merk op dat om in een hoek te draaien, het argument "vertraging" specifiek voor een bepaalde snelheid moet worden berekend. Hieronder enkele voorbeelden die kunnen worden gebruikt voor het testen van de motoren:

turnCW (40, 180); // draai 180 graden met de klok mee en stopdriveWheels (20, -20); // draai driveLinks (20); // linksaf 

Voor het testen van de motoren is het goed om een ​​externe drukknop toe te voegen (in mijn geval aangesloten op Arduino pin 12), zodat je de code naar Arduino kunt downloaden, de Roomba starten, maar de uitvoering stoppen totdat de drukknop wordt ingedrukt. Meestal kunt u voor het testen van motoren dit doen in het configuratiegedeelte van de code.

Zie als voorbeeld de eenvoudige Arduino-code hieronder (merk op dat de code functies en definities gebruikt die eerder zijn ontwikkeld):

#include "roombaDefines.h"#include // Roomba Create2 connectionint rxPin=10;int txPin=11;SoftwareSerial Roomba(rxPin,txPin);//------ --------------------------------------- ongeldige setup() { Roomba.begin(19200); pinMode(ddPin, UITGANG); pinMode (knopPin, INPUT_PULLUP); // aangesloten op Arduino pin 12 en gebruikt voor "start" vertraging (2000); wakker worden (); // Wake-up Roomba startSafe(); // Start Roomba in Veilige modus terwijl (digitalRead (buttonPin)) { } // wachtknop ingedrukt te houden om code turnCW continu uit te voeren (40, 180); //test Roomba 180 graden met de klok mee draaien en stoppen}//----------------------------------- ----------void loop() { }  

Stap 7:Roomba bedienen via Bluetooth

Laten we, om ons eerste deel van het project te voltooien, een Bluetooth-module (HC-06) op onze Arduino installeren. Het bovenstaande diagram laat zien hoe u dit moet doen. Gewoonlijk wordt de HC-06 af fabriek afgesteld met een baudrate van 9.600. Het is belangrijk dat u deze wijzigt in 19.200 om compatibel te zijn met de communicatiesnelheid van Arduino-Roomba. U kunt dat doen door een AT-commando naar de module te sturen (AT+BAUD5 waarbij "5" de code is voor 19.200).

Als je twijfelt over hoe de HC-06 werkt, bekijk dan mijn tutorial:"dingen" verbinden via Bluetooth / Android / Arduino.

Om de Roomba te besturen, zullen we een generieke app gebruiken die door mij is ontwikkeld om mobiele robots te besturen, met behulp van de MIT AppInventor 2:"MJRoBot BT Remote Control". De app is gratis te downloaden in de Google store via de link:App:MJRoBot BT Remote Control.

De app heeft een eenvoudige interface, waarmee u opdrachten naar de BT-module kunt sturen in beide, TEKST-modus of rechtstreeks via voorgeprogrammeerde knoppen (elke keer dat een knop wordt ingedrukt, wordt een teken verzonden):

• w:Vooruit

• s:Achteruit

• d:Juist

• a:Links

• f:Stop

• p:AAN / UIT (niet gebruikt op dit eerste deel)

• m:handmatig / automatisch (gebruikt om Roomba opnieuw op te starten als er een obstakel als een klif wordt gevonden in de veilige modus)

• +:Snelheid +

• -:Snelheid -

U kunt indien nodig ook andere opdrachten als tekst verzenden. Er is ook een tekstvenster voor berichten die van de BT-module worden ontvangen. Deze functie is erg belangrijk tijdens de testfase, het kan op dezelfde manier worden gebruikt als de "Seriële Monitor".

De loop() een deel van de code is het "luisteren" van het bluetooth-apparaat en, afhankelijk van het ontvangen commando, een actie ondernemen:

void loop() { checkBTcmd(); // controleer of een commando is ontvangen van de BT-afstandsbediening manualCmd ();} 

De functie checkBTcmd() wordt hieronder weergegeven:

void checkBTcmd() // controleer of een commando is ontvangen van BT remote control { if (BT1.available()) { command =BT1.read(); BT1.flush(); } } 

Zodra een commando is ontvangen, wordt de functie manualCmd() zal de gepaste actie ondernemen:

void manualCmd(){ switch (commando) { case 'm':startSafe(); Serial.print("Roomba in veilige modus"); BT1.print("Roomba BT Ctrl OK - Veilige modus"); BT1.println('\n'); commando ='f'; speelgeluid (3); pauze; geval 'f':driveStop(); // schakel beide motoren uit writeLEDs ('s', 't', 'o', 'p'); staat =commando; pauze; geval 'w':aandrijving (motorSpeed, 0); writeLEDs (' ', 'g', 'o', ' '); staat =commando; pauze; geval 'd':driveRight(motorSpeed); writeLEDs ('r', 'i', 'g', 'h'); pauze; geval 'a':driveLeft(motorSpeed); writeLEDs ('l', 'e', ​​'f', 't'); pauze; geval 's':aandrijving (-motorSpeed, 0); writeLEDs ('b', 'a', 'c', 'k'); staat =commando; pauze; case '+':if (state =='w') { motorSpeed ​​=motorSpeed ​​+ 10; if (motorSpeed> MAX_SPEED) {motorSpeed ​​=MAX_SPEED; } commando ='w'; } else {commando =staat;} pauze; case '-':if (state =='w') { motorSpeed ​​=motorSpeed ​​- 10; } if (motorsnelheid  

Stap 8:Conclusie

De volledige Arduino-code die hier wordt gebruikt en gerelateerde documenten zijn te vinden op mijn GITHUB:Roomba_BT_Ctrl.

Houd er rekening mee dat niet alle Roomba-actuators zijn becommentarieerd in deze tutorial. Er zijn andere motoren die worden gebruikt voor het reinigen, andere LED's die worden gebruikt voor het schema, knoppen, sensoren, enz.

Verschillende van de functies die ik in mijn programma heb gemaakt, waren gebaseerd op de Create 2-bibliotheek die is ontwikkeld door Dom Amato. U kunt de volledige bibliotheek downloaden op:https://github.com/brinnLabs/Create2 .

Mijn bedoeling hier was om het simpel te houden en je een startplatform te geven om met Roomba te gaan spelen. In de toekomst doe ik alsof ik andere tutorials publiceer, met behulp van een Raspberry-Pi, de Roomba met internet verbind, de sensoren uitlees, enz.

Zoals altijd hoop ik dat dit project anderen kan helpen hun weg te vinden in de spannende wereld van elektronica en robotica!

Ga voor meer projecten naar mijn blog (in het Portugees):

MJRoBot.org

Saludos uit het zuiden van de wereld!

Tot ziens bij mijn volgende tutorial!

Dank je

Marcelo

Code

Github

https://github.com/Mjrovai/Roomba_BT_Ctrl