Neuigkeiten Das Projekt Technik RoboSpatium Unterstützung Stichwortverzeichnis Download Reaktionen Spiele Gadgets Kontakt

<<< R15 Hoverboard R19 Koffer-Robot >>>

R18 basierend auf ESP32 - Konstruktion

Das Video zu R18

Hier geht's zum Onlineshop von DFRobot, von dem ich die elektronischen Komponenten für den Roboter bezogen habe.

Bemerkungen zum Rover

Abbildung 1:
Die Grundidee von R18 ist, einen wirklich leicht nachzubauenden Rover auf die Räder zu stellen. Meine bislang gebauten Roboter waren immer für mein RoboSpatium konzipiert und die dazu notwendigen Anpassungen sind besonders von der Softwareseite für Anfänger nur sehr schwer zu durchschauen. Diese Hürden habe ich mit R18 deutlich verringert, indem:
1.) die elektronischen Komponenten und
2.) die Software
auf das nötigste reduziert sind.
Beides führt außerdem dazu, dass der Preis pro Rover eher klein ausfällt, womit ich gleich 3 Stück davon gebaut habe - alle vorherigen Rover sind bis Heute Einzelstücke geblieben.
...und schließlich habe ich aus diesen Gründen auch so richtig viel Zeit in diese Nachbauanleitung gesteckt. Sollte dennoch etwas unklar geblieben sein, hinterlasst einen Kommentar oder tretet mit mir anderweitig in Kontakt.

Bau der Mechanik

Abbildung 2:
Um die mechanischen Komponenten anzufertigen, habe ich zwei meiner 3D-Drucker angeworfen. Etwa 170 Gramm Filament sind für die Mechanik in zwei Tagen pro Rover verarbeitet worden. Die Bauteile des roten Rovers sind dabei mit meinem ältesten 3D-Drucker entstanden - nicht perfekt, aber allemal ausreichend für die Mechanik. Zusammengehalten wird das Alles von 3mm Schrauben mit 20mm Gewindelänge, sowie einem 30cm langen Stück Gewindestange und vielen Muttern.
Wer allzu weit herausstehende Schrauben nicht mag, kann auch zusätzlich eine Packung 3mmSchrauben mit 10mm Gewindelänge kaufen oder zur Säge greifen.

Abbildung 3:
Der Zusammenbau beginnt mit dem Anschrauben der Achsen für die Räder am Chassis. Dazu werden zwei 30mm lange Stücke von der Gewindestange zurechtgeschnitten, oder man nimmt gleich eine Schraube mit 30mm Länge.
Die Ritzel werden mit einem Tropfen Sekundenkleber auf der Welle der Motoren fixiert. Die Welle sollte etwa 1mm hervorstehen. Die Motoren werden dann in die Aussparungen eingeschoben. Zur Verschraubung des Deckels müssen Muttern auf der oberseite des Chassis eingeschoben werden (siehe Abbildung 5)
Die beiden grünen Pfeile zeigen auf Öffnungen im Chassis, an denen M3er Muttern zur Befestigung des Kameramastes (Siehe Abbilfung 7) eingeführt werden müssen.

Abbildung 4:
Sollten die tiefen Aussparungen, in welche M3er Muttern eingeschoben werden müssen, beim Druck etwas zu eng ausgefallen sein (was bei mir der Fall war), so kann die Mutter mit einem Feuerzeug oder Lötkolben vorsichtig ein wenig erwärmt werden. PLA, wie ich es für die Teile verwende, erweicht schon bei 60 Grad ausreichend, um die Muttern einzuführen. Erhitzt man die Mutter zu stark oder presst diese zu stark ein, so kann es passieren, dass diese auf der anderen Seite wieder herausfällt. Man muss wie so oft im Leben das richtige Gefühl für einen Vorgang entwickeln.

Abbildung 5:
4 Muttern müssen zur Verschraubung des Deckels der beiden Motoren auf der Unterseite in die Aussparungen auf der Oberseite eingeführt werden.
Die Räder werden mit je zwei weiteren Muttern auf der Achse gehalten.

