Steuerung eines Roomba-Roboters mit Arduino und Android-Gerät

Apps und Onlinedienste

Über dieses Projekt

Als einer der Gewinner des Instructables Robotics Contest 2016 erhielt ich als Preis einen iRobot Roomba Create2. Es ist eine großartige und sehr erschwingliche Plattform für die Robotikentwicklung, die etwa 200 US-Dollar kostet. Create 2 ermöglicht eine Vielzahl von Programmiermethoden. Zu Beginn habe ich es mit einem Arduino und einer Android-APP verwendet, um den Roboter zu bewegen. In diesem ersten Tutorial werde ich untersuchen, wie man den Arduino über den seriellen Port mit dem Roomba verbindet und wie man seine Motoren, LEDs und seinen Sound steuert. Bei zukünftigen Projekten werde ich seine Sensoren erforschen und auch einen Raspberry Pi verwenden, um den Roomba mit dem Internet zu verbinden.

Unten, ein Video, das meine ersten Ergebnisse bei der Programmierung eines Roomba-Roboters zeigt:

Schritt 1:Stückliste

• iRobot Create2

• Arduino UNO

• Bluetooth-Modul HC-06

• Drucktaste

Schritt 2:Der Roomba Create2

Der Roomba ist ein Roboter mit Differentialantrieb, mit 2 Rädern und einer vorderen Laufrolle. Seine Geschwindigkeit beträgt bis zu 500 mm/s und kann nach oben oder hinten befohlen werden.

Zur Signalisierung können wir mit vier 7-Segment-Anzeigen und 5 LEDs zählen (siehe Abbildung):

• Sauber

• Spot

• Dock

• Warnung/Check

• Schmutz/Ablagerungen

Als interne Sensoren haben wir unter anderem:

• Klippendetektor (4 vorne)

• Stoßdetektoren (2 vorne)

• Rad-Encoder

Zur Programmierung sollte das Dokument:iRobot® Create® 2 Open Interface (OI) verwendet werden. Der Roomba kann in 3 Modi programmiert werden:

Passiver Modus:

• Nach dem Senden des Startbefehls oder eines der Reinigungsmodusbefehle (z. B. Spot, Clean, Seek Dock) geht das OI in den Passivmodus über. Wenn sich das OI im Passivmodus befindet, können Sie Sensordaten mit jedem der Sensorbefehle anfordern und empfangen, aber Sie können die aktuellen Befehlsparameter für die Aktoren (Motoren, Lautsprecher, Lichter, Low-Side-Treiber, digitale Ausgänge) nicht auf etwas anderes ändern .

Abgesicherter Modus:Gibt Ihnen die volle Kontrolle über Roomba, mit Ausnahme der folgenden sicherheitsrelevanten Bedingungen:

• Ladegerät angeschlossen und mit Strom versorgt.

• Erkennung eines Radsturzes (an jedem Rad).

• Erkennung einer Klippe während der Vorwärtsbewegung (oder Rückwärtsbewegung mit einem kleinen Wenderadius, weniger als ein Roboterradius).

• Sollte eine der oben genannten sicherheitsrelevanten Bedingungen auftreten, während sich das OI im abgesicherten Modus befindet, stoppt Roomba alle Motoren und kehrt in den passiven Modus zurück.

Vollmodus:

• Gibt Ihnen die vollständige Kontrolle über Roomba, alle seine Aktoren und alle sicherheitsrelevanten Bedingungen, die eingeschränkt sind, wenn sich das OI im abgesicherten Modus befindet, da der Vollmodus die Klippen-, Radfall- und internen Ladegerät-Sicherheitsfunktionen abschaltet .

Schritt 3:Die serielle Verbindung

Für die Kommunikation zwischen Roomba und Arduino wird der serielle Port verwendet. Standardmäßig kommuniziert Roomba mit 115.200 Baud, aber um mit Arduino zu kommunizieren, werden wir es auf 19.200 umstellen.

Es gibt 2 Möglichkeiten, die Roomba-Baudrate einzustellen:

