Bionic Spider Controller - Teil 2 - AZ-Delivery

0 Kommentare

Im letzten Blogbeitrag wurde die bionische Spinne mit einem selbstgebauten Controller über das ESPNOW Protokoll gesteuert.

Dieses ermöglicht eine einfache Gerät-zu-Gerät-Verbindung, ohne dass eine diese mit einem Netzwerk verbunden sein müssen.

In diesem Blog verwenden wir das UDP-Internetprotokoll, um die Datenpakete zwischen den Mikrocontrollern auszutauschen. Hierfür müssen sich die Fernsteuerung und die Spinne im selben Netzwerk befinden.

Diese kleine Einschränkung hat aber auch den Vorteil, dass die Reichweite mit Repeatern und Accesspoints Ihres Heimnetzes meistens weitläufiger und flächendeckend ist und so eine Verbindung sogar über eine weitere Strecke als die Sichtweite hergestellt werden kann.

Hardware

Falls Sie den Controller bereits im Spider Controller Blog gebaut haben, können Sie den folgenden Teil überspringen und mit der Software fortfahren.

Als Joystick stehen zwei Ausführungen zur Verfügung, zum einen kann das KY-023 Modul verwendet werden. Da hier aber wieder einiges an Verkabelung notwendig wäre, empfiehlt sich das PS2 Joystick Shield, welches direkt auch auf einen Mikrocontroller mit Uno Layout gesteckt werden kann.

Da der Mikrocontroller mit dem Roboter kommunizieren muss, wird ein Mikrocontroller mit WiFi Funktionalität benötigt. Des Weiteren werden zwei ADC für je die X- und Y-Achse benötigt, deswegen muss hier ein ESP32 verwendet werden.

(Der ESP8266 verfügt nur über einen ADC-Eingang.)

Für die realisierung des Projekts benötigen Sie:

ESP32 NodeMCU D1 R32

PS2 Joystick Shield

(optional) 9V Blockbatterie + Batterieclip

und natürlich ein Zusammengebautes Bionic Spider Robot Kit

Da die Analogeingänge der zwei Joystick Achsen an den GPIO 2 und 4 anliegen, welche mit dem ADC2 verbunden sind, können diese nicht gleichzeitig mit dem WLAN Modul verwendet werden. Die Anschlüsse IO 34 und IO35 (ADC1) liegen aber direkt neben diesen, dadurch kann ganz einfach die Funktionsfähigkeit über eine Drahtbrücke hergestellt werden.

Abbildung 1: Drahtbrücke zwischen den Anschlüssen

Verbinden Sie die Anschlüsse wie oben abgebildet.

Da am GPIO 2 die On-Board LED angeschlossen ist, muss hier der Pin entfernt werden, da die Verbindung ansonsten den Wert der X-Achsen Spannung beeinflussen würde.

Das gleiche gilt für den Pin D12, da dieser den Boot Vorgang stört und somit kein boot mit aufgestecktem Shield möglich wäre. An diesem Anschluss liegt der mittlere Taster des Joysticks, dieser ist dadurch nicht mehr benutzbar. Falls sie diesen trotzdem implementieren wollen, muss dieser wieder mit einem freien Anschluss verbunden werden.

Abbildung 2: Shield mit Modifikationen

Das Shield kann einfach auf den D1 R32 gesteckt werden. Achten Sie darauf, dass der kleine Schalter in der linken Ecke auf 3v3 gestellt ist, da der ESP32 sonst durch die zu hohe Spannung von 5V beschädigt werden könnte.

Software

Falls Sie das erste Mal einen ESP32/ESP8266 in der Arduino IDE programmieren, kopieren Sie folgende URLs in der Arduino IDE unter: File->Preferences->Additional boards manager URLs : https://dl.espressif.com/dl/package_esp32_index.json

http://arduino.esp8266.com/stable/package_esp8266com_index.json

und installieren Sie in der Boardverwaltung das ESP32 und ESP8266 Paket.

