Rilevare oggetti con ESP32-CAM

ESP32-CAM è un potente microcontrollore a basso costo con un modulo di telecamera incorporato, in grado di catturare immagini e streaming di video in diretta. Sfruttando le sue capacità di elaborazione e integrando librerie o framework di apprendimento automatico esterno, è possibile abilitare il rilevamento di oggetti direttamente sull'ESP32-CAM. Questo tutorial ti guiderà attraverso l'impostazione del rilevamento di oggetti di base con ESP32-CAM utilizzando modelli pre-addestrati.

Cosa avrai bisogno

Modulo ESP32-CAM
Programmatore FTDI (adattatore da USB-SERIAL)
Fili jumper
Breadboard (opzionale)
Un computer con l'IDE Arduino installato
Bordo impulso o tensorflow lite per modelli di rilevamento degli oggetti

Passaggio 1: impostare l'IDE Arduino

1. Installa il pacchetto della scheda ESP32

Apri l'IDE Arduino.
Vai a File > Preferenze.
Nel campo "URLS ALTRIBILE DEL GESTORE DEL CONSIGLIO ALLE
```
https://dl.espressif.com/dl/package_esp32_index.json
```
Clic OK.
Vai a Utensili > Asse > Manager del consiglio di amministrazione.
Cerca "ESP32" e installa il pacchetto tramite i sistemi espressif.

2. Installa le librerie richieste

Installa la libreria "ESP32 Camera".
Per i modelli di rilevamento di oggetti, installare "Tensorflow Lite Micro" (o librerie simili).

Passaggio 2: cablaggio dell'ESP32-CAM

PIN ESP32-CAM	Pin del programmatore FTDI
GND	GND
5v	VCC (5V)
U0r	TX
U0t	Rx
GND	GND (IO0 a GND per lampeggiare)

Importante: Collega il pin IO0 a GND per mettere in modalità Flash ESP32-CAM.

Passaggio 3: caricamento di uno schizzo di rilevamento di oggetti di base

1. Seleziona la scheda e la porta

Vai a Utensili > Asse e seleziona Ai-Phinker ESP32-CAM.
Sotto Utensili, seleziona il corretto Com Port Per il tuo programmatore FTDI.

2. Preparazione del codice

Utilizzare un esempio di base per caricare un modello di rilevamento degli oggetti pre-addestrati (ad es. Modello Lite Tensorflow). Di seguito è riportato uno snippet di esempio per integrare il rilevamento degli oggetti:

#include <esp_camera.h>
#include <TensorFlowLite_ESP32.h>

// Replace with your specific model and labels
#include "model.h"
#include "labels.h"

void setup() {
  Serial.begin(115200);

  // Initialize the camera
  camera_config_t config;
  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 = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;

  if (!esp_camera_init(&config)) {
    Serial.println("Camera initialized successfully!");
  } else {
    Serial.println("Camera initialization failed!");
    while (1);
  }

  // Load the TensorFlow Lite model
  TfLiteStatus model_status = tflite::InitModel(model);
  if (model_status != kTfLiteOk) {
    Serial.println("Failed to initialize the model");
    while (1);
  }
}

void loop() {
  // Capture a frame
  camera_fb_t *frame = esp_camera_fb_get();
  if (!frame) {
    Serial.println("Camera capture failed");
    return;
  }

  // Run object detection
  tflite::RunInference(frame->buf, frame->len);

  // Display detected objects
  for (int i = 0; i < NUM_CLASSES; i++) {
    float confidence = tflite::GetConfidence(i);
    if (confidence > 0.5) {
      Serial.print("Detected: ");
      Serial.print(labels[i]);
      Serial.print(" with confidence: ");
      Serial.println(confidence);
    }
  }

  esp_camera_fb_return(frame); // Free the frame buffer
  delay(200);
}

3. Carica il codice

Premere il Reset Pulsante su ESP32-CAM mentre IO0 è collegato a GND.
Clic Caricamento Nell'IDE Arduino.
Una volta completato il caricamento, disconnettere IO0 da GND e premere il Reset pulsante di nuovo.

Passaggio 4: accedere ai risultati del rilevamento degli oggetti

Apri il monitor seriale (Utensili > Monitor seriale) e impostare il tasso di baud su 115200.
Visualizza gli oggetti rilevati e i loro punteggi di fiducia nel monitor seriale.
È possibile espanderlo visualizzando i risultati in un'interfaccia Web utilizzando HTML o integrando con piattaforme IoT come MQTT.

Passaggio 5: miglioramento del rilevamento degli oggetti

Ottimizzazione del modello: Utilizzare EDGE Impulse o Tensorflow Lite per addestrare modelli personalizzati ottimizzati per ESP32-CAM.
Interfaccia web: Migliora il progetto visualizzando gli oggetti rilevati direttamente in un'interfaccia del browser.
Integrazione IoT: Invia risultati di rilevamento ai servizi cloud per ulteriori sistemi di elaborazione o di avviso.

Risoluzione dei problemi

Modello troppo grande: Assicurarsi che la dimensione del modello si adatti alla memoria di ESP32-CAM.
Fotocamera non rilevata: Verificare il cablaggio e assicurarsi che la fotocamera sia collegata in modo sicuro.
Bassa precisione: Allenare o perfezionare il modello con dati più rilevanti.

Applicazioni di rilevamento degli oggetti con ESP32-CAM

Telecamere di sicurezza con moto o rilevamento di oggetti
Automazione della casa intelligente (ad es. Rilevamento di consegne o animali domestici)
Sistemi di monitoraggio e conteggio industriali
Monitoraggio e ricerca della fauna selvatica

Conclusione

Hai impostato correttamente il rilevamento di oggetti di base con ESP32-CAM. Questo potente modulo, combinato con modelli di apprendimento automatico, apre infiniti possibilità per applicazioni del mondo reale. Sperimenta diversi modelli, migliora la precisione ed espandi la funzionalità per soddisfare le esigenze del progetto!