Abbildung 6:
Der Schleifsporn am Heck des Rovers basiert auf einem Kronkorken. In diesen wird eine Scheibe eingeklebt, durch die eine Schraube gesteckt wird. Die Schraube darf nicht mit festgeklebt werden, sondern muss sich nach dem Verkleben der Plastikscheibe noch frei in dem Loch drehen können. Sekunden- oder Heißkleber eignen sich recht gut.

Abbildung 7:
Der Kameramast besteht aus zwei Teilen.

Abbildung 8:
Die Halterung für das Kameraservo und den Akku. Der Akkuhalter wird am Fuß nicht bündicg mit dem Chassis verschraubt. Es verbleibt ein Spalt, da der Akku ansonsten nicht eingeschoben werden kann. Erst nach Einschieben der Powerbank werden die Schrauben zo weit angezogen, biss der Akku festgeklemmt ist.

Abbildung 9:
Die Halterung der ESP32 Platine und des oberen Schleifkontaktes sind drehbar am Mast befestigt. Dazu müssen zwei Stücke der Gewindestange mit 65mm Länge zugeschnitten werden. Der obere Schleifkontakt wird nur benötigt, wenn der Rover nicht per Akku, sondern extern mit Energie versorgt werden soll.

Abbildung 10:
Die Stoßstange für den Rover ist optional, verhindert aber effektiv, dass sich die Roboter in meinem RoboSpatium verheddern oder dorthin gelangen können, wo sie nicht hin sollen...

Abbildung 11:
Verschiedene Perspektiven des fertigen Robers. Damit sollten die letzten Unklarheiten beseitigt sein.

Teileliste:

Bauteil	Anzahl	Bemerkung / Bezugsquelle
ESP32-CAM	1	Mikrocontrollerboard mit WLAN und Kameramodul. Erhältlich z.B. bei DFRobot.
Getriebemotoren 75:1	2	Antriebe Erhältlich bei DFRobot.
Micro Servo	1	Schwenken der Kamera Erhältlich bei DFRobot.
Powerbank	1	2A Ausgangsstrom wird benötigt.
M3er Schrauben und Muttern	Viele	20mm Gewindelänge passen für die meisten Verschraubungen. 10mm Geweindelänge, wenn die Schrauben an einigen Stellen nicht so weit überstehen sollen (Optional, rein optische Sache) 4x 30mm Gewindelänge für Räder und Stoßstange vorne, alternativ können stattdessen Stücke der Gewindestange zurechtgesägt werden.
Gewindestange 3mm	1	30cm Gesamtlänge, Teilstücke müssen zurechtgesägt werden.
PLA oder PETG	Circa 170g pro Rover	3D Druck der Mechanik Ein wenig TPU für die Reifen. Stattdessen können auch Gummiringe auf die Räder geklebt werden.
Lüsterklemme	2	Verkabelung
Doupont / Jumperkabel, weiblich	2	Rot / Schwarz für Verkabelung Rover 8 weitere zur Programmierung per Arduino UNO
USB Kabel	1	Hälfte mit Typ A-Stecker wird für Verbindung zur Powerbank benötigt.
1mm Draht oder Büroklammer	1	Verbindung Servoarm zur Kamera.
Sekundenkleber	1	Verklebung Ritzel auf Motorwelle und Kronkorken auf Schleifsporn.
Kronkorken	1	Schleifsporn
Arduino UNO	1	Wird zum Hochladen des Codes auf den ESP32 benötigt

Software Upload per Arduino UNO

ESP32 Programmierung mit einem Arduino UNO und der Arduino IDE

Abbildung 12:
Um die Software auf den Rovers zu bekommen, wird ein Arduino UNO als Programmierer und die Arduino IDE als Softwarepaket benötigt.

ESP32 Programmierung mit einem Arduino UNO - Verkabelung

Abbildung 13:
Zum Hochladen müssen Arduino Uno und ESP32 wie auf der Abbildung verkabelt werden:
Arduino +5V zu ESP32 +5V
Arduino GND zu ESP32 GND
Arduino Pin 0 zu ESP32 Pin UOR
Arduino Pin 0 zu ESP32 Pin UOT
Arduino GND zu ESP32 GND
Vor dem Hochladen des Codes müssen Pin GND und IO0 auf dem ESP32 Board überbrückt werden. Anschließend den Reset Knopf auf dem ESP32 Board drücken. Nach erfolgreichem Hochladen muss die Brücke entfernt und Reset erneut gedrückt werden. Der ESP32 bootet dann mit der neuen Firmware und sollte sich im WLAN anmelden.

