WiDC: Wi‑Fi FPV-robot – Externe bediening met live video

Onderdelen en benodigdheden

Arduino UNO	1
Espressif ESP8266 ESP-01	1
Arduino Proto Shield	1
DC-motor met wiel	1
H-brug	1

Apps en online diensten

• Autodesk Fusion 360 (voor 3D-ontwerp)
• Arduino IDE

Over dit project

Wat dacht je van een op afstand bestuurbare robot om je omgeving te verkennen, onbereikbare plekken te bereiken, te spioneren, foto's te maken, films op te nemen of video te streamen? Deze tutorial laat je zien hoe je een betaalbare robot voor al die doeleinden bouwt!

Deze handleiding is een verbetering van mijn eerdere tutorial (Wi‑fi Controlled FPV Rover Robot with Arduino ESP8), waarin ik een snellere zelfgemaakte robot presenteer. Het toont hoe je een tweewielige robot op afstand bedient via een Wi‑Fi‑netwerk, met behulp van twee DC‑motoren, een Arduino Uno en een ESP8266 Wi‑Fi‑module.

De robot kan worden bediend vanuit een gewone internetbrowser, gebruikmakend van een HTML‑interface. Een Android-smartphone kan worden gebruikt om video en audio van de robot naar de bedieninterface te streamen.

Net als in mijn eerdere tutorial laat ik zien hoe je een low‑cost frame voor een robotproject ontwerpt en bouwt, met alleen gewone handgereedschap (geen 3D‑printer, lasersnijder of CNC‑frezer nodig).

Je zou kunnen opmerken dat de gebruikte componenten niet per se geoptimaliseerd zijn voor dit doel. Een NodeMCU zou bijvoorbeeld de Arduino + ESP8266‑combinatie kunnen vervangen. Een Raspberry Pi met camera zou de smartphone kunnen vervangen en de motoren ook besturen. Het is zelfs mogelijk om een Android-smartphone als de "hersenen" van je robot te gebruiken. Dat is allemaal waar…

Deze tutorial is afgeleid van een ander project waar ik aan deelneem: Joy Robot (Hackaday of Hackster), en dezelfde hardware werd hier voor de eenvoud gebruikt. Een Arduino Uno werd gekozen omdat het zeer toegankelijk en eenvoudig te gebruiken is voor iedereen, en we wilden een simpele shield voor ontwerpen. In ons oorspronkelijke project besturen we ook servos en LED‑matrices, en interfaccen met de ESP. De smartphone wordt daar eigenlijk vervangen door een tablet, die ook andere applicaties draait. Je kunt andere gerelateerde tutorials vinden via de links hieronder:

• LED‑matrixarray besturen met Arduino Uno: Instructables
• Wi‑Fi‑browsergestuurde servomotoren: Instructables

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

In deze andere tutorial presenteer ik een manier om een robot te besturen vanaf een smartphone met de Blynk‑app! Bekijk het hier:

Hackster

Stap 1: Gereedschap

De volgende gereedschappen werden gebruikt voor de constructie van deze prototype:

• Handzaag (voor het zagen van acrylaatplaten)
• Schroevendraaier (voor bouten en moeren)
• Liniaal (voor het meten van afmetingen)
• Stanleymes (voor het snijden van de structuur en maken van gaten)
• Boormachine (voor het boren van gaten in acrylaat voor schroeven)
• Schuurpapier (om ruwe randen glad te maken)
• Soldeerbout (voor het solderen van motoraansluitingen)
• Een computer (voor het compileren en uploaden van Arduino‑code)

Deze gereedschappen werden gebruikt voor de productie van de mechanische structuur, assemblage van de robot en aansluiting van elektronische componenten. Sommige gereedschappen zijn niet nodig als je kiest voor een kant‑en‑klare structuur in plaats van zelf te bouwen.

Je kunt ook andere apparatuur gebruiken (bijv. een 3D‑printer of lasersnijder), afhankelijk van de tools die beschikbaar zijn in jouw makerspace.

Stap 2: Mechanische structuur en materialen

De volgende materialen werden gebruikt voor de mechanische structuur:

• 2 mm acrylaatplaat
• DC‑tandwielmotor met wiel (×2)
• 30 mm zwenkwiel (×1)
• M2 × 10 mm schroeven (×5)
• M2 × 1,5 mm moeren (×5)
• M3 × 10 mm schroeven (×9)
• M3 × 40 mm schroeven (×4)
• M3 × 1,5 mm moeren (×12)
• 5/32″ × 1″ schroeven (×4)
• 5/32″ moeren (×12)
• Universele telefoonhouder
• Stalen hoekbeugel "L"-vormig (30 × 30 mm) (×4)

Stap 3: Elektronische componenten

De volgende elektronische componenten werden in deze robot gebruikt:

• Arduino Uno
• ESP8266
• Proto Shield (voor een compactere versie) of een gewoon breadboard
• 1 kΩ weerstand (×2)
• 10 kΩ weerstand (×1)
• DC‑tandwielmotor met wiel (×2)
• H‑brugmodule
• Enkele jumper‑draden
• 5 V USB powerbank

Alle componenten vind je gemakkelijk online bij je favoriete webwinkel. Zoals in de inleiding benadrukt, was de keuze van de componenten afgeleid van een ander project en kan worden geoptimaliseerd met een andere microcontroller.

Stap 4: De structuur ontwerpen

Allereerst moest ik de mechanische structuur van mijn robot ontwerpen. Je kunt ook een complete structuur online kopen als je niet zelf wilt bouwen (er zijn veel robotkits beschikbaar). In dat geval kun je direct naar Stap 6 gaan. Voor deze tutorial werd een low‑cost acrylaatframe ontworpen voor de bevestiging van motoren en andere componenten. De structuur werd 3D‑geontwerpt met Fusion 360 CAD‑software en gebouwd met gewone gereedschappen (geen 3D‑printer, lasersnijder of CNC‑frezer nodig). Je kunt dezelfde principes gebruiken om een aangepaste structuur te ontwerpen die aan jouw behoeften voldoet.

Eerst maakte ik een 3D‑model van de hoofcomponenten om de indeling van de structuur te bepalen. Sommige modellen werden gedownload uit de GrabCAD Community Library (GrabCAD):

• Arduino Uno (link)
• Tandwielmotor (link)
• H‑brug (link)
• Powerbank (link)
• Universele telefoonhouder (link)

De elektronische componenten werden in een vlak gerangschikt om de benodigde voetafdruk van de robot te bepalen. Vervolgens koos ik de positie voor de motoren en wielen om een stabiele structuur te creëren. Op basis van die posities werd de hoofstructuur ontworpen, bestaande uit drie platen (een basisplaat en twee zijplaten) die met beugels met elkaar verbonden zijn.

Bestanden: base.pdf, base.svg

Stap 5: De structuur bouwen en assembleren

De constructie van de basisstructuur wordt in de volgende stappen uitgevoerd:

1. Zagen van de acrylaatbasis volgens de afmetingen in de 2D‑tekening: Dit kan met een lasersnijder (als je er toegang tot hebt) of, zoals in mijn geval, met gewone gereedschappen. Eerst moet je de afmetingen van je model overbrengen naar de acrylaatplaat. Print je 2D‑tekening op zelfklevend papier, knip het papier in geschikte afmetingen en plak het masker op het acrylaat. Met een stanleymes en een liniaal snij je het acrylaat in rechte lijnen. Je hoeft niet helemaal doorheen te zagen, alleen lijnen aanbrengen waar het later kan breken. Leg het acrylaat plat, bevestig het met klemmen en oefen druk uit tot het breekt. Herhaal dit tot alle zagen klaar zijn. Gebruik schuurpapier om ruwe randen glad te maken. Je kunt ook een handzaag gebruiken.

2. Boren van de gaten op de posities zoals in de 2D‑tekening: Boor de gaten op de aangegeven posities (gemarkeerd in het masker) met een boormachine. Acrylaat is relatief eenvoudig te boren. Als je geen boormachine hebt, kun je gaten handmatig boren met een scherp gereedschap zoals een stanleymes. Je kunt het ook gebruiken om kleine gaten te vergroten voor schroefmaten. Haal het masker eraf en je basis is klaar.

