Rpibot - Robotik lernen - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:15

Ich bin Embedded Software Engineer in einem deutschen Automobilunternehmen. Ich habe dieses Projekt als Lernplattform für eingebettete Systeme gestartet. Das Projekt wurde früh abgesagt, aber es hat mir so gut gefallen, dass ich in meiner Freizeit weitergemacht habe. Das ist das Ergebnis…

Ich hatte folgende Anforderungen:

• Einfache Hardware (Schwerpunkt ist die Software)
• Günstige Hardware (ca. 100€)
• Erweiterbar (einige Optionen sind bereits Bestandteil der Beschreibung)
• Versorgungsspannung für alle Komponenten aus einer einzigen 5V-Quelle (Powerbank)

Es gab nicht wirklich ein Ziel außer dem Lernen. Die Plattform kann für Lernen, Überwachung, Roboterwettbewerbe, … verwendet werden.

Es ist kein Anfänger-Tutorial. Sie benötigen einige Grundkenntnisse über:

• Programmierung (Python)
• Grundelektronik (um Module durch die richtige Spannung miteinander zu verbinden)
• Grundlegende Regelungstheorie (PID)

Schließlich werden Sie wahrscheinlich Probleme haben, wie ich es getan habe. Mit etwas Neugier und Ausdauer gehen Sie durch das Projekt und lösen die Herausforderungen. Mein Code ist so einfach wie möglich und die kritischen Codezeilen sind kommentiert, um Hinweise zu geben.

Der vollständige Quellcode und die Dateien sind hier verfügbar:

Lieferungen:

Mechanik

• 1x Sperrholzplatte (A4-Format, 4 mm dick)
• 3x M4 x 80 Schraube und Mutter
• 2x Getriebemotoren mit sekundärer Abtriebswelle für Encoder. Räder.
• 1x Freilauf

1x Schwenk- und Neigekamerahalterung (optional)

Elektronik

• 1x Raspberry Pi Zero mit Header und Kamera
• 1x PCA 9685 Servosteuerung
• 2x optisches Encoderrad und Schaltung
• 1x weibliche Überbrückungsdrähte
• 1x USB-Powerbank
• 1x DRV8833 Dual-Motor-Treiber
• 2x Micro-Servos SG90 für Kameraschwenk und -neigung (optional)
• 1x MPU9250-IMU (optional)
• 1x HC-SR04 Ultraschall-Distanzsensor (optional)
• 1x Lochplatine und Lötdraht, Stiftleisten, …

Schritt 1: Bauen Sie das Chassis auf

Ich bin kein guter Mechaniker. Auch das Ziel des Projekts ist es, nicht zu viel Zeit im Chassis zu verbringen. Jedenfalls habe ich folgende Anforderungen definiert:

• Günstige Materialien
• Schneller Auf- und Abbau
• Erweiterbar (z. B. Platz für zusätzliche Sensoren)
• Leichte Materialien zum Energiesparen für die Elektronik

Ein einfaches und billiges Chassis kann aus Sperrholz hergestellt werden. Es ist einfach mit einer Laubsäge und einer Handbohrmaschine zu bearbeiten. Sie können kleine Holzteile kleben, um die Halterungen für Sensoren und Motoren zu erstellen.

Denken Sie an den Austausch defekter Komponenten oder das elektrische Debugging. Die Hauptteile sollten mit Schrauben befestigt werden, um austauschbar zu sein. Eine Heißklebepistole mag einfach sein, aber wahrscheinlich nicht der beste Weg, um ein Chassis zu bauen… Ich brauchte viel Zeit, um über ein einfaches Konzept nachzudenken, um die Teile leicht zu demontieren. 3D-Druck ist eine gute Alternative, kann aber recht teuer oder zeitaufwändig sein.

Der Freilauf ist endlich sehr leicht und einfach zu montieren. Die Alternativen waren alle schwer oder voller Reibung (ich habe ein paar davon ausprobiert, bevor ich die letzte gefunden habe). Ich musste nur einen hölzernen Abstandshalter schneiden, um den Heckfreilauf nach der Montage der Haupträder auszugleichen.

Radeigenschaften (für Softwareberechnungen)

Umfang: 21, 5 cmImpulse: 20 Impulse/U. Auflösung: 1,075 cm (endlich 1 Impuls ist ca. 1cm, was für Softwareberechnungen einfach ist)

