Objekte mit der ESP32-CAM erkennen

Die ESP32-CAM ist ein leistungsstarker, kostengünstiger Mikrocontroller mit integriertem Kameramodul, das Bilder aufnehmen und Live-Videos streamen. Durch die Nutzung seiner Verarbeitungsfunktionen und die Integration externer Bibliotheken oder Frameworks können Sie die Objekterkennung direkt auf der ESP32-CAM aktivieren. In diesem Tutorial werden Sie durch die Einrichtung der grundlegenden Objekterkennung mit der ESP32-CAM mithilfe von vorgebildeten Modellen geführt.

Was Sie brauchen werden

ESP32-CAM-Modul
FTDI-Programmierer (USB-to-Serial-Adapter)
Jumperdrähte
Breadboard (optional)
Ein Computer mit der Arduino -IDE installiert
Randimpuls oder Tensorflow lite für Objekterkennungsmodelle

Schritt 1: Einrichten der Arduino -IDE

1. Installieren Sie das ESP32 -Boardpaket

Öffnen Sie die Arduino -IDE.
Gehen zu Datei > Vorlieben.

Fügen Sie im Feld "URLS des Board Managers" hinzu:

https://dl.espressif.com/dl/package_esp32_index.json

Klicken OK.
Gehen zu Werkzeuge > Planke > Boards Manager.
Suchen Sie nach "ESP32" und installieren Sie das Paket mit Espresssif -Systemen.

2. Installieren Sie die erforderlichen Bibliotheken

Installieren Sie die Bibliothek "ESP32 Camera".
Installieren Sie für Objekterkennungsmodelle "TensorFlow Lite Micro" (oder ähnliche Bibliotheken).

Schritt 2: Verkabelung der ESP32-CAM

ESP32-CAM-PIN	FTDI -Programmierer Pin
GND	GND
5v	VCC (5V)
U0r	Tx
U0T	Rx
GND	GND (IO0 bis GND zum Blinken)

Wichtig: Schließen Sie den IO0-Pin an GND an, um die ESP32-CAM in den Flash-Modus zu setzen.

Schritt 3: Hochladen einer grundlegenden Skizze zur Objekterkennung

1. Wählen Sie die Karte und den Port aus

Gehen zu Werkzeuge > Planke und auswählen Ai-Thecher ESP32-CAM.
Unter WerkzeugeWählen Sie die richtige aus Com Port Für Ihren FTDI -Programmierer.

2. Vorbereiten des Code

Verwenden Sie ein grundlegendes Beispiel, um ein vorgebildetes Objekterkennungsmodell (z. B. TensorFlow Lite-Modell) zu laden. Unten finden Sie ein Beispielausschnitt zur Integration der Objekterkennung:

#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. Laden Sie den Code hoch hoch

Drücken Sie die Zurücksetzen Taste auf der ESP32-CAM, während IO0 mit GND verbunden ist.
Klicken Hochladen In der Arduino -Ide.
Sobald der Upload abgeschlossen ist, trennen Sie IO0 von GND und drücken Sie die Zurücksetzen Button wieder.

Schritt 4: Zugriff auf die Ergebnisse der Objekterkennung

Öffnen Sie den Serienmonitor (Werkzeuge > Serienmonitor) und den Baudrate auf festlegen 115200.
Zeigen Sie erkannte Objekte und ihre Vertrauenswerte im Seriennachmonitor.
Sie können dies erweitern, indem Sie Ergebnisse in einer Webschnittstelle mit HTML oder in IoT -Plattformen wie MQTT integrieren.

Schritt 5: Verbesserung der Objekterkennung

Modelloptimierung: Verwenden Sie Edge Impulse oder TensorFlow Lite, um benutzerdefinierte Modelle zu trainieren, die für die ESP32-CAM optimiert sind.
Webschnittstelle: Verbessern Sie das Projekt, indem Sie die erkannten Objekte direkt in einer Browserschnittstelle anzeigen.
IoT -Integration: Senden Sie Erkennungsergebnisse an Cloud -Dienste für weitere Verarbeitung oder Warnsysteme.

Fehlerbehebung

Modell zu groß: Stellen Sie sicher, dass die Modellgröße in den Speicher der ESP32-CAM passt.
Kamera nicht erkannt: Überprüfen Sie die Verkabelung und stellen Sie sicher, dass die Kamera sicher angeschlossen ist.
Geringe Genauigkeit: Trainieren oder fein das Modell mit relevanteren Daten.

Anwendungen der Objekterkennung mit ESP32-CAM

Überwachungskameras mit Bewegung oder Objekterkennung
Smart Home Automation (z. B. Erkennung von Lieferungen oder Haustieren)
Industrieüberwachungs- und Zählsysteme
Wildtierüberwachung und Forschung

Abschluss

Sie haben erfolgreich eine grundlegende Objekterkennung mit der ESP32-CAM eingerichtet. Dieses leistungsstarke Modul, kombiniert mit Modellen für maschinelles Lernen, eröffnet endlose Möglichkeiten für reale Anwendungen. Experimentieren Sie mit verschiedenen Modellen, verbessern Sie die Genauigkeit und erweitern Sie die Funktionalität, die Ihren Projektanforderungen entspricht!