De nos jours, la sécurité est tout au plus préoccupante pour quiconque, qu'il s'agisse de la sécurité des données ou de la sécurité de leur propre maison. Avec l'avancement de la technologie et de l'amélioration de l'IoT, les serrures de porte numériques sont devenues très courantes de nos jours. La serrure numérique ne nécessite aucune clé physique, mais elle utilise la RFID, l'empreinte digitale, l'identification du visage, la broche, les mots de passe, etc. pour contrôler le verrou de la porte. Par le passé, nous avons développé de nombreuses applications de  serrures de porte numériques  utilisant ces différentes technologies. Dans ce didacticiel,  .

Le module AI-Thinker ESP32-CAM est une carte de développement à faible coût avec une caméra OV2640 de très petite taille et un emplacement pour carte micro SD. Il dispose d'une puce ESP32 S avec connectivité Wi-Fi et Bluetooth intégrée, avec 2 processeurs LX6 32 bits haute performance, architecture de pipeline à 7 étages. Nous avons déjà expliqué  en détail ESP32-CAM  et nous avons utilisé pour construire une  sonnette vidéo de porte Wi-Fi  . Cette fois, nous utilisonsons l'ESP32-CAM pour créer un  système de verrouillage de porte basé sur la reconnaissance  faciale à l'aide d'un module de relais et d'un verrouillage de solénoïde.

Composants requis

  • ESP32 CAM
  • Conseil FTDI
  • Module de relais
  • Verrouillage solénoïde
  • Fils de cavalier

Verrouillage solénoïde

Une serrure électromagnétique fonctionne sur le mécanisme de verrouillage électronique-mécanique. Ce type de serrure a un ergot avec une coupe inclinée et un bon support de montage. Lorsque l’alimentation est appliquée, DC crée un champ magnétique qui déplace la limace à l’intérieur et la porte en position déverrouillée. La limace conservera sa position jusqu'à ce que l'alimentation soit coupée. Lorsque l'alimentation est coupée, la limace se déplace vers l'extérieur et verrouille la porte. Il n'utilise aucune alimentation dans un état verrouillé. Pour piloter le verrouillage solénoïde, vous auriez besoin d'une source d'alimentation pouvant fournir 12 V @ 500 mA. 

Serrure de porte solénoïde

Nous avons utilisé une serrure à solénoïde pour construire une  serrure de porte RFID basée sur Arduino  .

Schéma

Le schéma de circuit du  système de verrouillage de porte à reconnaissance faciale ESP32-CAM  est indiqué ci-dessous:

Schéma du circuit du système de verrouillage de porte à reconnaissance faciale ESP32-CAM

Le circuit ci-dessus combiné avec une carte FTDI, un module de relais et un verrouillage solénoïde. La carte FTDI est utilisée pour flasher le code dans ESP32-CAM car elle n'a pas de connecteur USB tandis que le module de relais est utilisé pour activer ou désactiver le verrouillage du solénoïde. Les broches VCC et GND de la carte FTDI et du module de relais sont connectées aux broches Vcc et GND de l'ESP32-CAM. TX et RX de la carte FTDI sont connectés à RX et TX de ESP32 et la broche IN du module de relais est connecté à IO4 de ESP32-CAM.

ESP32-CAM Conseil FTDI
5V VCC
GND GND
UOR TX
UOT RX
ESP32-CAM Module de relais
5V VCC
GND GND
IO4 DANS

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

Après avoir connecté le matériel selon le schéma de circuit, il devrait ressembler à quelque chose comme ci-dessous:

Système de verrouillage de porte à reconnaissance faciale ESP32-CAM

Installez la carte ESP32 sur Arduino IDE

Ici, Arduino IDE est utilisé pour le programmeur ESP32-CAM. Pour cela, installez d'abord l'add-on ESP32 sur Arduino IDE.

Pour installer la carte ESP32 dans votre IDE Arduino, allez dans  Fichier> Préférences.

Installez la carte ESP32 sur Arduino IDE

