Speed control in mobile http for 4WD car

[asgaroth]

Hello, I am trying to implement speed control for a wifi controlled commercial robot car.
However it seems that I am stuck ! Sketch compiles but the speed does not change...
Is seems that the button setting speed of the html does not reach the speed of the motors, or something like that.
Could anyone have a look and make a correction. Beginner here...
Thank you.

It seems as a new user I cannot make an attachment, so I paste the app_httpd.cpp code here:

// WARNING!!! Make sure that you have either selected ESP32 Wrover Module,
//            or another board which has PSRAM enabled
// Adafruit ESP32 Feather
#include "esp_http_server.h"
#include "esp_timer.h"
#include "esp_camera.h"
#include "img_converters.h"
#include "camera_index.h"
#include "Arduino.h"

#define LEFT_M0     13
#define LEFT_M1     12
#define RIGHT_M0    14
#define RIGHT_M1    15

int speed = 75;
int noStop = 0;
const int freq = 2000;
const int motorPWMChannnel = 8;
const int lresolution = 8;
volatile unsigned int  motor_speed   = 100;
void robot_setup();
void robot_stop();
void robot_fwd();
void robot_back();
void robot_left();
void robot_right();
volatile unsigned long previous_time = 0;
volatile unsigned long move_interval = 250;
unsigned int get_speed(unsigned int sp)
{
  return map(sp, 0, 100, 0, 255);
}

void robot_setup()
{
  ledcSetup(3, 2000, 8); /* 2000 hz PWM, 8-bit resolution and range from 0 to 255 */
  ledcSetup(4, 2000, 8); /* 2000 hz PWM, 8-bit resolution and range from 0 to 255 */
  ledcSetup(5, 2000, 8); /* 2000 hz PWM, 8-bit resolution and range from 0 to 255 */
  ledcSetup(6, 2000, 8); /* 2000 hz PWM, 8-bit resolution and range from 0 to 255 */
  ledcAttachPin(LEFT_M0, 3);//IO13
  ledcAttachPin(LEFT_M1, 4);//IO12
  ledcAttachPin(RIGHT_M0, 5);//IO14
  ledcAttachPin(RIGHT_M1, 6);//IO15
  
  pinMode(33, OUTPUT);
  robot_stop();  
}

// Motor Control Functions

void update_speed()
{  
    ledcWrite(motorPWMChannnel, get_speed(motor_speed));
}

void robot_stop()
{
  ledcWrite(3, 0);
  ledcWrite(4, 0);
  ledcWrite(5, 0);
  ledcWrite(6, 0);
}

void robot_fwd()
{
  ledcWrite(3, 0);
  ledcWrite(4, speed);
  ledcWrite(5, 0);
  ledcWrite(6, speed);
}

void robot_back()
{
  ledcWrite(3, speed);
  ledcWrite(4, 0);
  ledcWrite(5, speed);
  ledcWrite(6, 0);
}

void robot_right()
{
  ledcWrite(3, 0);
  ledcWrite(4, speed);
  ledcWrite(5, speed);
  ledcWrite(6, 0);
}

void robot_left()
{
  ledcWrite(3, speed);
  ledcWrite(4, 0);
  ledcWrite(5, 0);
  ledcWrite(6, speed);
}


//LED
extern int gpLed;
//WIFI
extern String WiFiAddr;

void WheelAct(int nLf, int nLb, int nRf, int nRb);

typedef struct {
        size_t size; //number of values used for filtering
        size_t index; //current value index
        size_t count; //value count
        int sum;
        int * values; //array to be filled with values
} ra_filter_t;

typedef struct {
        httpd_req_t *req;
        size_t len;
} jpg_chunking_t;

#define PART_BOUNDARY "123456789000000000000987654321"
static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
static const char* _STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";

static ra_filter_t ra_filter;
httpd_handle_t stream_httpd = NULL;
httpd_handle_t camera_httpd = NULL;

