Machen Sie einen mit dem Internet verbundenen Roboter (für etwa 500 US-Dollar) (mit einem Arduino und einem Netbook) - Gunook

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

Dieses Instructable zeigt Ihnen, wie Sie Ihren eigenen Web-verbundenen Roboter bauen (mit einem Arduino-Mikrocontroller und einem Asus eee-PC). Warum möchten Sie einen Web-verbundenen Roboter? Natürlich zum Spielen. Fahren Sie Ihren Roboter von der anderen Seite des Raums oder quer durch das Land, mit nichts anderem als Skype und einem Webbrowser (nichts auf dem steuernden Computer zu installieren). Danach? Tauchen Sie in die Software ein und passen Sie sie nach Belieben an, fügen Sie ein GPS hinzu, damit Sie auf einer Karte sehen können, wo Sie fahren, fügen Sie Temperatursensoren hinzu, um Temperaturgradienten in Ihrem Haus zu kartieren, oder Sonarsensoren, um Kontrollen in Ihrem Web hinzuzufügen Fahrer können und können nicht stoßen. Merkmale:

• Günstig - (~500 US-Dollar, wenn Sie alle Teile neu kaufen und erheblich billiger, wenn Sie in Ihrem Teilebehälter herumwühlen)
• Einmal in Betrieb genommen, benötigt die Steuerung des Roboters nur einen Webbrowser - (und Skype, wenn Sie sehen möchten, wohin Sie fahren)
• Open Source und leicht anpassbar - (verwendet einen Arduino-Mikrocontroller, Verarbeitung für den Webserver und alle Software kann unter Linux ausgeführt werden (der gesamte Code ist auch stark kommentiert, um das Einsteigen und Ändern von Dingen zu erleichtern))
• Modulares Design (kein vollständig integriertes System, wenn Sie problemlos einen anderen Videokonferenzdienst verwenden möchten, oder wenn Sie einen Basic-Stempel anstelle eines Arduino haben, einfach ein kleines Stück Code eingeben und einstecken)

Hier ist ein kurzes Video von meinem Web Connected Robot, der aus der Küche gefahren wird.

Schritt 1: Teile & Werkzeuge

Es werden nur wenige Teile benötigt: Roboter: Arduino Controlled Servo Robot - (SERB) ($ 175 @ oomlout.com) oder (machen Sie Ihre eigenen)

Ein Open-Source-Roboter, der einen Arduino-Mikrocontroller als Gehirn verwendet