3. Componenten monteren met schroeven en moeren volgens de 3D‑tekening: Monteer de componenten met schroeven en moeren volgens de video, en je structuur is klaar. M3‑schroeven worden gebruikt voor de bevestiging van de beugels en DC‑motoren. M2‑schroeven voor elektronische componenten, en de 5/32″‑schroeven voor het voorwiel en de telefoonklem. Neem nu een pauze en ga verder met de elektronica in de volgende stap…

Bestand: base.pdf

Stap 6: De elektronica assembleren

Het voorgestelde schema gebruikt een Arduino Uno als hoofdcontroller, die communiceert met een ESP8266 voor Wi‑Fi. De Arduino stuurt de DC‑motoren aan via een H‑brug‑aandrijfschakeling, die maximaal twee motoren onafhankelijk in beide richtingen kan besturen.

Een powerbank werd gebruikt om de elektronica te voeden, aangesloten op de USB‑poort van de Arduino. Dit is een eenvoudige manier om je Arduino te voeden: makkelijk op te laden, eenvoudig te vervangen, en levert een veilige 5 V spanning.

Sluit alle componenten aan volgens het schema. Je hebt enkele jumper‑draden nodig om de ESP8266‑module (die niet protoboard‑vriendelijk is), de H‑brug en de DC‑motoren te verbinden. Je kunt een Proto Shield (voor een compactere schakeling), een gewoon breadboard of je eigen Arduino‑shield ontwerpen.

Let op: de ESP8266‑01 is niet breadboard‑vriendelijk. Deze wordt met jumper‑draden aangesloten, maar niet op de structuur bevestigd.

Steek een USB‑kabel in de Arduino en ga door naar de volgende stap.

Bestanden: wiDC_Esquem_C3_A1tico.pdf, wiDC.fzz, wiDC_bb.pdf

Stap 7: Arduino‑code

Installeer de nieuwste Arduino IDE. Geen bibliotheek nodig voor communicatie met de ESP‑8266‑module of motorbesturing. Controleer de baudrate van je ESP8266 en stel deze correct in de code in. Download de Arduino‑code (WiDC.ino) en vervang XXXXX door de SSID van je Wi‑Fi‑router en YYYYY door het wachtwoord. Verbind de Arduino met je computer via USB en upload de code.

Steek een USB‑kabel in de Arduino en ga door naar de volgende stap.

// Bibliotheken
#include <SoftwareSerial.h>
SoftwareSerial esp8266(3, 2); // RX pin = 3, TX pin = 2

// Variabelen
#define DEBUG true
int state = 5; // initiële staat (5 = standby)

// Motor pinnen
const int motor1Pin1 = 5;
const int motor1Pin2 = 6;
const int motor2Pin1 = 9;
const int motor2Pin2 = 10;

// Motorbesturing
int motorSpeed = 150; // PWM snelheid

