We include the necessary libraries for this project and configure the camera

The following libraries are included in the code:

              
              #include "esp_camera.h"   // This library provides functions to initialize and control the ESP32 camera module.
              #include <WiFi.h> // This library enables Wi-Fi connectivity.
              #include <WebSocketsServer.h> // This library allows creating a WebSocket server.
              #include <AsyncTCP.h> // This library provides asynchronous TCP/IP communication.
              #include <ESPAsyncWebServer.h> // This library enables the creation of an asynchronous web server on ESP32.
              
            

Pin Definitions

The code defines various GPIO pin numbers for camera and other purposes:

              
              #define PWDN_GPIO_NUM     32
              #define RESET_GPIO_NUM    -1
              #define XCLK_GPIO_NUM      0
              #define SIOD_GPIO_NUM     26
              #define SIOC_GPIO_NUM     27
          
              #define Y9_GPIO_NUM       35
              #define Y8_GPIO_NUM       34
              #define Y7_GPIO_NUM       39
              #define Y6_GPIO_NUM       36
              #define Y5_GPIO_NUM       21
              #define Y4_GPIO_NUM       19
              #define Y3_GPIO_NUM       18
              #define Y2_GPIO_NUM        5
              #define VSYNC_GPIO_NUM    25
              #define HREF_GPIO_NUM     23
              #define PCLK_GPIO_NUM     22
              
            

Camera Configuration

A function named configCamera() is defined to configure the camera module:

              
              void configCamera(){
                camera_config_t config;
                // Camera pin configuration
                config.ledc_channel = LEDC_CHANNEL_0;
                config.ledc_timer = LEDC_TIMER_0;
                config.pin_d0 = Y2_GPIO_NUM;
                config.pin_d1 = Y3_GPIO_NUM;
                config.pin_d2 = Y4_GPIO_NUM;
                config.pin_d3 = Y5_GPIO_NUM;
                config.pin_d4 = Y6_GPIO_NUM;
                config.pin_d5 = Y7_GPIO_NUM;
                config.pin_d6 = Y8_GPIO_NUM;
                config.pin_d7 = Y9_GPIO_NUM;
                config.pin_xclk = XCLK_GPIO_NUM;
                config.pin_pclk = PCLK_GPIO_NUM;
                config.pin_vsync = VSYNC_GPIO_NUM;
                config.pin_href = HREF_GPIO_NUM;
                config.pin_sscb_sda = SIOD_GPIO_NUM;
                config.pin_sscb_scl = SIOC_GPIO_NUM;
                config.pin_pwdn = PWDN_GPIO_NUM;
                config.pin_reset = RESET_GPIO_NUM;
                config.xclk_freq_hz = 10000000;
                config.pixel_format = PIXFORMAT_JPEG;
          
                config.frame_size = FRAMESIZE_QVGA;
                config.jpeg_quality = 15;
                config.fb_count = 100;
          
                // Initialize the camera
                esp_err_t err = esp_camera_init(&config);
                if (err != ESP_OK) {
                  Serial.printf("Camera init failed with error 0x%x", err);
                  return;
                }
              }
            
          

Live Camera Function

A function named liveCam() is defined to capture and send a live camera frame:

              
              void liveCam(uint8_t num){
                // Capture a frame
                camera_fb_t *fb = esp_camera_fb_get();
                if (!fb) {
                  Serial.println("Frame buffer could not be acquired");
                  return;
                }
                
                // Replace this with your own function
                webSocket.sendBIN(num, fb->buf, fb->len);
          
                // Return the frame buffer back to be reused
                esp_camera_fb_return(fb);
              }
              
            

The code defines a WebSocket server and handles WebSocket events. It uses the WebSocketsServer library to handle WebSocket connections and the AsyncWebServer library to create an asynchronous web server. Let's break down the code further.

                
                // Define WebSocket server on port 81
                WebSocketsServer webSocket = WebSocketsServer(81);
                
                // Create AsyncWebServer on port 80
                AsyncWebServer server(80);
                
                // Variable to store the WebSocket connection number
                uint8_t cam_num;
                
                // Boolean flag to indicate if a client is connected
                bool connected = false;
                
                // String variable to store received WebSocket message
                String message = "";
                
                // Function to handle WebSocket text messages
                void handleWebSocketMessage(uint8_t *data, size_t len) {
                  data[len] = 0;
                  message = (char*)data;
                  Serial.println(message);
                  moveMotor(); // Call a function to move the motor based on the received message
                }
                
                // Function to handle WebSocket events
                void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {
                  switch(type) {
                    case WStype_DISCONNECTED:
                      Serial.printf("[%u] Disconnected!\n", num);
                      break;
                    case WStype_CONNECTED:
                      cam_num = num;
                      connected = true;
                      break;
                    case WStype_TEXT:
                      handleWebSocketMessage(payload, length);
                      break;
                    case WStype_BIN:
                    case WStype_ERROR:      
                    case WStype_FRAGMENT_TEXT_START:
                    case WStype_FRAGMENT_BIN_START:
                    case WStype_FRAGMENT:
                    case WStype_FRAGMENT_FIN:
                      break;
                  }
                }
              
            