Schritt 2: Elektronik und Verkabelung

Das Projekt verwendet verschiedene Module, wie in der Abbildung gezeigt.

Der Raspberry Pi Zero ist der Hauptcontroller. Es liest die Sensoren und steuert die Motoren durch ein PWM-Signal. Es ist per WLAN mit einem entfernten PC verbunden.

Die DRV8833 ist eine Doppelmotor-H-Brücke. Es liefert den Motoren ausreichend Strom (was der Raspberry Pi nicht kann, da die Ausgänge nur einige mA liefern können).

Der optische Encoder liefert jedes Mal ein quadratisches Signal, wenn das Licht durch die Encoderräder geht. Wir werden die HW-Interrupts des Raspberry Pi verwenden, um die Informationen jedes Mal zu erhalten, wenn das Signal umgeschaltet wird.

Das pca9695 ist eine Servosteuerplatine. Es kommuniziert über einen seriellen I2C-Bus. Dieses Board liefert die PWM-Signale und die Versorgungsspannung, die die Servos zum Schwenken und Neigen der Cam steuern.

Der MPU9265 ist ein 3-Achsen-Beschleunigungs-, 3-Achsen-Winkeldrehzahl- und 3-Achsen-Magnetflusssensor. Wir werden es hauptsächlich verwenden, um die Kompassrichtung zu erhalten.

Die verschiedenen Module sind alle durch Steckbrücken miteinander verbunden. Ein Steckbrett fungiert als Dispatcher und stellt Versorgungsspannungen (5V und 3,3V) und Masse bereit. Die Anschlüsse sind alle in der Anschlusstabelle (siehe Anhang) beschrieben. Wenn Sie 5 V an einen 3,3 V-Eingang anschließen, wird Ihr Chip wahrscheinlich zerstört. Gehen Sie sorgfältig vor und überprüfen Sie Ihre gesamte Verdrahtung vor der Lieferung (hier ist besonders der Encoder zu berücksichtigen). Sie sollten die Hauptversorgungsspannungen auf der Versandplatine mit einem Multimeter messen, bevor Sie alle Platinen anschließen. Die Module wurden mit Nylonschrauben im Chassis befestigt. Auch hier habe ich sie gerne repariert aber auch im Störungsfall entfernbar.

Das einzige Löten waren schließlich die Motoren und das Steckbrett und die Header. Um ehrlich zu sein, mag ich die Überbrückungsdrähte, aber sie können zu Wackelkontakten führen. In manchen Situationen können einige Softwareüberwachungen Sie bei der Analyse der Verbindungen unterstützen.

Schritt 3: Software-Infrastruktur

Nachdem wir die Mechanik erreicht haben, werden wir eine Software-Infrastruktur einrichten, um komfortable Entwicklungsbedingungen zu haben.

Git

Dies ist ein kostenloses und quelloffenes Versionskontrollsystem. Es wird verwendet, um große Projekte als Linux zu verwalten, kann aber auch problemlos für kleine Projekte verwendet werden (siehe Github und Bitbucket).

Die Projektänderungen können lokal verfolgt und auch auf einen Remote-Server übertragen werden, um Software mit der Community zu teilen.

Die wichtigsten verwendeten Befehle sind:

git clone https://github.com/makerobotics/RPIbot.git [Quellcode und Git-Konfiguration abrufen]

git pull origin master [das Neueste aus dem Remote-Repository abrufen]

git status [den Status des lokalen Repositorys abrufen. Wurden Dateien geändert?] git log [Liste der Commits abrufen] git add. [alle geänderten Dateien zur Stufe hinzufügen, die für den nächsten Commit berücksichtigt werden sollen] git commit -m "comment for commit" [die Änderungen an das lokale Repository übertragen]git push origin master [alle Commits an das Remote-Repository übertragen]

Protokollierung

Python bietet einige integrierte Protokollierungsfunktionen. Die Softwarestruktur sollte bereits das gesamte Logging-Framework definieren, bevor mit der Weiterentwicklung begonnen wird.

