Conception d'un système de verrouillage numérique avec clavier et interface microcontrôleur

La construction d'un système de verrouillage numérique à partir de zéro est l'un des projets électroniques les plus enrichissants pour les étudiants, les amateurs et les éducateurs. Il relie le matériel et les logiciels, enseigne les principes de sécurité réels et produit un appareil de travail tangible. Que vous planifiez un laboratoire de classe ou une construction personnelle de bricolage, ce guide offre une passerelle complète et étape par étape pour créer un verrouillage numérique fiable à l'aide d'un clavier et d'un microcontrôleur.

De la sélection des composants et du câblage du circuit à l'écriture de boîtiers robustes de code et de bords de test, cet article couvre tout ce dont vous avez besoin pour concevoir un système fonctionnel, sécurisé et prêt à l'expansion.

Comprendre l'architecture du système de verrouillage numérique

Un verrou numérique remplace les tumblers mécaniques d'un verrou traditionnel par une logique électronique. Au cœur du système, il se compose de trois couches primaires : l'interface d'entrée, l'unité de commande et le mécanisme d'actionnement. L'utilisateur entre un code via un clavier, le microcontrôleur compare l'entrée avec un mot de passe stocké, et si les codes correspondent, il active un mécanisme de verrouillage tel qu'un servo ou un solénoïde.

Cette architecture introduit plusieurs concepts d'ingénierie importants : débonfler les entrées de commutateur, gérer la consommation d'énergie, gérer la logique d'authentification et assurer un fonctionnement sûr. Contrairement à un simple projet de bouton poussoir, un verrou numérique exige un design délibéré autour du timing, de la sécurité et de la rétroaction des utilisateurs.

Schéma de bloc système

Le système peut être visualisé comme suit:

  • Input: clavier Matrix (4x4 ou 3x12) agissant comme interface humaine
  • Processus: Microcontrôleur (Arduino Uno, ESP32 ou STM32) qui scanne le clavier et valide le code
  • Extrait: Moteur à servomoteur, serrure à solénoïde ou serrure électromagnétique à relais
  • Feedback: Affichage LCD en option, LED ou un buzzer pour confirmation sonore/visuelle

Cette approche en couches maintient la conception modulaire. Vous pouvez échanger le clavier pour un capteur biométrique ou mettre à niveau le contrôleur pour ajouter la connexion Wi-Fi sans changer l'architecture de base.

Composantes essentielles et critères de sélection

Options de microcontrôleur

Pour la plupart des projets éducatifs, un Arduino Uno est suffisant en raison de ses nombreuses broches d'entrée/sortie, de sa facilité de programmation et de son large support de bibliothèque. Si vous avez besoin de connectivité sans fil ou d'une plus grande puissance de traitement pour le chiffrement, l'ESP32 offre Bluetooth et Wi-Fi intégrés. Pour les applications ultra-faible puissance, considérez le STM32 ou ATtiny85.

Les principaux facteurs de sélection sont le nombre d'épingles numériques d'entrée/sortie, la disponibilité de sorties PWM pour le contrôle des servocommandes, la consommation d'énergie et le soutien communautaire.

Types de claviers et de fils de matrice

Un clavier 4x4 a 16 touches disposées en quatre lignes et quatre colonnes. En appuyant sur un raccourci de touches une ligne à une broche de colonne, le microcontrôleur peut détecter la clé qui a été pressée en balançant chaque ligne et en lisant les états de colonne.

Bien que les claviers 3x4 soient plus petits et moins chers, les clés supplémentaires sur un modèle 4x4 (A, B, C, D) peuvent être utilisées pour des fonctions comme « Entrée », « Espace de secours » ou « Annuler ».