Copiez maintenant le lien ci-dessous et collez-le dans le champ "URL supplémentaires du gestionnaire de cartes" comme indiqué dans la figure ci-dessous. Ensuite, cliquez sur le bouton «OK»:

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

URL supplémentaire de Board Manager

Maintenant, allez dans  Outils> Tableau> Gestionnaire de tableaux

Programmation ESP32 Arduino IDE

Dans Board Manager, recherche ESP32 et installez «ESP32 by Espressif Systems».

ESP32 par Espressif Systems

Explication du code

Nous avons expliqué la  reconnaissance faciale avec ESP32  dans l'article précédent; ici, nous modifions le même code pour contrôler une serrure de porte à solénoïde. Le code complet est divisé en quatre parties. L'un est le code principal de la caméra et du module de relais où l'ESP32 verrouille ou déverrouille la porte en fonction de la reconnaissance faciale, et les trois autres codes concernent la page Web, l'index de la caméra et les broches de la caméra. Le code complet est donné à la fin de cette page. Nous expliquons ici certaines parties importantes du code.

Démarrez le programme en incluant tous les fichiers de la bibliothèque.


#include "esp_camera.h"
#comprendre 
#include "camera_pins.h"

Dans la ligne suivante, décommentez le module de caméra que vous utilisez avec ESP32. Dans le code, cinq modèles de caméras différentes sont présentes. Dans ce cas, nous utilisons le modèle AI-THINKER.


// # définir CAMERA_MODEL_WROVER_KIT
// # définir CAMERA_MODEL_ESP_EYE
// # définir CAMERA_MODEL_M5STACK_PSRAM
// # définir CAMERA_MODEL_M5STACK_WIDE
#define CAMERA_MODEL_AI_THINKER

Après cela, insérez vos informations d'identification réseau dans les variables suivantes:


const char * ssid = "Nom Wi-Fi";
const char * password = "Mot de passe Wi-Fi";

Définissez ensuite la broche sur laquelle le module de relais est connecté. Nous utilisonsons la fonction  millis ()  pour verrouiller la porte après l'avoir déverrouillée dans un intervalle de temps défini, ici c'est 5 secondes.


#define relais 4
long prevMillis = 0;
intervalle int = 5000;

Dans la fonction  setup ()  , initialisez le moniteur série à une vitesse de transmission de 115 200 à des fins de débogage. Ensuite, dans les lignes suivantes, définissez le mode de broche pour le module de relais et réglez également le relais à une position basse réglez.


