In today's blog post, we want to build a remote-controlled exploration robot from the Acebott Smart Car Kit. The robot is to be controlled using a joystick and show its surroundings on a small display in radar optics.
The ultrasonic sensor, which is already mounted on a servomotor with an acrylic holder, is used to scan the surroundings.

The control system uses the PS2 joystick shield and ESP32 D1 R32 setup that you may already be familiar with from the blog posts on controlling the Bionic Spider robot.

Hardware

If you have already made the modifications to the PS2 Joystick Shield in a previous blog from the Bionic Spider Controller series, you can skip the following paragraph.

 

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 Acebott robot car

 

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.

 

 

Display extension

As the controller is supposed to display the vehicle's surroundings in the form of a radar screen, as seen in many films, a display is required.

Here we recommend the 1.3" OLED graphic display (SH1106). This is not only a large, easy-to-read graphic display, but also has the right layout for the socket strip of the HC05 module on the shield (top right). This means that the display can be plugged in without any major modifications.

Only the upper SMD resistor next to button A needs to be removed, as this was originally designed to halve the voltage on the RXD pin of the HC05 so that the module is not damaged when operating with the UNO microcontroller.

 

Image modification

 

As the microcontroller used (ESP32) has a logic level of 3.3V, communication with the display would no longer work with the halved voltage.

 

Software

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.

Although this makes data exchange very fast, it is also insecure, as it is not possible to determine whether the recipient is actually receiving the data. Communication via a network also enables a greater range compared to ESPnow or Bluetooth, as the network can cover a large area with repeaters and access points.
Basically, the two devices can communicate with each other at any location where you have reception with your smartphone.

 

The library for UDP communication is already included in the extensive board package for the ESP32.

 

In addition to the UDP and WiFi library, other external libraries are required, which you still need to install.

U8g2

ArduinoJson

These can be downloaded from GitHub as .zip files via the following links and can be used in the Arduino IDE under

Sketch > include Library > Add .zip Library ...

can be selected and installed.

 

The ESP32Servo, ultrasonic and vehicle Libraries are already included in the .zip file of the instructions. These have also already been installed in the instructions for advanced users.

 

Code smart car

#include <vehicle.h> #include <ultrasonic.h> #include <ESP32Servo.h> #include <ArduinoJson.h> #include <WiFi.h> #include <WiFiUdp.h> ultrasonic myUltrasonic; vehicle myCar; Servo myServo; JsonDocument doc; WiFiUDP udp; const char* ssid = "xxx"; const char* password = "xxx"; String cmd; String msg; int v = 255; //speed void setup() {   Serial.begin(115200);   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());   myCar.Init();//Initialize all motors   myUltrasonic.Init(13,14);   myServo.attach(25);//initialize } 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");       myCar.Move(Forward, v);     }     else if(cmd.indexOf("CMD_BWD") >= 0) {       Serial.println("BWD");       myCar.Move(Backward, v);     }     else if(cmd.indexOf("CMD_RGT") >= 0) {       Serial.println("RGT");       myCar.Move(Move_Right, v);     }     else if(cmd.indexOf("CMD_LFT") >= 0) {       Serial.println("LFT");       myCar.Move(Move_Left, v);     }     else if(cmd.indexOf("CMD_STOP") >= 0) {       Serial.println("Stop");       myCar.Move(Stop,0);     }     else if(cmd.indexOf("BTN_A") >= 0) {       Serial.println("A");       int j = 0;       for(int i=30; i<=150; i+=5) {         myServo.write(i);         Serial.println(myUltrasonic.Ranging());         doc["vals"][j]["angle"] = i + 180;         doc["vals"][j]["dist"] = myUltrasonic.Ranging();         delay(150);         j++;       }       doc["count"] = j;       serializeJson(doc, msg);       Serial.println(msg);       udp.beginPacket(udp.remoteIP(), udp.remotePort());       udp.print(msg);       udp.endPacket();       myServo.write(90);     }     else if(cmd.indexOf("BTN_B") >= 0) {       Serial.println("B");     }     else if(cmd.indexOf("BTN_C") >= 0) {       Serial.println("C");     }     else if(cmd.indexOf("BTN_D") >= 0) {       Serial.println("D");     }     else if(cmd.indexOf("BTN_E") >= 0) {       Serial.println("E");       myCar.Move(Clockwise,v);     }     else if(cmd.indexOf("BTN_F") >= 0) {       Serial.println("F");       myCar.Move(Contrarotate,v);     }     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:

At startup, the ESP32 connects to the WLAN, opens a UDP port and initializes the motors, ultrasonic sensor and servo. In the main loop, it waits for incoming UDP commands and evaluates them as text commands. Depending on the command, the motors are controlled or special functions are executed.

With the BTN_A command, the servo swivels the ultrasonic sensor in steps, measures the distance at each position and saves the angle and distance in a JSON array. Once the scan is complete, the JSON is serialized and sent back to the sender via UDP, after which the servo returns to the middle position.

After each executed action, the ESP32 sends the feedback "RDY" to signal that it is ready for the next command.

 

You can use the code here download.

Once you have loaded the program onto the microcontroller with the correct WLAN access data, the IP address of the device will be displayed. Make a note of this as it is required by the controller.

Code controller

#include <math.h> #include <Arduino.h> #include <U8g2lib.h> #include <Wire.h> #include <WiFi.h> #include <esp_wifi.h> #include <WiFiUdp.h> #include <ArduinoJson.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 = "xxx"; const char* password = "xxx"; const char* rcvIP = "192.168.178.xxx"; int calibY, calibX; bool status = true; long sentTime; String msg; WiFiUDP udp; U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R2, U8X8_PIN_NONE, 3, 1); JsonDocument doc; void drawLineAngle(float angleDeg, float length) {   float angleRad = angleDeg * DEG_TO_RAD;   int x1 = 64 - cos(angleRad) * length;   int y1 = 63 + sin(angleRad) * length;   u8g2.drawLine(64, 63, x1, y1); } 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();   }   u8g2.begin();   u8g2.clearBuffer();   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     }     else {       msg = "CMD_STOP";       status = false; //marking sent       sentTime = millis(); //store time for limitation     }     if(!digitalRead(A)) {       Serial.println("A");       msg = "BTN_A";       status = false; //marking sent       sentTime = millis(); //store time for limitation +3000     }     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[pSize];     int len = udp.read(buf, pSize);     buf[len] = 0; //termination     if (String(buf) == "RDY") {       status = true;       Serial.println("ACK");           }     else {       Serial.println(buf);       deserializeJson(doc, buf);       float l;       u8g2.clearBuffer();       for(int i = 0; i<doc["count"]; i++) {         l = doc["vals"][i]["dist"];         if(l>60) l = 60;         drawLineAngle(doc["vals"][i]["angle"] , l);       }       u8g2.sendBuffer();     }   }   delay(100); }

Explanation:

After starting, the ESP32 connects to the WLAN, initializes the OLED display, calibrates the joystick to its middle position and sets the required GPIOs for the buttons. The joystick axes are continuously evaluated in the main loop. If they exceed a threshold value, a direction of travel is determined and sent as a command (e.g. forwards, backwards, left, right), or stop if the joystick is in the center position, via UDP. In addition, special commands can be triggered using the A-F buttons. To avoid multiple transmissions, each command is only sent again after confirmation or a timeout has occurred.

 

Incoming UDP packets are also evaluated. If the response "RDY" is received, this signals that the receiver is ready for the next command. If the packet contains a JSON object with measurement data instead, this is parsed and displayed as a line display on the OLED. The angle and distance of the measured values represent lines that start from the center of the display. This creates a simple graphical representation of the environment detected by the other ESP32.

 

The lines are created with the drawLineAngle() function. Here, the end coordinates of the line are calculated using the sine and cosine. You can find a detailed explanation in the blog Retro watch with GC9A01A.

 

You can use the code here download.

Load the program with the correct access data and IP address of the receiver onto the microcontroller.

Conclusion

If you now press button A on the controller, the display will show you the surroundings in the next 60 cm graphically as a line for each measurement. One pixel corresponds to approximately one centimeter. If you want a wider display radius, you can adjust the controller program accordingly, but you should note the maximum length of 60 pixels.

Of course, this project only lays the foundations for your own extensions and modifications. In addition to scanning the environment, other functions can also be added; the unassigned buttons on the controller shield are available here.

Have fun rebuilding :)