Serrures

  • Moteur de serveur: Idéal pour les prototypes et les boîtiers légers. Un servo SG90 ou MG995 standard peut faire pivoter un mécanisme de verrouillage entre 0° et 90°.
  • Solénoïde de verrouillage[: Fournit une tenue plus forte, adapté aux tiroirs ou aux armoires. Nécessite un conducteur transistor et une diode de retour en raison de charges inductives.
  • Serrure électromagnétique contrôlée par relais[: Utilisée pour les portes. Nécessite une alimentation 12V séparée et un module relais pour changer le circuit à haut courant.

Pour les projets éducatifs, un servomoteur est recommandé car il donne une rétroaction visuelle claire sans circuit supplémentaire de conducteur.

Câblage du circuit : guide de connexion étape par étape

Cartographie des broches de clavier

La plupart des claviers matriciels ont huit broches, quatre pour les lignes et quatre pour les colonnes. Utilisez un multimètre en mode continuité pour déterminer le pinout si la feuille de données n'est pas disponible. Connectez les broches de ligne aux entrées numériques (p. ex., broches 9, 8, 7, 6 sur Arduino) et les broches de colonne aux sorties (p. ex., broches 5, 4, 3, 2). Dans le code, les lignes seront définies comme des entrées avec résistances de traction, et les colonnes seront entraînées bas une à la fois.

Connexion Servo

Le fil de signalisation du servo se connecte à une broche compatible PWM sur le microcontrôleur, comme la broche 10 sur Arduino. Les fils de puissance (rouge) et de masse (noir ou brun) du servo se rendent aux rails 5V et GND, respectivement. Pour les servos multiples ou les modèles à haute torque, utilisez une alimentation externe 5V pour éviter de surcharger le régulateur Arduino.

Affichage LCD en option

Inclure un écran LCD I2C (16x2 ou 20x4) améliore la rétroaction des utilisateurs en montrant « Entrer le code », « Accès accordé » et « Code Wong ». Connectez SDA à A4 et SCL à A5 sur un Arduino Uno, ou utilisez des broches I2C dédiées sur d'autres microcontrôleurs. L'adresse I2C est généralement 0x27 ou 0x3F; utilisez un croquis de scanner I2C pour confirmer.

Considérations relatives à la gestion de l'énergie

Si le système fonctionne sur des batteries, envisagez d'ajouter un mode de sommeil au microcontrôleur et d'utiliser un servo de faible puissance comme le SG90. Le clavier lui-même tire un courant négligeable, mais le servo peut consommer plusieurs centaines de milliamps lors du déplacement.

Résumé du diagramme complet du câblage

  • Pilons de rangée de clavier → Pins Arduino 9, 8, 7, 6
  • Pinces de colonne clavier → Pins Arduino 5, 4, 3, 2
  • Signal de serveur → Pin Arduino 10
  • Servo VCC → rail 5V
  • Servo GND → Rail de terre
  • LCD SDA[ → A4
  • LCD SCL[ → A5
  • LCD VCC → 5V
  • LCD GND[ → Sol

Toujours connecter un terrain commun entre tous les composants. Utilisez une table à pain pour le prototypage et vérifiez chaque connexion avec un multimètre avant de alimenter le circuit.

Programmation du microcontrôleur: logique fondamentale et mise en œuvre

Installation de la bibliothèque

Deux bibliothèques Arduino sont essentielles pour ce projet : Keypad de Mark Stanley et Alexander Brevig, et Servo de Michael Margolis. Installez les deux via le gestionnaire de bibliothèque Arduino. La bibliothèque Keypad gère la numérisation de matrice et le débonflage automatiquement, simplifiant considérablement le code.

Conception de machines d'État

Au lieu d'une boucle monolithique, une approche machine d'état rend le code plus robuste et plus facile à étendre. Définissez des états tels que IDLE, ENTERING CODE[, VERIFYING[, UNLOCKED[ et LOCKED[. Le microcontrôleur reste dans IDLE jusqu'à ce qu'une clé soit pressée, passe à ENTERING CODE pour accumuler des chiffres et se déplace vers VERIFYING lorsque la touche «#» est pressée.

Démarche de code : Exemple de travail complet

#include <Keypad.h>
#include <Servo.h>
#include <LiquidCrystal_I2C.h>

const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
 {'1','2','3','A'},
 {'4','5','6','B'},
 {'7','8','9','C'},
 {'*','0','#','D'}
};
byte rowPins[ROWS] = {9, 8, 7, 6};
byte colPins[COLS] = {5, 4, 3, 2};

Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
Servo lockServo;
LiquidCrystal_I2C lcd(0x27, 16, 2);

const String correctCode = "1234";
String inputCode = "";
const unsigned long unlockDuration = 5000;
unsigned long unlockStartTime = 0;
bool isUnlocked = false;

enum State { IDLE, ENTERING, VERIFIED, UNLOCKED, LOCKED };
State currentState = IDLE;

void setup() {
 lockServo.attach(10);
 lockServo.write(0);
 lcd.init();
 lcd.backlight();
 lcd.setCursor(0, 0);
 lcd.print("Enter Code:");
 currentState = IDLE;
}

void loop() {
 char key = keypad.getKey();

 switch (currentState) {
 case IDLE:
 if (key) {
 inputCode = "";
 lcd.clear();
 lcd.setCursor(0, 0);
 lcd.print("Enter Code:");
 currentState = ENTERING;
 }
 // fall through to handle first key
 if (currentState == ENTERING) {
 processKey(key);
 }
 break;

 case ENTERING:
 processKey(key);
 lcd.setCursor(0, 1);
 lcd.print(inputCode);
 break;

 case VERIFIED:
 if (inputCode == correctCode) {
 unlock();
 currentState = UNLOCKED;
 unlockStartTime = millis();
 lcd.clear();
 lcd.setCursor(0, 0);
 lcd.print("Access Granted");
 } else {
 lock();
 currentState = LOCKED;
 lcd.clear();
 lcd.setCursor(0, 0);
 lcd.print("Wrong Code");
 delay(2000);
 currentState = IDLE;
 lcd.clear();
 lcd.setCursor(0, 0);
 lcd.print("Enter Code:");
 }
 break;

 case UNLOCKED:
 if (millis() - unlockStartTime >= unlockDuration) {
 lock();
 currentState = IDLE;
 lcd.clear();
 lcd.setCursor(0, 0);
 lcd.print("Enter Code:");
 }
 break;

 case LOCKED:
 // wait then return to idle (handled in VERIFIED)
 break;
 }
}

void processKey(char key) {
 if (!key) return;
 if (key == '#') {
 currentState = VERIFIED;
 } else if (key == '*') {
 inputCode = "";
 lcd.setCursor(0, 1);
 lcd.print(" ");
 } else {
 inputCode += key;
 }
}

void unlock() {
 lockServo.write(90);
}

void lock() {
 lockServo.write(0);
 isUnlocked = false;
}

Explication des sections clés du code

Le code ci-dessus utilise une machine d'état pour gérer le comportement du verrou. Dans l'état IDLE, le système attend toute pression de clé. Une fois qu'une clé est détectée, elle passe à ENTRÉE, où jusqu'à 16 caractères peuvent être accumulés. La clé '*' efface le tampon d'entrée, et la clé '#' déclenche la vérification.

Après vérification dans l'état VERIFIED, le servo tourne à 90 degrés pendant cinq secondes avant de se reverrouiller automatiquement. Une tentative ratée affiche "Wrong Code" pendant deux secondes, puis se réinitialise. L'écran LCD fournit une rétroaction en temps réel sur l'état actuel et les chiffres entrés.

Traitement des cas de bord d'entrée

Dans le code de production, envisager de limiter la longueur d'entrée pour éviter les débordements de tampon. L'exemple ci-dessus ne fait pas appliquer une longueur maximale, mais vous pouvez ajouter une vérification à l'intérieur pour ignorer les touches lorsque .

Essai, dépannage et validation

Protocole d'essai systématique

Tester un verrou numérique nécessite une approche méthodique. Commencez par le clavier seul en téléchargeant un croquis simple de balayage des clés et en appuyant sur chaque bouton pour confirmer correctement le registre de toutes les clés. Ensuite, testez le servo indépendamment en utilisant l'exemple de balayage Servo pour vérifier la rotation et la livraison d'énergie.

Une fois les composants individuels validés, lancez le croquis de verrouillage numérique composite. Testez les scénarios suivants :

  • Entrez le code correct et vérifiez que le servo se déverrouille pendant exactement cinq secondes
  • Saisissez un code incorrect et confirmez que le système affiche une erreur et reste verrouillé
  • Appuyez sur '*' pour effacer le tampon d'entrée
  • Entrez moins de quatre chiffres et appuyez sur « # » pour vérifier que les codes vides ou partiels sont rejetés.
  • Maintenez une clé vers le bas pour confirmer la logique de débonflage empêche les caractères répétés

Questions et solutions communes

Symptom Cause Solution
Keypad returns no key Wiring mismatch or wrong pin numbers Verify row/column pin order in both wiring and code
Servo jitters or does not move Insufficient power or incorrect PWM pin Use external 5V supply; confirm pin supports PWM
LCD shows garbled characters Wrong I2C address or wiring Run I2C scanner to find address; check pull-up resistors
System resets when servo moves Voltage drop from servo inrush current Add a 470µF capacitor across servo power lines

Considérations avancées en matière de sécurité

Politique de mot de passe et stockage

Pour une utilisation réelle, entreposez un hachage du mot de passe et comparez les hachages pour vous protéger contre l'inspection de la mémoire. Si vous utilisez un Arduino Uno, considérez la bibliothèque SHA-256, bien que le hachage sur un microcontrôleur 8 bits soit lent. Pour des performances plus rapides, utilisez un ESP32 avec accélération matérielle.

Mesures anti-forte-forte

Pour empêcher les attaquants d'essayer tous les codes possibles, implémentez un mécanisme de verrouillage. Après trois tentatives ratées, désactivez le clavier pendant 30 secondes et affichez un message de refroidissement chronométré. Pour une sécurité supplémentaire, log a échoué les tentatives d'un EEPROM externe afin que le verrouillage persiste sur les cycles de puissance.

Conception de sécurité et de sécurité des défaillances

Décidez si votre serrure doit échouer en toute sécurité (déverrouiller sur la perte de puissance) ou en toute sécurité (arrêtez-vous sur la perte de puissance). Un verrou basé sur un servomoteur maintient généralement sa position lorsque la puissance est retirée, mais un solénoïde peut se trouver dans son état par défaut.

Applications pédagogiques et intégration des programmes

Objectifs d'apprentissage STEM

Ce projet s'harmonise avec plusieurs normes éducatives, dont les normes de la prochaine génération pour la science (NGSS)[ pour la conception d'ingénierie et les normes de l'Association des enseignants en sciences informatiques (CSTA)[ pour la programmation et la pensée des systèmes.

Extensions suggérées pour les classes

  • Gestion de l'utilisateur[: Permettre l'enregistrement de plusieurs codes d'utilisateur dans EEPROM
  • Logs d'accès[: Enregistrer les horodatages des tentatives réussies et ratées à l'aide d'un module CCF
  • : Ajoutez un ESP32 et créez un tableau de bord web simple via [WiFi library pour la surveillance à distance
  • Mise à jour biométrique: Remplacer ou augmenter le clavier par un capteur d'empreintes digitales utilisant le module Adafruit AS608

Applications et scalabilité du monde réel

Les principes exposés ici s'étendent directement aux systèmes de contrôle d'accès commerciaux. De nombreux verrous intelligents sur le marché utilisent le même clavier matriciel et l'architecture du microcontrôleur, avec un cryptage supplémentaire et une connectivité cloud.

Pour les déploiements plus importants, vous remplacerez l'Arduino par une plate-forme plus robuste comme Raspberry Pi Pico ou ESP32-S3, ajouterez une horloge en temps réel pour les règles d'accès temporelles et intégrerez-vous à un serveur de gestion central. La logique d'authentification centrale reste cependant identique au code ci-dessus.

Lecture et ressources supplémentaires

Pour approfondir votre compréhension de la conception d'interfaces de sécurité et de clavier embarqués, explorez les ressources externes suivantes :

Conclusion

Concevoir un système de verrouillage numérique avec un clavier et une interface microcontrôleur est bien plus qu'un simple projet — c'est une leçon complète en électronique, programmation intégrée et conception de système de sécurité. En suivant les étapes décrites dans ce guide, vous pouvez construire un prototype fonctionnel qui démontre les principes de contrôle d'accès réel.

L'architecture modulaire de ce système vous permet de continuer à l'étendre avec la connectivité sans fil, les capteurs biométriques ou la logarithme du cloud à mesure que vos compétences s'accroîtnt. Que vous soyez un éducateur à la recherche d'une activité pratique STEM ou un amateur intéressé par la domotique, ce projet de verrouillage numérique fournit une base solide pour comprendre comment des systèmes sécurisés sont conçus et construits.