Utiliser la carte ESP32 pour sécuriser la porte d’entrée avec un code

ESP32 23-01-25

115 0

Plan de tutoriel

1- Pourquoi on sécurise une porte avec un code ?

2- Comment la carte ESP32 contrôle l'accès de la porte ?

3- Matériel nécessaire

4- Montage du système

5- Programmation de la carte ESP32 avec Micropython

Pourquoi on sécurise une porte avec un code ?

Sécuriser une porte avec un code est une méthode courante utilisée pour renforcer la sécurité d'un espace ou d'une zone.

1. Contrôle d'accès

Un code permet de limiter l'accès à une porte uniquement aux personnes autorisées.

Contrairement à une clé physique, un code peut être partagé de manière temporaire ou permanente sans nécessiter d’objet matériel.

2. Réduction des risques liés aux clés physiques

Pas de perte de clé : Il n’est pas nécessaire de transporter une clé ou un badge qui pourrait être perdu ou volé.

Facilité de modification : Si le code est compromis, il peut être rapidement modifié, contrairement à une serrure traditionnelle qui nécessiterait un changement de cylindre ou de clés.

3. Sécurité renforcée

Un code peut être combiné à d'autres systèmes de sécurité comme des alarmes, des caméras, ou même des authentifications biométriques pour une double vérification.

L'utilisation de codes complexes ou aléatoires réduit les risques de deviner le code par des intrus.

4. Suivi et gestion des accès

Avec des systèmes modernes, il est possible d’attribuer des codes spécifiques à chaque utilisateur, permettant de suivre qui entre et sort d’un lieu.

Certains systèmes permettent également de limiter l'accès à certaines plages horaires.

Comment la carte ESP32 contrôle l'accès de la porte ?

Étape 1 : Saisie du code via le clavier matriciel

L’utilisateur entre un code d’accès sur le clavier matriciel 4x4. Ce clavier est connecté à l’ESP32 via des broches GPIO.

Chaque pression d'une touche envoie un signal électrique correspondant à une ligne et une colonne du clavier.

L’ESP32 interprète les signaux pour identifier quelle touche a été pressée et stocke temporairement le code saisi.

Étape 2 : Vérification du code

Une fois que l’utilisateur a terminé la saisie (par exemple, en appuyant sur une touche "Entrée"), l’ESP32 compare le code saisi avec un code prédéfini stocké dans sa mémoire.

Si le code est correct :

- L’ESP32 envoie une commande pour ouvrir la porte.

- L’écran SSD1306 affiche un message du type : "Code correct, ouverture".

Si le code est incorrect :

- L’ESP32 n’autorise pas l’accès.

- L’écran SSD1306 affiche "Accès refusé" ou "Code incorrect".

Étape 3 : Contrôle du moteur DC avec le module L298N

Le module L298N est utilisé pour contrôler la rotation du moteur DC 5V (dans les deux sens). Voici comment cela fonctionne :

a- Connexion ESP32 au module L298N :

Deux broches GPIO de l’ESP32 sont utilisées pour contrôler la direction de rotation du moteur (par exemple, IN1 et IN2 du L298N).

Une autre broche PWM de l’ESP32 régule la vitesse du moteur (via ENA ou ENB du L298N).

b- Ouverture de la porte :

Lorsque le code est correct, l’ESP32 configure les broches du L298N pour faire tourner le moteur dans un sens.

Le moteur actionne un mécanisme (comme une crémaillère ou une poulie) pour ouvrir la porte.

c- Fermeture de la porte :

Après un délai défini (par exemple, 10 secondes), l’ESP32 configure les broches du L298N pour inverser le sens de rotation du moteur.

La porte se ferme automatiquement.

Matériel nécessaire

ESP32 :

La carte ESP32 gère toutes les communications entre les composants.

Contrôle les broches connectées au clavier, à l'afficheur SSd1306, et au module L298N.

Clavier matriciel 4x4 :

Le clavier est composé de 4 lignes et 4 colonnes qui sont connectées à 8 GPIO de l’ESP32.

L’ESP32 utilise une technique de scanning matriciel pour détecter quelles touches sont pressées.

Afficheur SSD1306 :

L'afficheur SSd1306 affiche des messages tels que :

"Entrer le code :"

"Code correct, ouverture"

"Code incorrect, accès refusé".

Module L298N :

Il est connecté à l’ESP32 et alimente le moteur DC 5V.

Entrées IN1, IN2 : Définissent la direction du moteur.

ENA : Contrôle la vitesse du moteur (PWM).

Moteur DC 5V :

Le moteur est connecté aux bornes de sortie du L298N (OUT1 et OUT2).

