So verwenden Sie ESP32-CAM zum Erstellen eines Gesichtserkennungssystems

Es gibt viele Personenerkennungssysteme, die Unterschriften, Fingerabdrücke, Stimme, Handgeometrie, Gesichtserkennung usw. verwenden, um Personen zu identifizieren, aber es gibt keine Gesichtserkennungssysteme.

Gesichtserkennungssysteme können nicht nur zu Sicherheitszwecken zur Identifizierung von Personen an öffentlichen Orten, sondern auch zur Anwesenheitskontrolle in Büros und Schulen eingesetzt werden.

In diesem Projekt werden wir ein Gesichtserkennungssystem mit ESP32-CAM bauen, das auch als ESP32-CAM-Sicherheitssystem verwendet werden kann, indem es das Gesicht einer nicht autorisierten Person erkennt. ESP32-CAM ist ein sehr kleines Kameramodul, das den ESP32-S-Chip verwendet. Mit dem ESP32-CAM-Modul können wir ein Gesichtserkennungssystem ohne komplexe Programmierung und zusätzliche Komponenten bauen.

Das AI-Thinker ESP32-CAM-Modul verfügt über einen ESP32-S-Chip, eine ultrakleine OV2640-Kamera und einen Micro-SD-Kartensteckplatz. Der Micro-SD-Kartensteckplatz kann zum Speichern von mit der Kamera aufgenommenen Bildern oder zum Speichern von Dateien verwendet werden. Das ESP32-CAM-Modul kann in einer Vielzahl von IoT-Anwendungen eingesetzt werden. Es kann als Gesichtserkennungssystem in Büros, Schulen und anderen privaten Bereichen sowie für die drahtlose Überwachung, die drahtlose QR-Code-Erkennung und viele andere IoT-Anwendungen verwendet werden.

ESP32-CAM-Module können mit ESP-IDF oder der Arduino IDE programmiert werden. Das ESP32-CAM-Modul verfügt außerdem über mehrere GPIO-Pins zum Anschluss an externe Hardware. Das ESP32-CAM hat keinen USB-Anschluss, daher benötigen Sie zum Programmieren des Moduls eine FTDI-Platine.

Merkmale:

Das kleinste 802.11b/g/n Wi-Fi BT SoC-Modul

32-Bit-CPU mit geringem Stromverbrauch, die auch Anwendungsprozessoren bedienen kann

Bis zu 160MHz Taktfrequenz, integrierte Rechenleistung bis zu 600 DMIPS

Eingebautes 520 KB SRAM, externes 4MPSRAM

Unterstützt UART/SPI/I2C/PWM/ADC/DAC

Unterstützt OV2640- und OV7670-Kameras mit integriertem Blitz

Unterstützt das Hochladen von Bildern über WLAN

TF-Kartenunterstützung

Unterstützt mehrere Schlafmodi

Eingebettetes Lwip und FreeRTOS

Unterstützt den STA/AP/STA+AP-Betriebsmodus

Smart Config/AirKiss-Technologie wird unterstützt

Unterstützung für lokale und Remote-Firmware-Upgrades über serielle Schnittstellen (FOTA)

Spezifikationen:

SPI-Flash: Der Standardwert ist 32 Mbit

Speicher: 520 KB SRAM + 4 MB PSRAM

TF-Kartenunterstützung: Max. 4G

Unterstützte Schnittstellen: UART, SPI, I2C, PWM

Bildausgabeformat: JPEG, BMP, Graustufen

IO-Anschluss: 9

Stromversorgungsbereich: 5V

Erforderliche Komponente

ESP32-CAM

FTDI-Programmierer

Schaltplan

Um die ESP32 CAM-Überwachungskamera zu bauen, benötigen wir nur das ESP32-Kameramodul und den FTDI-Programmierer, um sie zu programmieren.

Das ESP32-CAM hat keinen USB-Anschluss, daher benötigen Sie einen FTDI-Programmierer, um Code auf das ESP32-CAM hochzuladen, wie im Bild oben gezeigt. Die Vcc- und GND-Pins des ESP32 sind mit den Vcc- und GND-Pins der FTDI-Platine verbunden. Die Tx- und Rx-Pins des ESP32 sind mit den Rx- und Tx-Pins der FTDI-Platine verbunden.

