In the last blog post, the bionic spider was controlled with a self-built controller using the ESPNOW protocol.

This enables a simple device-to-device connection without having to be connected to a network.

In this blog, we use the UDP internet protocol to exchange data packets between the microcontrollers. To do this, the remote control and the spider must be in the same network.

However, this small limitation also has the advantage that the range with repeaters and access points in your home network is usually more extensive and comprehensive, meaning that a connection can even be established over a longer distance than the line of sight.

 

Hardware

If you have already installed the controller in the Spider Controller Blog you can skip the following part and continue with the software.

 

Two joystick versions are available, one of which is the KY-023 module can be used. However, as this would again require a lot of cabling, we recommend the PS2 Joystick Shieldwhich can also be connected directly to a microcontroller with Uno layout can be plugged in.

As the microcontroller has to communicate with the robot, a microcontroller with WiFi functionality is required. Furthermore, two ADCs are required for each of the X and Y axes, which is why an ESP32 must be used here.

(The ESP8266 only has one ADC input).

 

For the realization of the project you need:

ESP32 NodeMCU D1 R32

PS2 Joystick Shield

(optional) 9V block battery + Battery clip

and of course an assembled one Bionic Spider Robot Kit

 

As the analog inputs of the two joystick axes are connected to GPIO 2 and 4, which are connected to the ADC2, these cannot be used simultaneously with the WLAN module. However, the connections IO 34 and IO35 (ADC1) are located directly next to these, which means that functionality can be easily established via a wire jumper.

Figure 1: Wire bridge between the connections

 

Connect the connections as shown above.

As the on-board LED is connected to GPIO 2, the pin must be removed here, as the connection would otherwise affect the value of the X-axis voltage.

The same applies to pin D12, as this interferes with the boot process and therefore no boot would be possible with the shield plugged in. The middle button of the joystick is connected to this connection, which means it can no longer be used. If you still want to implement this, it must be reconnected to a free connection.

 

Figure 2: Shield with modifications

 

The shield can simply be plugged onto the D1 R32. Make sure that the small switch in the left-hand corner is set to 3v3 otherwise the ESP32 could be damaged by the excessive voltage of 5V.

 

Software

If you are programming an ESP32/ESP8266 in the Arduino IDE for the first time, copy the following URLs in the Arduino IDE under: File->Preferences->Additional boards manager URLs :  https://dl.espressif.com/dl/package_esp32_index.json

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

 

and install the ESP32 and ESP8266 package in the board administration.

 

For communication, the data packets are exchanged using UDP. With this communication protocol, the packets are simply sent without checking whether the packet has been received.

This makes data exchange very fast, but also insecure, as it is not possible to determine whether the recipient actually receives the data.

 

The library for UDP communication is already included in the extensive board packages for the ESP8266 and ESP32.

 

In the ESPnow blog, the MAC address of the microcontroller was required for communication.
When communicating via UDP, only the IP address of the receiver is required. This is assigned automatically via the router's DHCP server when connecting to the home network (WLAN).
The IP address can either be determined via the user interface of your router, but is also displayed on the serial monitor at the start of the receiver program.

 

Code bionic Spider

Load the following code onto the ESP8266 of the Bionic Spider kit by selecting the correct port and board in the 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");   }   }

Explanation:

The required libraries are integrated at the beginning. The file commands.h with the movement sequences can be found together with the code in the download at the end of this section.

The WLAN access data is then defined and a variable for the received command is declared. The object for the UDP library is also created.

In setup(), the microcontroller is connected to the WLAN and the individual servomotors are initialized.

In the loop(), the incoming data packets are transferred from the sender to the cmd string is saved. This is then evaluated by the if queries and the corresponding command is executed. Once the command has been executed, a confirmation is sent back to the controller.

 

You can download the complete code here download.
Enter your WLAN access data in the program instead of the placeholders.

 

After uploading to the microcontroller, open the serial monitor and make a note of the IP address that is displayed.
If this is not displayed at the beginning, you can use the two lines at the beginning in the loop() for the output.

 

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

Explanation:

First, the required libraries are integrated, macros are created for the pins of the various buttons and the WLAN access data and the IP address of the receiver are declared. The global variables for the calibration of the joystick axes, the command to be sent and for the implementation of the confirmation message are then declared.

In setup(), the microcontroller is connected to the WLAN, the joystick axes are calibrated and the digital inputs are defined.

In the loop(), the joystick position is first read out as an analog value and stored in corresponding variables.

This is followed by a check, which resets the transmission status after a timeout of 10 seconds.

The evaluation algorithm for the direction of movement checks whether the values of the axes exceed a limit value of 50. This is necessary because both the potentiometers used to read out the position of the axes and the analog-to-digital converters (ADC) move minimally around the zero value even in the zero position (so-called drifting).

If an axis is above the threshold value, the values of the magnitude of the two axes are compared with each other. In this way, the axis that has moved the most and is therefore the one that points the way can be determined.

In addition, the digital inputs are read out and the corresponding command (button designation) is saved in the variable msg when a button is pressed.

Finally, the command is sent to the robot as a UDP packet.

When the receiver has executed the command, it sends a confirmation back to the sender. If this is received, the variable status up again true which makes it possible to resend.

 

You can download the entire program here download.

Upload this with the correct WLAN access data and IP address to the ESP32 D1 R32 by selecting the correct port.

 

Conclusion

In this blog post, you learned how to control the bionic Spider robot using the UDP communication protocol.

Of course, this project only lays the foundations for your own extensions and modifications. For example, you can operate a microcontroller in AP mode so as not to be dependent on an external router.

Thus, in addition to ESP's own ESPnow communication protocol with UDP, you have also become familiar with a very widespread protocol that is used in many time-critical applications.

 

Have fun rebuilding :)