void setup() {
  Serial.begin (115200);
  pinMode (relais, SORTIE);
  digitalWrite (relais, LOW);

Dans la fonction  loop ()  , vérifiez si le visage correspond au visage inscrit. Si oui, déverrouillez la porte pendant 5 secondes et après 5 secondes, verrouillez-la à nouveau.


boucle void () { 
    if (matchFace == true && activeRelay == false) {
      activeRelay = vrai;
      digitalWrite (relais, HAUT);
      prevMillis = millis ();
    }
    if (activeRelay == true && millis () - prevMillis> intervalle) {
      activeRelay = faux;
      matchFace = faux;
      digitalWrite (relais, LOW);
    }

Test du  système de verrouillage de porte à reconnaissance faciale ESP32-CAM

Enfin, pour télécharger le code, connectez la carte FDTI à votre ordinateur portable et sélectionnez le `` Module ESP32 Wrover '' comme carte. Modifiez également les autres paramètres comme indiqué dans l'image ci-dessous:

Module Wrover ESP32

N'oubliez pas de connecter la broche IO0 à GND avant de télécharger le code et de s'aider également sur le bouton de réinitialisation ESP32, puis cliquez sur le bouton de téléchargement.

Remarque:  si vous obtenez des erreurs lors du téléchargement du code, vérifiez que IO0 est connecté à GND et que vous avez sélectionné les bons paramètres dans le menu Outils.

Après avoir téléchargé le code, retirez les broches IO0 et GND. Ensuite, ouvrez le moniteur série et changez le débit en bauds à 115200. Après cela, appuyez sur le bouton de réinitialisation ESP32, il imprimera l'adresse IP ESP et le numéro de port. sur le moniteur série.

Adresse IP et numéro de port ESP32 sur le moniteur série

Naviguez maintenant vers le navigateur et entrez l'adresse IP ESP qui est copiée à partir du moniteur série pour accéder au streaming de la caméra. Cela vous mènera à la page de streaming. Pour démarrer la diffusion vidéo, cliquez sur le bouton «Démarrer le flux» en bas de la page.

ESP32 CAM pour le streaming vidéo

Pour reconnaître les visages avec ESP32-CAM, nous devons d'abord enregistrer les visages. Pour cela, activez les fonctions de reconnaissance et de détection de visage à partir des paramètres, puis cliquez sur le bouton Enroll Face. Il faut plusieurs tentatives pour sauver le visage. Après avoir enregistré le visage, il détecte le visage comme  sujet 0  où zéro est le numéro du visage.

Reconnaissance faciale avec ESP32 CAM

Après avoir enregistré les visages, si un visage est reconnu dans le flux vidéo, ESP32 rendra le module de relais haut pour déverrouiller la porte.

Reconnaissance faciale ESP32-CAM

C'est ainsi que l'ESP32-CAM peut être utilisé pour construire un  système de sécurité basé sur la reconnaissance faciale  . Le code complet peut être  téléchargé à partir de ce lien  et est également fourni ci-dessous avec une vidéo de démonstration. 

 
Code
 

Code

#include "esp_camera.h"
#include
//
// WARNING!!! Make sure that you have either selected ESP32 Wrover Module,
//            or another board which has PSRAM enabled
//
// Select camera model
//#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* password = "ac312124";
#define LED_BUILTIN 4
#define relay 4 
#define buzzer 2
boolean matchFace = false;
boolean activeRelay = false;
long prevMillis = 0;
int interval = 5000;
void startCameraServer();
void setup() {
  Serial.begin(115200);
  Serial.setDebugOutput(true);
  Serial.println();
  pinMode(relay, OUTPUT); 
  pinMode(buzzer, OUTPUT); 
  pinMode (LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);
  digitalWrite(relay, LOW);
  digitalWrite(buzzer, LOW);
  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;
  //init with high specs to pre-allocate larger buffers
  if(psramFound()){
    config.frame_size = FRAMESIZE_UXGA;
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }
#if defined(CAMERA_MODEL_ESP_EYE)
  pinMode(13, INPUT_PULLUP);
  pinMode(14, INPUT_PULLUP);
#endif
  // camera init
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }
  sensor_t * s = esp_camera_sensor_get();
  //initial sensors are flipped vertically and colors are a bit saturated
  if (s->id.PID == OV3660_PID) {
    s->set_vflip(s, 1);//flip it back
    s->set_brightness(s, 1);//up the blightness just a bit
    s->set_saturation(s, -2);//lower the saturation
  }
  //drop down frame size for higher initial frame rate
  s->set_framesize(s, FRAMESIZE_QVGA);
#if defined(CAMERA_MODEL_M5STACK_WIDE)
  s->set_vflip(s, 1);
  s->set_hmirror(s, 1);
#endif
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  startCameraServer();
  Serial.print("Camera Ready! Use 'http://");
  Serial.print(WiFi.localIP());
  Serial.println("' to connect");
}
void loop() {
    if (matchFace == true && activeRelay == false){
      activeRelay = true;
      digitalWrite (relay, HIGH);
      digitalWrite (buzzer, HIGH);
      delay(800);
      digitalWrite (buzzer, LOW);
      prevMillis = millis();
    }
    if(activeRelay == true && millis()- prevMillis > interval){
      activeRelay = false;
      matchFace = false; 
      digitalWrite(relay, LOW);
    }               
}
Vidéo

Vidéo