Der Logger kann so konfiguriert werden, dass er mit einem definierten Format im Terminal oder in einer Protokolldatei protokolliert. In unserem Beispiel wird der Logger von der Webserver-Klasse konfiguriert, wir könnten dies aber auch selbst tun. Hier setzen wir nur den Logging-Level auf DEBUG:

logger = Logging.getLogger(_name_)

logger.setLevel(logging. DEBUG)

Messen und Plotten

Um Signale im Zeitverlauf zu analysieren, ist es am besten, sie in einem Diagramm darzustellen. Da der Raspberry Pi nur über ein Konsolenterminal verfügt, verfolgen wir die Daten in einer durch Semikolon getrennten CSV-Datei und zeichnen sie vom Remote-PC aus.

Die durch Semikolon getrennte Trace-Datei wird von unserem Python-Hauptcode generiert und muss folgende Header haben:

timestamp;yawCorr;encoderR;I_L;odoDistance;ax;encoderL;I_R;yaw;eSpeedR;eSpeedL;pwmL;speedL;CycleTimeControl;wz;pwmR;speedR;Iyaw;hdg;m_y;m_x;eYaw;cycleTimeSense;

1603466959.65;0;0;25;0.0;-0.02685546875;0;25;0;25;25;52;0.0;23;0.221252441406;16;0.0;0;252.069366413;-5.19555664062;-16.0563964844;0;6; 1603466959.71;0;0;50;0.0;0.29150390625;0;50;0;25;25;55;0.0;57;-8.53729248047;53;0.0;0;253.562118111;-5.04602050781;-17.1031494141;0;6; 1603466959.76;0;-1;75;0.0;-0.188232421875;1;75;2;25;25;57;0;52;-24.1851806641;55;0;0;251.433794171;-5.64416503906;-16.8040771484;2;7;

Die erste Spalte enthält den Zeitstempel. Die folgenden Spalten sind frei. Das Plotting-Skript wird mit einer Liste der zu plottenden Spalten aufgerufen:

remote@pc:~/python rpibot_plotter -f trace.csv -p speedL, speedR, pwmL, pwmR

Das Plotskript ist im Tool-Ordner verfügbar:

Der Plotter verwendet Mathplotlib in Python. Sie müssen es auf Ihren PC kopieren.

Für mehr Komfort wird das Python-Skript von einem Bash-Skript (plot.sh) aufgerufen, mit dem die Trace-Datei des Raspberry Pi auf den Remote-PC kopiert und der Plotter mit einer Signalauswahl aufgerufen wird. Das Bash-Skript "plot.sh" fragt wenn Datei kopiert werden muss. Dies war für mich bequemer, als jedes Mal manuell zu kopieren. Mit "sshpass" wird die Datei per scp vom Raspberry Pi auf den Remote-PC kopiert. Es ist in der Lage, eine Datei zu kopieren, ohne nach dem Passwort zu fragen (es wird als Parameter übergeben).

Schließlich öffnet sich ein Fenster mit dem Plot wie im Bild gezeigt.

Fernkommunikation

Die Entwicklungsschnittstelle zum Raspberry Pi ist SSH. Dateien können direkt auf dem Ziel bearbeitet oder mit scp kopiert werden.

Zur Steuerung des Roboters läuft auf dem Pi ein Webserver, der die Steuerung über Websockets ermöglicht. Diese Schnittstelle wird im nächsten Schritt beschrieben.

Einrichten des Raspberry Pi

Im Ordner "doc" des Quellcodes (setup_rpi.txt) befindet sich eine Datei, die das Setup des Raspberry Pi beschreibt. Es gibt nicht viele Erklärungen, aber viele nützliche Befehle und Links.

Schritt 4: Die Benutzeroberfläche

Wir verwenden den leichten Tornado-Webserver, um die Benutzeroberfläche zu hosten. Es ist ein Python-Modul, das wir aufrufen, wenn wir die Robotersteuerungssoftware starten.

Softwarearchitektur

Die Benutzeroberfläche besteht aus den folgenden Dateien:gui.html [Beschreibung der Webseiten-Steuerelemente und des Layouts] gui.js [Enthält den Javascript-Code, um die Steuerelemente zu handhaben und eine Websocket-Verbindung zu unserem Roboter zu öffnen] gui.css [Enthält die Stile von die HTML-Steuerelemente. Hier werden die Positionen der Bedienelemente definiert]

Die Websocket-Kommunikation