Für die Kommunikation werden die Datenpakete mittels UDP ausgetauscht. Bei diesem Kommunikationsprotokoll werden die Pakete einfach gesendet, ohne nachzuvollziehen, ob das Paket empfangen wurde.

Dadurch ist der Datenaustausch zwar sehr schnell, aber auch unsicher, da nicht festgestellt wird, ob der Empfänger die Daten tatsächlich empfängt.

Die Bibliothek für die UDP Kommunikation ist bereits in den umfangreichen Boardpaketen für den ESP8266 und ESP32 enthalten.

Im ESPnow Blog war für die Kommunikation die MAC-Adresse der Mikrocontroller notwendig.
Bei der Kommunikation via UDP wird nur noch die IP-Adresse des Empfängers benötigt. Diese wird bei der Verbindung mit dem Heimnetz(WLAN) automatisch über den DHCP-Server des Routers zugewiesen.
Die IP-Adresse kann entweder über die Benutzeroberfläche Ihres Routers ermittelt werden, wird aber auch zu Beginn des Empfänger-Programms am Seriellen Monitor angezeigt.

Code bionic Spider

Laden Sie den folgenden Code auf den ESP8266 des Bionic Spider Bausatzes unter Auswahl des richtigen Ports und Board in der Arduino IDE.

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include "commands.h"

const char* ssid = "Name";
const char* password = "PSWD";
String cmd; //recieved Command

WiFiUDP udp;

void setup() {
Serial.begin(115200);
Serial.println();

WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    if(millis() > 30000) ESP.restart();
}

udp.begin(4210);

Serial.println("ESP8266 ready (Reciever)");
Serial.print("IP:");
Serial.println(WiFi.localIP());

servo_14.attach(14, SERVOMIN, SERVOMAX);// Connect the servo to pin 14
servo_12.attach(12, SERVOMIN, SERVOMAX);// Connect the servo to pin 12
servo_13.attach(13, SERVOMIN, SERVOMAX);// Connect the servo to pin 13
servo_15.attach(15, SERVOMIN, SERVOMAX);// Connect the servo to pin 15
servo_16.attach(16, SERVOMIN, SERVOMAX);// Connect the servo to pin 16
servo_5.attach(5, SERVOMIN, SERVOMAX);// Connect the servo to pin 5
servo_4.attach(4, SERVOMIN, SERVOMAX);// Connect the servo to pin 4
servo_2.attach(2, SERVOMIN, SERVOMAX);// Connect the servo to pin 2

Servo_PROGRAM_Zero();// Reset the servo program to zero
}

void loop() {
//Serial.print("IP:");
//Serial.println(WiFi.localIP());
int pSize = udp.parsePacket();
if (pSize) {
    char buf[20];
    int len = udp.read(buf, 20);
    buf[len] = 0;

    cmd = String(buf);
    Serial.println(cmd);
}

if(cmd.length() > 0) {
    if(cmd.indexOf("CMD_FWD") >= 0) {
      Serial.println("FWD");
      forward();
    }
    else if(cmd.indexOf("CMD_BWD") >= 0) {
      Serial.println("BWD");
      back();
    }
    else if(cmd.indexOf("CMD_RGT") >= 0) {
      Serial.println("RGT");
      rightmove();
    }
    else if(cmd.indexOf("CMD_LFT") >= 0) {
      Serial.println("LFT");
      leftmove();
    }
    else if(cmd.indexOf("BTN_A") >= 0) {
      Serial.println("A");
      dance1();
    }
    else if(cmd.indexOf("BTN_B") >= 0) {
      Serial.println("B");
      dance2();
    }
    else if(cmd.indexOf("BTN_C") >= 0) {
      Serial.println("C");
      hello();
    }
    else if(cmd.indexOf("BTN_D") >= 0) {
      Serial.println("D");
      pushup();
    }
    else if(cmd.indexOf("BTN_E") >= 0) {
      Serial.println("D");
      turnright();
    }
    else if(cmd.indexOf("BTN_F") >= 0) {
      Serial.println("D");
      turnleft();
    }

    cmd = "";
    // send ready to controller to recieve new commands
    udp.beginPacket(udp.remoteIP(), udp.remotePort());
    udp.print("RDY");
    udp.endPacket();
    Serial.println("ACK gesendet");
}

}

