WiDC:WLAN-gesteuerter FPV-Roboter

Apps und Onlinedienste

	Autodesk Fusion 360
	Arduino-IDE

Über dieses Projekt

Wie wäre es mit einem ferngesteuerten Roboter, um Ihre Umgebung zu erkunden, unzugängliche Orte zu erreichen, auszuspionieren, Fotos zu machen, Filme zu drehen oder ein Video zu übertragen? Dieses Tutorial zeigt Ihnen, wie Sie für all diese Zwecke ein Unentbehrliches machen!

Dieses Tutorial ist eine Verbesserung meines vorherigen Tutorials (https://www.instructables.com/id/Wi-fi-Controlled-FPV-Rover-Robot-with-Arduino-ESP8/), in dem ich ein schnelleres Home- Roboter gemacht. Es zeigt, wie man einen ferngesteuerten zweirädrigen Roboter über ein Wi-Fi-Netzwerk mit zwei Gleichstrommotoren, einem Arduino Uno und einem ESP8266 Wi-Fi-Modul entwickelt.

Der Roboter kann von einem gewöhnlichen Internetbrowser mit einer HTML-entwickelten Schnittstelle gesteuert werden. Ein Android-Smartphone kann verwendet werden, um Video und Audio vom Roboter an die Steuerschnittstelle zu übertragen.

Wie in meinem vorherigen Tutorial zeige ich, wie man mit normalen Werkzeugen (kein 3D-Drucker, Laserschneider oder CNC-Router erforderlich) einen kostengünstigen Rahmen für ein Roboterprojekt entwirft und baut.

Man könnte bemerken, dass die hier verwendeten Komponenten möglicherweise nicht für ihren Zweck optimiert sind. Anstelle der Arduino + ESP8266-Kombination könnte beispielsweise eine NodeMCU verwendet werden. Ein Rapsberry Pi mit Kamera würde das Smartphone ersetzen und auch die Motoren steuern. Es ist sogar möglich, ein Android-Smartphone als "Gehirn" für Ihren Roboter zu verwenden. Das stimmt...

Dieses Tutorial wurde von einem anderen Projekt abgeleitet, an dem ich Teil bin:Joy Robot (https://hackaday.io/project/12873-rob-da-alegria-joy-robot oder https://www.hackster.io/igorF2/ robo-da-alegria-joy-robot-85e178), und der Einfachheit halber wurde hier dieselbe Hardware verwendet. Ein Arduino Uno wurde gewählt, weil es für jeden sehr zugänglich und einfach zu bedienen ist, und wir wollten ein einfaches Schild dafür entwerfen. In unserem ursprünglichen Projekt steuern wir auch einige Servos und LED-Matrizen und Schnittstellen mit dem ESP. Das Smartphone wird tatsächlich durch ein Tablet ersetzt, auf dem auch andere Anwendungen laufen. Unter den folgenden Links finden Sie möglicherweise andere Tutorials zu diesem Roboter:

Steuerung des LED-Matrix-Arrays mit Arduino Uno:

https://www.instructables.com/id/Controlling-a-LED-Matrix-Array-With-Arduino-Uno/

Wi-Fi-Browser-gesteuerte Servomotoren:

https://www.instructables.com/id/Wi-Servo-Wi-fi-Browser-Controlled-Servomotors-with/

Diese Anleitung kann angepasst und in Form oder Bedienoberfläche an Ihre Bedürfnisse angepasst werden.

In diesem anderen Tutorial präsentiere ich eine Möglichkeit, einen Roboter mit der Blynk-App von einem Smartphone aus zu steuern! Schau es dir an:

https://www.hackster.io/igorF2/wi-fi-controlling-robot-using-wemos-d1-esp8266-and-blynk-464198

Schritt 1:Werkzeuge

Die folgenden Werkzeuge wurden für den Bau dieses Prototyps verwendet:

Tools:

• Handsäge (zum Schneiden von Acrylplatten)

• Schraubendreher (zum Platzieren von Schrauben und Muttern)

• Lineal (zum Messen der Modellmaße)

• Gebrauchsmesser (zum Schneiden der Struktur und zum Bohren von Löchern)

• Bohrmaschine (verwendet zum Bohren des Acryls für die Installation der Schrauben)

• Schleifpapier (um raue Kanten zu glätten)

• Lötkolben (zum Löten von Motorklemmen)

• Ein Computer (zum Kompilieren und Hochladen von Arduino-Code)

Diese Werkzeuge wurden für die Herstellung der mechanischen Struktur des Roboters, die Montage des Roboters und die Verbindung elektronischer Komponenten verwendet. Einige der Werkzeuge werden nicht benötigt, wenn Sie eine Struktur kaufen, anstatt eine eigene zu bauen.

Sie können sogar andere Geräte verwenden (z. B. einen 3D-Drucker oder Laserschneider), abhängig von den in Ihrem Makerspace verfügbaren Werkzeugen.

Schritt 2:Mechanische Struktur und Materialien

Die folgenden Materialien wurden für die mechanische Struktur verwendet:

Mechanische Materialien:

• 2 mm Acrylglas

• DC-Getriebemotor mit Rad (x2)

• 30-mm-Lenkrad (x1)

• M2 x 10 mm Schrauben (x5)

• M2 x 1,5 mm Muttern (x5)

• M3 x 10 mm Schrauben (x9)

• M3 x 10 mm Schrauben (x9)

• M3 x 40 mm Schrauben (x4)

• M3 x 1,5 mm Muttern (x12)

• 5/32" x 1" Schrauben (4x)

• 5/32" Muttern (x12)

• Universeller Telefonhalter

• Stahlwinkel "L"-förmige Halterung (30 x 30 mm) (x4)

Schritt 3:Elektronische Komponenten

Die folgenden elektronischen Komponenten wurden in diesem Roboter verwendet:

• Arduino Uno (kaufen / kaufen)

• ESP8266 (kaufen)

• Protoshield (für eine kompaktere Version) oder ein gewöhnliches Steckbrett (kaufen)

• 1 kOhm Widerstand (x2)

• 10 kOhm Widerstand (x1)

• DC-Getriebemotor mit Rad (x2) (kaufen)

• H-Brückenmodul (kaufen)

• Einige Überbrückungsdrähte

• 5V USB-Powerbank

Alle Komponenten finden Sie ganz einfach online in Ihrem bevorzugten E-Commerce-Shop.

Wie in der Einleitung zu diesem Tutorial hervorgehoben wurde, wurde die Auswahl der Komponenten aus anderen von mir entworfenen Projekten abgeleitet und kann beispielsweise mit einem anderen Mikrocontroller optimiert werden.

Schritt 4:Entwerfen der Struktur

Zuerst musste ich die mechanische Struktur meines Roboters entwerfen. Sie können auch die komplette Struktur online kaufen, wenn Sie nicht Ihre eigene benutzerdefinierte Struktur bauen möchten (es gibt viele Roboterbausätze online). In diesem Fall können Sie zu Schritt 6 springen. Für dieses Tutorial wurde ein kostengünstiger Acrylrahmen für die Befestigung der Motoren und anderer Komponenten entworfen. Die in diesem Tutorial vorgestellte Struktur wurde mit der CAD-Software Fusion 360 in 3D entworfen und mit gewöhnlichen Werkzeugen konstruiert (kein 3D-Drucker, Laserschneider oder CNC-Router erforderlich). Sie können die unten beschriebenen Prinzipien verwenden, um eine benutzerdefinierte Struktur zu entwerfen, die Ihren Anforderungen entspricht.

Zuerst musste ich ein 3D-Modell der Hauptkomponenten erstellen, um die Anordnung der Struktur zu bestimmen. Einige davon wurden aus der GrabCAD Community Library heruntergeladen (https://grabcad.com/library ):

• Arduino Uno (https://grabcad.com/library/arduino-uno-13)

• Getriebemotor (https://grabcad.com/library/bomotor-1)

• H-Brücke (https://grabcad.com/library/motor-driver-l9110-1)

• Powerbank (https://grabcad.com/library/power-bank-7)

• Universeller Handyhalter (https://grabcad.com/library/universal-phone-halter-for-the-gopro-accessories-1)

Die elektronischen Komponenten wurden in einer Ebene angeordnet, damit ich den Platzbedarf meines Roboters ermitteln konnte. Danach musste ich die Position für die Motoren und Räder auswählen, um eine stabile Struktur zu schaffen.

Basierend auf diesen Positionen wurde die Hauptstruktur entworfen, die aus drei Platten (einer Grundplatte und zwei Seitenplatten) besteht, die mit einigen Klammern verbunden sind.

Schritt 5:Aufbau und Montage der Struktur

Der Aufbau der Basisstruktur gliedert sich in folgende Schritte:1. Schneiden Sie die Acrylbasis entsprechend den Maßen in der 2D-Zeichnung zu: Dies kann mit einem Laserschneider (wenn Sie Zugang zu einem haben) oder, wie in meinem Fall, mit gewöhnlichem Werkzeug erfolgen.

Zuerst müssen Sie die Maße Ihres Modells auf die Acrylglasplatte übertragen. Drucken Sie Ihre 2D-Zeichnung mit einem gewöhnlichen Drucker auf ein Klebepapier, schneiden Sie das Papier dann in die passenden Maße und tragen Sie diese Maske auf die Oberfläche des Acryls auf. Schneiden Sie das Acryl mit einem Cuttermesser und mithilfe eines Lineals oder einer Skala ein gerade Linien. Sie müssen das Blatt nicht vollständig durchschneiden, sondern es einfach einritzen, um einige Spuren zu erstellen, in denen das Stück später geschnitten wird. Legen Sie das Acryl auf eine ebene Fläche, halten Sie es mit einigen Klammern fest und üben Sie etwas Druck aus, bis die Platte in zwei Teile bricht. Wiederholen Sie diesen Vorgang, bis alle Schnitte fertig sind. Danach können Sie raue Kanten mit einem Schleifpapier glätten. Sie können das Acryl auch mit einer Handsäge schneiden.2. Bohren Sie die Löcher an den in der 2D-Zeichnung gezeigten Positionen: Bohren Sie die Löcher an den in der 2D-Zeichnung gezeigten Positionen (in der Maske angegeben) mit einer Bohrmaschine. Acryl lässt sich relativ leicht bohren. Wenn Sie also keine Bohrmaschine zur Verfügung haben, können Sie die Löcher manuell mit einem scharfen Werkzeug, wie einem Cuttermesser, bohren. Sie können es auch verwenden, um kleine Löcher auf Schraubengrößen zu vergrößern. Entfernen Sie die Maske und Ihre Basis ist fertig.

3. Montieren Sie die Komponenten mit Schrauben und Muttern gemäß der 3D-Zeichnung: Montieren Sie die Komponenten mit Schrauben und Muttern gemäß dem Video, und Ihre Struktur ist einsatzbereit. Für die Montage der Halterungen und DC-Motoren werden M3-Schrauben verwendet. Für die Montage der elektronischen Bauteile wurden M2-Schrauben verwendet, während die 5/32"-Schrauben für die Montage des Vorderrads und des Smartphone-Clips verwendet werden. Machen Sie nun eine Pause und beginnen Sie im folgenden Schritt mit der Montage der Schaltung...

Schritt 6:Zusammenbau der Elektronik

Die hier vorgeschlagene Schaltung verwendet einen Arduino Uno als Hauptcontroller, der mit einem ESP8266 für die Wi-Fi-Kommunikation verbunden ist. Der Arduino steuert die Gleichstrommotoren mit einer H-brige-Treiberschaltung, die bis zu zwei rotierende Motoren steuern kann sie unabhängig in beide Richtungen.

Eine Powerbank wurde verwendet, um die Elektronik mit Strom zu versorgen, die direkt an den USB-Port von Arduino angeschlossen war. Dies ist eine einfache Möglichkeit, Ihren Arduino mit Strom zu versorgen:einfach aufzuladen, kann leicht ausgetauscht werden und bietet eine sichere Spannung von 5 V.

Verbinden Sie alle Komponenten gemäß dem Schaltplan. Sie benötigen einige Überbrückungsdrähte, um das ESP8266-Modul anzuschließen, das nicht protoboard-freundlich ist, H-Brücken- und Gleichstrommotoren. Sie können ein Protoshield (für eine kompaktere Schaltung), ein gewöhnliches Steckbrett verwenden oder Ihr eigenes Arduino-Shield entwerfen.

Sie werden feststellen, dass der ESP8266-1 nicht für Steckbretter geeignet ist. Es wird mit einigen Überbrückungsdrähten verbunden, aber nicht an der Struktur befestigt.

Schließen Sie ein USB-Kabel an das Arduino-Board an und fahren Sie mit dem nächsten Schritt fort.

Schritt 7:Arduino-Code

Installieren Sie die neueste Arduino-IDE. Für die Kommunikation mit dem ESP-8266-Modul oder die Steuerung der Motoren wurde keine Bibliothek benötigt. Bitte überprüfen Sie die Baudrate Ihres ESP8266 und stellen Sie sie richtig im Code ein. Laden Sie den Arduino-Code (WiDC.ino) herunter und ersetzen Sie das XXXXX durch die SSID Ihres WLAN-Routers und YYYYY nach Router-Passwort. Verbinden Sie das Arduino-Board mit dem USB-Port Ihres Computers und laden Sie den Code hoch.

Schließen Sie ein USB-Kabel an das Arduino-Board an und fahren Sie mit dem nächsten Schritt fort.

//include library#include SoftwareSerial esp8266(3, 2); // RX-Pin =3, TX-Pin =2 // Definition von Variablen #define DEBUG true // Nachrichten zwischen ESP8266 und Arduino im seriellen Portint-Zustand anzeigen =5; // Anfangszustand des Roboters definieren (5 =stand-by) // Motorpins definierenconst int motor1Pin1 =5;const int motor1Pin2 =6;const int motor2Pin1 =9;const int motor2Pin2 =10; // Motordrehzahl definierenint motorSpeed ​​=150; // Motordrehzahl (PWM) // ***** // SETUP // *****void setup () { // Pin-Modi einstellen PinMode (motor1Pin1, OUTPUT); pinMode (motor1Pin2, AUSGANG); pinMode (motor2Pin1, AUSGANG); pinMode (motor2Pin2, AUSGANG); // Kommunikation starten Serial.begin (9600); esp8266.begin(9600); sendData("AT+RST\r\n", 2000, DEBUG); // Modul zurücksetzen sendData("AT+CWMODE=1\r\n", 1000, DEBUG); // Stationsmodus einstellen sendData("AT+CWJAP=\"XXXXX\",\"YYYYY\"\r\n", 2000, DEBUG); // Wi-Fi-Netzwerk verbinden (ersetzen Sie XXXXX durch die SSID Ihres Wi-Fi-Routers und YYYYY durch seine Passwortverzögerung (5000); // warten Sie auf die Verbindung sendData("AT+CIFSR\r\n", 1000, DEBUG); / /show IP address sendData("AT+CIPMUX=1\r\n", 1000, DEBUG); //Mehrere Verbindungen zulassen sendData("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); / / Webserver auf Port 80 starten}//*********//MAIN LOOP//*********void loop(){ if (esp8266.available()) //verify eingehende Daten { if (esp8266.find("+IPD,")) //wenn es eine Nachricht gibt { String msg; esp8266.find("?"); //nach der Nachricht suchen msg =esp8266.readStringUntil(' ' ); // ganze Nachricht lesen String-Befehl =msg.substring (0, 3); // die ersten 3 Zeichen =Befehl Serial.println (Befehl); // vorwärts bewegen if (Befehl =="cm1") { state =1; } // rückwärts bewegen if(command =="cm2") { state =2; } //nach rechts drehen if(command =="cm3") { state =3; } //nach links drehen if(command ==" cm4") { state =4; } // Nichts tun if(command =="cm5") { state =5; } } } //STATE 1:vorwärts gehen if (state ==1) { analogWrite(m otor1Pin1, motorSpeed); digitalWrite (motor1Pin2, LOW); analogWrite (motor2Pin1, motorSpeed); digitalWrite (motor2Pin2, LOW); } //STATE 2:rückwärts bewegen if (state ==2) { DigitalWrite (motor1Pin1, LOW); analogWrite (motor1Pin2, motorSpeed); digitalWrite (motor2Pin1, LOW); analogWrite (motor2Pin2, motorSpeed); } //STATE 3:nach rechts bewegen, wenn (state ==3) {analogWrite (motor1Pin1, motorSpeed); digitalWrite (motor1Pin2, LOW); digitalWrite (motor2Pin1, LOW); analogWrite (motor2Pin2, motorSpeed); } // ZUSTAND 4:nach links bewegen, wenn (Zustand ==4) { DigitalWrite (motor1Pin1, LOW); analogWrite (motor1Pin2, motorSpeed); analogWrite (motor2Pin1, motorSpeed); digitalWrite (motor2Pin2, LOW); } //STATE 5:nichts tun, wenn (state ==5) { DigitalWrite (motor1Pin1, LOW); digitalWrite (motor1Pin2, LOW); digitalWrite (motor2Pin1, LOW); digitalWrite (motor2Pin2, LOW); } } //******************** // Hilfsfunktionen //********************String sendData (String-Befehl, const int Timeout, Boolean Debug) { String response =""; esp8266.print (Befehl); lange int-Zeit =millis(); while ((time + timeout)> millis()) { while (esp8266.available()) { char c =esp8266.read(); Antwort +=c; }} Wenn (Debug) {Serial.print (Antwort); } Antwort zurückgeben;}  

Code erklärt:

Der Code verwendet einen seriellen Port für die Kommunikation zwischen dem Arduino und dem ESP8266 und einen anderen für die Kommunikation zwischen dem Arduino und einem Computer. Nachdem das Arduino Uno nur über einen seriellen Port verfügte, wurde die SoftwareSeial-Bibliothek verwendet, um einen sekundären Port mit den digitalen Pins 2 und 3 zu erstellen.

//include library#include SoftwareSerial esp8266(3, 2); //RX-Pin =3, TX-Pin =2 

Während des Setups müssen beide serielle Kommunikationen gestartet und ihre Baudrate definiert werden (eine zwischen dem Arduino und Ihrem seriellen Monitor und die andere, um der ESP8266-Geschwindigkeit zu entsprechen). Beachten Sie, dass mein ESP8266 auf 9600 kbps eingestellt war. Standardmäßig kommen die meisten dieser Module mit 115200 kbps, aber die SoftwareSerial-Bibliothek kann nicht mit dieser Geschwindigkeit arbeiten und Sie müssen ihre Baudrate ändern. Bei mir funktionierten 9600 kbps gut.

In diesem Projekt habe ich keine spezielle Bibliothek für die Kommunikation mit dem WLAN-Modul verwendet. Stattdessen wurden nur die folgenden normalen AT-Befehle (ein Satz von Anweisungen, der auf der ESP8266-Standardfirmware definiert ist) verwendet:

• AT+RST:ESP8266-Modul zurücksetzen

• AT+CWMODE:Modul auf Stationsmodus oder Zugangspunkt setzen

• AT+CWJAP:Verbinden Sie ein Wi-Fi-Netzwerk mit seiner SSID und seinem Passwort

• AT+CIPMUX:Set-Modul für Mehrfachverbindungen oder Einzelverbindung

• AT+CIPSERVER:Startet den Webserver auf einem bestimmten Port //Starte die Kommunikation

 Serial.begin(9600); esp8266.begin(9600); sendData("AT+RST\r\n", 2000, DEBUG); // Modul zurücksetzen sendData("AT+CWMODE=1\r\n", 1000, DEBUG); // Stationsmodus einstellen sendData("AT+CWJAP=\"XXXXX\",\"YYYYY\"\r\n", 2000, DEBUG); // Wi-Fi-Netzwerk verbinden (ersetzen Sie XXXXX durch die SSID Ihres Wi-Fi-Routers und YYYYY durch seine Passwortverzögerung (5000); // warten Sie auf die Verbindung sendData("AT+CIFSR\r\n", 1000, DEBUG); / /show IP address sendData("AT+CIPMUX=1\r\n", 1000, DEBUG); //Mehrere Verbindungen zulassen sendData("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); / / Webserver auf Port 80 starten 

Eine Hilfsfunktion (sendData) wird zum Senden von Daten (von Arduino an ESP8266), Lesen und Anzeigen der Antwort auf dem Serial Monitor verwendet.

String sendData(String-Befehl, const int timeout, boolean debug){ String response =""; esp8266.print (Befehl); lange int-Zeit =millis(); while ((time + timeout)> millis()) { while (esp8266.available()) { char c =esp8266.read(); Antwort +=c; }} Wenn (Debug) {Serial.print (Antwort); } Antwort zurückgeben;} 

Mit dem obigen Code setzt das Arduino das Modul zurück, tritt einem Netzwerk bei, wartet einige Zeit auf die Verbindung, zeigt dann seine IP-Adresse an und startet einen Webserver. Danach wird die Hauptschleife gestartet und der Mikrocontroller wartet auf Befehle.

void loop(){ if (esp8266.available()) //Überprüfe eingehende Daten { if (esp8266.find("+IPD,")) //wenn es eine Nachricht gibt { String msg; esp8266.find("?"); //nach der Nachricht suchen msg =esp8266.readStringUntil(' '); // ganze Nachricht lesen String-Befehl =msg.substring (0, 3); // erste 3 Zeichen =Befehl Serial.println (Befehl); // vorwärts bewegen if (Befehl =="cm1") { state =1; } // rückwärts bewegen if (Befehl =="cm2") { state =2; } // rechts abbiegen if (Befehl =="cm3") { state =3; } // links abbiegen if (Befehl =="cm4") { state =4; } // Nichts tun if (Befehl =="cm5") { state =5; } } } 

Fünf mögliche Befehle wurden definiert (cm1 bis cm5). Immer wenn der Arduino einen dieser Befehle empfängt, tritt er in einen von fünf möglichen Zuständen ein (vorwärts bewegen, rückwärts bewegen, nach rechts bewegen, nach links bewegen und in Bereitschaft bleiben) und in diesem Zustand fortfahren, bis er einen anderen Befehl erhält.

Jeder Zustand definiert die Signale für die Motorpins. Ich habe digitalWrite (pin, LOW) verwendet, wenn ich einen Pin auf 0 V setzen wollte, und analogWrite (pin, motoSpeed), wenn ich einen Pin einschalten wollte. Mit analogWrite konnte ich die Geschwindigkeit des Motors ändern und den Roboter langsamer machen.

//STATE 1:vorwärts bewegen if (state ==1) { analogWrite (motor1Pin1, motorSpeed); digitalWrite (motor1Pin2, LOW); analogWrite (motor2Pin1, motorSpeed); digitalWrite (motor2Pin2, LOW); } //STATE 2:rückwärts bewegen if (state ==2) { DigitalWrite (motor1Pin1, LOW); analogWrite (motor1Pin2, motorSpeed); digitalWrite (motor2Pin1, LOW); analogWrite (motor2Pin2, motorSpeed); } //STATE 3:nach rechts bewegen, wenn (state ==3) {analogWrite (motor1Pin1, motorSpeed); digitalWrite (motor1Pin2, LOW); digitalWrite (motor2Pin1, LOW); analogWrite (motor2Pin2, motorSpeed); } // ZUSTAND 4:nach links bewegen, wenn (Zustand ==4) { DigitalWrite (motor1Pin1, LOW); analogWrite (motor1Pin2, motorSpeed); analogWrite (motor2Pin1, motorSpeed); digitalWrite (motor2Pin2, LOW); } //STATE 5:nichts tun, wenn (state ==5) { DigitalWrite (motor1Pin1, LOW); digitalWrite (motor1Pin2, LOW); digitalWrite (motor2Pin1, LOW); digitalWrite (motor2Pin2, LOW); } 

Beachten Sie, dass die Motoren zwischen 3 und 6 V arbeiten. Sobald eine 5-V-Stromquelle verwendet wird, können Sie die durchschnittliche Spannung der Motoren (mit PWM) zwischen 3 und 5 V modulieren und so ihre Geschwindigkeit ändern. Es erlaubt Ihnen nicht, die Geschwindigkeit des Roboters fein zu steuern

Schritt 8:Webbasierte Steuerungsschnittstelle

Eine HTML-Schnittstelle wurde für die Steuerung des Roboters entwickelt. Laden Sie interface.rar herunter und extrahieren Sie alle Dateien in einen bestimmten Ordner. Dann öffnen Sie es in Firefox. In dieser Schnittstelle wird ein Textfeldformular verwendet, um die IP-Adressen des ESP-Moduls und des Video-/Audioservers (von der Android IP-Webcam-App) einzugeben. Es gibt jedoch einen Test, der den Roboter drehen lässt, bis ein anderer Befehl empfangen wird. Die Pfeiltasten der Tastatur werden verwendet, um den Roboter vorwärts oder rückwärts zu bewegen und nach links oder rechts zu drehen. Ein Android-Smartphone wurde verwendet, um Video und Audio vom Roboter an die Steuerschnittstelle zu übertragen. Sie finden die App möglicherweise im Google Play Store (https://play.google.com/store/apps/details?id=com.pas.webcam). Installieren Sie sie und fahren Sie mit dem nächsten Schritt fort.

HTML-Code erklärt:

Die HTML-Schnittstelle hat zwei Unterteilungen:eine für Audio und Video (vom Android IP-Webcam-Server) und eine für die Befehle.

Die Audio- und Videounterteilung hat ein Formular mit einem Textfeld am unteren Rand. Dies wird als Eingabe verwendet, um die IP-Adresse des Webcam-Servers anzugeben und zu laden. Es kommt mit einer Standard-IP-Adresse (192.168.0.5), aber der Benutzer kann eine andere IP eingeben. Video und Audio werden in Objekte unterhalb des Textfelds geladen.

 
 IP-Webcam ( IP):  
  
 

Die andere Abteilung hat ein anderes Formular mit einem Textfeld, damit der Benutzer seine ESP8266-IP-Adresse mitteilen kann.

 
 Arduino IP-Adresse:  
  
 Drücken und halten Sie die Pfeiltasten der Tastatur, um den Roboter zu bewegen 
 

JavaScript wird verwendet, um mit der Schnittstelle umzugehen und Daten an den Arduino zu senden. Diese Skripte sind in verschiedenen Dateien kodiert und dem HTML-Header hinzugefügt.

Javascript erklärt:

Um die IP-Adresse aus dem HTML-Formular auszulesen und in "Video"- und "Audio"-Objekte zu laden, wird eine Funktion (readUrlAV) verwendet.

function readUrlAV (form) { TextVar =form.inputbox.value; VideoVar ="http://"+TextVar+":8080/video"; AudioVar ="http://"+TextVar+":8080/audio.opus"; document.getElementById("video").setAttribute('data', VideoVar); document.getElementById("audio").setAttribute('data', AudioVar);} 

Das Skript liest die Tastatur regelmäßig und wartet darauf, dass der Benutzer eine beliebige Taste drückt. Wenn der Benutzer eine beliebige Pfeiltaste drückt (links ='37', oben ='38', rechts ='39' oder 'runter' =40), sendet er einen Befehl ("cm1" bis "cm4") für eine gegebene IP die Anschrift. Beachten Sie, dass es eine Latch-Funktion gibt, die verhindert, dass derselbe Befehl immer wieder wiederholt wird. Daten werden nur übertragen, wenn die Taste gedrückt wird.

var Latch =false;document.onkeydown =checkKeyDown;Funktion checkKeyDown(e) { e =e || Fenster.Ereignis; if (e.keyCode =='38') { // Pfeil nach oben if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get(ArduinoVar, {"cm1":1000}); {Verbindung:schließen}; Latch =wahr; } } else if (e.keyCode =='40') { // Pfeil nach unten if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get(ArduinoVar, {"cm2":1000}); {Verbindung:schließen}; Latch =wahr; } } else if (e.keyCode =='37') { // Pfeil nach links if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get(ArduinoVar, {"cm3":1000}); {Verbindung:schließen}; Latch =wahr; } } else if (e.keyCode =='39') { // Pfeil nach rechts if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get(ArduinoVar, {"cm4":1000}); {Verbindung:schließen}; Latch =wahr; } }} 

Wenn eine Pfeiltaste losgelassen wird, wird die Funktion doNothing ausgeführt, die den Befehl "cm5" (Motoren stoppen) sendet und den Riegel zurücksetzt, wodurch die Schnittstelle verschiedene Befehle senden kann.

document.onkeyup =checkKeyUp;Funktion checkKeyUp(e) { e =e || Fenster.Ereignis; if ((e.keyCode =='38')||(e.keyCode =='40')||(e.keyCode =='37')||(e.keyCode =='39')) { setTimeout(doNothing, 200); }}function doNothing(){ TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get( ArduinoVar, { "cm5":1000 }); {Connection:close}; latch =false;}  

Step 9:Usage

When the Arduino is restarted, it will try to connect your wi-fi network automatically. Use the Serial Monitor to check if the connection was successfull, and to obtain which IP was assigned to your ESP-8266 by your router. Open the html file in an internet browser (Firefox) and inform this IP address in the textbox.You might also user other means to find out which IP address you router assigned to your device. Disconnect the the Arduino Uno from your computer and connect it to the power bank. Wait for it to connect again. Launch IP Webcam app in the smartphone attached to the robot. Type the video/audio IP on your control interface and connect to the server and you'll be ready to go. You might need to reduce the resolution of the video in the app to reduce the delay between during the transmission. Click and hold the arrow buttons of your keyboar to rotate the robot or move it forward/backward and have fun exploring your environment.

Notice that robot runs on open loop. This way, it's quite difficult to make it move straight forward. Small difference between the motors, aligment, etc. will cause cumulative deviations.

The robot start moving when it receives a given command ("cm1" to "cm4"), and keep that state until a different command is received ("cm1" to "cm5"). Sometimes the ESP8266 loses some messages, and that might cause some trouble. If, for instance, a "cm5" command is lost, the robot will keed moving even after any arrow key was released. I'm still dealing with this problem. Feel free to change the way the commands are interpreted to avoid this kind of problem.

Code

• Arduino-Code
• Interface

Arduino-CodeArduino

//include libraries#include SoftwareSerial esp8266(3, 2); //RX pin =3, TX pin =2//definition of variables#define DEBUG true //show messages between ESP8266 and Arduino in serial portint state =5; //define initial state of the robot (5 =stand-by)//define motor pinsconst int motor1Pin1 =5;const int motor1Pin2 =6;const int motor2Pin1 =9;const int motor2Pin2 =10;//define motor speedint motorSpeed =150; //motor speed (PWM)//*****//SETUP//*****void setup(){ //set pin modes pinMode(motor1Pin1, OUTPUT); pinMode(motor1Pin2, OUTPUT); pinMode(motor2Pin1, OUTPUT); pinMode(motor2Pin2, OUTPUT); //start communication Serial.begin(9600); esp8266.begin(9600); sendData("AT+RST\r\n", 2000, DEBUG); //reset module sendData("AT+CWMODE=1\r\n", 1000, DEBUG); //set station mode sendData("AT+CWJAP=\"XXXXX\",\"YYYYY\"\r\n", 2000, DEBUG); //connect wi-fi network (replace XXXXX by your Wi-Fi router SSID and YYYYY by its password delay(5000); //wait for connection sendData("AT+CIFSR\r\n", 1000, DEBUG); //show IP address sendData("AT+CIPMUX=1\r\n", 1000, DEBUG); //allow multiple connections sendData("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); // start web server on port 80}//*********//MAIN LOOP//*********void loop(){ if (esp8266.available()) //verify incoming data { if (esp8266.find("+IPD,")) //if there is a message { String msg; esp8266.find("?"); //look for the message msg =esp8266.readStringUntil(' '); //read whole message String command =msg.substring(0, 3); //first 3 characters =command Serial.println(command); //move forward if(command =="cm1") { state =1; } //move backward if(command =="cm2") { state =2; } //turn right if(command =="cm3") { state =3; } //turn left if(command =="cm4") { state =4; } //do nothing if(command =="cm5") { state =5; } } } //STATE 1:move forward if (state ==1) { analogWrite(motor1Pin1, motorSpeed); digitalWrite(motor1Pin2, LOW); analogWrite(motor2Pin1, motorSpeed); digitalWrite(motor2Pin2, LOW); } //STATE 2:move backward if (state ==2) { digitalWrite(motor1Pin1, LOW); analogWrite(motor1Pin2, motorSpeed); digitalWrite(motor2Pin1, LOW); analogWrite(motor2Pin2, motorSpeed); } //STATE 3:move right if (state ==3) { analogWrite(motor1Pin1, motorSpeed); digitalWrite(motor1Pin2, LOW); digitalWrite(motor2Pin1, LOW); analogWrite(motor2Pin2, motorSpeed); } //STATE 4:move left if (state ==4) { digitalWrite(motor1Pin1, LOW); analogWrite(motor1Pin2, motorSpeed); analogWrite(motor2Pin1, motorSpeed); digitalWrite(motor2Pin2, LOW); } //STATE 5:do nothing if (state ==5) { digitalWrite(motor1Pin1, LOW); digitalWrite(motor1Pin2, LOW); digitalWrite(motor2Pin1, LOW); digitalWrite(motor2Pin2, LOW); } }//*******************//Auxiliary functions//*******************String sendData(String command, const int timeout, boolean debug){ String response =""; esp8266.print(command); long int time =millis(); while ( (time + timeout)> millis()) { while (esp8266.available()) { char c =esp8266.read(); response +=c; } } if (debug) { Serial.print(response); } return response;}

InterfaceHTML

Keine Vorschau (nur Download).

Kundenspezifische Teile und Gehäuse

Schaltpläne