Die Benutzeroberfläche ist nicht die coolste, aber sie macht ihren Job. Ich habe mich hier auf für mich neue Technologien wie Websockets konzentriert.

Die Website kommuniziert über Websockets mit dem Roboter-Webserver. Dies ist ein bidirektionaler Kommunikationskanal, der geöffnet bleibt, wenn die Verbindung initiiert wurde. Wir senden die Befehle des Roboters per Websocket an den Raspberry Pi und bekommen Informationen (Geschwindigkeit, Position, Kamerastream) zur Anzeige zurück.

Das Interface-Layout

Die Benutzeroberfläche verfügt über eine manuelle Eingabe für die Befehle. Dies wurde am Anfang verwendet, um Befehle an den Roboter zu senden. Ein Kontrollkästchen schaltet den Kamerastream ein und aus. Die beiden Schieberegler steuern das Schwenken und Neigen der Kamera. Der obere rechte Teil der Benutzeroberfläche steuert die Bewegung des Roboters. Sie können die Geschwindigkeit und die Zielentfernung steuern. Die grundlegenden Telemetrieinformationen werden in der Roboterzeichnung angezeigt.

Schritt 5: Programmierung der Roboterplattform

Dieser Teil war das Hauptziel des Projekts. Ich habe einen Großteil der Software umgestaltet, als ich das neue Chassis mit den DC-Motoren einführte. Ich habe Python aus verschiedenen Gründen als Programmiersprache verwendet:

• Es ist die Hauptsprache des Raspberry Pi
• Es ist eine Hochsprache mit vielen eingebauten Funktionen und Erweiterungen
• Es ist objektorientiert, kann aber auch für die sequentielle Programmierung verwendet werden
• Keine Kompilierung oder Werkzeugkette notwendig. Bearbeiten Sie den Code und führen Sie ihn aus.

Hauptsoftwarearchitektur

Die Software ist objektorientiert, unterteilt in wenige Objekte. Meine Idee war, den Code in 3 Funktionsblöcke aufzuteilen:

Sinn denken betätigen

Sinn.py

Erfassung und Verarbeitung von Hauptsensoren. Die Daten werden in einem Wörterbuch gespeichert, um von der folgenden Stufe verwendet zu werden.

Control.py

Eine Aktuator-Unterklasse steuert nach einiger Abstraktion die Motoren und Servos. Das Hauptobjekt Control behandelt die High-Level-Befehle und auch die Steueralgorithmen (PID) für den Motor.

rpibot.py

Dieses Hauptobjekt verwaltet den Tornado-Webserver und instanziiert die Sense- und Control-Klassen in separaten Threads.

Jedes Modul kann einzeln oder als Teil des gesamten Projekts ausgeführt werden. Sie können nur die Sensorinformationen erfassen und ausdrucken, um zu überprüfen, ob die Sensoren richtig angeschlossen sind und die richtigen Informationen liefern.

Die PID-Regelung

Die erste Aufgabe besteht darin, herauszufinden, was wir kontrollieren wollen. Ich begann damit, die Position zu kontrollieren, was sehr komplex war und nicht viel half.

Schließlich wollen wir jede Radgeschwindigkeit und auch die Roboterrichtung kontrollieren. Dazu müssen wir zwei Steuerlogiken kaskadieren.

Um die Komplexität Schritt für Schritt zu steigern, sollte der Roboter gesteuert werden:

offene Schleife (mit konstanter Leistung)

pwm = K

dann füge den Close-Loop-Algorithmus hinzu

pwm = Kp.speedError+Ki. Integration(speedError)

und schließlich als letzten Schritt die Richtungssteuerung hinzufügen.

Für die Geschwindigkeitsregelung habe ich einen "PI"-Regler und "P" nur für das Gieren verwendet. Ich stelle die Parameter manuell durch Experimentieren ein. Hier könnten wahrscheinlich viel bessere Parameter verwendet werden. Mein Ziel war nur eine gerade Linie und ich hätte sie fast erreicht. Ich habe in der Software eine Schnittstelle erstellt, um einige Variablen über die Benutzeroberfläche zu schreiben. Das Setzen des Parameters Kp auf 1.0 erfordert folgenden Befehl in der Benutzeroberfläche:

SET;Kp;1.0