Erklärung:

Zu Beginn werden die benötigten Bibliotheken eingebunden. Die Datei commands.h mit den Abläufen der Bewegungen finden Sie zusammen mit dem Code im Download am Ende des Abschnitts.

Im Anschluss werden die WLAN Zugangsdaten definiert und eine Variable für den empfangenen Befehl deklariert. Außerdem wird das Objekt für die UDP-Bibliothek erzeugt.

Im setup() wird der Mikrocontroller mit dem WLAN verbunden und die einzelnen Servomotoren initialisiert.

Im loop() werden die eingehenden Datenpakete vom Sender in den cmd String gespeichert. Dieser wird im Anschluss durch die if Abfragen ausgewertet und der entsprechende Befehl ausgeführt. Nach dem Ausführen des Befehls wird eine Bestätigung an den Controller zurückgesendet.

Den kompletten Code können Sie hier herunterladen.
Geben Sie im Programm Ihre WLAN Zugangsdaten anstelle der Platzhalter ein.

Nach dem Hochladen auf den Mikrocontroller öffnen Sie den Seriellen Monitor und notieren Sie die IP-Adresse, welche angezeigt wird.
Sollte diese am Anfang nicht angezeigt werden, können Sie die zwei Zeilen am Anfang im loop() für die Ausgabe nutzen.

Code Controller

#include <WiFi.h>
#include <esp_wifi.h>
#include <WiFiUdp.h>

#define X 34
#define Y 35

#define A 26
#define B 25
#define C 17
#define D 16
#define E 27
#define F 14

const char* ssid = "name";
const char* password = "pswd";
const char* rcvIP = "192.168.178.xxx";

int calibY, calibX;
bool status = true;
long sentTime;
String msg;

WiFiUDP udp;

void setup() {
Serial.begin(115200);
delay(2000);

WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    if(millis() > 7000) ESP.restart();
}

Serial.println("ESP32 ready (Controller)");

calibX = analogRead(X); //calibrating current Position to zero
calibY = analogRead(Y);

pinMode(A, INPUT_PULLUP);
pinMode(B, INPUT_PULLUP);
pinMode(C, INPUT_PULLUP);
pinMode(D, INPUT_PULLUP);
pinMode(E, INPUT_PULLUP);
pinMode(F, INPUT_PULLUP);
}

void loop() {
int valX = analogRead(X) - calibX;
int valY = analogRead(Y) - calibY;
//Serial.println(valX);
//Serial.println(valY);

//no acknowledgement recieved after 10 sec. -> set marker to true; reenable sending
if((millis() - sentTime) > 10000) {
    status = true;
}
if(status) {
    //threshold values
    if(valX < -50 || valY < -50 || valX > 50 || valY > 50) {
      Serial.println("trig");
      //choose dominant coordinate
      if(abs(valX) > abs(valY)) {
        if(valX < 0) {
          Serial.println("LEFT");
          msg = "CMD_LFT";
        }
        else {
          Serial.println("Right");
          msg = "CMD_RGT";
        }
      }
      else {
        if(valY < 0) {
          Serial.println("BWD");
          msg = "CMD_BWD";
        }
        else {
          Serial.println("FWD");
          msg = "CMD_FWD";
        }
      }
      status = false; //marking sent
      sentTime = millis(); //store time for limitation
    }
    //check buttons
    else {
      if(!digitalRead(A)) {
        Serial.println("A");
        msg = "BTN_A";
        status = false; //marking sent
        sentTime = millis(); //store time for limitation
      }
      else if(!digitalRead(B)) {
        Serial.println("B");
        msg = "BTN_B";
        status = false; //marking sent
        sentTime = millis(); //store time for limitation
      }
      else if(!digitalRead(C)) {
        Serial.println("C");
        msg = "BTN_C";
        status = false; //marking sent
        sentTime = millis(); //store time for limitation
      }
      else if(!digitalRead(D)) {
        Serial.println("D");
        msg = "BTN_D";
        status = false; //marking sent
        sentTime = millis(); //store time for limitation
      }
      else if(!digitalRead(E)) {
        Serial.println("E");
        msg = "BTN_E";
        status = false; //marking sent
        sentTime = millis(); //store time for limitation
      }
      else if(!digitalRead(F)) {
        Serial.println("F");
        msg = "BTN_F";
        status = false; //marking sent
        sentTime = millis(); //store time for limitation
      }

    }
    udp.beginPacket(rcvIP, 4210);
    udp.print(msg);
    udp.endPacket();
    msg = "";
}

int pSize = udp.parsePacket();
if (pSize) {
    char buf[20];
    int len = udp.read(buf, 20);
    buf[len] = 0; //termination

    if (String(buf) == "RDY") {
      status = true;
      Serial.println("ACK");

    }
}
delay(100);
}