• Halten Sie beim Ausschalten des Roomba weiterhin die Clean/Power-Taste gedrückt, nachdem das Licht ausgeschaltet wurde. Nach etwa 10 Sekunden spielt Roomba eine Melodie mit absteigenden Tonhöhen. Roomba kommuniziert mit 19.200 Baud, bis der Prozessor die Batterieleistung verliert oder die Baudrate explizit über die OI geändert wird.

• Verwenden Sie den Pin zum Ändern der Baudrate (Pin 5 am Mini-DIN-Anschluss), um die Baudrate von Roomba zu ändern. Warten Sie nach dem Einschalten von Roomba 2 Sekunden und pulsieren Sie dann die Baudratenänderung dreimal auf niedrig. Jeder Impuls sollte zwischen 50 und 500 Millisekunden dauern. Roomba kommuniziert mit 19200 Baud, bis der Prozessor die Batterieleistung verliert oder die Baudrate explizit über die OI geändert wird.

Das obige Diagramm zeigt, wie das Arduino mit dem Roomba Mini-DIN-Anschluss verbunden werden sollte

Schritt 4:Roomba starten

Das erste, was Sie bei der Programmierung eines Roomba tun müssen, ist:

• "Wach auf" den Roboter

• Definieren Sie den Modus (Sicher oder vollständig)

Wir können es "aufwecken", indem wir einen Low-Impuls an Mini-DIN-Pin 5 (Geräteeingang erkennen) senden, wie in der Funktion unten gezeigt:

void WakeUp (void){ setWarningLED (ON); digitalWrite (ddPin, HIGH); Verzögerung (100); digitalWrite (ddPin, LOW); Verzögerung (500); digitalWrite (ddPin, HIGH); Verzögerung(2000);}  

Zum Starten von Roomba müssen immer 2 Codes gesendet werden:"START" [128] und der Modus, in unserem Fall "SAFE MODE" [131]. Wenn Sie einen "FULL MODE" wünschen, sollte stattdessen der Code [132] gesendet werden.