static ra_filter_t * ra_filter_init(ra_filter_t * filter, size_t sample_size){
    memset(filter, 0, sizeof(ra_filter_t));

    filter->values = (int *)malloc(sample_size * sizeof(int));
    if(!filter->values){
        return NULL;
    }
    memset(filter->values, 0, sample_size * sizeof(int));

    filter->size = sample_size;
    return filter;
}

static int ra_filter_run(ra_filter_t * filter, int value){
    if(!filter->values){
        return value;
    }
    filter->sum -= filter->values[filter->index];
    filter->values[filter->index] = value;
    filter->sum += filter->values[filter->index];
    filter->index++;
    filter->index = filter->index % filter->size;
    if (filter->count < filter->size) {
        filter->count++;
    }
    return filter->sum / filter->count;
}

static size_t jpg_encode_stream(void * arg, size_t index, const void* data, size_t len){
    jpg_chunking_t *j = (jpg_chunking_t *)arg;
    if(!index){
        j->len = 0;
    }
    if(httpd_resp_send_chunk(j->req, (const char *)data, len) != ESP_OK){
        return 0;
    }
    j->len += len;
    return len;
}

static esp_err_t capture_handler(httpd_req_t *req){
    camera_fb_t * fb = NULL;
    esp_err_t res = ESP_OK;
    int64_t fr_start = esp_timer_get_time();

    fb = esp_camera_fb_get();
    if (!fb) {
        Serial.printf("Camera capture failed");
        httpd_resp_send_500(req);
        return ESP_FAIL;
    }

    httpd_resp_set_type(req, "image/jpeg");
    httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=capture.jpg");

    size_t fb_len = 0;
    if(fb->format == PIXFORMAT_JPEG){
        fb_len = fb->len;
        res = httpd_resp_send(req, (const char *)fb->buf, fb->len);
    } else {
        jpg_chunking_t jchunk = {req, 0};
        res = frame2jpg_cb(fb, 80, jpg_encode_stream, &jchunk)?ESP_OK:ESP_FAIL;
        httpd_resp_send_chunk(req, NULL, 0);
        fb_len = jchunk.len;
    }
    esp_camera_fb_return(fb);
    int64_t fr_end = esp_timer_get_time();
    Serial.printf("JPG: %uB %ums", (uint32_t)(fb_len), (uint32_t)((fr_end - fr_start)/1000));
    return res;
}

static esp_err_t stream_handler(httpd_req_t *req){
    camera_fb_t * fb = NULL;
    esp_err_t res = ESP_OK;
    size_t _jpg_buf_len = 0;
    uint8_t * _jpg_buf = NULL;
    char * part_buf[64];

    static int64_t last_frame = 0;
    if(!last_frame) {
        last_frame = esp_timer_get_time();
    }

    res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);
    if(res != ESP_OK){
        return res;
    }

    while(true){
        fb = esp_camera_fb_get();
        if (!fb) {
            Serial.printf("Camera capture failed");
            res = ESP_FAIL;
        } else {
            if(fb->format != PIXFORMAT_JPEG){
                bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
                esp_camera_fb_return(fb);
                fb = NULL;
                if(!jpeg_converted){
                    Serial.printf("JPEG compression failed");
                    res = ESP_FAIL;
                }
            } else {
                _jpg_buf_len = fb->len;
                _jpg_buf = fb->buf;
            }
        }
        if(res == ESP_OK){
            size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len);
            res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
        }
        if(res == ESP_OK){
            res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
        }
        if(res == ESP_OK){
            res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
        }
        if(fb){
            esp_camera_fb_return(fb);
            fb = NULL;
            _jpg_buf = NULL;
        } else if(_jpg_buf){
            free(_jpg_buf);
            _jpg_buf = NULL;
        }
        if(res != ESP_OK){
            break;
        }
        int64_t fr_end = esp_timer_get_time();

        int64_t frame_time = fr_end - last_frame;
        last_frame = fr_end;
        frame_time /= 1000;
        uint32_t avg_frame_time = ra_filter_run(&ra_filter, frame_time);
        Serial.printf("MJPG: %uB %ums (%.1ffps), AVG: %ums (%.1ffps)"
            ,(uint32_t)(_jpg_buf_len),
            (uint32_t)frame_time, 1000.0 / (uint32_t)frame_time,
            avg_frame_time, 1000.0 / avg_frame_time
        );
    }

    last_frame = 0;
    return res;
}

