Surveillance Rover - Iordan Ion-Alexandru
Introducere
Proiectul este o drona de supraveghere care se poate deplasa in orice directie, transmite imagini video in timp real si evita obstacolele cu ajutorul unui senzor de distanta.
Scopul proiectului este de a crea un sistem mobil de monitorizare care poate patrula automat sau fi controlat de la distanta, oferind siguranta si eficienta in zone greu accesibile sau in spatii interioare.
Ideea a pornit de la nevoia unui sistem flexibil, usor de deplasat si cu autonomie partiala, care sa poata fi folosit pentru supravegherea unui spatiu fara interventie umana constanta.
Cred ca proiectul este util atat pentru noi, ca experienta practica si aplicata in domeniul automatizarilor si al sistemelor inteligente, cat si pentru altii, deoarece poate fi adaptat pentru securitate, inspectii tehnice sau monitorizare ambientala.
Descriere generală
Descrierea componentelor principale:
1. ESP32-CAM (Unitatea de Comunicație și Video)
Funcție principală: Podul de comunicație între laptop și Arduino
Ce face:
Comunicație WiFi: Primește comenzile de la laptop prin rețeaua wireless Stream video: Captează imagini cu camera integrată și le transmite live către laptop Procesare comenzi: Interpretează comenzile primite (ex: "FORWARD", "CAM_UP") Comunicație serială: Transmite comenzile procesate către Arduino prin UART Feedback: Colectează răspunsurile de la Arduino și le retransmite către laptop
2. ARDUINO UNO + L293D Shield (Controlerul Principal)
Funcție principală: Executorul comenzilor hardware
Ce face Arduino:
Primește comenzile de la ESP32-CAM prin comunicația serială Procesează comenzile și le convertește în semnale pentru componente Controlează timpii și secvențele de execuție Citește datele de la senzori Trimite feedback către ESP32-CAM
Ce face Shield-ul L293D:
Driver pentru motoare: Amplifică semnalele de la Arduino pentru a controla motoarele DC Control direcție: Permite rotația în ambele sensuri pentru fiecare motor Protecție: Izolează Arduino de curenții mari consumați de motoare
3. Motoarele DC (4 bucăți - Sistemul de Propulsie)
Funcție principală: Deplasarea robotului
Ce fac:
2 motoare stânga + 2 motoare dreapta = control diferențial FORWARD: Toate motoarele se rotesc înainte BACK: Toate motoarele se rotesc înapoi LEFT: Motoarele din dreapta merg înainte, cele din stânga se opresc/merg înapoi RIGHT: Motoarele din stânga merg înainte, cele din dreapta se opresc/merg înapoi STOP: Toate motoarele se opresc
4. Senzorul Ultrasonici HC-SR04 (Ochii Robotului)
Funcție principală: Detectarea obstacolelor și măsurarea distanțelor
Ce face:
ULTRASONIC_READ: Măsoară distanța până la cel mai apropiat obstacol Trimite unde ultrasonice și măsoară timpul de întoarcere Detectează obstacole la distanță
5. Bateriile LiPo (2 bucăți - Sursa de Energie)
Funcție principală: Alimentarea întregului sistem
Ce fac:
Bateria 1: Alimentează motoarele DC (tensiune mai mare, curent mare) Bateria 2: Alimentează electronica (ESP32, Arduino, senzori) Asigură autonomia robotului pentru funcționarea wireless Permit operarea independentă fără cabluri de alimentare
Fluxul de Funcționare Complet:
Utilizatorul apasă un buton în aplicația web de pe laptop (ex: w = "Înainte") Laptopul trimite comanda "FORWARD" prin WiFi ESP32-CAM primește comanda și o transmite prin serial către Arduino Arduino procesează comanda și activează motoarele prin L293D Motoarele DC se rotesc și robotul se deplasează înainte Senzorul ultrasonici monitorizează continuu obstacolele Camera ESP32 transmite imaginile live către laptop Utilizatorul vede unde merge robotul și poate ajusta traiectoria
Întregul sistem funcționează ca o extensie a utilizatorului, permițând controlul precis al robotului de la distanță cu feedback vizual și senzorial în timp real.
Hardware Design
Software Design
Mediu de dezvoltare:
Proiectul este dezvoltat folosind Arduino IDE. Acesta este specific pentru dezvoltarea firmware-ului pe platforme bazate pe microcontrolere, cum ar fi ESP32.
Librării și surse 3rd-party
- ESP32 Camera Library: Este probabil utilizată pentru gestionarea funcționalităților camerei.
- WebServer Library: Utilizată pentru implementarea serverului web.
- FS Library: Posibil utilizată pentru gestionarea fișierelor HTML și altor resurse statice.
- Alte librării Arduino standard pentru comunicare și control hardware.
- Biblioteci incluse
esp_http_server.h: Gestionarea serverului HTTP.
esp_camera.h: Funcționalități pentru camera ESP32. img_conve rters.h și fb_gfx.h: Conversii de imagini și grafică. esp32-hal-ledc.h: Controlul LED-urilor și PWM. camera_index.h: Resurse pentru interfața camerei. globals.h: Variabile globale utilizate în proiect.
Structuri planificate
- Captură de imagini: Algoritmi pentru capturarea imaginilor de la modulul camerei.
- Streaming video: Structuri pentru transmiterea fluxului video prin HTTP.
- Controlul camerei: Funcții pentru ajustarea parametrilor camerei (ex. rezoluție, luminozitate).
- Interfață web: HTML și JavaScript pentru interacțiunea utilizatorului cu camera prin browser.
Algoritmi ESP32-CAM
- Inițializarea WiFi
const char *ssid = "Wifi Name";
const char *password = "Wifi Password";
- Inițializarea senzorului ultrasonic
const int TRIGGER_PIN = 15;
const int ECHO_PIN = 14;
pinMode(TRIGGER_PIN, OUTPUT);
pinMode(ECHO_PIN, INPUT);
Serial.println("Ultrasonic sensor initialized");
- Inițializarea comunicării seriale
HardwareSerial mySerial(1); // Use UART1
mySerial.begin(9600, SERIAL_8N1, 13, 4); // Baud, config, RX, TX
mySerial.println("Hello, world?");
- Configurarea camerei
camera_config_t config; config.ledc_channel = LEDC_CHANNEL_0; config.ledc_timer = LEDC_TIMER_0; config.pin_d0 = Y2_GPIO_NUM; // ...configurație pini... config.xclk_freq_hz = 10000000; // 10 MHz config.pixel_format = PIXFORMAT_RGB565;
if (psramFound()) {
config.frame_size = FRAMESIZE_QVGA;
config.jpeg_quality = 10;
config.fb_count = 3;
config.fb_location = CAMERA_FB_IN_PSRAM;
} else {
config.frame_size = FRAMESIZE_QVGA;
config.jpeg_quality = 12;
config.fb_count = 1;
config.fb_location = CAMERA_FB_IN_DRAM;
}
- Initializarea camerei
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) {
Serial.printf("Camera init failed with error 0x%x", err);
return;
}
- Conectarea la WI-FI
WiFi.begin(ssid, password); WiFi.setSleep(false);
Serial.print("WiFi connecting");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
-Citire seriala
if (mySerial.available()) {
Serial.write(mySerial.read());
}
if (Serial.available()) {
mySerial.write(Serial.read());
}
-Calcularea distantei
current_distance_cm = duration == 0 ? -1 : duration * 0.0343 / 2;
if (duration == 0) {
Serial.println("Out of range or no object detected.");
} else {
Serial.print("Distance: ");
Serial.print(current_distance_cm);
Serial.println(" cm");
}
Algoritim ARDUINO
-Declare motors
AF_DCMotor motor1(1); AF_DCMotor motor2(2); AF_DCMotor motor3(3); AF_DCMotor motor4(4);
-Functia Setup
void setup() {
Serial.begin(9600);
Serial.println("Enter command: W/A/S/D");
motor1.setSpeed(200);
motor2.setSpeed(200);
motor3.setSpeed(200);
motor4.setSpeed(200);
stopAllMotors();
}
- Functii de control
void moveForward() {
Serial.println("Moving forward");
motor1.run(FORWARD);
motor2.run(FORWARD);
motor3.run(FORWARD);
motor4.run(FORWARD);
}
void moveBackward() {
Serial.println("Moving backward");
motor1.run(BACKWARD);
motor2.run(BACKWARD);
motor3.run(BACKWARD);
motor4.run(BACKWARD);
}
void turnLeft() {
Serial.println("Turning left");
motor1.run(BACKWARD);
motor2.run(BACKWARD);
motor3.run(FORWARD);
motor4.run(FORWARD);
}
void turnRight() {
Serial.println("Turning right");
motor1.run(FORWARD);
motor2.run(FORWARD);
motor3.run(BACKWARD);
motor4.run(BACKWARD);
}
void stopAllMotors() {
motor1.run(RELEASE);
motor2.run(RELEASE);
motor3.run(RELEASE);
motor4.run(RELEASE);
}
-Loop function
void loop() {
if (Serial.available()) {
char command = Serial.read();
lastCommandTime = millis(); // Reset timeout timer on input
switch (command) {
case 'W':
case 'w':
moveForward();
break;
case 'S':
case 's':
moveBackward();
break;
case 'A':
case 'a':
turnLeft();
break;
case 'D':
case 'd':
turnRight();
break;
default:
stopAllMotors();
break;
}
}
// Stop motors if no command received recently
if (millis() - lastCommandTime > timeout) {
stopAllMotors();
}
}
Surse și funcții implementate
- Fișierul CameraWebServer.ino: Conține logica principală a aplicației, inclusiv inițializarea camerei și serverului web.
- Fișierul app_httpd.cpp: Probabil gestionează cererile HTTP și răspunsurile serverului.
- Fișierul control.html: Conține interfața web pentru controlul camerei.
- Fișierele camera_index.h și camera_pins.h: Definiții pentru pinii hardware și indexul camerei.
- Fișierul globals.h: Variabile globale utilizate în proiect.
- Fișierul partitions.csv: Configurația partițiilor pentru ESP32.
Conectarea prin serial la Arduino UNO pentru controlul motoarelor
- ESP32-CAM este conectat la Arduino Uno prin intermediul pinii de comunicație serială software (SoftwareSerial).
- Pinii 14 (RX) și 15 (TX) de pe ESP32-CAM sunt utilizați pentru recepționarea și transmiterea datelor către Arduino Uno.
Rolul comunicării seriale
- Transmiterea mesajelor de stare:
- ESP32-CAM trimite mesaje prin portul serial (Serial2) către Arduino Uno pentru a indica starea motorului (ex. “Moving Forward”, “Moving Backward”, “Motors Stopped”).
- Aceste mesaje pot fi utilizate de Arduino Uno pentru monitorizare sau pentru a efectua alte acțiuni în funcție de starea motorului.
- Recepționarea comenzilor:
- ESP32-CAM poate fi configurat să primească comenzi de la Arduino Uno prin portul serial (Serial2), deși acest aspect nu este implementat în codul actual.
Rezultate Obţinute
Download