Ich könnte den P-Parameter gerade niedrig genug einstellen, um ein Überschwingen zu vermeiden. Der verbleibende Fehler wird durch den I-Parameter korrigiert (integrierter Fehler)

Es war schwierig für mich herauszufinden, wie man beide Regler kaskadiert. Die Lösung ist einfach, aber ich habe vorher viele andere Möglichkeiten ausprobiert… Also habe ich schließlich das Geschwindigkeitsziel der Räder geändert, um sich in die eine oder andere Richtung zu drehen. Das direkte Ändern des Drehzahlreglerausgangs war ein Fehler, da der Drehzahlregler versuchte, diese Störung zu beseitigen.

Das verwendete Kontrolldiagramm ist beigefügt. Es zeigt nur die linke Seite der Robotersteuerung.

Schritt 6: Die Sensorkalibrierungen

Zunächst ist zu beachten, dass die gesamte IMU ordnungsgemäß funktionieren muss. Ich habe 3 Teile bestellt und zurückgeschickt, bis ich einen voll funktionsfähigen Sensor hatte. Bei jedem vorherigen Sensor funktionierten einige Teile des Sensors nicht richtig oder überhaupt nicht. Ich habe einige Beispielskripte verwendet, um die Grundlagen zu testen, bevor ich ihn in den Roboter einbaue.

Die IMU-Sensorsignale müssen vor der Verwendung kalibriert werden. Einige Sensorsignale sind abhängig vom Montagewinkel und der Position.

Die Beschleunigungs- und Drehzahlkalibrierungen

Die einfachste Kalibrierung ist für die Längsbeschleunigung (A_x). Im Stillstand sollte es ca. 0 m/s² betragen. Wenn Sie den Sensor richtig drehen, können Sie die Schwerkraft messen (ca. 9, 8 m/s²). Um a_x zu kalibrieren, muss man es nur richtig montieren und dann den Offset definieren, um im Stillstand 0 m/s² zu erhalten. Nun ist A_x kalibriert. Die Offsets für die Drehzahlen erhalten Sie auf ähnliche Weise im Stillstand.

Die Magnetometer-Kalibrierung für den Kompass

Für die Magnetfeldsensoren ist eine aufwendigere Kalibrierung notwendig. Wir verwenden m_x und m_y, um das Magnetfeld in der horizontalen Ebene zu erhalten. Mit m_x und m_y haben wir die Möglichkeit, einen Kompasskurs zu berechnen.

Für unseren einfachen Zweck werden wir nur die Harteisenabweichung kalibrieren. Dies muss durchgeführt werden, da sich der Sensor in der Endposition befindet, da er von Magnetfeldstörungen abhängig ist.

Wir zeichnen m_x und m_y auf, während wir den Roboter um die z-Achse drehen. Wir zeichnen m_x vs. m_y in einem XY-Diagramm. Das Ergebnis ist eine Ellipse, wie im Bild gezeigt. Die Ellipse muss zum Ursprung zentriert sein. Hier betrachten wir die maximalen und minimalen Werte von m_x und m_y, um die Offsets in beide Richtungen zu erhalten. Schließlich überprüfen wir die Kalibrierung und sehen, dass die Ellipse jetzt zentriert ist.

Eine Weicheisenkalibrierung würde bedeuten, dass wir das Bild von einer Ellipse in einen Kreis ändern. Dies kann durch Hinzufügen eines Faktors zu jedem Sensorwert erfolgen.

Nun kann eine Testroutine codiert werden, um neu zu kalibrieren oder zumindest zu überprüfen, ob die Sensoren noch kalibriert sind.

Der Kompasskurs

Die Magnetometerdaten werden nun verwendet, um den Kompasskurs zu berechnen. Dazu müssen wir die m_x- und m_y-Signale in einen Winkel umwandeln. Python stellt direkt die math.atan2-Funktion bereit, die dieses Ziel hat. Die komplette Berechnung ist in der Datei mpu9250_i2c.py ("calcHeading(mx, my, mz)") definiert.

Schritt 7: Alternative Designs

Das Projekt nahm viel Zeit in Anspruch, da das Design völlig offen war. Für jede Komponente habe ich einige Prototypen implementiert und die Grenzen des Systems erfahren.