static esp_err_t cmd_handler(httpd_req_t *req){
    char*  buf;
    size_t buf_len;
    char variable[32] = {0,};
    char value[32] = {0,};

    buf_len = httpd_req_get_url_query_len(req) + 1;
    if (buf_len > 1) {
        buf = (char*)malloc(buf_len);
        if(!buf){
            httpd_resp_send_500(req);
            return ESP_FAIL;
        }
        if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK) {
            if (httpd_query_key_value(buf, "var", variable, sizeof(variable)) == ESP_OK &&
                httpd_query_key_value(buf, "val", value, sizeof(value)) == ESP_OK) {
            } else {
                free(buf);
                httpd_resp_send_404(req);
                return ESP_FAIL;
            }
        } else {
            free(buf);
            httpd_resp_send_404(req);
            return ESP_FAIL;
        }
        free(buf);
    } else {
        httpd_resp_send_404(req);
        return ESP_FAIL;
    }

    int val = atoi(value);
    sensor_t * s = esp_camera_sensor_get();
    int res = 0;

    if(!strcmp(variable, "framesize")) {
        if(s->pixformat == PIXFORMAT_JPEG) res = s->set_framesize(s, (framesize_t)val);
    }
    else if(!strcmp(variable, "quality")) res = s->set_quality(s, val);
    else if(!strcmp(variable, "contrast")) res = s->set_contrast(s, val);
    else if(!strcmp(variable, "brightness")) res = s->set_brightness(s, val);
    else if(!strcmp(variable, "saturation")) res = s->set_saturation(s, val);
    else if(!strcmp(variable, "gainceiling")) res = s->set_gainceiling(s, (gainceiling_t)val);
    else if(!strcmp(variable, "colorbar")) res = s->set_colorbar(s, val);
    else if(!strcmp(variable, "awb")) res = s->set_whitebal(s, val);
    else if(!strcmp(variable, "agc")) res = s->set_gain_ctrl(s, val);
    else if(!strcmp(variable, "aec")) res = s->set_exposure_ctrl(s, val);
    else if(!strcmp(variable, "hmirror")) res = s->set_hmirror(s, val);
    else if(!strcmp(variable, "vflip")) res = s->set_vflip(s, val);
    else if(!strcmp(variable, "awb_gain")) res = s->set_awb_gain(s, val);
    else if(!strcmp(variable, "agc_gain")) res = s->set_agc_gain(s, val);
    else if(!strcmp(variable, "aec_value")) res = s->set_aec_value(s, val);
    else if(!strcmp(variable, "aec2")) res = s->set_aec2(s, val);
    else if(!strcmp(variable, "dcw")) res = s->set_dcw(s, val);
    else if(!strcmp(variable, "bpc")) res = s->set_bpc(s, val);
    else if(!strcmp(variable, "wpc")) res = s->set_wpc(s, val);
    else if(!strcmp(variable, "raw_gma")) res = s->set_raw_gma(s, val);
    else if(!strcmp(variable, "lenc")) res = s->set_lenc(s, val);
    else if(!strcmp(variable, "special_effect")) res = s->set_special_effect(s, val);
    else if(!strcmp(variable, "wb_mode")) res = s->set_wb_mode(s, val);
    else if(!strcmp(variable, "ae_level")) res = s->set_ae_level(s, val);
    else {
        res = -1;
    }

    if(res){
        return httpd_resp_send_500(req);
    }

    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
    return httpd_resp_send(req, NULL, 0);
}

