Comment utiliser ESP32-CAM pour créer un système de reconnaissance faciale

Il existe de nombreux systèmes de reconnaissance de personnes qui utilisent les signatures, les empreintes digitales, la voix, la géométrie de la main, la reconnaissance faciale, etc. pour identifier les personnes, mais il n’existe pas de systèmes de reconnaissance faciale.

Les systèmes de reconnaissance faciale peuvent être utilisés non seulement à des fins de sécurité pour identifier les personnes dans les lieux publics, mais également à des fins de présence dans les bureaux et les écoles.

Dans ce projet, nous allons construire un système de reconnaissance faciale utilisant ESP32-CAM, qui peut également être utilisé comme système de sécurité ESP32-CAM en reconnaissant le visage d'une personne non autorisée. L'ESP32-CAM est un très petit module de caméra qui utilise la puce ESP32-S. En utilisant le module ESP32-CAM, nous pouvons construire un système de reconnaissance faciale sans utiliser de programmation complexe ni de composants supplémentaires.

Le module ESP32-CAM d'AI-Thinker est doté d'une puce ESP32-S, d'une caméra OV2640 ultra-compacte et d'un emplacement pour carte micro SD. L'emplacement pour carte Micro SD peut être utilisé pour stocker des images prises à partir de la caméra ou pour stocker des fichiers. Le module ESP32-CAM peut être utilisé dans une large gamme d'applications IoT. Il peut être utilisé comme système de détection de visage dans les bureaux, les écoles et autres espaces privés, ainsi que pour la surveillance sans fil, la reconnaissance sans fil de codes QR et de nombreuses autres applications IoT.

Les modules ESP32-CAM peuvent être programmés à l'aide de l'ESP-IDF ou de l'IDE Arduino. Le module ESP32-CAM dispose également de plusieurs broches GPIO pour la connexion à du matériel externe. L'ESP32-CAM n'a pas de connecteur USB, donc pour programmer le module, vous avez besoin d'une carte FTDI.

Caractéristiques:

Le plus petit module SoC Wi-Fi BT 802.11b/g/n

Processeur 32 bits à faible consommation pouvant également servir de processeur d'application

Vitesse d'horloge jusqu'à 160 MHz, puissance de calcul intégrée jusqu'à 600 DMIPS

SRAM intégrée de 520 Ko, RAM externe de 4 MPS

Prise en charge UART/SPI/I2C/PWM/ADC/DAC

Prend en charge les appareils photo OV2640 et OV7670 avec flash intégré

Prise en charge du téléchargement d'images via Wi-Fi

Prise en charge de la carte TF

Prend en charge plusieurs modes de veille

Lwip et FreeRTOS intégrés

Prise en charge du mode de fonctionnement STA/AP/STA+AP

La technologie Smart Config/AirKiss est prise en charge

Prise en charge des mises à niveau du micrologiciel locales et distantes via les ports série (FOTA)

Caractéristiques:

Flash SPI : la valeur par défaut est 32 Mbit

Mémoire : 520 Ko SRAM + 4 Mo PSRAM

Prise en charge de la carte TF : Max. 4G

Interfaces prises en charge : UART, SPI, I2C, PWM

Format de sortie d'image : JPEG, BMP, niveaux de gris

Port d'E/S : 9

Plage d'alimentation : 5 V

Composant requis

ESP32-CAM

Programmeur FTDI

Schéma de principe du circuit

Pour construire la caméra de sécurité ESP32 CAM, nous avons uniquement besoin du module de caméra ESP32 et du programmeur FTDI pour la programmer.

L'ESP32-CAM n'a pas de connecteur USB, vous avez donc besoin d'un programmateur FTDI pour télécharger le code sur l'ESP32-CAM, comme indiqué dans l'image ci-dessus. Les broches Vcc et GND de l'ESP32 sont connectées aux broches Vcc et GND de la carte FTDI. Les Tx et Rx de l'ESP32 sont connectés aux Rx et Tx de la carte FTDI.

Remarque : reliez l'IO0 à la terre avant de télécharger le code. L'IO0 détermine si l'ESP32 est en mode clignotant. Lorsque GPIO 0 est connecté à GND, l'ESP32 est en mode clignotant.

Après avoir programmé l'ESP32, j'ai retiré la carte FTDI et connecté le module à une alimentation 3,3 V à l'aide du régulateur 7805. Les paramètres du flux vidéo de la caméra ESP32 sont les suivants :

Installer la carte ESP32 sur l'IDE Arduino

Ici, l'ESP32-CAM est programmé à l'aide de l'IDE Arduino. Pour cela, nous devons installer le plug-in ESP32 sur l'IDE Arduino.

Pour installer la carte ESP32 dans votre IDE Arduino, accédez à Fichier Préférences

Copiez maintenant le lien suivant et collez-le dans le champ « URL supplémentaires du gestionnaire de forums », comme indiqué ci-dessous. Cliquez ensuite sur le bouton OK :

Passons maintenant au Conseil des outils, le gestionnaire du conseil

Recherchez ESP32 dans Board Manager et installez « ESP32 by Espressif Systems ».

Code du serveur Web de la caméra ESP32