void setup() {
  pinMode(motor1Pin1, OUTPUT);
  pinMode(motor1Pin2, OUTPUT);
  pinMode(motor2Pin1, OUTPUT);
  pinMode(motor2Pin2, OUTPUT);

  Serial.begin(9600);
  esp8266.begin(9600);

  sendData("AT+RST\r\n", 2000, DEBUG); // reset module
  sendData("AT+CWMODE=1\r\n", 1000, DEBUG); // station mode
  sendData("AT+CWJAP=\"XXXXX\",\"YYYYY\"\r\n", 2000, DEBUG); // Wi‑Fi verbinden
  delay(5000); // wachten op verbinding
  sendData("AT+CIFSR\r\n", 1000, DEBUG); // IP‑adres tonen
  sendData("AT+CIPMUX=1\r\n", 1000, DEBUG); // meerdere verbindingen toestaan
  sendData("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); // webserver op poort 80
}

void loop() {
  if (esp8266.available()) {
    if (esp8266.find("+IPD,")) {
      String msg;
      esp8266.find("?");
      msg = esp8266.readStringUntil(' ');
      String command = msg.substring(0, 3);
      Serial.println(command);

      if (command == "cm1") state = 1; // vooruit
      else if (command == "cm2") state = 2; // achteruit
      else if (command == "cm3") state = 3; // rechts
      else if (command == "cm4") state = 4; // links
      else if (command == "cm5") state = 5; // stop
    }
  }

  // Staat 1: vooruit
  if (state == 1) {
    analogWrite(motor1Pin1, motorSpeed); digitalWrite(motor1Pin2, LOW);
    analogWrite(motor2Pin1, motorSpeed); digitalWrite(motor2Pin2, LOW);
  }
  // Staat 2: achteruit
  else if (state == 2) {
    digitalWrite(motor1Pin1, LOW); analogWrite(motor1Pin2, motorSpeed);
    digitalWrite(motor2Pin1, LOW); analogWrite(motor2Pin2, motorSpeed);
  }
  // Staat 3: rechts
  else if (state == 3) {
    analogWrite(motor1Pin1, motorSpeed); digitalWrite(motor1Pin2, LOW);
    digitalWrite(motor2Pin1, LOW); analogWrite(motor2Pin2, motorSpeed);
  }
  // Staat 4: links
  else if (state == 4) {
    digitalWrite(motor1Pin1, LOW); analogWrite(motor1Pin2, motorSpeed);
    analogWrite(motor2Pin1, motorSpeed); digitalWrite(motor2Pin2, LOW);
  }
  // Staat 5: stop
  else if (state == 5) {
    digitalWrite(motor1Pin1, LOW); digitalWrite(motor1Pin2, LOW);
    digitalWrite(motor2Pin1, LOW); digitalWrite(motor2Pin2, LOW);
  }
}

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

Code uitleg:

De code gebruikt één seriële poort voor communicatie tussen Arduino en ESP8266, en een andere voor communicatie met de computer. Omdat de Arduino Uno maar één hardware seriële poort heeft, wordt de SoftwareSerial bibliotheek gebruikt om een tweede poort te creëren op digitale pinnen 2 en 3.

Tijdens setup() worden beide seriële communicaties gestart en hun baudrate ingesteld (één voor de Serial Monitor, één om de snelheid van de ESP8266 te matchen). Let op: mijn ESP8266 was ingesteld op 9600 kbps. Standaard komen deze modules op 115200 kbps, maar SoftwareSerial kan niet op die snelheid werken; je moet de baudrate van de module verlagen. Voor mij werkte 9600 kbps prima.

In dit project werd geen specifieke bibliotheek voor de Wi‑Fi‑module gebruikt. Alleen de volgende standaard AT‑commando's (instructies gedefinieerd in de standaard firmware van de ESP8266) werden gebruikt:

• AT+RST: reset ESP8266
• AT+CWMODE: module in station‑ of access‑point‑mode zetten
• AT+CWJAP: verbinden met Wi‑Fi‑netwerk (SSID + wachtwoord)
• AT+CIPMUX: meerdere of enkele verbindingen toestaan
• AT+CIPSERVER: webserver starten op een gegeven poort

Een hulp­functie sendData wordt gebruikt voor het versturen van commando's naar de ESP8266, het lezen van het antwoord en het tonen op de Serial Monitor.

De loop() wacht op binnenkomende data. Zodra een commando (cm1–cm5) ontvangen wordt, gaat de Arduino in een van de vijf mogelijke staten (vooruit, achteruit, rechts, links, standby) en blijft in die staat totdat een ander commando wordt ontvangen.

Elke staat definieert de signalen voor de motorpinnen. digitalWrite(pin, LOW) zet een pin op 0 V, analogWrite(pin, motorSpeed) schakelt de pin in met PWM, waardoor de motorsnelheid geregeld kan worden.

De motoren werken tussen 3 en 6 V. Met een 5 V voeding kun je de gemiddelde spanning (via PWM) tussen 3 en 5 V moduleren, wat de snelheid verandert. Het biedt geen heel fijn motorcontrole, maar is voldoende voor deze toepassing.

Bestand: WiDC.ino

Stap 8: Web‑gebaseerde bedieninterface

Een HTML‑interface is ontworpen voor de besturing van de robot. Download interface.rar, pak de bestanden uit in een map en open het in Firefox. Een tekstvak wordt gebruikt om het IP‑adres van de ESP‑module en van de video/audio‑server (van de Android IP Webcam‑app) in te voeren. Er is een testknop die de robot laat draaien totdat een ander commando wordt ontvangen. Toetsenbordpijltjes worden gebruikt om de robot vooruit/achteruit te laten rijden en links/rechts te laten draaien.

Een Android‑smartphone wordt gebruikt om video en audio van de robot naar de bedieninterface te streamen. De app vind je in de Google Play Store (IP Webcam). Installeer het en ga naar de volgende stap.

HTML‑code uitleg:

De interface heeft twee secties: één voor audio/video (van de Android IP Webcam‑server) en één voor de commando's.

De audio/video‑sectie bevat een formulier met een tekstvak en een knop om het IP‑adres van de webcam‑server op te geven en te laden. Standaard staat 192.168.0.5 ingesteld, maar de gebruiker kan een ander IP invoeren. Video en audio worden in objecten onder het tekstvak geladen.

De commando‑sectie heeft een ander formulier met een tekstvak voor het IP‑adres van de ESP8266. Daarnaast wordt een afbeelding van een toetsenbord getoond met de instructie om de pijltjestoetsen ingedrukt te houden om de robot te bewegen.

JavaScript wordt gebruikt voor de interface en het versturen van data naar de Arduino. De scripts staan in aparte bestanden en worden in de HTML‑header geladen.

JavaScript uitleg:

De functie readUrlAV leest het IP‑adres uit het formulier en laadt het in de "video"- en "audio"-objecten.

Het script luistert periodiek naar toetsenbordinvoer. Wanneer de gebruiker een pijltjestoets indrukt (links=37, boven=38, rechts=39, onder=40), wordt een commando ("cm1" tot "cm4") naar het opgegeven IP‑adres gestuurd. Er zit een "latch"-functie in die voorkomt dat hetzelfde commando herhaaldelijk wordt verstuurd. Data wordt alleen verstuurd op het moment dat de toets wordt ingedrukt.

Wanneer een pijltjestoets wordt losgelaten, wordt de functie doNothing uitgevoerd, die commando "cm5" (stop de motoren) stuurt en de latch reset, zodat nieuwe commando's kunnen worden verstuurd.

Bestand: interface.rar

Stap 9: Gebruik

Wanneer de Arduino herstart, probeert hij automatisch verbinding te maken met je Wi‑Fi‑netwerk. Gebruik de Serial Monitor om te controleren of de verbinding geslaagd is en welk IP‑adres je router aan de ESP‑8266 heeft toegewezen. Open het HTML‑bestand in een browser (Firefox) en voer dit IP‑adres in het tekstvak in. Je kunt ook andere methoden gebruiken om het toegewezen IP‑adres te achterhalen.

Ontkoppel de Arduino Uno van je computer en sluit hem aan op de powerbank. Wacht tot hij opnieuw verbonden is. Start de IP Webcam‑app op de smartphone die op de robot zit. Voer het video/audio‑IP in op je bedieninterface en verbind met de server. Je bent nu klaar om te gaan verkennen. Je moet misschien de videoresolutie in de app verlagen om de vertraging tijdens de transmissie te verminderen. Klik en houd de pijltjestoetsen van je toetsenbord ingedrukt om de robot te laten draaien of vooruit/achteruit te bewegen en veel plezier met het verkennen van je omgeving.

Let op: de robot draait in open lus. Het is daarom lastig om hem rechtdoor te laten rijden. Kleine verschillen tussen de motoren, uitlijning, etc. zullen cumulatieve afwijkingen veroorzaken.

De robot begint te bewegen wanneer hij een commando ontvangt (cm1–cm4) en blijft in die staat totdat een ander commando (cm1–cm5) wordt ontvangen. Soms verliest de ESP8266 berichten, wat problemen kan geven. Als bijvoorbeeld een "cm5"-commando verloren gaat, blijft de robot rijden zelfs na het loslaten van de pijltjestoets. Ik werk nog aan dit probleem. Voel je vrij om de manier waarop commando's worden geïnterpreteerd aan te passen om dit soort problemen te vermijden.

Code

• Arduino‑code (WiDC.ino)
• Interface (interface.rar)

CAD‑bestanden

base_7JLgOpcox6.svg

Schema's

Zie bijgevoegde afbeeldingen in de originele tutorial.