Hinweis: Erden Sie IO0, bevor Sie den Code hochladen. IO0 bestimmt, ob sich der ESP32 im Blinkmodus befindet. Wenn GPIO 0 mit GND verbunden ist, befindet sich der ESP32 im Blinkmodus.

Nachdem ich den ESP32 programmiert hatte, entfernte ich die FTDI-Platine und schloss das Modul mithilfe des 7805-Reglers an eine 3,3-V-Stromversorgung an. Die Einstellungen für den ESP32-Cam-Videostream sind wie folgt:

Installieren Sie das ESP32-Board auf der Arduino IDE

Hier wird die ESP32-CAM mithilfe der Arduino IDE programmiert. Dazu müssen wir das ESP32 Plugin auf der Arduino IDE installieren.

Um das ESP32-Board in Ihrer Arduino IDE zu installieren, gehen Sie zu Dateieinstellungen

Kopieren Sie nun den folgenden Link und fügen Sie ihn in das Feld „Weitere Board Manager-URLs“ ein, wie unten gezeigt. Klicken Sie dann auf die Schaltfläche „OK“:

Nun zum Board of Tools, dem Board Manager

Suchen Sie im Board Manager nach ESP32 und installieren Sie „ESP32 von Espressif Systems“.

ESP32-Kamera-Webservercode

Wir haben bereits einen Beispielcode für ESP32-Cam-Videostreaming und Gesichtserkennung. Öffnen Sie das ESP32-Beispiel über „Datei“ Beispiele „ESP32“ Kamera und öffnen Sie dann das Beispiel CameraWebServer.

Bevor Sie den Code hochladen, müssen Sie Ihren WLAN-Namen und Ihr Passwort eingeben.

const char* ssid = "WiFi-Name";

const char* Password = "Passwort";

Definieren Sie dann das ESP-Kameramodul. Im Code werden 5 Kameramodule definiert. Entfernen Sie daher die Kommentarzeichen von „CAMERA_MODEL_AI_THINKER“ und kommentieren Sie die verbleibenden Module aus.

Jetzt ist der Code zum Hochladen bereit.

Um den Code hochzuladen, schließen Sie die FDTI-Platine an Ihren Laptop an und wählen Sie „ESP32 Wrover Module“ als Ihre Platine aus. Ändern Sie auch andere Einstellungen basierend auf diesem Bild:

Drücken Sie vor dem Hochladen des Codes die ESP32-Reset-Taste und klicken Sie dann auf die Schaltfläche „Hochladen“.

Hinweis: Sollte beim Hochladen des Codes ein Fehler auftreten, überprüfen Sie, ob IO0 mit GND verbunden ist und ob Sie im Menü „Tools“ die richtige Einstellung gewählt haben.

Trennen Sie die IO0- und GND-Pins, nachdem Sie den Code hochgeladen haben. Öffnen Sie dann den seriellen Monitor und ändern Sie die Baudrate auf 115200. Drücken Sie dann die ESP32-Reset-Taste und die ESP-IP-Adresse und Portnummer werden auf dem seriellen Monitor ausgedruckt, wie unten gezeigt.

Um nun auf den Kamera-Stream zuzugreifen, navigieren Sie zu Ihrem Browser und geben Sie Ihre ESP-IP-Adresse ein. Sie gelangen dann zur Streaming-Media-Seite. Um einen ESP32-Cam-Videostream zu starten, klicken Sie unten auf der Seite auf die Schaltfläche „Streaming starten“

Sie können die Streaming-Qualität ändern, indem Sie die „Auflösung“ auf der Streaming-Seite ändern. Sie können das Bild auch anklicken, indem Sie auf die Schaltfläche „Standbild abrufen“ klicken, aber dieser Code bietet nicht die Möglichkeit, das Bild zu speichern.

Nachdem wir den Videostream getestet haben, testen wir nun die Gesichtserkennungs- und Erkennungsfunktion der ESP32-Kamera. Aktivieren Sie die Gesichtserkennung und -erkennung in den Einstellungen:

Um die Gesichtserkennung durchzuführen, müssen Sie zunächst Ihr Gesicht registrieren. Sie können neue Gesichter registrieren, indem Sie auf die Option „Gesichter registrieren“ klicken. Es sind mehrere Versuche erforderlich, um das Gesicht zu speichern. Nach dem Speichern des Gesichts wird das Gesicht als Subjekt 0 erkannt, das nun durch die Gesichtserkennung als Sicherheitssystem verwendet werden kann.

So lässt sich das ESP-Kameramodul ganz einfach für Videostreaming und Gesichtserkennung konfigurieren.

# „esp_camera.h“ einbinden

#einschließen

// Achtung!! Stellen Sie sicher, dass Sie das ESP32 Wrover-Modul auswählen,

// oder eine andere Karte mit aktiviertem PSRAM

// Wählen Sie ein Kameramodell

//#define CAMERA_MODEL_WROVER_KIT

//#define CAMERA_MODEL_ESP_EYE

//#define CAMERA_MODEL_M5STACK_PSRAM

//#define CAMERA_MODEL_M5STACK_WIDE

#define CAMERA_MODEL_AI_THINKER

# „camera_pins.h“ einbinden

const char*ssid = "Galaxy-M20";

const char* Passwort = "ac312124";

Ungültiger startCameraServer();

Ungültige Einstellungen () {

Seriennummer. Start (115200);

Serial.setDebugOutput(true);

Seriennummer.println();

camera_config_t-Konfiguration;

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;

pin_href = HREF_GPIO_NUM; config.pin_href = href_gPIo_num;

pin_sscb_sda = SIOD_GPIO_NUM;

pin_sscb_scl = SIOC_GPIO_NUM;

config.pin_pwdn = PWDN_GPIO_NUM;

Pin_Reset = GPIO_NUM_ZURÜCKSETZEN;

config.xclk_freq_hz = 20000000;

config.pixel_format = PIXFORMAT_JPEG;

// Mit hohen Spezifikationen initialisieren, um größere Puffer vorab zuzuweisen

Wenn (psramFound ()) {

config.frame_size = FRAMESIZE_UXGA;

config.jpeg_qualität = 10;

config.fb_count = 2;

} andere {

config.frame_size = FRAMESIZE_SVGA;

config.jpeg_qualität = 12;

config.fb_count = 1;

}

# Falls definiert (CAMERA_MODEL_ESP_EYE)

PinMode (13, INPUT_PULLUP);

pinMode(14, INPUT_PULLUP);

# im Koffer

// Kamerainitialisierung

esp_err_t err = esp_camera_init(&config);

Wenn (falsch! = ESP_OK) {

Serial.printf("Kamerainitialisierung fehlgeschlagen, Fehler 0x%x", err);

Zurück;

}

sensor_t * s = esp_camera_sensor_get();

// Der anfängliche Sensor ist vertikal umgedreht und die Farbe ist etwas gesättigt

wenn (s->id.PID == OV3660_PID) {

s->set_vflip(s, 1); // Dreh es zurück

s->set_brightness(s, 1); // Helligkeit leicht erhöhen

s->set_saturation(s, -2); // Reduziere die Sättigung

}

// Reduzieren Sie die Framegröße, um eine höhere anfängliche Framerate zu erhalten

s->set_framesize(s, FRAMESIZE_QVGA);

# Falls definiert (CAMERA_MODEL_M5STACK_WIDE)

s->set_vflip(s, 1);

s->set_hmirror(s, 1);

# im Koffer

WiFi.begin(ssid, Passwort);

Und (WiFi.status ()! = WL_CONNECTED) {

Verzögerung (500);

Serial.print(".");

}

Seriennummer.println ("");

Serial.println("WiFi-Verbindung ");

startCameraServer();

Serial.print("Kamera bereit! Verwenden Sie 'http://");

Serial.print(WiFi.localIP());

Serial.println("' zum Verbinden ");

}

Ungültige Schleife () {

// Fügen Sie hier Ihren Hauptcode ein und wiederholen Sie:

Verzögerung (10000);