In this code, a WebSocket server is created on port 81 using the WebSocketsServer library. An AsyncWebServer is also created on port 80 using the AsyncWebServer library. The variable cam_num is used to store the WebSocket connection number, and the connected flag indicates whether a client is connected or not.

The handleWebSocketMessage function is responsible for handling WebSocket text messages. It takes the received data as input, converts it to a null-terminated string, stores it in the message variable, and prints it to the serial monitor. It also calls a function named moveMotor() to move the motor based on the received message.

The webSocketEvent function is the WebSocket event handler. It is called when a WebSocket event occurs. It takes four parameters: num (the WebSocket connection number), type (the type of event), payload (the received data payload), and length (the length of the payload).

Inside the webSocketEvent function, a switch statement is used to handle different types of WebSocket events. If the event type is WStype_DISCONNECTED, it prints a message indicating that the client has been disconnected. If the event type is WStype_CONNECTED, it stores the WebSocket connection number in cam_num and sets the connected flag to true. If the event type is WStype_TEXT, it calls the handleWebSocketMessage function to process the received text message. Other event types are ignored in this code.

This code provides a modular approach to control the speed and direction of two motors based on input values. It allows the motors to be adjusted within the defined minimum and maximum speed ranges and provides a function to stop both motors simultaneously.

                
                // variables for motor drivers
                #define minspd 80
                #define maxspd 150
                
                int leftMotor =0, rightMotor=0;
                int sped(int dSpeed){
                  int nspd;
                  if (abs(dSpeed)>100){
                    dSpeed > 0 ? dSpeed = 100 : dSpeed = -100;
                  }
                  if (dSpeed > 0){
                    nspd = map(dSpeed, 0, 100, minspd, maxspd);
                  }else if (dSpeed < 0){
                    nspd = map(dSpeed, -100, 0, -maxspd, -minspd);
                  }
                  else{
                    nspd = 0;
                  }
                  return nspd;
                }
                
                void motor1(int Hspd) {
                  int spd = sped(Hspd);
                  if (spd > 5) {
                    digitalWrite(motor1Pin1, HIGH);
                    digitalWrite(motor1Pin2, LOW);
                  }else if (spd < -5) {
                    digitalWrite(motor1Pin1, LOW);
                    digitalWrite(motor1Pin2, HIGH);
                    spd = -spd;
                  }else{
                    digitalWrite(motor1Pin1, LOW);
                    digitalWrite(motor1Pin2, LOW);
                  }
                  ledcWrite(pwmChannel_1, spd);
                }
                
                void motor2(int Hspd) {
                  int spd = sped(Hspd);
                  if (spd > 5) {
                    digitalWrite(motor2Pin1, HIGH);
                    digitalWrite(motor2Pin2, LOW);
                  }else if (spd < -5) {
                    digitalWrite(motor2Pin1, LOW);
                    digitalWrite(motor2Pin2, HIGH);
                    spd = -spd;
                  }else {
                    digitalWrite(motor2Pin1, LOW);
                    digitalWrite(motor2Pin2, LOW);
                  }
                  ledcWrite(pwmChannel_2, spd);
                }
                
                void stopAll() {
                  motor1(0);
                  motor2(0);
                }
                
                void moveMotor(){
                  if(message.length()>2){
                    x_reading = message.substring(message.indexOf(':')+1,message.indexOf(',')).toInt();
                    Serial.println(x_reading);
                    y_reading = message.substring(message.indexOf(',')+5,message.length()).toInt();
                    Serial.println(y_reading);
                  }
                  if (abs(y_reading)>15){
                    leftMotor = y_reading;
                    rightMotor = y_reading;
                  }else{
                    leftMotor = 0, rightMotor= 0;
                  }
                
                  if (abs(x_reading)>20){
                    rightMotor = rightMotor - x_reading;
                    leftMotor = leftMotor + x_reading;
                  }
                
                  motor1(leftMotor);
                  motor2(rightMotor);
                }
              
            