Il actionne le mécanisme d’ouverture/fermeture de la porte.

Montage du système

1- Montage de la carte ESP32 avec l’afficheur SSD1306 et le clavier 4×4:

- On connecte les 8 sorties du clavier aux 8 broches de la carte ESP32 suivant cet ordre: D2, D4, D5, D18, D19, D16, D15 et D23.

- Pour l’afficheur SSD1306 on connecte:

la broche SDA à la broche D21 de la carte ESP32

la broche SCL à la broche D22 de la carte ESP32

la broche GND à la broche GND de la carte ESP32

la broche VCC à la broche 5V de la carte ESP32

2- Montage de la carte ESP32 avec la carte L298N et le moteur:

Pour le module L2983N :

Connecter la broche N°17 de la carte ESP32 à la broche ENA du module L298N.

Connecter la broche N°3 de la carte ESP32 à la broche IN1 du module L298N.

Connecter la broche N°1 de la carte ESP32 à la broche IN2 du module L298N.

Connecter la broche GND de la carte ESP32 à la broche GND du module L298N.

Connecter la broche GND de la carte ESP32 à la borne (-) de la batterie 9V

Connecter la broche 12V du module L298N à la borne (+) de la batterie 9V

Pour le moteur :

Connecter les deux bornes du moteur aux deux broches OUT1 et OUT2 du module L298N

Programmation de la carte ESP32 avec Micropython

Voici un exemple de code pour implémenter ce système. Vous aurez besoin des bibliothèques suivantes :

ssd1306.py pour l'afficheur SSd1306 et DCMotor pour le module L293N.

from machine import UART
from dcmotor import DCMotor 
from machine import Pin, PWM,I2C
from time import sleep
import ssd1306
import time
import utime

i2c = I2C(scl=Pin(22), sda=Pin(21)) #Init i2c
oled=ssd1306.SSD1306_I2C(128,64,i2c,0x3c)
oled.fill(0)
oled.text('Code',10,10)
oled.show()

frequency = 15000       
pin1 = Pin(3, Pin.OUT)    
pin2 = Pin(1, Pin.OUT)  
enable = PWM(Pin(17), frequency)  
dc_motor = DCMotor(pin1, pin2, enable)      
dc_motor = DCMotor(pin1, pin2, enable, 350, 1023)

KEY_UP   = const(0)
KEY_DOWN = const(1)

keys = [['1', '2', '3', 'A'], ['4', '5', '6', 'B'], ['7', '8', '9', 'C'], ['*', '0', '#', 'D']]

# Pin names for keypad
cols = [19,16,15,23]
rows = [2,4,5,18]
# set pins for rows as outputs
row_pins = [Pin(pin_name, mode=Pin.OUT) for pin_name in rows]

# set pins for cols as inputs
col_pins = [Pin(pin_name, mode=Pin.IN, pull=Pin.PULL_DOWN) for pin_name in cols]

def init():
    for row in range(0,4):
        for col in range(0,4):
            row_pins[row].value(0)

def scan(row, col):
    """ scan the keypad """

    # set the current column to high
    row_pins[row].value(1)
    key = None

    # check for keypressed events
    if col_pins[col].value() == KEY_DOWN:
        key = KEY_DOWN
    if col_pins[col].value() == KEY_UP:
        key = KEY_UP
    row_pins[row].value(0)

    # return the key state
    return key

print("starting")

# set all the columns to low
init()
code="" 
while True:

    oled.fill(0)
    if (len(code)<4):  
      for row in range(4):
          for col in range(4):
              key = scan(row, col)
              if key == KEY_DOWN:
                  oled.text("code: ",10,0)
                  print("Key Pressed", keys[row][col])
                  code=code+keys[row][col]
                  oled.text(code, 55, 30)
                  oled.show()
                  last_key_press = keys[row][col]
                  time.sleep_ms(500)

    if (code=="2886"): 
      time.sleep(1) 
      dc_motor.forward(80) # le moteur tourne pour ouvrir la porte
      time.sleep(1)
      dc_motor.stop() # stop le moteur
      code=""
    if (code=="0000"):
      time.sleep(1)
      dc_motor.backwards(80) # le moteur tourne dans le sens inverse pour fermer la porte
      time.sleep(1)
      dc_motor.stop() # stop le moteur
      code=""

from machine import UART

from dcmotor import DCMotor

from machine import Pin, PWM,I2C

from time import sleep

import ssd1306

import time

import utime

i2c = I2C(scl=Pin(22), sda=Pin(21)) #Init i2c

oled=ssd1306.SSD1306_I2C(128,64,i2c,0x3c)

oled.fill(0)

oled.text('Code',10,10)

oled.show()

frequency = 15000