Das komplexeste Thema war der Rad-Encoder. Ich habe 3 verschiedene Optionen getestet, bevor ich den derzeit verwendeten optischen Encoder gefunden habe. Ich denke, dass die abgebrochenen Lösungen in einem solchen Projekt auch sehr interessant sind. Es betrifft die Teile, in denen ich am meisten gelernt habe.

Kontinuierliches Rotationsservo verbunden mit PCA 9695

Um eine zusätzliche H-Brücke für einen DC-Motor zu vermeiden, habe ich zunächst mit Endlosrotationsservos begonnen. Diese wurden von dem bereits vorhandenen Servotreiber pca 9695 angesteuert. Alle Antriebsmechaniken und die dazugehörige Elektronik waren viel einfacher. Dieses Design hatte zwei Nachteile:

• Der schlechte Regelbereich der Servos.
• Der fehlende Encoder-Halteort

Die Servos beginnen sich mit 50% pwm zu bewegen und haben bei ca. 55% volle Geschwindigkeit. Dies ist ein sehr schlechter Regelbereich.

Ohne Encoder-Halterung war es sehr schwierig, einen einsatzbereiten Encoder zu finden. Ich habe 3 verschiedene Reflexionsgeber getestet, die am Chassis montiert waren. Auf die Außenseite des Rades habe ich ein selbstgebautes Encoderrad mit schwarzen und weißen Abschnitten geklebt. Ich habe die QTR-1RC-Sensoren verwendet, die viel Signalverarbeitung benötigen, um das richtige Signal zu erhalten. Der Raspberry Pi war nicht in der Lage, diese Art von Echtzeitverarbeitung durchzuführen. Also beschloss ich, dem Roboter eine NodeMCU D1 mini als Echtzeit-Controller hinzuzufügen. Es wurde über den seriellen UART mit dem Raspberry Pi verbunden, um die verarbeiteten Sensordaten zu liefern. Die NodeMCU verwaltete auch den HC-SR04-Sensor. Die Mechanik war schwierig und nicht sehr robust, die serielle Leitung bekam Geräusche von der I2C-Leitung und den Motoren, also baute ich schließlich die zweite Version des Chassis mit einfachen DC-Getriebemotoren angetrieben von eine H-Brücke. Diese Motoren haben eine sekundäre Abtriebswelle, um einen optischen Encoder zu platzieren.

Schritt 8: Bildverarbeitung

Um das autonome Fahren zu verbessern, können wir einige Bildverarbeitungen vornehmen.

Die opencv-Bibliothek ist eine Referenz dafür. Es kann von Python verwendet werden, um die Hinderniserkennung schnell zu implementieren.

Wir erfassen ein Bild und wenden einige Bildverarbeitungsaufgaben an:

Erste Tests wurden mit Canny- und Sobel-Transformationen durchgeführt. Canny kann ein guter Kandidat sein, ist aber nicht vernünftig genug. Sobel ist zu sensibel (zu viele Objekte erkannt).

Schließlich habe ich meinen eigenen Filter erstellt, um alle horizontalen und vertikalen Farbverläufe zu mischen (Möbel erkennen):

• Transformieren Sie das Farbbild in ein Graustufenbild
• Verwischen Sie das Bild, um kleine Störungen zu entfernen
• Schwellwert für das Bild auf ein Schwarzweißbild
• Jetzt erkennen wir horizontale und vertikale Gradienten, um Objekte wie Wände und Möbel zu erkennen
• Wir filtern nur die großen Restkonturen (siehe farbige Konturen im Bild)

Jetzt können wir diese neuen Informationen nutzen, um Hindernisse zu erkennen…

Schritt 9: Nächste Schritte…

Jetzt haben wir eine einfache Roboterplattform mit Sensoren, Aktoren und einer Kamera. Mein Ziel ist es, mich autonom zu bewegen und ohne weitere Sensoren zur Station zurückzukehren. Dazu benötige ich folgende Schritte:

• Sensorfusion von Gier- und magnetischen Kurssignalen
• Kamerabildverarbeitung (dafür nur geringe CPU verfügbar)
• Kollisionserkennung (Ultraschallentfernung und Kamera)
• Kartenerstellung oder Orientierung

Jetzt gehen Sie und erstellen Sie Ihre eigenen Herausforderungen oder Ziele…