The code provided is for controlling the speed and direction of two motors. It includes several functions and variables to achieve this functionality:

• #define minspd 80: This line defines a constant variable minspd with a value of 80.
• #define maxspd 150: This line defines a constant variable maxspd with a value of 150.
• int leftMotor = 0, rightMotor = 0;: These variables store the current speed values for the left and right motors, initially set to 0.
• int sped(int dSpeed): This function takes an input speed value (dSpeed) and maps it to the appropriate range based on the predefined minimum and maximum speeds. It returns the mapped speed value.
• void motor1(int Hspd): This function controls the first motor. It takes a speed value (Hspd) as input and sets the appropriate digital outputs and pulse width modulation (PWM) value for the motor control pins.
• void motor2(int Hspd): This function controls the second motor. It takes a speed value (Hspd) as input and sets the appropriate digital outputs and PWM value for the motor control pins.
• void stopAll(): This function stops both motors by calling motor1(0) and motor2(0) to set their speeds to 0.
• void moveMotor(): This function is responsible for moving the motors based on received input. It extracts the x and y readings from a message, adjusts the motor speeds accordingly, and calls motor1() and motor2() with the updated speeds.

This code sets up the initial configuration, including establishing a WiFi connection, configuring the web server and WebSocket server, and initializing the necessary pins and PWM for motor control. The loop() function continues to check for WebSocket events and perform live camera operations.

                
                void setup() {
                  Serial.begin(115200);    // Initializes the serial communication at a baud rate of 115200
                  WiFi.begin("Wifi", "WifiPassword");    // Connects to a WiFi network with the given SSID and password
                  Serial.println("");
                  while (WiFi.status() != WL_CONNECTED) {    // Waits until the WiFi connection is established
                      delay(500);
                      Serial.print(".");
                  }
                  Serial.println("");
                  String IP = WiFi.localIP().toString();    // Retrieves the local IP address of the device
                  Serial.print("IP address: " + IP);
              
                  index_html.replace("server_ip", IP);    // Replaces the placeholder "server_ip" in the HTML template with the actual IP address
              
                  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
                      request->send(200, "text/html", index_html);    // Handles the root URL request and sends the HTML template as a response
                  });
              
                  server.begin();    // Starts the web server
                  webSocket.begin();    // Starts the WebSocket server
                  webSocket.onEvent(webSocketEvent);    // Registers the WebSocket event handler function
                  configCamera();    // Configures the camera
              
                  // Sets the pins for motors as outputs
                  pinMode(motor1Pin1, OUTPUT);
                  pinMode(motor1Pin2, OUTPUT);
                  pinMode(enable1Pin, OUTPUT);
                  pinMode(motor2Pin1, OUTPUT);
                  pinMode(motor2Pin2, OUTPUT);
                  pinMode(enable2Pin, OUTPUT);
              
                  // Configures LED PWM functionalities
                  ledcSetup(pwmChannel_1, freq, motorResolution);
                  ledcSetup(pwmChannel_2, freq, motorResolution);
              
                  // Attaches the PWM channels to the corresponding GPIO pins
                  ledcAttachPin(enable1Pin, pwmChannel_1);
                  ledcAttachPin(enable2Pin, pwmChannel_2);
                }

                void loop() {
                  // http_resp();    // Uncommented code related to HTTP response, if available
                  webSocket.loop();    // Continuously checks for WebSocket events and handles them
                  liveCam(cam_num);    // Calls the function to perform live camera operations
                }
                
              

The provided code consists of two main functions: setup() and loop(). Here's an explanation of each function:

• setup(): This function is executed once when the device starts up. It performs the following tasks:
• Initializes the serial communication at a baud rate of 115200.
• Connects to a WiFi network with the given SSID and password.
• Waits until the WiFi connection is established.
• Retrieves the local IP address of the device.
• Replaces the placeholder "server_ip" in the HTML template with the actual IP address.
• Registers a route handler for the root URL ("/") to handle HTTP GET requests and send the HTML template as a response.
• Starts the web server.
• Starts the WebSocket server.
• Registers the WebSocket event handler function.
• Configures the camera.
• Sets the necessary pins for motor control as outputs.
• Configures LED Pulse Width Modulation (PWM) functionalities for motor control.
• Attaches the PWM channels to the corresponding GPIO pins.
• loop(): This function is executed repeatedly in an infinite loop. It performs the following tasks:
• Checks for WebSocket events and handles them.
• Performs live camera operations using the provided liveCam() function.

You can download the full code here: RoboCar Code and flash it onto your ESP32CAM!