Erklärung:

Zu Beginn werden die benötigten Bibliotheken eingebunden, Makros für die Pins der verschiedenen Buttons erstellt und die WLAN Zugangsdaten und die IP-Adresse des Empfängers deklariert. Im Anschluss werden noch die globalen Variablen für die Kalibrierung der Joystick Achsen, den zu sendenden Befehl und für die Umsetzung der Bestätigungsnachricht deklariert.

Im setup() wird der Mikrocontroller mit dem WLAN verbunden, die Joystickachsen kalibriert und die digital-Eingänge definiert.

Im loop() wird als erstes die Joystick-Position als Analogwert ausgelesen und in entsprechenden Variablen gespeichert.

Danach folgt eine Überprüfung, durch welche der Sendestatus nach einer Zeitüberschreitung von 10 Sekunden zurückgesetzt wird.

Der Auswertungsalgorithmus für die Bewegungsrichtung überprüft, ob die Werte der Achsen einen Grenzwert von 50 überschreiten, dies ist notwendig, da sowohl die Potentiometer, über welche die Position der Achsen ausgelesen wird als auch die Analog-Digital-Wandler (ADC) sich auch in der Nullposition minimal um den Nullwert bewegen (sog. driften).

Befindet sich eine Achse über dem Schwellwert, so werden die Werte des Betrags der beiden Achsen miteinander verglichen. So kann die Achse ermittelt werden, die am stärksten bewegt wurde und somit richtungsweisend ist.

Des Weiteren werden noch die Digitaleingänge ausgelesen und beim Drücken eines Tasters der entsprechende Befehl (Tastenbezeichnung) in der Variable msg gespeichert.

Zum Schluss wird der Befehl als UDP Paket an den Roboter gesendet.

Wenn der Empfänger den Befehl ausgeführt hat, sendet dieser eine Bestätigung an den Sender zurück. Wird diese empfangen, wird die Variable status wieder auf true gesetzt, wodurch ein erneutes senden möglich ist.

Das gesamte Programm können Sie hier herunterladen.

Laden Sie dieses mit den korrekten WLAN Zugangsdaten und IP-Adresse auf den ESP32 D1 R32 unter Auswahl des richtigen Ports hoch.

Fazit

In diesem Blogbeitrag haben Sie gelernt, wie der bionic Spider Roboter mittels des UDP Kommunikationsprotokoll angesteuert werden kann.

Natürlich legt dieses Projekt nur die Grundlagen für Ihre eigenen Erweiterungen und Modifikationen. Zum Beispiel können Sie, um nicht auf einen externen Router angewiesen zu sein, einen Mikrocontroller im AP-Modus betreiben.

Somit haben Sie neben dem ESP eigenen ESPnow Kommunikationsprotokoll mit UDP auch ein sehr weit verbreitetes Protokoll kennengelernt, welches in vielen Zeitkritischen Anwendung verwendet wird.

Viel Spaß beim Nachbauen :)

Kategorien: Esp32, Esp8266, Projekte für anfänger