static esp_err_t status_handler(httpd_req_t *req){
    static char json_response[1024];

    sensor_t * s = esp_camera_sensor_get();
    char * p = json_response;
    *p++ = '{';

    p+=sprintf(p, "\"framesize\":%u,", s->status.framesize);
    p+=sprintf(p, "\"quality\":%u,", s->status.quality);
    p+=sprintf(p, "\"brightness\":%d,", s->status.brightness);
    p+=sprintf(p, "\"contrast\":%d,", s->status.contrast);
    p+=sprintf(p, "\"saturation\":%d,", s->status.saturation);
    p+=sprintf(p, "\"special_effect\":%u,", s->status.special_effect);
    p+=sprintf(p, "\"wb_mode\":%u,", s->status.wb_mode);
    p+=sprintf(p, "\"awb\":%u,", s->status.awb);
    p+=sprintf(p, "\"awb_gain\":%u,", s->status.awb_gain);
    p+=sprintf(p, "\"aec\":%u,", s->status.aec);
    p+=sprintf(p, "\"aec2\":%u,", s->status.aec2);
    p+=sprintf(p, "\"ae_level\":%d,", s->status.ae_level);
    p+=sprintf(p, "\"aec_value\":%u,", s->status.aec_value);
    p+=sprintf(p, "\"agc\":%u,", s->status.agc);
    p+=sprintf(p, "\"agc_gain\":%u,", s->status.agc_gain);
    p+=sprintf(p, "\"gainceiling\":%u,", s->status.gainceiling);
    p+=sprintf(p, "\"bpc\":%u,", s->status.bpc);
    p+=sprintf(p, "\"wpc\":%u,", s->status.wpc);
    p+=sprintf(p, "\"raw_gma\":%u,", s->status.raw_gma);
    p+=sprintf(p, "\"lenc\":%u,", s->status.lenc);
    p+=sprintf(p, "\"hmirror\":%u,", s->status.hmirror);
    p+=sprintf(p, "\"dcw\":%u,", s->status.dcw);
    p+=sprintf(p, "\"colorbar\":%u", s->status.colorbar);
    *p++ = '}';
    *p++ = 0;
    httpd_resp_set_type(req, "application/json");
    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
    return httpd_resp_send(req, json_response, strlen(json_response));
}


//Handler that processes the speed control. This will allow the speed slider to set the motor speed in the motor_speed variable.
esp_err_t set_speed_handler(httpd_req_t *req) {
  char query[32];
  int speed = 255;  // Default speed value

  // Get the query string (e.g., ?val=100)
  if (httpd_req_get_url_query_str(req, query, sizeof(query)) == ESP_OK) {
    char value[32];
    if (httpd_query_key_value(query, "val", value, sizeof(value)) == ESP_OK) {
      speed = atoi(value);  // Convert speed from string to integer
      // Validate the speed value
      if (speed < 0) {
        speed = 0;  // Set to minimum speed if negative
      } else if (speed > 255) {
        speed = 255;  // Set to maximum speed if greater than 255
      }
    }
  }

  // Set motor speed
  motor_speed = speed;
  update_speed();  // Update the motor speed based on the slider value

  // Send response back
  const char* response = "Speed set successfully";
  httpd_resp_send(req, response, strlen(response));

  return ESP_OK;
}
//Handler that processes the speed control. This will allow the speed slider to set the motor speed in the motor_speed variable.


