WiDC:Wi-Fi-gestuurde FPV-robot

Over dit project

Hoe zit het met het gebruik van een op afstand bestuurbare robot om je omgeving te verkennen, ontoegankelijke plaatsen te bereiken, te spioneren, foto's te maken, films te maken of een video uit te zenden? Deze tutorial laat je zien hoe je voor al die doeleinden een onuitsprekelijke kunt maken!

Deze tutorial is een verbetering van mijn vorige tutorial (https://www.instructables.com/id/Wi-fi-Controlled-FPV-Rover-Robot-with-Arduino-ESP8/), waarin ik een snellere home- robot gemaakt. Het laat zien hoe je een op afstand bestuurbare tweewielige robot ontwerpt via een wifi-netwerk, met behulp van twee gelijkstroommotoren, een Arduino Uno en een ESP8266 wifi-module.

De robot kan worden bestuurd vanuit een gewone internetbrowser, met behulp van een door HTML ontworpen interface. Een Android-smartphone kan worden gebruikt om video en audio van de robot naar de bedieningsinterface uit te zenden.

Net als in mijn vorige tutorial laat ik zien hoe je een goedkoop frame voor een robotproject ontwerpt en bouwt, met alleen gewone gereedschappen (geen 3D-printer, lasersnijder of CNC-router nodig).

Je zou kunnen opmerken dat de componenten die hier worden gebruikt mogelijk niet zijn geoptimaliseerd voor hun doel. In plaats van de combinatie Arduino + ESP8266 kan bijvoorbeeld een NodeMCU worden gebruikt. Een Rapsberry Pi met een camera zou de smartphone vervangen en ook de motoren aansturen. Het is zelfs mogelijk om een ​​Android-smartphone als 'brein' voor je robot te gebruiken. Dat is waar...

Deze tutorial is afgeleid van een ander project waar ik deel van uitmaak:Joy Robot (https://hackaday.io/project/12873-rob-da-alegria-joy-robot of https://www.hackster.io/igorF2/ robo-da-alegria-joy-robot-85e178), en voor de eenvoud werd hier dezelfde hardware gebruikt. Er is gekozen voor een Arduino Uno omdat deze zeer toegankelijk en gebruiksvriendelijk is voor iedereen, en we wilden er een eenvoudig schild voor ontwerpen. In ons oorspronkelijke project besturen we ook enkele servo's en LED-matrices en interfaces met de ESP. De smartphone wordt eigenlijk vervangen door een tablet, waarop ook andere applicaties draaien. Mogelijk vindt u andere tutorials met betrekking tot die robot in de onderstaande links:

LED-matrixarray besturen met Arduino Uno:

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

Wi-Fi-browsergestuurde servomotoren:

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

Deze handleiding kan worden aangepast en de vorm of bedieningsinterface kan worden gewijzigd om aan uw behoeften te voldoen.

In deze andere tutorial presenteer ik een manier om een ​​robot vanaf een smartphone te besturen met behulp van de Blynk-app! Check it out:

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

Stap 1:Gereedschap

De volgende gereedschappen zijn gebruikt voor de constructie van dit prototype:

Hulpprogramma's:

• Handzaag (voor het snijden van acrylplaten)

• Schroevendraaier (voor het plaatsen van bouten en moeren)

• Liniaal (voor het meten van de afmetingen van het model)

• Gebruiksmes (voor het snijden van de structuur en het maken van gaten)

• Boormachine (gebruikt voor het boren van acryl voor installatie van de schroeven)

• Schuurpapier (om ruwe randen glad te maken)

• Soldeerbout (voor het solderen van motorklemmen)

• Een computer (voor het compileren en uploaden van Arduino-code)

Die tools werden gebruikt voor de productie van de mechanische structuur van de robot, de assemblage van de robot en de aansluiting van elektronische componenten. Sommige tools zijn niet nodig als u ervoor kiest om een ​​structuur te kopen in plaats van uw eigen structuur te bouwen.

Je kunt zelfs andere apparaten gebruiken (bijvoorbeeld een 3D-printer of lasersnijder), afhankelijk van de tools die beschikbaar zijn in je makerspace.

Stap 2:Mechanische structuur en materialen

De volgende materialen zijn gebruikt voor de mechanische structuur:

Mechanische materialen:

• 2mm acrylaat plaat

• DC-reductiemotor met wiel (x2)

• 30 mm zwenkwiel (x1)

• M2 x 10 mm schroeven (x5)

• M2 x 1,5 mm moeren (x5)

• M3 x 10 mm schroeven (x9)

• M3 x 10 mm schroeven (x9)

• M3 x 40 mm schroeven (x4)

• M3 x 1,5 mm moeren (x12)

• 5/32" x 1" schroeven (x4)

• 5/32" moeren (x12)

• Universele telefoonhouder

• Stalen hoek "L" vormige beugel (30 x 30 mm) (x4)

Stap 3:Elektronische componenten

De volgende elektronische componenten zijn in deze robot gebruikt:

• Arduino Uno (kopen / kopen)

• ESP8266 (kopen)

• Protoshield (voor een compactere versie) of een gewoon breadboard (kopen)

• 1 kohm weerstand (x2)

• 10 kohm weerstand (x1)

• DC-reductiemotor met wiel (x2) (kopen)

• H-brug module (kopen)

• Enkele jumperdraden

• 5V USB-powerbank

Je vindt alle onderdelen eenvoudig online in je favoriete e-commerce winkel.

Zoals werd benadrukt in de inleiding van deze tutorial, is de keuze van de componenten afgeleid van een ander project dat ik heb ontworpen, en kan worden geoptimaliseerd met bijvoorbeeld een andere microcontroller.

Stap 4:De structuur ontwerpen

Eerst moest ik de mechanische structuur van mijn robot ontwerpen. U kunt de volledige structuur ook online kopen als u niet uw eigen aangepaste structuur wilt bouwen (er zijn veel robotkits online beschikbaar). In dit geval kunt u naar stap 6 gaan. Voor deze zelfstudie is een goedkoop acrylframe ontworpen voor de bevestiging van de motoren en andere componenten. De structuur die in deze tutorial wordt gepresenteerd, is in 3D ontworpen met Fusion 360 CAD-software en geconstrueerd met gewone gereedschappen (geen 3D-printer, lasersnijder of CNC-router nodig). U kunt dezelfde principes gebruiken die hieronder worden beschreven om een ​​aangepaste structuur te ontwerpen die aan uw behoeften voldoet.

Eerst moest ik een 3D-model maken van de hoofdcomponenten om de opstelling van de constructie te bepalen. Sommige zijn gedownload van de GrabCAD Comunity Library (https://grabcad.com/library ):

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

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

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

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

• Universele telefoonhouder (https://grabcad.com/library/universal-phone-holder-for-the-gopro-accessories-1)

De elektronische componenten waren in een vlak gerangschikt, zodat ik de voetafdrukbehoefte van mijn robot kon berekenen. Daarna moest ik de positie voor de motoren en wielen kiezen om een ​​stabiele structuur te creëren.

Op basis van die posities is de hoofdstructuur ontworpen, die is samengesteld uit drie platen (een basisplaat en twee zijplaten) die met enkele beugels zijn verbonden.

Stap 5:Bouwen en monteren van de structuur

De opbouw van de opbouw van de basis is opgedeeld in de volgende stappen:1. Snijd de acrylbasis volgens de afmetingen in de 2D-tekening: Dit kan met een lasersnijder (als je die hebt) of, zoals in mijn geval, met gewoon gereedschap.

Eerst moet je de afmetingen van je model overzetten op de plexiglas plaat. Druk uw 2D-tekening af met een gewone printer op zelfklevend papier, snij het papier vervolgens in geschikte afmetingen en breng dat masker aan op het oppervlak van het acrylaat. Snijd met een mes en met behulp van een liniaal of een schaal het acryl in rechte lijnen. U hoeft niet helemaal door het vel te snijden, u hoeft het alleen maar te scoren om enkele sporen te maken waar het stuk later zal worden gesneden. Plaats het plexiglas op een vlakke ondergrond, houd het op zijn plaats met enkele klemmen en oefen wat druk uit totdat het blad in tweeën breekt. Herhaal dit proces totdat alle sneden zijn gedaan. Daarna kunt u schuurpapier gebruiken om ruwe randen glad te strijken. U kunt ook een handzaag gebruiken om het acryl te zagen.2. Boor de gaten in de posities in de 2D-tekening: Boor met een boormachine de gaten op de posities zoals weergegeven in de 2D-tekening (aangegeven in het masker). Acryl is relatief eenvoudig te boren. Dus als je geen boormachine hebt, kun je de gaten handmatig boren met een scherp gereedschap, zoals een mes. U kunt het ook gebruiken om kleine gaatjes te vergroten zodat ze in schroefmaten passen. Verwijder het masker en je basis is klaar.

3. Monteer de componenten met schroeven en moeren volgens de 3D-tekening: Monteer de componenten met schroeven en moeren volgens de video en uw structuur is klaar voor gebruik. Voor de montage van de beugels en DC-motoren worden M3-schroeven gebruikt. M2-schroeven werden gebruikt voor de installatie van elektronische componenten, terwijl de 5/32"-schroeven worden gebruikt voor de installatie van het voorwiel en de smartphone-clip. Neem nu een pauze en begin met het monteren van het circuit in de volgende stap...

Stap 6:De elektronica monteren

Het hier voorgestelde circuit gebruikt een Arduino Uno als hoofdcontroller, die een interface heeft met een ESP8266 voor Wi-Fi-communicatie. De Arduino bestuurt de DC-motoren met behulp van een H-brige-aandrijfcircuit, dat tot twee motoren kan besturen, ze onafhankelijk in beide richtingen.

Een powerbank werd gebruikt om de elektronica van stroom te voorzien, rechtstreeks aangesloten op de USB-poort van Arduino. Dit is een gemakkelijke manier om uw Arduino van stroom te voorzien:eenvoudig op te laden, gemakkelijk te vervangen en levert een veilige 5V-spanning.

Sluit alle componenten aan volgens het schema. U hebt enkele jumperdraden nodig om de ESP8266-module aan te sluiten, die niet protoboard-vriendelijk is, h-bridge en DC-motoren. Je kunt een protoshield gebruiken (voor een compacter circuit), een gewoon breadboard of je eigen Arduino-schild ontwerpen.

Je zult merken dat de ESP8266-1 niet breadboard-vriendelijk is. Het zal worden aangesloten met behulp van enkele jumperdraden, maar het zal niet aan de structuur worden bevestigd.

Sluit een USB-kabel aan op het Arduino-bord en ga verder met de volgende stap.

Stap 7:Arduino-code

Installeer de nieuwste Arduino IDE. Er was geen bibliotheek nodig voor communicatie met de ESP-8266-module of besturing van de motoren. Controleer de baudrate van je ESP8266 en stel deze correct in de code in. Download Arduino-code (WiDC.ino) en vervang de XXXXX door je wifi-router SSID en YYYYY op routerwachtwoord. Sluit het Arduino-bord aan op de USB-poort van uw computer en upload de code.

Sluit een USB-kabel aan op het Arduino-bord en ga verder met de volgende stap.

//include libraries#include SoftwareSerial esp8266(3, 2); // RX-pin =3, TX-pin =2//definitie van variabelen #define DEBUG true // toon berichten tussen ESP8266 en Arduino in seriële portint-status =5; //definieer de beginstatus van de robot (5 =stand-by)//definieer motorpinnenconst int motor1Pin1 =5;const int motor1Pin2 =6;const int motor2Pin1 =9;const int motor2Pin2 =10;//definieer motorsnelheidint motorSpeed ​​=150; //motorsnelheid (PWM)//*****//SETUP//*****void setup () {//set pin-modi pinMode (motor1Pin1, OUTPUT); pinMode (motor1Pin2, UITGANG); pinMode (motor2Pin1, UITGANG); pinMode (motor2Pin2, UITGANG); //start communicatie 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); // verbind wifi-netwerk (vervang XXXXX door de SSID van je wifi-router en YYYYY door de wachtwoordvertraging (5000); // wacht op verbinding sendData ("AT+CIFSR\r\n", 1000, DEBUG); / /show IP-adres sendData("AT+CIPMUX=1\r\n", 1000, DEBUG); //meerdere verbindingen toestaan ​​sendData("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); / / start webserver op poort 80}//*********//MAIN LOOP//*********void loop(){ if (esp8266.available()) //verify inkomende gegevens {if (esp8266.find("+IPD,")) //als er een bericht is { String msg; esp8266.find("?"); // zoek naar het bericht msg =esp8266.readStringUntil(' ' ); //lees het hele bericht String opdracht =msg.substring (0, 3); //eerste 3 tekens =opdracht Serial.println (opdracht); // ga vooruit if (opdracht =="cm1") { state =1; } // ga achteruit if (commando =="cm2") { state =2; } // sla rechtsaf if (command =="cm3") { state =3;} // sla linksaf if (commando ==" cm4") { state =4; } // niets doen if (command =="cm5") { state =5; } } } // STATE 1:ga vooruit if (state ==1) { analogWrite(m otor1Pin1, motorSnelheid); digitalWrite (motor1Pin2, LAAG); analogWrite (motor2Pin1, motorSpeed); digitalWrite (motor2Pin2, LAAG); } // STATE 2:ga achteruit als (state ==2) { digitalWrite (motor1Pin1, LOW); analogWrite (motor1Pin2, motorSpeed); digitalWrite (motor2Pin1, LAAG); analogWrite (motor2Pin2, motorSpeed); } //STATE 3:ga naar rechts als (status ==3) {analogeWrite(motor1Pin1, motorSpeed); digitalWrite (motor1Pin2, LAAG); digitalWrite (motor2Pin1, LAAG); analogWrite (motor2Pin2, motorSpeed); } // STATE 4:ga naar links als (state ==4) { digitalWrite (motor1Pin1, LOW); analogWrite (motor1Pin2, motorSpeed); analogWrite (motor2Pin1, motorSpeed); digitalWrite (motor2Pin2, LAAG); } // STATE 5:niets doen als (state ==5) { digitalWrite (motor1Pin1, LOW); digitalWrite (motor1Pin2, LAAG); digitalWrite (motor2Pin1, LAAG); digitalWrite (motor2Pin2, LAAG); } }//*********************//Hulpfuncties//********************String sendData (String-opdracht, const int time-out, boolean debug){ String response =""; esp8266.print(opdracht); lange int-tijd =millis(); while ( (tijd + time-out)> millis()) { while (esp8266.available()) { char c =esp8266.read(); reactie +=c; } } if (debug) { Serial.print(respons); } antwoord terug;}  

Code uitgelegd:

De code gebruikt een seriële poort voor de communicatie tussen de Arduino en de ESP8266, en een andere voor de communicatie tussen de Arduino en een computer. Toen de Arduino Uno maar één seriële poort had, werd de SoftwareSeial-bibliotheek gebruikt om een ​​secundaire poort te maken, met behulp van digitale pinnen 2 en 3.

//include libraries#include SoftwareSerial esp8266(3, 2); //RX-pin =3, TX-pin =2 

Tijdens de installatie moeten beide seriële communicatie worden gestart en moet hun baudrate worden gedefinieerd (een tussen de Arduino en uw seriële monitor en een andere om de ESP8266-snelheid aan te passen). Merk op dat mijn ESP8266 was ingesteld op 9600 kbps. De meeste van deze modules hebben standaard 115200 kbps, maar de SoftwareSerial-bibliotheek kan niet op die snelheid werken en u moet de baudrate ervan wijzigen. Voor mij werkte 9600 kbps prima.

In dit project heb ik geen specifieke bibliotheek gebruikt voor de communicatie met de wifi-module. In plaats daarvan werden alleen de volgende gewone AT-commando's (een reeks instructies gedefinieerd op ESP8266 standaardfirmware) gebruikt:

• AT+RST:reset ESP8266-module

• AT+CWMODE:module instellen op stationsmodus of toegangspunt

• AT+CWJAP:verbind een Wi-Fi-netwerk gegeven door zijn SSID en wachtwoord

• AT+CIPMUX:module instellen voor meerdere verbindingen of enkele verbinding

• AT+CIPSERVER:start webserver op een bepaalde poort //start communicatie

 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); // verbind wifi-netwerk (vervang XXXXX door de SSID van je wifi-router en YYYYY door de wachtwoordvertraging (5000); // wacht op verbinding sendData ("AT+CIFSR\r\n", 1000, DEBUG); / /show IP-adres sendData("AT+CIPMUX=1\r\n", 1000, DEBUG); //meerdere verbindingen toestaan ​​sendData("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); / / start webserver op poort 80 

Een hulpfunctie (sendData) wordt gebruikt voor het verzenden van gegevens (van Arduino naar ESP8266), het lezen en weergeven van de respons op de seriële monitor.

String sendData(String-opdracht, const int time-out, boolean debug){ String response =""; esp8266.print(opdracht); lange int-tijd =millis(); while ( (tijd + time-out)> millis()) { while (esp8266.available()) { char c =esp8266.read(); reactie +=c; } } if (debug) { Serial.print(respons); } antwoord terug;} 

Door de bovenstaande code te gebruiken, reset de Arduino de module, sluit hij zich aan bij een netwerk, wacht even op de verbinding, toont dan zijn IP-adres en start een webserver. Daarna wordt de hoofdlus gestart en wacht de microcontroller op opdrachten.

void loop(){ if (esp8266.available()) // inkomende gegevens verifiëren { if (esp8266.find("+IPD,")) //if er een bericht is { String msg; esp8266.find("?"); // zoek naar het bericht msg =esp8266.readStringUntil(' '); //lees het hele bericht String-opdracht =msg.substring (0, 3); //eerste 3 tekens =opdracht Serial.println (opdracht); // ga vooruit if (commando =="cm1") { state =1; } // ga achteruit if (commando =="cm2") { state =2; } // sla rechtsaf if(commando =="cm3") { state =3; } // sla linksaf if (commando =="cm4") { state =4; } // niets doen if(command =="cm5") { state =5; } } } 

Er werden vijf mogelijke commando's gedefinieerd (cm1 tot cm5). Telkens wanneer de Arduino een van die opdrachten ontvangt, gaat hij naar een van de vijf mogelijke toestanden (vooruit, achteruit, naar rechts, naar links en stand-by) en gaat hij in die toestand verder totdat hij een andere opdracht ontvangt.

Elke status definieert de signalen voor motorpinnen. Ik gebruikte digitalWrite (pin, LOW) toen ik een pin op 0V wilde zetten en analogWrite (pin, motoSpeed) toen ik een pin wilde inschakelen. Door analogWrite te gebruiken, kon ik de snelheid van de motor veranderen en de robot langzamer laten bewegen.

//STATE 1:ga vooruit als (state ==1) { analogWrite (motor1Pin1, motorSpeed); digitalWrite (motor1Pin2, LAAG); analogWrite (motor2Pin1, motorSpeed); digitalWrite (motor2Pin2, LAAG); } // STATE 2:ga achteruit als (state ==2) { digitalWrite (motor1Pin1, LOW); analogWrite (motor1Pin2, motorSpeed); digitalWrite (motor2Pin1, LAAG); analogWrite (motor2Pin2, motorSpeed); } //STATE 3:ga naar rechts als (status ==3) {analogeWrite(motor1Pin1, motorSpeed); digitalWrite (motor1Pin2, LAAG); digitalWrite (motor2Pin1, LAAG); analogWrite (motor2Pin2, motorSpeed); } // STATE 4:ga naar links als (state ==4) { digitalWrite (motor1Pin1, LOW); analogWrite (motor1Pin2, motorSpeed); analogWrite (motor2Pin1, motorSpeed); digitalWrite (motor2Pin2, LAAG); } // STATE 5:niets doen als (state ==5) { digitalWrite (motor1Pin1, LOW); digitalWrite (motor1Pin2, LAAG); digitalWrite (motor2Pin1, LAAG); digitalWrite (motor2Pin2, LAAG); } 

Merk op dat de motoren werken tussen 3 en 6V. Zodra een 5V-stroombron wordt gebruikt, kunt u de gemiddelde spanning van de motor (met PWM) tussen 3 en 5V moduleren, waardoor de snelheid verandert. Je kunt de snelheid van de robot niet nauwkeurig regelen

Stap 8:webgebaseerde bedieningsinterface

Er is een html-interface ontworpen voor de besturing van de robot. Download interface.rar en pak alle bestanden uit in een bepaalde map. Open het vervolgens in Firefox. In die interface wordt een tekstvakformulier gebruikt om de IP-adressen van de ESP-module en van de video-/audioserver (van de Android IP Webcam-app) in te voeren. Er is een test maar, die de robot laat draaien totdat een ander commando wordt ontvangen. De pijltjestoetsen op het toetsenbord worden gebruikt om de robot naar voren of naar achteren te bewegen en om naar links of rechts te draaien. Een Android-smartphone werd gebruikt om de video en audio van de robot naar de bedieningsinterface uit te zenden. Mogelijk vindt u de app in de Google Play Store (https://play.google.com/store/apps/details?id=com.pas.webcam). Installeer deze en ga naar de volgende stap.

HTML-code uitgelegd:

De html-interface heeft twee delen:een voor audio en video (van de Android IP-webcamserver) en een voor de opdrachten.

Audio en video divisie heeft een formulier met een tekstvak een knop. Dit wordt gebruikt als invoer om het IP-adres van de webcamserver op te geven en te laden. Het wordt geleverd met een standaard IP-adres (192.168.0.5), maar de gebruiker kan een ander IP-adres invoeren. Video en audio worden geladen in objecten onder het tekstvak.

 
 IP-webcam ( IP):  
  
 

De andere divisie heeft een andere vorm met een tekstvak, zodat de gebruiker zijn ESP8266 IP-adres kan doorgeven.

 
 Arduino IP-adres:  
  
 Houd de pijltoetsen op het toetsenbord ingedrukt om de robot te verplaatsen 
 

JavaScript wordt gebruikt voor het omgaan met de interface en het verzenden van gegevens naar de Arduino. Die scripts zijn gecodeerd in verschillende bestanden en toegevoegd aan de html-header.

Javascript uitgelegd:

Een functie (readUrlAV) wordt gebruikt om het IP-adres uit het html-formulier te lezen en te laden in "video"- en "audio"-objecten.

functie readUrlAV (formulier) { 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);} 

Het script leest het toetsenbord periodiek en wacht tot de gebruiker een toets indrukt. Als de gebruiker op een pijltoets drukt (links ='37', omhoog ='38', rechts ='39' of 'omlaag' =40), stuurt hij een commando ("cm1" naar "cm4") voor een bepaald IP-adres adres. Merk op dat er een vergrendelingsfunctie is, die voorkomt dat dezelfde opdracht steeds opnieuw wordt herhaald. Gegevens worden alleen overgedragen als de toets wordt ingedrukt.

var latch =false;document.onkeydown =checkKeyDown;functie checkKeyDown(e) { e =e || venster.gebeurtenis; if (e.keyCode =='38') { // pijl omhoog if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get( ArduinoVar, { "cm1":1000 }); {Verbinding:sluiten}; grendel =waar; } } else if (e.keyCode =='40') { // pijl omlaag if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get( ArduinoVar, { "cm2":1000 }); {Connection:close}; latch =true; } } else if (e.keyCode =='37') { // left arrow if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get( ArduinoVar, { "cm3":1000 }); {Connection:close}; latch =true; } } else if (e.keyCode =='39') { // right arrow if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get( ArduinoVar, { "cm4":1000 }); {Connection:close}; latch =true; } }} 

When any arrow key is released, doNothing function is executed, which sends command "cm5" (stop the motors), and resets the latch, allowing interface to send differente commands.

document.onkeyup =checkKeyUp;function checkKeyUp(e) { e =e || window.event; 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.

//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;}

Geen voorbeeld (alleen downloaden).