Nous disposons déjà d'un exemple de code issu du streaming vidéo et de la reconnaissance faciale de la caméra ESP32. Ouvrez l'exemple ESP32 à l'aide de la commande "Fichier" Exemples "ESP32" Caméra, puis ouvrez l'exemple CameraWebServer.

Avant de télécharger le code, vous devrez saisir votre nom et votre mot de passe Wi-Fi.

const char* ssid = "nom WiFi";

const char* Password = "Mot de passe";

Définissez ensuite le module de caméra ESP. Dans le code, ils définissent 5 modules de caméra, donc décommentez « CAMERA_MODEL_AI_THINKER » et commentez les modules restants.

Le code est maintenant prêt à être téléchargé.

Pour télécharger le code, connectez la carte FDTI à votre ordinateur portable et sélectionnez « ESP32 Wrover Module » comme carte. Modifiez également d'autres paramètres en fonction de cette image :

Avant de télécharger le code, appuyez sur le bouton de réinitialisation ESP32, puis cliquez sur le bouton Télécharger.

Remarque : si vous rencontrez une erreur lors du téléchargement du code, vérifiez que IO0 est connecté à GND et que vous avez sélectionné le bon paramètre dans le menu Outils.

Déconnectez les broches IO0 et GND après avoir téléchargé le code. Ouvrez ensuite le moniteur série et modifiez le débit en bauds sur 115 200. Appuyez ensuite sur le bouton de réinitialisation de l'ESP32 et l'adresse IP et le numéro de port de l'ESP s'imprimeront sur le moniteur série comme indiqué ci-dessous.

Pour accéder au flux de la caméra, accédez à votre navigateur et saisissez votre adresse IP ESP. Cela vous amènera à la page de diffusion multimédia. Pour démarrer un flux vidéo de caméra ESP32, cliquez sur le bouton « Démarrer la diffusion » en bas de la page

Vous pouvez modifier la qualité du streaming en modifiant la « résolution » sur la page de streaming. Vous pouvez également cliquer sur l'image en cliquant sur le bouton « Get Still », mais ce code n'a pas l'option permettant d'enregistrer l'image.

Après avoir testé le flux vidéo, nous allons maintenant tester la fonction de détection et de reconnaissance faciale de la caméra ESP32. Activez la reconnaissance et la détection faciales dans les paramètres :

Pour effectuer la reconnaissance faciale, vous devez d'abord enregistrer votre visage. Vous pouvez enregistrer de nouveaux visages en cliquant sur l'option « Enregistrer les visages ». Il faut plusieurs tentatives pour enregistrer le visage. Après avoir enregistré le visage, il détectera le visage comme sujet 0, qui peut maintenant être utilisé comme système de sécurité en reconnaissant le visage.

Voici comment le module de caméra ESP peut être facilement configuré pour le streaming vidéo et la reconnaissance faciale.

#include « esp_camera.h »

#include

// Attention !! Assurez-vous de sélectionner le module ESP32 Wrover,

// ou une autre carte avec PSRAM activée

// Sélectionnez un modèle d'appareil photo

//#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

#include « camera_pins.h »

const char* ssid = "Galaxy-M20 ";

const char* Mot de passe = "ac312124";

startCameraServer(non valide) ;

Paramètres non valides () {

Numéro de série. Début (115200);

Série.setDebugOutput(true);

Numéro de série.println() ;

configuration de la caméra_config_t ;

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 = RÉINITIALISER_NUMÉRO_GPIO;

config.xclk_freq_hz = 20000000;

config.pixel_format = PIXFORMAT_JPEG;

// Initialiser avec des spécifications élevées pour pré-allouer des tampons plus grands

Si (psramFound()) {

config.frame_size = FRAMESIZE_UXGA;

config.jpeg_quality = 10;

config.fb_count = 2;

} autre {

config.frame_size = TAILLE DU CADRE_SVGA;

config.jpeg_quality = 12;

config.fb_count = 1;

}

# Si défini (CAMERA_MODEL_ESP_EYE)

pinMode (13, INPUT_PULLUP);

pinMode(14, INPUT_PULLUP);

# au cas où

// Initialisation de la caméra

esp_err_t err = esp_camera_init(&config);

Si (faux ! = ESP_OK) {

Serial.printf(" L'initialisation de la caméra a échoué, erreur 0x%x", err);

Dos;

}

capteur_t * s = esp_camera_sensor_get();

// Le capteur initial est inversé verticalement et la couleur est un peu saturée

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

s->set_vflip(s, 1); // Retournez-le

s->set_brightness(s, 1); // Augmente légèrement la luminosité

s->set_saturation(s, -2); // Réduire la saturation

}

// Réduisez la taille de l'image pour obtenir une fréquence d'images initiale plus élevée

s->set_framesize(s, TAILLE_CADRE_QVGA);

# Si défini (CAMERA_MODEL_M5STACK_WIDE)

s->set_vflip(s, 1);

s->set_hmirror(s, 1);

# au cas où

WiFi.begin(ssid, mot de passe);

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

Retard (500);

Série.print(".");

}

Numéro de série.println ("");

Serial.println("Connexion WiFi ");

démarrer le serveur de caméra();

Serial.print(" Appareil photo prêt ! Utilisez 'http://");

Série.print(WiFi.localIP());

Serial.println("' pour se connecter ");

}

Boucle invalide () {

// Placez votre code principal ici et répétez :

Retard (10000);