static esp_err_t index_handler(httpd_req_t *req){
   httpd_resp_set_type(req, "text/html");
   String page = "";
page += "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0\">\n";
page += "<style>body { background-color:#333333; } .test { -moz-user-select: none; -o-user-select: none; -khtml-user-select: none; -webkit-user-select: none; -ms-user-select: none; user-select: none; }</style>";

page += "<script>var xhttp = new XMLHttpRequest();</script>";
page += "<script>function getsend(arg) { xhttp.open('GET', arg +'?' + new Date().getTime(), true); xhttp.send() } </script>";


//Live Stream
page += "<p align=center><IMG SRC='http://" + WiFiAddr + ":81/stream' style='width:400px; transform:rotate(0deg);'>";


page +="<div unselectable=\"on\" onselectstart=\"return false\">";

//BUTTON Forward
page += "<p align=center> <button style=background-color:#4CAF50;color:white;font-size:18px;width:125px;height:70px onmousedown=getsend('go') onmouseup=getsend('stop') ontouchstart=getsend('go') ontouchend=getsend('stop') >Forward</button> </p>";

//Align 3 buttons in a row
page += "<p align=center>";
//BUTTON Left
page += "<button style=background-color:#4CAF50;color:white;font-size:18px;font-family:Arial,sans-serif;width:125px;height:70px; onmousedown=getsend('left') onmouseup=getsend('stop') ontouchstart=getsend('left') ontouchend=getsend('stop') >Left</button>&nbsp;";
//BUTTON Stop
page += "<button style=background-color:#4CAF50;color:white;font-size:18px;font-family:Arial,sans-serif;width:90px;height:70px onmousedown=getsend('stop') onmouseup=getsend('stop')> Stop</button>&nbsp;";
//BUTTON Right
page += "<button style=background-color:#4CAF50;color:white;font-size:18px;font-family:Arial,sans-serif;width:125px;height:70px onmousedown=getsend('right') onmouseup=getsend('stop') ontouchstart=getsend('right') ontouchend=getsend('stop') >Right</button>";

page += "</p>";
//BUTTON Backward
page += "<p align=center><button style=background-color:#4CAF50;color:white;font-size:18px;font-family:Arial,sans-serif;width:125px;height:70px onmousedown=getsend('back') onmouseup=getsend('stop') ontouchstart=getsend('back') ontouchend=getsend('stop') >Backward</button></p>";  

//Align 3 buttons in a row
page += "<p align=center>";
//BUTTON Light On
page += "<button style=background-color:Orange;color:white;font-size:18px;font-family:Arial,sans-serif;width:125px;height:40px onmousedown=getsend('ledon')>Light ON</button>";
//BUTTON Light Off
page += "<button style=background-color:Orange;color:white;font-size:18px;font-family:Arial,sans-serif;width:125px;height:40px onmousedown=getsend('ledoff')>Light OFF</button>";
//BUTTON Save image
page += "<button style=background-color:Orange;color:white;font-size:18px;font-family:Arial,sans-serif;width:125px;height:40px onmousedown=getsend('saveimage')>Save Image</button>";


page += "<script>";
page += "function updateSliderValue() {";
page += "  var slider = document.getElementById('speedControl');";
page += "  var value = document.getElementById('sliderValue');";
page += "  value.innerHTML = slider.value;";
page += "}";
page += "function setSpeed() {";
page += "  var speed = document.getElementById('speedControl').value;";
//page += " console.log("Slider speed: ", speed);  // Add this to check if the speed value is correct";  
//page += "  alert('Speed set to: ' + speed);";  // You can replace this with any action you want, e.g., send the speed to the ESP32 for controlling a motor.
//set_speed command
page += "  xhttp.open('GET', '/set_speed?val=' + speed, true);";
page += "  xhttp.send();";
//set_speed command

page += "}";
page += "</script>";

//TITLE FOR SPEED CONTROL
page += "<p style='font-size:16px; color:white; font-family:Arial,sans-serif; text-align:center;'>Speed Control</p>";

//SLIDER
page += "<p align=center>";
page += "<input type='range' min='0' max='255' value='255' id='speedControl' oninput='updateSliderValue()' style='width: 80%;'>";
page += "<span id='sliderValue' style='display:block; font-size:16px; color:white; font-family:Arial,sans-serif; text-align:center;' >255</span>";

//SET SPEED BUTTON
page += "<p align=center>";
page += "<button onclick='setSpeed()' style=background-color:Orange;color:white;font-size:18px;font-family:Arial,sans-serif;width:125px;height:40px;'>Set Speed</button>";

page += "</p>";
page +="</div>";

   return httpd_resp_send(req, &page[0], strlen(&page[0]));
}


static esp_err_t go_handler(httpd_req_t *req){
    //WheelAct(HIGH, LOW, HIGH, LOW);
    robot_fwd();
    Serial.println("Go");
    httpd_resp_set_type(req, "text/html");
    return httpd_resp_send(req, "OK", 2);
}
static esp_err_t back_handler(httpd_req_t *req){
    //WheelAct(LOW, HIGH, LOW, HIGH);
    robot_back();
    Serial.println("Back");
    httpd_resp_set_type(req, "text/html");
    return httpd_resp_send(req, "OK", 2);
}

static esp_err_t left_handler(httpd_req_t *req){
    //WheelAct(HIGH, LOW, LOW, HIGH);
    robot_left();
    Serial.println("Left");
    httpd_resp_set_type(req, "text/html");
    return httpd_resp_send(req, "OK", 2);
}
static esp_err_t right_handler(httpd_req_t *req){
    //WheelAct(LOW, HIGH, HIGH, LOW);
    robot_right();
    Serial.println("Right");
    httpd_resp_set_type(req, "text/html");
    return httpd_resp_send(req, "OK", 2);
}

static esp_err_t stop_handler(httpd_req_t *req){
    //WheelAct(LOW, LOW, LOW, LOW);
    robot_stop();
    Serial.println("Stop");
    httpd_resp_set_type(req, "text/html");
    return httpd_resp_send(req, "OK", 2);
}

static esp_err_t ledon_handler(httpd_req_t *req){
    digitalWrite(gpLed, HIGH);
    Serial.println("LED ON");
    httpd_resp_set_type(req, "text/html");
    return httpd_resp_send(req, "OK", 2);
}
static esp_err_t ledoff_handler(httpd_req_t *req){
    digitalWrite(gpLed, LOW);
    Serial.println("LED OFF");
    httpd_resp_set_type(req, "text/html");
    return httpd_resp_send(req, "OK", 2);
}

void startCameraServer(){
    httpd_config_t config = HTTPD_DEFAULT_CONFIG();

    httpd_uri_t go_uri = {
        .uri       = "/go",
        .method    = HTTP_GET,
        .handler   = go_handler,
        .user_ctx  = NULL
    };

    httpd_uri_t back_uri = {
        .uri       = "/back",
        .method    = HTTP_GET,
        .handler   = back_handler,
        .user_ctx  = NULL
    };

    httpd_uri_t stop_uri = {
        .uri       = "/stop",
        .method    = HTTP_GET,
        .handler   = stop_handler,
        .user_ctx  = NULL
    };

    httpd_uri_t left_uri = {
        .uri       = "/left",
        .method    = HTTP_GET,
        .handler   = left_handler,
        .user_ctx  = NULL
    };
    
    httpd_uri_t right_uri = {
        .uri       = "/right",
        .method    = HTTP_GET,
        .handler   = right_handler,
        .user_ctx  = NULL
    };
    
    httpd_uri_t ledon_uri = {
        .uri       = "/ledon",
        .method    = HTTP_GET,
        .handler   = ledon_handler,
        .user_ctx  = NULL
    };
    
    httpd_uri_t ledoff_uri = {
        .uri       = "/ledoff",
        .method    = HTTP_GET,
        .handler   = ledoff_handler,
        .user_ctx  = NULL
    };

    httpd_uri_t index_uri = {
        .uri       = "/",
        .method    = HTTP_GET,
        .handler   = index_handler,
        .user_ctx  = NULL
    };

    httpd_uri_t status_uri = {
        .uri       = "/status",
        .method    = HTTP_GET,
        .handler   = status_handler,
        .user_ctx  = NULL
    };

    httpd_uri_t cmd_uri = {
        .uri       = "/control",
        .method    = HTTP_GET,
        .handler   = cmd_handler,
        .user_ctx  = NULL
    };

    httpd_uri_t capture_uri = {
        .uri       = "/capture",
        .method    = HTTP_GET,
        .handler   = capture_handler,
        .user_ctx  = NULL
    };

   httpd_uri_t stream_uri = {
        .uri       = "/stream",
        .method    = HTTP_GET,
        .handler   = stream_handler,
        .user_ctx  = NULL
    };

    //URI FOR SETTING MOTOR SPEED WITH SLIDER
    httpd_uri_t set_speed_uri = {
    .uri       = "/set_speed",
    .method    = HTTP_GET,
    .handler   = set_speed_handler,
    .user_ctx  = NULL
    };
    //URI FOR SETTING MOTOR SPEED WITH SLIDER

    ra_filter_init(&ra_filter, 20);
    Serial.printf("Starting web server on port: '%d'", config.server_port);
    if (httpd_start(&camera_httpd, &config) == ESP_OK) {
        httpd_register_uri_handler(camera_httpd, &index_uri);
        httpd_register_uri_handler(camera_httpd, &go_uri); 
        httpd_register_uri_handler(camera_httpd, &back_uri); 
        httpd_register_uri_handler(camera_httpd, &stop_uri); 
        httpd_register_uri_handler(camera_httpd, &left_uri);
        httpd_register_uri_handler(camera_httpd, &right_uri);
        httpd_register_uri_handler(camera_httpd, &ledon_uri);
        httpd_register_uri_handler(camera_httpd, &ledoff_uri);

        //URI FOR SETTING MOTOR SPEED WITH SLIDER
        httpd_register_uri_handler(camera_httpd, &set_speed_uri);
        //URI FOR SETTING MOTOR SPEED WITH SLIDER
    }

    config.server_port += 1;
    config.ctrl_port += 1;
    Serial.printf("Starting stream server on port: '%d'", config.server_port);
    if (httpd_start(&stream_httpd, &config) == ESP_OK) {
        httpd_register_uri_handler(stream_httpd, &stream_uri);
    }
}