pin1 = Pin(3, Pin.OUT)

pin2 = Pin(1, Pin.OUT)

enable = PWM(Pin(17), frequency)

dc_motor = DCMotor(pin1, pin2, enable)

dc_motor = DCMotor(pin1, pin2, enable, 350, 1023)

KEY_UP = const(0)

KEY_DOWN = const(1)

keys = [['1', '2', '3', 'A'], ['4', '5', '6', 'B'], ['7', '8', '9', 'C'], ['*', '0', '#', 'D']]

# Pin names for keypad

cols = [19,16,15,23]

rows = [2,4,5,18]

# set pins for rows as outputs

row_pins = [Pin(pin_name, mode=Pin.OUT) for pin_name in rows]

# set pins for cols as inputs

col_pins = [Pin(pin_name, mode=Pin.IN, pull=Pin.PULL_DOWN) for pin_name in cols]

def init():

for row in range(0,4):

for col in range(0,4):

row_pins[row].value(0)

def scan(row, col):

""" scan the keypad """

# set the current column to high

row_pins[row].value(1)

key = None

# check for keypressed events

if col_pins[col].value() == KEY_DOWN:

key = KEY_DOWN

if col_pins[col].value() == KEY_UP:

key = KEY_UP

row_pins[row].value(0)

# return the key state

return key

print("starting")

# set all the columns to low

init()

code=""

while True:

oled.fill(0)

if (len(code)<4):

for row in range(4):

for col in range(4):

key = scan(row, col)

if key == KEY_DOWN:

oled.text("code: ",10,0)

print("Key Pressed", keys[row][col])

code=code+keys[row][col]

oled.text(code, 55, 30)

oled.show()

last_key_press = keys[row][col]

time.sleep_ms(500)

if (code=="2886"):

time.sleep(1)

dc_motor.forward(80) # le moteur tourne pour ouvrir la porte

time.sleep(1)

dc_motor.stop() # stop le moteur

code=""

if (code=="0000"):

time.sleep(1)

dc_motor.backwards(80) # le moteur tourne dans le sens inverse pour fermer la porte

time.sleep(1)

dc_motor.stop() # stop le moteur

code=""

Explications

1- Saisie du code :

L’utilisateur entre le code via le clavier matriciel.

2- Affichage :

L’écran OLED affiche les instructions et le code entré en temps réel.

3- Contrôle du moteur :

Si le code est correct, le moteur s’active pour ouvrir la porte.

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Jeu TETRIS contrôlé par la carte Micro:bit

Micro:bit 27-02-25

Commander le jeu Dinausore par la carte Arduino

Arduino UNO 18-02-25

Arduino UNO et le moteur pas à pas 28BYJ-48

Arduino UNO 17-02-25

Jeu PACMAN commandé par l’Arduino

Arduino UNO 15-02-25

Construction des barrières des chemins de fer commandées par Arduino

Arduino UNO 13-02-25

Atelier robotique

Tutoriels populaires

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino UNO 4525vues

Allumer une LED par la carte ESP32

ESP32 4105vues

Présentation de la carte ESP32

ESP32 3984vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 3736vues

Allumer une LED connectée à la carte ESP32 via WIFI

ESP32 Wifi 3523vues

Construction des robots

Tutoriels plus commentés

Commander trois LEDs par la télécommande en utilisant le capteur KY-032 et la carte Micro:bit

Micro:bit 3 commentaires

Allumer une LED connectée à l’Arduino UNO via WIFI

Arduino UNO Wifi 3 commentaires

Création des jeux avec Micro:bit et MakeCode

Micro:bit 2 commentaires

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur SSD1306

Arduino UNO 2 commentaires

Système de détection d’obstacles basé sur HC-SR04, afficheur SSD1306 et Arduino UNO

Arduino UNO 2 commentaires

Utiliser la carte ESP32 pour sécuriser la porte d’entrée avec un code

Plan de tutoriel

1- Pourquoi on sécurise une porte avec un code ?

2- Comment la carte ESP32 contrôle l'accès de la porte ?

3- Matériel nécessaire

4- Montage du système

5- Programmation de la carte ESP32 avec Micropython

Pourquoi on sécurise une porte avec un code ?

Comment la carte ESP32 contrôle l'accès de la porte ?

Matériel nécessaire

ESP32 :

Clavier matriciel 4x4 :

Afficheur SSD1306 :

Module L298N :

Moteur DC 5V :

Montage du système

1- Montage de la carte ESP32 avec l’afficheur SSD1306 et le clavier 4×4:

2- Montage de la carte ESP32 avec la carte L298N et le moteur:

Programmation de la carte ESP32 avec Micropython

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles