Detectarea obiectelor cu ESP32-CAM

ESP32-CAM este un microcontroller puternic, low-cost, cu un modul de cameră încorporat, capabil să capteze imagini și să transmită un videoclip live. Utilizând capacitățile sale de procesare și integrarea bibliotecilor sau cadrelor externe de învățare automată, puteți activa detectarea obiectelor direct pe ESP32-CAM. Acest tutorial vă va ghida prin configurarea detectării de bază a obiectelor cu ESP32-CAM folosind modele pre-instruite.

Ce vei avea nevoie

Modul ESP32-CAM
Programator FTDI (adaptor USB-to-serial)
Fire de jumper
Panoul de pâine (opțional)
Un computer cu IDE Arduino instalat
Edge Impulse sau TensorFlow Lite pentru modelele de detectare a obiectelor

Pasul 1: Configurarea IDE Arduino

1. Instalați pachetul de bord ESP32

Deschideți IDE Arduino.
Du -te la Fişier > Preferințe.
În câmpul „URL -uri suplimentare de manager de bord”, adăugați:
```
https://dl.espressif.com/dl/package_esp32_index.json
```
Clic Bine.
Du -te la Instrumente > Bord > Manager de plăci.
Căutați „ESP32” și instalați pachetul de Espressif Systems.

2. Instalați bibliotecile necesare

Instalați biblioteca „Camera ESP32”.
Pentru modelele de detectare a obiectelor, instalați „TensorFlow Lite Micro” (sau biblioteci similare).

Pasul 2: Cablarea ESP32-CAM

Pin ESP32-CAM	Pinul programator FTDI
GND	GND
5V	VCC (5V)
U0R	TX
U0T	Rx
GND	GND (IO0 la GND pentru intermitent)

Important: Conectați pinul IO0 la GND pentru a pune ESP32-CAM în modul flash.

Pasul 3: Încărcarea unei schițe de bază de detectare a obiectelor de bază

1. Selectați placa și portul

Du -te la Instrumente > Bord și selectați AI-gânditor ESP32-CAM.
Sub Instrumente, selectați corect Port com Pentru programatorul dvs. FTDI.

2. Pregătirea codului

Utilizați un exemplu de bază pentru a încărca un model de detectare a obiectului pre-instruit (de exemplu, modelul Tensorflow Lite). Mai jos este un fragment de probă pentru a integra detectarea obiectelor:

#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. Încărcați codul

Apăsați Resetează Butonul de pe ESP32-CAM în timp ce IO0 este conectat la GND.
Clic Încărcați în IDE Arduino.
Odată ce încărcarea este completă, deconectați IO0 de la GND și apăsați Resetează din nou buton.

Pasul 4: Accesarea rezultatelor detectării obiectelor

Deschideți monitorul în serie (Instrumente > Monitor în serie) și setați rata de transfer la 115200.
Vizualizați obiectele detectate și scorurile lor de încredere în monitorul în serie.
Puteți extinde acest lucru prin afișarea rezultatelor într -o interfață web folosind HTML sau integrarea cu platforme IoT precum MQTT.

Pasul 5: Îmbunătățirea detectării obiectelor

Optimizarea modelului: Utilizați Edge Impulse sau TensorFlow Lite pentru a antrena modele personalizate optimizate pentru ESP32-CAM.
Interfață web: Îmbunătățiți proiectul prin afișarea obiectelor detectate direct într -o interfață a browserului.
Integrare IoT: Trimiteți rezultate de detectare către Cloud Services pentru procesare ulterioară sau de alertă.

Depanare

Model prea mare: Asigurați-vă că dimensiunea modelului se încadrează în memoria ESP32-CAM.
Camera nu este detectată: Verificați cablarea și asigurați -vă că camera este conectată în siguranță.
Precizie scăzută: Antrenați-vă sau reglați-vă modelul cu date mai relevante.

Aplicații ale detectării obiectelor cu ESP32-CAM

Camere de securitate cu mișcare sau detectare a obiectelor
Automatizarea inteligentă a casei (de exemplu, detectarea livrărilor sau a animalelor de companie)
Sisteme de monitorizare și numărare industrială
Monitorizarea și cercetarea faunei sălbatice

Concluzie

Ați configurat cu succes detectarea obiectelor de bază cu ESP32-CAM. Acest modul puternic, combinat cu modele de învățare automată, deschide posibilități interminabile pentru aplicațiile din lumea reală. Experimentați cu diferite modele, îmbunătățiți precizia și extindeți funcționalitatea pentru a se potrivi nevoilor proiectului dvs.!