(Jede Dual-Servo-Roboterplattform mit einem Arduino kann verwendet werden (Option 1) (bitte Nachricht an mich, wenn Sie andere Optionen entdecken) Computer: Asus eee PC 4G ($280) (@Best Buy)

Ein kleiner preiswerter Laptop, der für diesen Zweck perfekt ist

(jeder Laptop (oder Desktop, wenn Sie mit einem Akkord laufen möchten), der Verarbeitungsskizzen ausführen kann, kann verwendet werden) Laptop-Schreibtisch: Laser Cut Acryl ($ 25 (@ oomlout)) oder (Erstellen Sie Ihren eigenen Schritt 3)

Ein paar zusätzliche Acrylteile, die auf einen (SERB) geschraubt werden, um ihm einen Schreibtisch zu geben, auf dem der Laptop sitzen kann

Nuts and Bols: (im Heimdepot erhältlich)

• 3mm x 10mm Schraube (x4)
• 3mm x 15mm Schraube (x4)
• 3mm Mutter (x8)

Schritt 2: Schneiden von Teilen & Montage

Es gibt drei Optionen, um Teile für Ihren Laptop-Schreibtisch zu erhalten. Schneideoption 1: (Kauf bei oomlout.com)

Lasergeschnittene Schreibtischteile und die notwendige Hardware sind bei oomlout für 25 US-Dollar erhältlich (hier)

Option 2: (Schneiden mit Ihrem eigenen Laserschneider oder Ponoko.com)

• Laden Sie die folgende Datei herunter (03-WEBB-Acrylic Parts.cdr oder 03-WEBB-Acrylic Parts (Ponoko P2).eps)
• Schneiden Sie sie aus 3 mm (1/8") Acryl

Option 3: (Rollensäge)

• Laden Sie das Dekupiersägemuster von unten herunter (03-WEBB-ScrollSaw Pattern (A4).pdf (für Papier im A4-Format) oder 03-WEBB-ScrollSaw Pattern (Letter).pdf (für Papier im Letter-Format))
• Überprüfen Sie, ob es beim Drucken nicht skaliert wurde (indem Sie die gedruckten Lineale messen)
• Kleben Sie auf ein Stück 3 mm (1/8") Acryl und schneiden Sie die Stücke aus.

Zusammenbau: Laden Sie die untenstehende Aufbauanleitung (04-WEBB-Assembly Guide.pdf) herunter und bauen Sie den Laptoptisch zusammen.

Schritt 3: Software - (Arduino)

Für diejenigen, die neu bei Arduino sind, lesen Sie die großartige Anleitung für die ersten Schritte auf Arduino.cc Zuerst die Software, die auf dem Arduino läuft. Es ist ein sehr einfaches Programm, das Arduino überwacht seinen seriellen Port auf Daten. Was es sucht, ist eine 5 Byte lange Konversation.

• Byte 1-3 (Prüfbytes "AAA")
• Byte 4 Befehl (sagt dem Arduino, was zu tun ist) (Unterstützte Befehle 'F' - Vorwärts, 'B' - Rückwärts, 'L' - Links, 'R' - Rechts, 'S' - Geschwindigkeit, 'X' - SetSpeedLeft, 'Y' - SetSpeedRight, 'C' - Stop)
• Byte 5 Parameter - Bei den Fahrbefehlen wird dies als Zeitintervall interpretiert (Parameter * 100 ms), bei den Geschwindigkeitsbefehlen als Prozentwert von 0-100

Der Code ist ausführlich kommentiert und angesichts dieses Frameworks sollte das Hinzufügen zusätzlicher Befehle einfach sein. Zum Download:

• Laden Sie die angehängte Zip-Datei herunter. (05-WEBB-Arduino-Code.zip)
• Entpacken Sie in Ihr Arduino Sketch-Verzeichnis. (Standard: Eigene Dokumente\Arduino)
• Öffnen Sie Ihre Arduino-Entwicklungsumgebung und laden Sie sie auf Ihr Arduino hoch.

Zum Kopieren und Einfügen

• Kopieren Sie den Code von unten.
• Fügen Sie es in die Arduino-Entwicklungsumgebung ein.
• Laden Sie auf Ihr Arduino hoch.

Anhang: Das Arduino-Programm

/* * Arduino Controlled Web Connected Robot (WEBB) - Serial Host * Weitere Informationen finden Sie unter: https://www.oomlout.com/serb * * Verhalten: Der Arduino lauscht an seinem seriellen Port auf einen Befehl * im Format 254, 88, 88, (BEFEHL), (ZEIT) * Unterstützte Befehle - &aposF&apos - 70 - Vorwärts * &aposB&apos - 66 - Rückwärts * &aposL&apos - 76 - Links * &aposR&apos - 82 - Rechts * &aposS&apos - 83 - Geschwindigkeit * &aposX&apos - 88 - SetSpeedLeft * &aposY&apos - 89 - SetSpeedRight * &aposC&apos - 67 - Stop * Unterstützte Zeiten - 0 - 255 (0 bis 25,5 Sekunden) Wert * 100 Millisekunden *sp * Verdrahtung: Rechtes Servosignal - Pin 9 * Linkes Servosignal - Pin 10 * * Lizenz: Dieses Werk ist lizenziert unter der Creative Commons * Attribution-Share Alike 3.0 Unported License. Um * eine Kopie dieser Lizenz anzuzeigen, besuchen Sie * https://creativecommons.org/licenses/by-sa/3.0/ * oder senden Sie einen Brief an Creative Commons, 171 Second * Street, Suite 300, San Francisco, California 94105, * VEREINIGTE STAATEN VON AMERIKA. * */ //--------------------------------------------------------- ----------------------------------------//START OF ARDUINO SERIAL SERVER PRÄAMBEL//Definieren von Konstanten entsprechend jedem Befehl (auch die ASCII-Codenummer) #define FORWARD 70 //F#define BACKWARD 66 //B#define LEFT 76 //L#define RIGHT 82 //R#define SETSPEED 83 //S#define STOP 67 //C#define SETSPEEDLEFT 88 //X #define SETSPEEDRIGHT 89 //Y/*Die drei Prüfbytes (die den Roboter daran hindern, auf zufällige serielle *Daten zu reagieren) derzeit "AAA" */#define checkByte1 65 // "A"#define checkByte2 65 // "A "#define checkByte3 65 // "A" //------------------------------------------------- ---------------------------------- // START VON ARDUINO CONTROLLED SERVO ROBOT (SERB) PRÄAMBEL#include #define LEFTSERVOPIN 10 // Der Pin, mit dem das linke Servo verbunden ist #define RIGHTSERVOPIN 9 // Der Pin des rechten Servos ist mit Servo leftServo verbunden; Servo rechtsServo; int linke Geschwindigkeit = 50; // hält die Geschwindigkeit des Roboters leftServo // einen Prozentsatz zwischen 0 und 100int rightSpeed = 100; // hält die Geschwindigkeit des Roboters rightServo //einen Prozentsatz zwischen 0 und 100 // END OF ARDUINO CONTROLLED SERVO ROBOT (SERB) PRÄAMBEL//------------------ -------------------------------------------------- ----- // Holt alles zum Laufenvoid setup () { Serial.begin (9600); // Startet die serielle Schnittstelle serbSetup(); // Setzt den Zustand aller notwendigen // Pins und fügt Servos zu Ihrer Skizze hinzu} // Das Hauptprogramm loopvoid loop () { serbPollSerialPort (); // sucht ständig nach dem seriellen Port // wenn Daten vorhanden sind, werden sie verarbeitet} // ----------------------------------------- ------------------------------------------ //START DER ARDUINO SERIELLE SERVER-ROUTINEN/ * * Verarbeitet Befehle, die an die serielle Schnittstelle von Arduino geliefert werden */void serbPollSerialPort(){ int dta; //Variable zum Halten des seriellen Bytes if (Serial.available() >= 5) {//wenn 5 Bytes im Puffer sind (Länge einer vollständigen Anfrage) dta = Serial.read(); if (dta = checkByte1) {// Überprüft das erste Prüfbyte dta = Serial.read (); if (dta = checkByte2) {// Überprüft das zweite Prüfbyte dta = Serial.read (); if (dta = checkByte3) {// Überprüft das dritte Prüfbyte int command = Serial.read (); // Viertes Byte ist der Befehl int param1 = Serial.read (); //Fünftes Byte ist param1 interpretCommand(command, param1); //sendet die geparste Anfrage an ihn&aposs handler } } } }}/* * Nimmt den Befehl und Parameter und übergibt sie an den Roboter */void interpretCommand(int command, int param1){if (command == FORWARD){goForward(); Verzögerung (param1 * 100); goStop();} // wenn vorwärts else if(command == BACKWARD){goBackward(); Verzögerung (param1 * 100); goStop();} // wenn rückwärts else if(command == LEFT){goLeft(); Verzögerung (param1 * 100); goStop ();} // wenn links sonst if (Befehl == RIGHT) {goRight (); Verzögerung (param1 * 100); goStop();} //wenn rechts sonst if(command == SETSPEED){setSpeed(param1);} //wenn die Geschwindigkeit sonst eingestellt wird if(command == STOP){goStop();} //wenn stop else if(command == SETSPEEDLEFT) {setSpeedLeft (param1);} // wenn die linke Geschwindigkeit eingestellt wird else if (command == SETSPEEDRIGHT) {setSpeedRight (param1);} // wenn die rechte Geschwindigkeit eingestellt wird else { // wenn der nicht erkannte Befehl ein wenig Shimmey gehe nach links(); Verzögerung (150); Geh rechts(); Verzögerung (150); goStop(); }}//---------------------------------------------------------- --------------------------//START VON ARDUINO CONTROLLED SERVO ROBOT (SERB) ROUTINES/* * Richten Sie Ihr Arduino so ein, dass es Ihren SERB mit. anspricht die enthaltenen Routinen*/void serbSetup(){ setSpeed(leftSpeed); pinMode (LINKSSERVOPIN, AUSGANG); // Setzt den linken Servo-Signal-Pin // um PinMode auszugeben (RIGHTSERVOPIN, OUTPUT); // Setzt den rechten Servosignal-Pin // um leftServo.attach (LEFTSERVOPIN) auszugeben; // befestigt linkes Servo rightServo.attach (RIGHTSERVOPIN); // befestigt rechtes Servo goStop();}/* * setzt die Geschwindigkeit des Roboters zwischen 0-(gestoppt) und 100-(volle Geschwindigkeit) * HINWEIS: Die Geschwindigkeit ändert nicht die aktuelle Geschwindigkeit, Sie müssen die Geschwindigkeit ändern * dann rufen Sie einen an der go-Methoden, bevor Änderungen auftreten.*/ void setSpeed(int newSpeed){ setSpeedLeft(newSpeed); // Setzt die linke Geschwindigkeit setSpeedRight (newSpeed); // setzt die rechte Geschwindigkeit}/* * Setzt die Geschwindigkeit des linken Rades */void setSpeedLeft(int newSpeed){ if(newSpeed >= 100) {newSpeed = 100;} //wenn die Geschwindigkeit größer als 100 ist //mach es 100 if (newSpeed = 100) {newSpeed = 100;} // wenn die Geschwindigkeit größer als 100 ist // mache es 100 if (newSpeed <= 0) {newSpeed = 0;} // wenn die Geschwindigkeit kleiner als 0 ist // it 0 rightSpeed = newSpeed * 0,9; // skaliert die Geschwindigkeit auf}/* * sendet den Roboter vorwärts */void goForward () { leftServo.write (90 + leftSpeed); rightServo.write(90 - rightSpeed);} /* * schickt den Roboter rückwärts */void goBackward(){ leftServo.write(90 - leftSpeed); rightServo.write(90 + rightSpeed);} /* * sendet den Roboter nach rechts */void goRight(){ leftServo.write(90 + leftSpeed); rightServo.write(90 + rightSpeed);}/* * sendet den Roboter nach links */void goLeft(){ leftServo.write(90 - leftSpeed); rightServo.write(90 - rightSpeed);}/* * stoppt den Roboter */void goStop(){ leftServo.write(90); rightServo.write(90);}//ENDE DER ARDUINO-KONTROLLIERTEN SERVOROBOTER (SERB)-ROUTINEN//---------------------------------------- ----------------------------------------------------------

Schritt 4: Software - Roboter-Laptop (WebServer)

(Processing ist eine Open-Source-Programmiersprache und -Umgebung, mit der man super einfach loslegen kann. Für weitere Details besuchen Sie Processing) Die Software, die auf dem Roboter-Laptop läuft, ist ebenfalls recht einfach. Es ist ein eher rudimentärer Webserver (hört auf Webseitenanfragen von einem Webbrowser), eine kleine Benutzeroberfläche (um ihn einzurichten) und Möglichkeiten, die vom Webserver empfangenen Befehle an den Arduino weiterzugeben. Schnell installieren: (an Fenstern)

• Laden Sie die ZIP-Datei unten herunter (06-WEBB-Processing Webserver (Windows exe).zip)
• Entpacken Sie es und führen Sie die.exe-Datei (_WEBB_WebServer_RobotComputer.exe) aus.

In Bearbeitung bearbeiten:

• Laden Sie die Zip-Datei unten herunter (06-WEBB-Processing Webserver (source files).zip)
• Entpacken Sie überall auf Ihrem Computer.
• Öffnen Sie die Verarbeitungsumgebung und öffnen Sie (_WEBB_WebServer_RobotComputer.pde)

Zu testen:

• Führen Sie das Programm aus.
• In Feld Nr. 1 wird eine Liste der verfügbaren Kommunikationsanschlüsse auf Ihrem Computer angezeigt (klicken Sie auf den, mit dem Ihr Arduino verbunden ist Komm-Port)
• Testen Sie in Box #2, ob Ihr Arduino angeschlossen ist. Klicken Sie auf einen der Pfeile und hoffentlich bewegt sich Ihr Roboter für eine halbe Sekunde in die angeklickte Richtung.
• Klicken Sie in Feld #3 auf die Schaltfläche "Start", um den Webserver zu starten.
• Öffnen Sie einen Webbrowser (auf dem Roboter-Laptop) und besuchen Sie https://127.0.0.1:12345/ControlPage.html (hoffentlich wird die Steuerungswebseite mit Schaltflächen angezeigt) -Details zur Verwendung dieser Seite im nächsten Schritt -

Was ist los:

• Der Webserver lauscht auf Port 12345 auf http-Anfragen (was wird gesendet, wenn Sie eine Webseitenadresse eingeben)
• Es gibt zwei Arten von Anfragen, auf die es reagiert.

1. Es hört auf "ControlPage.html" und sendet die Kontroll-Webseite 2. Es hört auf Anfragen der Form "/request?command=F&param1=100" (diese Befehle werden geparst und an den Arduino gesendet (dieses Beispiel würde resultieren) im Roboter für 10 Sekunden vorwärts)Anhang: (Der Code für den WebServer)

/* * Arduino Controlled Web Connected Robot (WEBB) - Webserver * Für weitere Details besuchen Sie: https://www.oomlout.com/serb * * Verhalten: Das Programm lauscht auf http (Webpage) Requests in der Form * "/request ?command=F&param1=100" und übergibt sie dann an den * Arduino * Unterstützte Befehle - &aposF&apos - 70 - Vorwärts * &aposB&apos - 66 - Rückwärts * &aposL&apos - 76 - Links * &aposR&apos - 82 - Rechts * &aposS&apos - 83 - Geschwindigkeit * &aposX&apos - 88 - SetSpeedLeft * &aposY&apos - 89 - SetSpeedRight * &aposC&apos - 67 - Stop * param1&aposs - 0 - 255 (0 bis 25,5 Sekunden) Wert * 100 Millisekunden * * Liefert auch die Kontroll-Webseite an den Browser, wenn nach ControlPage.html gefragt wird * * Betrieb: 1. Klicken Sie auf den Comm-Port, mit dem Ihr Arduino verbunden ist * 2. Verwenden Sie die Testtasten, um zu sehen, ob Ihr Arduino zuhört * (bewegt sich eine halbe Sekunde lang in die angeklickte Richtung) * 3. Klicken Sie auf Start und Ihr Webserver wird auf Anfragen hören * * * Lizenz: Dieses Werk ist lizenziert unter den Creative Commons * Attribu tion-Share Alike 3.0 Unported-Lizenz. Um * eine Kopie dieser Lizenz anzuzeigen, besuchen Sie * https://creativecommons.org/licenses/by-sa/3.0/ * oder senden Sie einen Brief an Creative Commons, 171 Second * Street, Suite 300, San Francisco, California 94105, * VEREINIGTE STAATEN VON AMERIKA. * */Verarbeitung.serial importieren.*; // Importieren Sie die serielle Bibliothek, um Serial zu verwenden (für das Gespräch mit Arduino) import processing.net.*; // Importieren Sie die Netzbibliothek, um den Server zu verwenden (für die Kommunikation mit dem Internet)/* Variablen zum seriellen Anschluss */int serialPortIndex = -1; //der Index des seriellen Ports, den wir in Serial.list() verwenden listString commOptions; // Eine Variable zum Speichern von Serial.list (), damit es nicht erforderlich ist, // die seriellen Ports jedes Mal abzufragen, wenn wir sie referenzieren möchten (Polling verursacht einen // Sprung in den Arduino-Servos) Serial serialPort; // Macht den seriellen Port in dieser Skizze adressierbar/* Grafik- und Rendering-bezogene Variablen */PFont font; //macht die Schriftart öffentlich, sodass sie nur einmal geladen werden muss (Arial-72)/* Netzwerkbezogene Variablen */Server wServer; //Der Server, der Web-Anfragen verarbeitetint port = 12345; // Der Port, den der Server abhört toint cycleCount = 0; //Zählt, wie oft die Zeichenschleife ausgeführt wird (wird verwendet, um //den "laufenden" Text zu animieren) /* Dienstprogrammvariablen */ PImage bg; //Das aktuelle Hintergrundbild \WEBB-background.png/* * Button Related Variables * (Buttons sind sehr grob implementiert, Bounding Boxes werden gespeichert und Grafik und Text werden * auf das Hintergrundbild gezeichnet) dh. Durch Verschieben von Schaltflächenvariablen wird das Aussehen der Schaltflächen nicht verschoben */Schaltfläche comm1; Taste Komm2; Taste comm3; Taste comm4; // Die Schaltflächen zur Auswahl des richtigen seriellen PortsButton up; Knopf rechts; Knopf links; Button down; // Die Richtungstasten zum Testen, ob der Roboter antwortetButton webServer; //Der Button zum Starten des WebServers/* * richtet alles ein */void setup() { frameRate(5); // Verlangsamt die Skizze ein wenig, damit sie das System nicht so stark beansprucht bg = loadImage("WEBB-background.png"); // Lädt das Hintergrundbild (im Skizzenordner gespeichert) size(700, 400); // Setzt die Schriftgröße des Skizzenfensters = loadFont("ArialMT-72.vlw"); // Lädt die Schriftart, die wir in dieser Skizze verwenden werden commOptions = Serial.list (); // Fragt die seriellen Ports ab und ruft eine Liste der verfügbaren Ports ab // (Dies nur einmal zu tun verhindert, dass der Roboter jedes Mal zuckt, wenn er // der serielle Port abgefragt wird) defineButtons(); // Definiert die Begrenzungsrahmen für jeden Button background (bg); // Malt das Hintergrundbild (dieses Bild enthält alle Schaltflächengrafiken)}/* Die Skizzen-Hauptschleife */void draw() { if(cycleCount==0){ //-- Aufruf von Draw-Routinen drawCommBox(); // Zeichnet die Elemente in die Comm Box (Box 1) drawTestBox(); // Zeichnet alle Elemente in die Testbox (Box 2) drawWebServerBox(); // Zeichnet alle Elemente in die WebServer Box (Box 3) } //-- Aufruf von Arbeitsroutinen pollWebServer(); // Fragt den Webserver ab, ob Anfragen über das Netzwerk eingegangen sind}//-------------------------------------------- ----------------------------------------------//Start von Draw-Routinen (aufgeteilt, nur um den Code besser lesbar zu machen)/* * Die Draw-Aktualisierungsroutine (wird jeden Zyklus ausgeführt) für Elemente in der Kommunikationsbox (Box 1) */void drawCommBox () { fill(0, 0, 0); // Setze die Füllung auf schwarz textFont (font, 15); //Setze die Schriftart auf die richtige Größe für(int i = 0; i 0){running = running + ".";} //die Anzahl der Punkte basiert auf cycleCount if((cycleCount / 1) > 1){ running = running + ".";} if((cycleCount / 1) > 2){running = running + ".";} if((cycleCount / 1) > 3){cycleCount=0;} text(running, 520, 210); } ZyklusAnzahl++; //Jedes Mal durch cycleCount wird um eins erhöht} //End of Draw-Routinen//------------------------------ ------------------------------------------ // ------------------ -------------------------------------------//Start der Serviceroutinen/ * * mousePressed wird jedes Mal aufgerufen, wenn die Maus gedrückt wird dies * prüft, ob sich die Maus innerhalb einer der Schaltflächenbegrenzungsfelder befindet * und ob die entsprechende Routine aufgerufen wird*/void mousePressed(){ if(comm1.pressed()) { updateSerialPort(0);} //Ändert den Komm-Port an Index 0 in Serial.list() else if(comm2.pressed()) {updateSerialPort(1);} //Ändert den Komm-Port an Index 1 in Serial.list() else if(comm3.pressed()) {updateSerialPort(2);} //Ändert den Kommunikationsport an Index 2 in Serial.list() else if(comm4.pressed()) {updateSerialPort(3);} //Ändert den Kommunikationsanschluss bei Index 3 in Serial.list() else if(up.pressed()) {sendRobotCommand("F", 5);} //Sendet einen Befehl, um den Roboter um 0,5. vorwärts zu bewegen Sekunden sonst if(left.pressed()) {sendRobotCommand("L", 5);} / /Sendet einen Befehl, um den Roboter für 0,5 Sekunden nach links zu bewegen else if(right.pressed()) {sendRobotCommand("R", 5);} //Sendet einen Befehl, um den Roboter für 0,5 Sekunden nach rechts zu bewegen else if(down. press()) {sendRobotCommand("B", 5);} //Sendet einen Befehl, um den Roboter für 0,5 Sekunden rückwärts zu bewegen else if(webServer.pressed()) {startWebServer();} //Startet den webServer cycleCount = 0; Hintergrund (bg); // Überarbeitet das Hintergrundbild (dieses Bild enthält alle Schaltflächengrafiken) draw();}/* * Wird nach einer Ausführung aufgerufen, überprüft es den Server, um zu sehen, ob es wartende Verbindungen gibt * Wenn eine wartende Verbindung vorhanden ist, wird gezogen die Anforderung aus und übergibt sie an die parseRequest(String) *-Routine, um zusätzlichen Text zu entfernen. Dies wird dann an die Routine interpretRequest(String) gesendet, um * die entsprechende Aktionsroutine aufzurufen (dh Anweisungen an den Roboter zu senden).* * Eine Anfrage wird übergeben, indem die Computeradresse und der Port in einen Webbrowser eingegeben werden * Für lokalen Computer "https://127.0.0.1:12345/request?command=F&param1=100" * * Beispielanfrage: * GET /request? command=F&param1=100 HTTP/1.1 * User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/525.19 (KHTML, wie Gecko) * Akzeptieren: *//* * Akzeptieren-Sprache: en-US, en * Akzeptieren-Zeichensatz: ISO-8859-1, *, utf-8 * Akzeptieren-Kodierung: gzip, deflate, bzip2 * Host: 127.0.0.1:12345 * Verbindung: Keep-Alive * * Beispielantwort (für verarbeitete Anfrage) * HTTP/1.1 200 OK * Verbindung: schließen * Inhaltstyp: text/html * * Befehl: F param1: 100 */void pollWebServer(){ if(wServer != null){ //Wenn der webServer läuft Client-Anfrage = wServer.available(); //Lade den nächsten Client in der Zeile in den //Server (null wenn keine Anfragen warten) if(request != null){ //wenn es einen Anfrageprozess gibt it String fullRequest = request.readString(); //Anfrageinhalt als String speichern String ip = request.ip(); // Die IP-Adresse des Clients als String speichern String requestString = parseRequest(fullRequest.toUpperCase()); //Entferne alle zusätzlichen //Informationen und belasse nur den Request-String (Text nach GET) //(wird in Großbuchstaben umgewandelt, um das String-Testen zu vereinfachen) if(requestString.indexOf("REQUEST?") != -1){ //Überprüft, ob die Anfrage "REQUEST?" String-Antwort = interpretRequest(requestString); //Sendet die Anfrage an den Anfrageinterpreter request.write("HTTP/1.1 200 OK\nVerbindung: schließen\nInhaltstyp: text/html\n\n" + Antwort); //Sendet der Antwort eine 200, um zu sagen, dass die Anfrage //bearbeitet wurde und den "Antwort"-String als Antwort wServer.disconnect(request); //Trennt den Client }else if(requestString.indexOf("CONTROLPAGE") != -1){ //Wenn die Anfrage für die Kontroll-Webseite ist String webPageArray = loadStrings("WEBB-ControlPage.html"); //Ladet die Control-WebPage von \data\WEBB-ControlPage.html //(wird als Zeilen-Array geladen) String webPage =""; // Um die Bearbeitung zu erleichtern, wurde die Webseite mit // Zeilenumbrüchen belassen, so dass diese for-Schleife diese Zeilen ausschneidet for(int i = 0; i portIndex) { // wenn der übergebene portIndex ein gültiger Index in Serial.list ist () //(dh nicht Option drei in einer Liste von zwei) serialPortIndex = portIndex; //setze die serialPortIndex-Variable auf den neuen Serialport-Index //(dies wird verwendet, um den Punkt neben dem aktiven Port anzuzeigen)} if(serialPortIndex != -1){ //überprüfe, ob vor einiger Zeit ein Port ausgewählt wurde if (serialPort != null) {serialPort.stop ();} // Wenn bereits ein serieller Port verwendet wird, stoppen Sie ihn, bevor Sie einen neuen laden serialPort = new Serial (this, Serial.list () [serialPortIndex], 9600); //Erzeuge ein neues serielles Objekt, um mit dem Arduino 9600 Baud zu kommunizieren}}/* * Nimmt eine Anforderungszeichenfolge (zB: "request?command=F&param1=100") und entfernt den Befehl * und param1 und übergibt ihn an die arduino (Hier würden zusätzliche Parameter oder Nicht-Arduino-Befehle hinzugefügt) * / String interpretRequest (String requestString) { String returnValue = "OK"; //Bereitet eine returnValue-Variable vor String-Befehl; //Die nächsten drei Zeilen extrahieren den Wert nach "command=" //(die zusätzliche Zeile ist, falls der Befehlsparameter am //Ende der Anfrage steht und nicht gefolgt von einem & if(requestString.indexOf("COMMAND=") != -1){ command = requestString.substring(requestString.indexOf("COMMAND=") + "COMMAND=".length());} else{command = "Z";} if(command.indexOf(" &") != -1){ command = command.substring(0, command.indexOf("&"));}else{command = command;} String param1String; //Die nächsten drei Zeilen extrahieren den Wert nach "param1= " //(die zusätzliche Zeile ist, falls der Befehlsparameter am //Ende der Anfrage steht und nicht gefolgt von einem & if(requestString.indexOf("PARAM1=") != -1){ param1String = requestString.substring (requestString.indexOf("PARAM1=") + "PARAM1=".length());} else{param1String = "0";} if(param1String.indexOf("&") != -1){ param1String = param1String.substring(0, param1String.indexOf("&"));} else{param1String = param1String;} int param1 = Integer.parseInt(param1String); //Verwandelt den param1 String in einen Ganzzahl sendRobotCommand(Befehl, Param1); // Sendet den Befehl an die Routine, die ihn an den Arduino sendet returnValue = "Befehl: " + Befehl + " param1: " + param1; // im Moment nur der geparste Befehl, aber // als html gesendet, damit die Formatierung eingefügt werden kann return returnValue;}/* * Nimmt einen Befehl (derzeit ein Buchstabe) und einen Parameter (ein Byte 0-255) und sendet ihn an die arduino * das hört und rastet * Derzeit unterstützte Befehle * F -*/void sendRobotCommand(String command, int param1) { println("command: " + command + " time: " + param1); String checkString = "AAA"; if (serialPort != null) { serialPort.write (checkString + Befehl); serialPort.write (byte (param1)); }}//Ende des Setups/nicht sehr häufig aufgerufene Routinen//---------------------------------- -------------------------------------------------- //Beispiel für Schaltflächen- und RectButton-Code aus dem Processing.org-Beispiel mit einigen Änderungen //hauptsächlich vorgenommen, um Rollover-Animationen zu vereinfachen und zu entfernen//https://processing.org/learning/topics/buttons.html (2008-09-23) Klasse Button{ int x, y; int Breite, Höhe; Button(int ix, int iy, int iwidth, int iheight) { x = ix; y = iy; Breite = Breite; Höhe = Höhe; aufrechtzuerhalten. Boolean gedrückt () { if (overRect ()) { true zurückgeben; } else { return false;} } boolean overRect() { if (mouseX >= x && mouseX = y && mouseY <= y+height) { return true; aufrechtzuerhalten. Sonst { false zurückgeben; } }}

Schritt 5: Software - (Webseite)

Nun, wir sind fast fertig, nur noch mit Ihrem Roboter zu sprechen. Um ins Gespräch zu kommen: (über ein lokales Netzwerk -unter Windows-)

• Entdecken Sie die lokale IP-Adresse des Laptops. Gehen Sie dazu zu "Start\Programme\Zubehör\Eingabeaufforderung" und geben Sie beim Öffnen des Terminalfensters "ipconfig" ein. Notieren Sie sich "IP-Adresse" und gehen Sie zu einem anderen Computer in Ihrem lokalen Netzwerk.
• Öffnen Sie einen Webbrowser, geben Sie "https:// (IP des Robotercomputers):12345/ControlPage.html" ein
• Die Steuerungswebseite sollte geladen werden, in das Feld "IP-Adresse" geben Sie die IP des Robotercomputers ein.
• Beginnen Sie mit der Steuerung Ihres Roboters.

Um ins Gespräch zu kommen: (über das Internet) Jetzt, wo es lokal funktioniert, ist es nur wenige Schritte entfernt, über das Internet zu sprechen.

• (Schwierigster Schritt) Einrichten der Portweiterleitung - Ihr Computer muss auf das Internet und nicht nur auf das lokale Netzwerk hören. Dazu müssen Sie Ihren Router anweisen, bestimmte Anfragen an den Computer weiterzuleiten, der den Roboter steuert. Dies ist ein bisschen komplex und geht weit über den Rahmen dieses Instructable hinaus. Wenn Sie jedoch PortForward.com besuchen, erhalten Sie dort alles, was Sie über die Konfiguration Ihres Routers wissen müssen (Sie müssen Port 12345 an Ihren Roboter-Laptop weiterleiten).
• Entdecken Sie als nächstes Ihre Internet-IP (besuchen Sie WhatIsMyIP.com)
• Starten Sie schließlich Skype, richten Sie einen Videoanruf ein und rufen Sie mit wem auch immer Sie sprechen, "https://(Internet-IP):12345/ControlPage.html" auf.
• Geben Sie die Internet-IP in das Feld "IP-Adresse" auf der Steuerungswebseite ein und Ihr Web Connected Robot wird aus der Ferne gefahren.

Schritt 6: Fertig

Das war's. Ich hoffe, Sie haben viel Spaß beim Fahren Ihres Roboters aus der Ferne. Wenn Sie Probleme mit der Software oder Hardware haben, können Sie gerne einen Kommentar hinterlassen und ich werde versuchen, Ihnen zu helfen. Wenn Sie mehr nette Projekte sehen möchten, besuchen Sie: oomlout.com