Vorbereitung der Arduino IDE

Die Anweisungen gelten für die Installation unter Linux. Getestet habe ich das Ganze unter Linux Mint 20.4 und RaspberryOS.

Die Arduino IDE kann mit den Befehlen "sudo apt-get update" gefolgt von "sudo apt-get install arduino" installiert werden.
Unter Linux Mint 20.4 musste ich noch zusätzliche Pakete mit "sudo apt install python-is-python3" und "sudo apt install python3-serial" installieren.
Nun die Arduino IDE öffnen und auf Datei -> Voreinstellungen gehen. In dem Feld "Zusätzliche Bordverwalter URLs" den folgenden Link eingeben:
https://dl.espressif.com/dl/package_esp32_index.json
und das Dialogfeld mit "OK" bestätigen.
Auf Werkzeuge->Board->Boardverwalter klicken. Dann nach ESP32 suchen und auf die Schaltfläche "Installieren" klicken.
Unter Werkzeuge->Port den entsprechenden Port mit dem Arduino UNO anklicken.
Unter Werkzeuge->Board->ESP32 Arduino-> den Eintrag "ESP32 Wrover Module" anklicken. In meinem Fall war die Liste "ESP32 Arduino" zweimal vorhanden, die längere Liste war in dem Fall die richtige.
Unter Werkzeuge->Upload Speed den Eintrag "115200" auswählen.
Unter Werkzeuge->Flash Frequency den Eintrag "40MHz" auswählen.
Unter Werkzeuge->Flash Mode den Eintrag "QIO" auswählen.
Unter Werkzeuge->Partition Scheme den Eintrag "Huge App (3mb No OTA)" auswählen.
Unter Werkzeuge->Programmer den Eintrag "AVR ISP" auswählen. Wenn die Liste leer ist, funktioniert's auch ohne eine Auswahl.
Nun die Arduino IDE schließen und den Ardino Sketch aus dem Download-Paket öffnen.
Im Quellcode müssen die SSID eures WLAN und dessen Passwort eingetragen werden:
const char* ssid = "Type-your-SSID-here";
const char* password = "Type-your-password-here";

Ebenfalls einzutragen ist eine IP-Adresse für euren Rover und die Gateway Adresse:
// Set your Static IP address
IPAddress local_IP(192, 168, 2, 184);
// Set your Gateway IP address
IPAddress gateway(192, 168, 2, 1);

Für die IP-Adresse gilt, dass die ersten drei Zahlen denen in deinem WLAN verwendeten Zahlen entsprechen muss, nur die vierte Zahl kann frei gewählt werden! Die ersten 3 Zahlen erfahrt ihr, indem ihr in einem Terminalfenster auf eurem (Linux) PC den Befehl "ifconfig" eingebt. als Ergebnis erhaltet ihr mehrere Zeilen und in einer davon steht in etwa:
inet 192.168.2.107 netmask 255.255.255.0 broadcast 192.168.2.255
Die ersten drei Zahlen nach inet bzw. broadcast sind die ersten drei Zahlen, die ihr im Sketch in den beiden Zeilen eintragen müsst, die vierte Zahl sollte dann die "184" (local_IP) bzw. die "1" (Gateway) sein. Im Quellcode müssen die vier Zahlen der Adressen durch Komma getrennt werden.
Das Kompillieren und den Upload über Sketch->Hochladen starten. Der Vorgang dauert einige Minuten.
Ist das Programm erfolgreich hochgeladen, kann die Brücke von GND zu dem Pin IO0 auf dem ESP32 Board entfernt und Reset erneut gedrückt werden. Der ESP32 bootet dann mit der neuen Firmware und sollte sich im WLAN anmelden. Ist das erfolgreich, so blinkt die rote LED auf der Rückseite des ESP32 Boards einmal kurz.
Nun einen Browser öffnen, der sich im selben WLAN befindet und die Adresse als Ziel eingeben:
http://192.168.2.184
Es muss unbedingt "http://" vor der IP Adresse stehen, da der Browser sonst standardmäßig versucht, eine verschlüsselte Verbindung aufzubauen (https://), was nicht funktioniert, da der ESP32 Webserver keine Verschlüsselung beherrscht.
Es sollte das Kontrollinterface im Browser zu sehen sein und ihr könnt den Videostream starten und die LED ein- und aussschalten. Der Fertig programmierte ESP32 kann jetzt im Rover eingebaut und verkabelt werden.

"Es klappt net!"

...ist keine Aussage, auf die ich irgendetwas antworten kann als "Ja und?"
In jedem der oben angegebenen Schritte wird irgend etwas von den einzelnen Programmen ausgegeben. Lest euch diese Angaben durch, denn dafür werden die von den Programmierern geschrieben! Wenn also etwas schief läuft, so ist das an den Meldungen zu lesen. Wenn ihr von mir Hilfe erwartet, dann müsst ihr unbedingt angeben:

Bei welchem Schritt ein Fehler ausgegeben wurde
und
Welche Meldung zu lesen war.
Gut zu wissen ist auch, mit welchem Betriebssystem (Version?) ihr arbeitet - wirklich weiter helfen kann ich euch nur mit Linux.

In Kontakt könnt ihr mit mir treten, in dem ihr einen Kommentar auf dieser Seite hinterlasst oder mir eine Mail schreibt. Die Addresse findet ihr in der Rubrik Kontakt.

Die Meldung "Es klappt!" bedarf keiner weiteren Angaben, freut mich aber außerordentlich zu hören oder zu lesen.

Meine Änderungen am Code des Webservers

Wenn ihr nicht nur meinen fertigen Code hochladen, sondern auch in Grundzügen verstehen wollt, was ich geändert habe, lest den folgenden Abschnitt durch. Die hier gelisteten Änderungen sind schon alle im Code des Download-Paketes implementiert und müssen nicht vorgenommen werden, um den Rover in Betrieb zu nehmen!

Die Webseite "index.html" mit den Schaltflächen steht im Quellcode des Webservers nicht im Klartext, sondern in komprimierter Form. An den Quelltext kommt ihr in lesbarer Form heran, indem ihr euch mit Hilfe eines Browsers mit dem Rover verbindet und dann den Seitenquelltext aufruft. Die index.html mit den von mir vorgenommenen Änderungen ist im Download-Paket enthalten. Dort findet ihr ebenfalls die "index-Camera-Server-WITHOUT-Rover-Control.html". Das ist die originale Datei des Kameraservers aus den Beispielen der Arduino IDE. Darauf und auf dem Arduino Sketch in dem Verzeichnis "Arduino-Camera-Server-WITHOUT-Rover-Control" basieren die zu machenden Änderungen dieser Beschreibung.

Checkbox für die onboard LED einfügen:
Sucht in der index.html nach der Zeile:
<div class="input-group" id="face_recognize-group">

und in diesem Abschnitt geht weiter, bis ihr zu der Zeile:
</div>
Unterhalb dieser Zeile, fügt ihr den folgenden Block ein:
<div class="input-group" id="flash-group">
  <label for="flash">Flash</label>
  <div class="switch">
    <input id="flash" type="checkbox" class="default-action">
    <label class="slider" for="flash"></label>
  </div>
</div>

Schaltflächen zum Vorwärts oder Rückwärts Fahren einfügen:
Sucht in der index.html nach der Zeile:
<section id="buttons">

Unterhalb dieser Zeile müssen die folgenden Zeilen eingefügt werden:
<button id="drive_forward">Drive Forward</button>
<button id="drive_backward">Drive Backward</button>
Sucht dann nach der folgenden Zeile:
const stillButton = document.getElementById('get-still')

unterhalb derer ist einzufügen:
const DriveForwardButton = document.getElementById('drive_forward')
const DriveBackwardButton = document.getElementById('drive_backward')
Sucht dann nach der Zeile:
enrollButton.onclick = () => {

und fügt darüber die folgenden Zeilen ein:
DriveForwardButton.onclick = () => {
  DriveForwardButton.innerHTML = 'Driving...'
  updateConfig(DriveForwardButton)
}
DriveBackwardButton.onclick = () => {
  DriveBackwardButton.innerHTML = 'Driving...'
  updateConfig(DriveBackwardButton)
}

Nun muss die geänderte index.html komprimiert werden, damit diese im Arduino Sketch eingefügt werden kann. Das kann über die Webseite:
https://gchq.github.io/CyberChef/#recipe=Gzip('Dynamic%20Huffman%20Coding','index.html.gz','',false)To_Hex('0x',16)Split('0x',',0x')
gemacht werden. Der Quelltext wird dazu in das Fenster "Input" kopiert. Folgende Einstellungen müssen vorgenommen werden:
Compression: "Dynamic Hoffman Coding"
Delimiter: 0x
Bytes per line: 16
Split delimiter: 0x
Join delimiter: ,0x

Durch Klicken auf die Schaltfläche "Bake" wird im Fenster "Output" das Ergebnis als Bytes im HEX Format angezeigt. Diesen Text kopieren und in der Arsuino IDE im Tab "camera_index" einfügen. Es muss der Text nach der Zeile:
const uint8_t index_ov2640_html_gz[] = {

bis vor dem abschließenden "}" ersetzt werden. Das allererste Komma in der Liste muss entfernt werden!
Ebenfalls korrigiert werden muss der Wert für:
#define index_ov2640_html_gz_len (4880)

Angegeben wird darin die Anzahl Bytes der komprimierten index.html. Dieser Wert wird auf der Webseite nicht angezeigt, muss daher errechnet werden. Angegeben wird oberhalb des Output Feldes die Anzahl der Zeilen. Multipliziert mit 16 erhält man die Anzahl der Bytes. Da die letzte Zeile nicht unbedingt vollständig ist, müssen die fehlenden Bytes abgezogen werden!

Nun müssen noch Änderungen im Tab "apt_http.cpp" vorgenommen werden:
sucht nach der Zeile:
else if(!strcmp(variable, "face_recognize")) {

Oberhalb dieser Zeile fügt ihr den folgenden Block ein:
else if(!strcmp(variable, "flash")) {
  #define LED_BUILTIN 33
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, atoi(value));
}
else if(!strcmp(variable, "drive_forward")) {
  #define LED_BUILTIN 4
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 1);
}
else if(!strcmp(variable, "drive_backward")) {
  #define LED_BUILTIN 4
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 0);
}

Der so geänderte Code muss wie oben beschrieben auf den ESP32 geladen werden. Zu beachten ist, dass die Schaltflächen "Drive Forward" und "Drive Backward" lediglich die rote LED auf der Rückseite des ESP32 Boards ein- bzw, ausschalten!

Elektronik

Abbildung 14:
Neben dem ESP32-CAM werden nur noch zwei mini Getriebemotoren, ein Mikro Servo und eine Powerbank benötigt.

Abbildung 15:
Die Verkabelung kann ganz ohne Lötkolben erfolgen. Die Leitungen von Masse und +5V werden in diesem Fall in zwei Schraubklemmen zusammengeführt. Die Verbindung zu den Pins auf dem ESP32 Board erfolgt über die Steckkontakte von Servo und Getriebemotoren (Steuerleitungen) beziehungsweise über sogenannte Doupont- oder Jumperkabel (+5V und Masse).

Abbildung 16:
Ein Micro USB Kabel habe ich durchtrennt, da die Hälfte mit dem Typ A Stecker für die Stromversorgung per Powerbank benötigt wird. Mit einem Multimeter wird die korrekte Polung geprüft - hier liegt offensichtlich plus 5V an der leicht roten Leitung, so wie es sein sollte.

Download

Die 3D-Dateien der Mechanik, der Schaltplan und der Arduino Sketch sind im Download-Paket (2.8MB) enthalten.

Testfahrten

Welche Roboter zur Zeit gesteuert werden können, seht ihr auf der Übersichtsseite meines RoboSpatiums.

<<< R15 Hoverboard R19 Koffer-Robot >>>

Neuigkeiten Das Projekt Technik RoboSpatium Unterstützung Stichwortverzeichnis Archiv Download Reaktionen Spiele Verweise Gadgets Kontakt Impressum