void startSafe(){ Roomba.write(128); //Roomba starten.write(131); // Verzögerung im abgesicherten Modus (1000);}  

Schritt 5:Einschalten der LEDs und des Displays

LEDs einschalten

Wie in der Einführung beschrieben, hat Roomba 5 LEDs:

• Power/Clean (zweifarbig rot/grün und intensitätsgesteuert)

• Spot (Grün, feste Intensität)

• Dock (Grün, feste Intensität)

• Warnung/Check (Orange, feste Intensität)

• Schmutz/Ablagerungen (Blau, feste Intensität)

Alle LEDs können mit Code [139] gesteuert werden. Um die Power-LED zu steuern, müssen Sie zwei Datenbytes an Roomba senden:„Farbe“ und „Intensität“.

Farbe:

• Grün =0

• Orange =128

• rot=255

Intensität:

• Niedrig=0

• Max=255

Die Funktion setPowerLED (byte setColor, byte setIntensity) tut es:

void setDigitLEDs(Byte Digit1, Byte Digit2, Byte Digit3, Byte Digit4){ Roomba.write(163); Roomba.write(Ziffer1); Roomba.write(Ziffer2); Roomba.write(Ziffer3); Roomba.write(digit4);} 

Um beispielsweise die POWER-LED mit oranger Farbe bei halber Intensität einzuschalten, können Sie die Funktion wie folgt aufrufen:

setPowerLED (128, 128); 

Um die restlichen 4 LEDs einzuschalten, müssen die folgenden Funktionen verwendet werden:

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

Alle oben genannten Funktionen haben einen ähnlichen Code wie diesen:

void setDebrisLED(bool enable){trümmerLED =enable; Roomba.write(139); Roomba.write((debrisLED ? 1 :0) + (spotLED ? 2 :0) + (dockLED ? 4 :0) + (warningLED ? 8 :0)); Roomba.write((Byte)Farbe); Roomba.write((Byte)Intensität);}  

Im Wesentlichen wird der Unterschied die Zeile sein:

debrisLED =aktivieren; 

die geändert werden müssen, um jede der anderen LEDs zu aktivieren (spotLED, dockLED, warningLED ).

Nachrichten an Display senden

Roomba verfügt über vier 7-Segment-Anzeigen, mit denen Sie Nachrichten auf zwei verschiedene Arten senden können:

• Code [163]:Digit LEDs Raw (Numerisch)

• Code [164]:Ziffern-LEDs ASCII (Annäherung von Buchstaben und Sondercodes)

Zahlen anzuzeigen ist sehr einfach. Sie müssen den Code [163] nach den 4 anzuzeigenden Ziffern senden. Die Funktion:setDigitLEDs(Byte Digit1, Byte Digit2, Byte Digit3, Byte Digit4) erledigt das für dich:

void setDigitLEDs(Byte Digit1, Byte Digit2, Byte Digit3, Byte Digit4){ Roomba.write(163); Roomba.write(Ziffer1); Roomba.write(Ziffer2); Roomba.write(Ziffer3); Roomba.write(ziffer4);}  

Um beispielsweise "1, 2, 3, 4" anzuzeigen, müssen Sie die Funktion aufrufen:

setDigitLEDs(1, 2, 3, 4); 

Mit Code [164] ist es möglich, eine Annäherung an ASCII zu senden. Die Funktion setDigitLEDFromASCII(Byte-Ziffer, Zeichenbuchstabe) tut das mit uns:

void setDigitLEDFromASCII(byte digit, char letter){ switch (digit){ case 1:digit1 =letter; brechen; Fall 2:Ziffer2 =Buchstabe; brechen; Fall 3:Ziffer3 =Buchstabe; brechen; Fall 4:Ziffer4 =Buchstabe; brechen; } Roomba.write(164); Roomba.write(Ziffer1); Roomba.write(Ziffer2); Roomba.write(Ziffer3); Roomba.write(ziffer4);}  

Zur Vereinfachung erstelle ich eine neue Funktion, um die 4 Ziffern gleichzeitig zu senden:

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

Um beispielsweise "STOP" anzuzeigen, müssen Sie die Funktion aufrufen:

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

Schritt 6:Bewegen des Roomba herum

Für Mobilität verfügt Roomba über 2 unabhängige DC-Motoren, die so programmiert werden können, dass sie bis zu 500 mm/s laufen. Es gibt mehrere Befehle, die verwendet werden können, um den Roboter zu steuern. Die wichtigsten sind:

• Code [137]:Antrieb ==> Muss +/- Geschwindigkeit in mm/s und +/- Radius in mm senden

• Code [145]:Drive Direct ==> Muss die Geschwindigkeit nach links/rechts in mm/s senden (+ für Vorwärts und - für Rückwärts)

• Code [146]:Drive PWM ==> Muss +/- PWM-Daten für das linke und rechte Rad senden

Unten ist der Code für diese 3 Optionen:

void drive (int speed, int radius) { Clamp (Geschwindigkeit, -500, 500); // def max. und min. Geschwindigkeit in mm/s Klemme (Radius, -2000, 2000); // def Max- und Min-Radius in mm Roomba.write (137); Roomba.write (Geschwindigkeit>> 8); Roomba.write (Geschwindigkeit); Roomba.write (Radius>> 8); Roomba.write(radius);}//---------------------------------------------------- -----------------------void driveWheels (int rechts, int links) {Klemme (rechts, -500, 500); Klemme (links, -500, 500); Roomba.write(145); Roomba.write(rechts>> 8); Roomba.write(rechts); Roomba.write(links>> 8); Roomba.write(links); }//----------------------------------------------------------- ---------------- DriveWheelsPWM (int rightPWM, int leftPWM) { Clamp (rightPWM, -255, 255); Klemme (linksPWM, -255, 255); Roomba.write(146); Roomba.write (rechtsPWM>> 8); Roomba.write(rechtsPWM); Roomba.write(leftPWM>> 8); Roomba.write(leftPWM);}  

Beachten Sie, dass die Funktion "Klemme" die maximalen und minimalen Werte definiert, die eingegeben werden dürfen. Diese Funktion ist in der Datei rombaDefines.h: . definiert

#define Klemme(Wert, min, max) (Wert  max ? max :Wert) 

Mit dem obigen Code können einfachere Funktionen erstellt werden, um Roomba herumzutreiben:

/------------------------------------------------------ --------------------void turnCW (vorzeichenlose kurze Geschwindigkeit, vorzeichenlose kurze Grade) { Laufwerk (Geschwindigkeit, -1); Klemme (Geschwindigkeit, 0, 500); Verzögerung (6600); Laufwerk(0,0);}//---------------------------------------------------- -----------------------void turnCCW (vorzeichenlose kurze Geschwindigkeit, vorzeichenlose kurze Grade) { Laufwerk (Geschwindigkeit, 1); Klemme (Geschwindigkeit, 0, 500); Verzögerung (6600); Laufwerk(0,0);}//---------------------------------------------------- -----------------------void driveStop(void){ drive(0,0);}//------------- -------------------------------------------------- --void driveLeft(int left){ driveWheels(left, 0);}//-------------------------------------------- -------------------------------- void driveRight(int right){ driveWheels(0, right);}  

Beachten Sie, dass das Argument "Verzögerung" speziell für eine bestimmte Geschwindigkeit berechnet werden muss, um den Winkel einzudrehen. Nachfolgend einige Beispiele, die zum Testen der Motoren verwendet werden können:

turnCW (40, 180); // um 180 Grad im Uhrzeigersinn drehen und stopdriveWheels (20, -20); // spin driveLeft (20); // links abbiegen 

Zum Testen der Motoren ist es gut, einen externen Taster hinzuzufügen (in meinem Fall mit Arduino Pin 12 verbunden), damit Sie den Code auf Arduino herunterladen können, den Roomba starten, aber die Ausführung stoppen, bis der Taster gedrückt wird. Normalerweise können Sie dies zum Testen von Motoren im Einrichtungsteil des Codes tun.

Als Beispiel sehen Sie sich bitte den einfachen Arduino-Code unten an (beachten Sie, dass der Code zuvor entwickelte Funktionen und Definitionen verwendet):

#include "roombaDefines.h"#include // Roomba Create2 connectionint rxPin=10;int txPin=11;SoftwareSerial Roomba(rxPin,txPin);//------ ---------------------------------------void setup() { Roomba.begin(19200); pinMode (ddPin, AUSGANG); pinMode (buttonPin, INPUT_PULLUP); // mit Arduino Pin 12 verbunden und zum "Starten" der Verzögerung verwendet (2000); Wach auf (); // Roomba aufwecken startSafe(); // Roomba im abgesicherten Modus starten, während (digitalRead (buttonPin)) {} // Wartetaste gedrückt werden, um den Code turnCW (40, 180) kontinuierlich auszuführen; // Roomba im Uhrzeigersinn um 180 Grad drehen und stoppen} //---------------------------------- ----------void loop() { }  

Schritt 7:Roomba über Bluetooth steuern

Um unseren ersten Teil des Projekts abzuschließen, installieren wir ein Bluetooth-Modul (HC-06) auf unserem Arduino. Das obige Diagramm zeigt, wie es geht. Normalerweise ist der HC-06 ab Werk auf eine Baudrate von 9.600 eingestellt. Es ist wichtig, dass Sie es auf 19.200 ändern, um mit der Arduino-Roomba-Kommunikationsgeschwindigkeit kompatibel zu sein. Sie können dies tun, indem Sie einen AT-Befehl an das Modul senden (AT+BAUD5, wobei "5" der Code für 19.200 ist).

Wenn Sie Zweifel haben, wie der HC-06 funktioniert, schauen Sie sich bitte mein Tutorial an:"Zeug" über Bluetooth / Android / Arduino verbinden.

Um den Roomba zu steuern, verwenden wir eine generische App, die von mir entwickelt wurde, um mobile Roboter zu steuern, mit dem MIT AppInventor 2:"MJRoBot BT Remote Control". Die App kann kostenlos im Google Store über den Link heruntergeladen werden:App:MJRoBot BT Remote Control.

Die App verfügt über eine einfache Schnittstelle, mit der Sie sowohl im TEXT-Modus als auch direkt über vorprogrammierte Tasten Befehle an das BT-Modul senden können (jedes Mal, wenn eine Taste gedrückt wird, wird ein Zeichen gesendet):

• w:Vorwärts

• s:Rückwärts

• d:Richtig

• a:Links

• f:Stopp

• p:ON / OFF (wird in diesem ersten Teil nicht verwendet)

• m:Manuell / Automatisch (Wird verwendet, um Roomba neu zu starten, wenn im abgesicherten Modus ein Hindernis wie eine Klippe gefunden wird)

• +:Geschwindigkeit +

• -:Geschwindigkeit -

Sie können bei Bedarf auch andere Befehle als Text senden. Es gibt auch ein Textfenster für Nachrichten, die vom BT-Modul empfangen werden. Diese Funktion ist während der Testphase sehr wichtig, sie kann wie der "Serielle Monitor" verwendet werden.

Die Schleife() Ein Teil des Codes "hört" das Bluetooth-Gerät und führt je nach empfangenem Befehl eine Aktion aus:

void loop() { checkBTcmd(); // überprüfen, ob ein Befehl von der BT-Fernbedienung manualCmd ();} . empfangen wird 

Die Funktion checkBTcmd() wird unten angezeigt:

void checkBTcmd () // überprüfen, ob ein Befehl von der BT-Fernbedienung empfangen wird { if (BT1.available ()) { command =BT1.read (); BT1.flush(); } } 

Sobald ein Befehl empfangen wird, wird die Funktion manualCmd() wird die entsprechenden Maßnahmen ergreifen:

void manualCmd(){ switch (Befehl) { case 'm':startSafe(); Serial.print ("Roomba im abgesicherten Modus"); BT1.print("Roomba BT Ctrl OK - Abgesicherter Modus"); BT1.println('\n'); Befehl ='f'; PlaySound (3); brechen; Fall 'f':driveStop(); // beide Motoren ausschalten writeLEDs ('s', 't', 'o', 'p'); Zustand =Befehl; brechen; Fall 'w':Antrieb (motorSpeed, 0); writeLEDs (' ', 'g', 'o', ' '); Zustand =Befehl; brechen; Fall 'd':driveRight(motorSpeed); writeLEDs ('r', 'i', 'g', 'h'); brechen; Fall 'a':driveLeft(motorSpeed); writeLEDs ('l', 'e', ​​'f', 't'); brechen; Fall 's':Laufwerk (-motorSpeed, 0); writeLEDs ('b', 'a', 'c', 'k'); Zustand =Befehl; brechen; Fall '+':if (state =='w') { motorSpeed ​​=motorSpeed ​​+ 10; if (motorSpeed ​​> MAX_SPEED) { motorSpeed ​​=MAX_SPEED; } Befehl ='w'; } else {Befehl =Zustand;} Pause; Fall '-':if (state =='w') { motorSpeed ​​=motorSpeed ​​- 10; } if (motorSpeed ​​ 

Schritt 8:Fazit

Der vollständige Arduino-Code, der hier verwendet wird, und zugehörige Dokumente finden Sie in meinem GITHUB:Roomba_BT_Ctrl.

Bitte beachten Sie, dass in diesem Tutorial nicht alle Roomba-Aktoren kommentiert wurden. Es gibt andere Motoren, die für die Reinigung verwendet werden, andere LEDs für den Zeitplan, Tasten, Sensoren usw.

Einige der Funktionen, die ich in meinem Programm erstellt habe, basieren auf der von Dom Amato entwickelten Create 2-Bibliothek. Sie können die komplette Bibliothek herunterladen unter:https://github.com/brinnLabs/Create2 .

Meine Absicht war es, einfach zu bleiben und Ihnen eine Startplattform zu bieten, um mit Roomba zu spielen. In Zukunft gebe ich vor, andere Tutorials zu veröffentlichen, mit einem Raspberry-Pi, den Roomba mit dem Internet zu verbinden, seine Sensoren auszulesen usw.

Wie immer hoffe ich, dass dieses Projekt anderen helfen kann, sich in der aufregenden Welt der Elektronik und Robotik zurechtzufinden!

Für weitere Projekte besuchen Sie bitte meinen Blog (auf Portugiesisch):

MJRoBot.org

Saludos aus dem Süden der Welt!

Wir sehen uns bei meinem nächsten Tutorial!

Danke

Marcelo