Pojazd zdalnie sterowany z kamerą na ESP32

[patryk_99]

Mój projekt to robot/samochód na module esp32 zawierający kamerę internetową ESP32 CAM. Popularny moduł kamery postanowiłem umieścić na serwomechaniźmie sterowanym zdalnie. Rzecz która moim zdaniem wyróżnia mojego robota jest pilot który tak samo jak robot jest zbudowany na module esp32 ale w wersji Wemos d1, mam na myśli to że większość projektów znalezionych przeze mnie w Internecie do sterowania robotem wykorzystuje telefon co jest prostszym ale mniej dla mnie ekscytującym rozwiązaniem. Początkowo robot miał mieć na swoim pokładzie dobrze znane arduino uno i moduł nrf24 jednak moje umiejętności programistyczne nie pozwoliły mi na wykorzystanie tego Modułu. Prób było wiele jednak za każdym razem nie potrafiłem sparować ze sobą tych dwóch modułów. Nie odpuściłem i postanowiłem wykorzystać właśnie Esp32 na którym już za pierwszym razem wszystko poszło zgodnie z planem. Do komunikacji między modułami wykorzystuję ESP-NOW.

Do sterowania silnikami pojazdu użyłem popularnego sterownika silników DC , natomiast do zasilania wykorzystuję 3 ogniwa Lion 3,7V.

Poniżej znajduje się kod do zaprogramowania robota :

#include <ESP32Servo.h>
#include <analogWrite.h>

//  Samochód na esp 32 sterowany zdalnie
//  Napęd na 4 koła
// Autor: Patryk 

#include <esp_now.h>
#include <WiFi.h>

//prawy silnik
int enableRightMotor=22; 
int rightMotorPin1=16;
int rightMotorPin2=17;
//Lewy silnik
int enableLeftMotor=23;
int leftMotorPin1=18;
int leftMotorPin2=19;
int buz = 13;
int pos;
#define MAX_MOTOR_SPEED 100
const int PWMFreq = 1000; 
const int PWMResolution = 8;
const int rightMotorPWMSpeedChannel = 4;
const int leftMotorPWMSpeedChannel = 5;

#define SIGNAL_TIMEOUT 1000  //maksymalny czas oczekiwania na sygnał
unsigned long lastRecvTime = 0;
const int SERVO_PIN = 26 ;// ESP32 pin GPIO26 connected to servo motor

Servo servoMotor;

struct PacketData
{
  byte xAxisValue;
  byte yAxisValue;
  byte xAxisValue2;
  byte yAxisValue2;
  byte switchPressed;
  byte switchPressed2;
};
PacketData receiverData;

bool throttleAndSteeringMode = false;


// funkcja realizowana gdy sygnał jest dostępny
void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) 
{
  if (len == 0)
  {
    return;
  }
  memcpy(&receiverData, incomingData, sizeof(receiverData));
  String inputData ;
  inputData = inputData + "values " +  receiverData.xAxisValue + "  " + receiverData.yAxisValue + "  " + receiverData.switchPressed+ "  " + receiverData.xAxisValue2 + "  " + receiverData.yAxisValue2 + "  " + receiverData.switchPressed2;
  Serial.println(inputData);
  simpleMovements();
  
  lastRecvTime = millis();   
}

void simpleMovements()
{
  if (receiverData.yAxisValue >= 175)       //do przodu>= 175
  {
    rotateMotor(MAX_MOTOR_SPEED, MAX_MOTOR_SPEED);
  }
  else if (receiverData.yAxisValue <= 75)   //do tyłu
  {
    rotateMotor(-MAX_MOTOR_SPEED, -MAX_MOTOR_SPEED);
  }
  else if (receiverData.xAxisValue >= 175)  //prawo
  {
    rotateMotor(-MAX_MOTOR_SPEED, MAX_MOTOR_SPEED);
    
  }
  else if (receiverData.xAxisValue <= 75)   //lewo
  {
    rotateMotor(MAX_MOTOR_SPEED, -MAX_MOTOR_SPEED);
    
  }
  else                                      //Stop 
  {
    rotateMotor(0, 0);
    
  }   
}


void rotateMotor(int rightMotorSpeed, int leftMotorSpeed)
{
  if (rightMotorSpeed < 0)
  {
    digitalWrite(rightMotorPin1,LOW);
    digitalWrite(rightMotorPin2,HIGH);    
  }
  else if (rightMotorSpeed > 0)
  {
    digitalWrite(rightMotorPin1,HIGH);
    digitalWrite(rightMotorPin2,LOW);      
  }
  else
  {
    digitalWrite(rightMotorPin1,LOW);
    digitalWrite(rightMotorPin2,LOW);      
  }
  
  if (leftMotorSpeed < 0)
  {
    digitalWrite(leftMotorPin1,LOW);
    digitalWrite(leftMotorPin2,HIGH);    
  }
  else if (leftMotorSpeed > 0)
  {
    digitalWrite(leftMotorPin1,HIGH);
    digitalWrite(leftMotorPin2,LOW);      
  }
  else
  {
    digitalWrite(leftMotorPin1,LOW);
    digitalWrite(leftMotorPin2,LOW);      
  } 

  ledcWrite(rightMotorPWMSpeedChannel, abs(rightMotorSpeed));
  ledcWrite(leftMotorPWMSpeedChannel, abs(leftMotorSpeed));    
}

void setUpPinModes()
{
  pinMode(enableRightMotor,OUTPUT);
  pinMode(rightMotorPin1,OUTPUT);
  pinMode(rightMotorPin2,OUTPUT);
  pinMode(buz, OUTPUT);
  pinMode(enableLeftMotor,OUTPUT);
  pinMode(leftMotorPin1,OUTPUT);
  pinMode(leftMotorPin2,OUTPUT);
  servoMotor.attach(SERVO_PIN);
  
  //sygnał pwm do sterowania szybkoscią samochodu
  ledcSetup(rightMotorPWMSpeedChannel, PWMFreq, PWMResolution);
  ledcSetup(leftMotorPWMSpeedChannel, PWMFreq, PWMResolution);  
  ledcAttachPin(enableRightMotor, rightMotorPWMSpeedChannel);
  ledcAttachPin(enableLeftMotor, leftMotorPWMSpeedChannel); 
  
  rotateMotor(0, 0);
}


void setup() 
{
  setUpPinModes();
  
  pos=90;
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);

  //  ESP-NOW
  if (esp_now_init() != ESP_OK) 
  {
    Serial.println("Error initializing ESP-NOW");
    return;
  }

  esp_now_register_recv_cb(OnDataRecv);
}
 
void loop() 
{                   
  if(receiverData.switchPressed == true){
    digitalWrite(buz, HIGH);
  }else{
    digitalWrite(buz, LOW);
  }
  //sygnał nieznaleziony
  unsigned long now = millis();
  if ( now - lastRecvTime > SIGNAL_TIMEOUT ) 
  {
    rotateMotor(0, 0);
  }
 
 servoMotor.write(pos);
if(pos<180){
if(receiverData.yAxisValue2>150){
  pos++;
  delay(20);
}
 }
if(pos>0){
 if(receiverData.yAxisValue2<120){
  pos--;
  delay(20);
}
}
 


}

 Mamy robota to teraz czas na kamerę tutaj wykorzystałem już gotowy kod który pozwoli na wyświetlenie obrazu w przeglądarce internetowej. Jedyne co trzeba zrobić to podłączyć się do tego samego Internetu co mamy kamerę i wpisać tam adres IP podany w porcie szeregowym Arduino IDE po wgraniu kodu.Cameraesp32.zip

Teraz zajmiemy się pilotem który na swoim pokładzie ma tak jak wspomniałem wcześniej esp32 Wemos d1 mini, dwa joysticki analogowe oraz 5 diod(cztery większe sygnalizują kierunki poruszania robota a jedna mała pomarańczowa, czy robot jest podłączony).

Poniżej podrzucam kod:

// Pilot do samochodu z użyciem esp32 d1 mini
// sterowany joystickiem
// Autor: Patryk 
//esp32 1.0.6 wersja wymagana
//WEMOS D1 MINI ESP32 

#include <esp_now.h>
#include <WiFi.h>

#define Gdioda 4
#define Hdioda 27
#define Pdioda 22
#define Ldioda 16
#define ON 17
#define X_AXIS_PIN 33 
#define Y_AXIS_PIN 34
#define X_AXIS_PIN2 32
#define Y_AXIS_PIN2 35
#define SWITCH_PIN  26
#define SWITCH_PIN2 25


uint8_t receiverMacAddress[] = {0x3C,0x71,0xBF,0x11,0x70,0x70};  //AC:67:B2:36:7F:28
 
struct PacketData
{
  byte xAxisValue;
  byte yAxisValue;
  byte xAxisValue2;
  byte yAxisValue2;
  byte switchPressed;
  byte switchPressed2;
};
PacketData data;


int mapAndAdjustJoystickDeadBandValues(int value, bool reverse)
{
  if (value >= 2200)
  {
    value = map(value, 2200, 4095, 127, 254);
  }
  else if (value <= 1800)
  {
    value = map(value, 1800, 0, 127, 0);  
  }
  else
  {
    value = 127;
  }

  if (reverse)
  {
    value = 254 - value;
  }
  return value;
}


// callback when data is sent
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status)
{
  Serial.print("\r\nLast Packet Send Status:\t ");
  Serial.println(status);
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Message sent" : "Message failed");
  if(status == 0){
    digitalWrite(ON, HIGH);
  }else{
    digitalWrite(ON, LOW);
  }
 
}

void setup() 
{
  
  
  
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);

  // Init ESP-NOW
  if (esp_now_init() != ESP_OK) 
  {
    Serial.println("Error initializing ESP-NOW");
    return;
  }
  else
  {
    Serial.println("Succes: Initialized ESP-NOW");
  }

  
  esp_now_register_send_cb(OnDataSent);
  
  esp_now_peer_info_t peerInfo;
  memcpy(peerInfo.peer_addr, receiverMacAddress, 6);
  peerInfo.channel = 0;  
  peerInfo.encrypt = false;
  
       
  if (esp_now_add_peer(&peerInfo) != ESP_OK)
  {
    Serial.println("Failed to add peer");
    return;
  }
  else
  {
    Serial.println("Succes: Added peer");
  } 

  pinMode(SWITCH_PIN, INPUT_PULLUP);
  pinMode(SWITCH_PIN2, INPUT_PULLUP);
  pinMode(Gdioda, OUTPUT);
  pinMode(Hdioda, OUTPUT);
  pinMode(Pdioda, OUTPUT);
  pinMode(Ldioda, OUTPUT);
  pinMode(ON, OUTPUT);   
}


 
void loop() 
{
  data.xAxisValue = mapAndAdjustJoystickDeadBandValues(analogRead(X_AXIS_PIN), false);
  data.yAxisValue = mapAndAdjustJoystickDeadBandValues(analogRead(Y_AXIS_PIN), false);
  data.xAxisValue2 = mapAndAdjustJoystickDeadBandValues(analogRead(X_AXIS_PIN2), false);
  data.yAxisValue2 = mapAndAdjustJoystickDeadBandValues(analogRead(Y_AXIS_PIN2), false);  
  data.switchPressed = false;
  data.switchPressed2 = false; 
  
  
 if(mapAndAdjustJoystickDeadBandValues(analogRead(X_AXIS_PIN), false) <100){
  digitalWrite(Gdioda, HIGH);
 }else{
  digitalWrite(Gdioda, LOW);
 }
 if(mapAndAdjustJoystickDeadBandValues(analogRead(X_AXIS_PIN), false) >150){
  digitalWrite(Hdioda, HIGH);
 }else{
  digitalWrite(Hdioda, LOW);
 }
 if(mapAndAdjustJoystickDeadBandValues(analogRead(Y_AXIS_PIN), false) <100){
  digitalWrite(Pdioda, HIGH);
 }else{
  digitalWrite(Pdioda, LOW);
 }
 if(mapAndAdjustJoystickDeadBandValues(analogRead(Y_AXIS_PIN), false) >150){
  digitalWrite(Ldioda, HIGH);
 }else{
  digitalWrite(Ldioda, LOW);
 }
 
  if (digitalRead(SWITCH_PIN) == LOW)
  {
    data.switchPressed = true;
  }
  
  if (digitalRead(SWITCH_PIN2) == LOW)
  {
    data.switchPressed2 = true;
  }
 
  esp_err_t result = esp_now_send(receiverMacAddress, (uint8_t *) &data, sizeof(data));
  if (result == ESP_OK) 
  {
    Serial.println("Sent with success");
    
  }
  else 
  {
    Serial.println("Error sending the data");
    
  }    
  
  if (data.switchPressed == true)
  {
    delay(500);
  }
  else
  {
    delay(50);
  }
}

Do pilota zrobiłem własną płytkę pcb więc czemu miałbym się nią nie podzielić. Niżej podrzucam plik gerber do płytki

Gerber_esp32-pilot_PCB_esp32-pilot_2025-03-09.zip

Napisane kody są oczywiście wgrywane do esp32 za pomocą Arduino IDE, bardzo ważną rzeczą którą muszę podkreślić jest to że do skompilowania tych kodów potrzebujemy bibliotekę płytek esp32 w wersji nie najnowszej a 1.0.6 ponieważ w nowszych wersjach nie ma niektórych zawartych w kodzie funkcji. Na sam koniec podrzucam parę zdjęć z początkowej fazy projektu jeszcze na czystym mostku H bez płytki pcb. Jestem otwarty na jakiekolwiek pytania dotyczące projektu.

[orb777]

Ciekawy projekt. Czy sterowanie z pada nie opóźnia/zawiesza obrazu z kamery? Też myślałem nad czymś takim, ale esp32-cam + esp32 do sterowania.

[patryk_99]

@orb777 nie opóźnia bo do wyświetlania obrazu jest drugi moduł esp tzw. Wroover kit z wejściem na kamerę a sterowanie robotem jak i serwem zapewnia drugi esp który jest w środku robota tylko nie mam niestety zdjęcia bez górnej obudowy 

[orb777]

@patryk_99 , teraz czaję panocku. Właśnie czegoś mi tu brakowało, myślałem, że jest jedno esp32 (cam) zwane w sposób dwojaki, a dalej dzieje się magia. Dzięki za wyjaśnienie. Naprawdę spoko projekcik, gratuluję.

Edytowano 10 marca przez orb777

[Polecacz 101]

Produkcja i montaż PCB - wybierz sprawdzone PCBWay!
   • Darmowe płytki dla studentów i projektów non-profit
   • Tylko 5$ za 10 prototypów PCB w 24 godziny
   • Usługa projektowania PCB na zlecenie
   • Montaż PCB od 30$ + bezpłatna dostawa i szablony
   • Darmowe narzędzie do podglądu plików Gerber
Zobacz również » Film z fabryki PCBWay

[patryk_99]

@orb777 Dzięki bardzo😉, na początku tak mialo byc ze moduł z kamerą bedzie tez sterował robotem ale kod z kamerą jest za duży i brałem też pod uwagę że obraz z kamery będzie się blokował 

[jand]

14 godzin temu, patryk_99 napisał:

potrzebujemy bibliotekę płytek esp32 w wersji nie najnowszej a 1.0.6 ponieważ w nowszych wersjach nie ma niektórych zawartych w kodzie funkcji

A co stoi na przeszkodzie by tak napisać program, aby dał się skompilować przy  najnowszej wersji core?

[ethanak]

@jand zmiana api esp-now jak mniemam 😉

[patryk_99]

@jand próbowałem to zrobić na samym początku ale nie bedę kryl poprostu nie umiem tego zrobic, jeżeli chcesz to mozesz to zmienić 

[JerryS]

Mega projekt, fajnie, że poszedłeś w ESP-NOW i własny pilot zamiast telefonu. Jak sprawdza się zasięg i stabilność połączenia? No i jak z czasem pracy na tych ogniwach?

[patryk_99]

@JerryS Ku zdziwieniu zasięg jak i stabilność połączenia jest na bardzo dobrym poziomie nie zdażyło mi się by pojazd nie wyłapał jakiegoś ruchu lub się zaciął. A jeżeli chodzi o ogniwa to jeszcze przed dodaniem kamery z serwem ogniwo  trzymało wystarczająco długo ładowałem go raz na 2tyg  jednak po dodaniu tych dwóch rzeczy czas się skrócił myślę że o 1/3.