[Railroader]

You can instlall Serial.print of the value sent to the driver and see what's going on, and watch serial monitor.

[sonofcy]

Actually, you posted the code the way we want, NOT attachment, in code tags.
What board are you using?

[asgaroth]

The board is AI Thinker ESP32-CAM, board used on LAFVIN 4WD robot car.

[xfpd]

@asgaroth

const int motorPWMChannnel = 8;

It looks like channel 8 is your motor speed channel. I don't know how to verify the channel is "working." (early in the sketch, you can see how motor speed is passed and mapped)

[gilshultz]

Arduinos are designed for experimentation and learning, often used with breadboards and loose wires, which can become unreliable if vibrated. They are not built for harsh, dirty, or electrically noisy environments commonly found in industrial, automotive, or other commercial applications, making them unsuitable for such settings.

To ensure we can provide the most accurate assistance, please include detailed information about your setup. Specify the exact board, shield, wiring configuration, and power sources you are using. An annotated schematic is ideal, as it provides a clear overview of your setup, but be sure to also include links to the technical specifications of your hardware components.

Provide links to the technical information about your hardware, and include a preliminary schematic that shows all power, ground, and connections. For additional guidance, you can refer to this link: Useful Links and Tutorials. Note that in this context, breadboard diagrams are not considered proper schematics.

How to make a schematic you can post.

When you submit a question on the forum you will usually need to add a schematic (circuit diagram). The tutorial that follows will explain some ways to create a useful image; however lets start by explaining how to add the image to your post. Its easy. Having created the image all you need to do is : Save the image somewhere convenient - maybe your desktop Start your post, and place the cursor (insertion point) where you want the image to be shown; [upload image to forum] 3: click th…

[asgaroth]

https://www.dropbox.com/scl/fo/gkew8etvn1thk1vni6e8b/h?rlkey=u3bn6bdm4e485xgw93rb50i3v&e=2&dl=0

[asgaroth]

After reviewing the Serial monitor, it seems that the Set speed button and the slider, don't show any messages there.

[xfpd]

@asgaroth

speed button and the slider

What slider?

[asgaroth]

Slider that sets the motor speed and then a button should be pressed to apply the selected speed.

[xfpd]

@asgaroth

Slider that sets the motor speed and then a button should be pressed

I see neither.

[asgaroth]

My bad, sorry, just edited the code of the 1st post. I originally pasted wrong code by mistake. Sorry. The code now seems better.

[xfpd]

Include the missing slider and buttons...

[asgaroth]

I just did