Come costruire una serratura con password e Arduino
Descrizione
Questo progetto è una serratura con password basata su Arduino, un tastierino matriciale 4x4 e un modulo relè 5V SRD-05VDC-SL-C. L’utente inserisce una password numerica, la cancella con il tasto asterisco e la conferma con il tasto cancelletto. Quando la password corretta viene confermata, Arduino commuta l’uscita del modulo relè. Il modulo relè usato in questo progetto ha l’ingresso di segnale attivo LOW, quindi il relè si attiva quando Arduino invia LOW e si disattiva quando Arduino invia HIGH. Il progetto è utile per imparare la scansione dei tastierini, la logica di accesso, i moduli relè, le uscite attive LOW e i sistemi con password basati su Arduino.
Componenti necessari:
- 1x Arduino UNO
- 1x Tastierino matriciale 4x4
- 1x Modulo relè 5V SRD-05VDC-SL-C con ingresso di segnale attivo LOW
- Cavi jumper (breadboard opzionale)
- Alimentatore esterno per la serratura o il carico, se necessario
Schema:
Codice base:
// https://nemiatools.com
#include <string.h> // Supporto al confronto delle stringhe
const byte ROW_NUM = 4; // Numero di righe del tastierino
const byte COLUMN_NUM = 4; // Numero di colonne del tastierino
char keys[ROW_NUM][COLUMN_NUM] = { // Mappa dei tasti
{'1', '2', '3', 'A'}, // Prima riga
{'4', '5', '6', 'B'}, // Seconda riga
{'7', '8', '9', 'C'}, // Terza riga
{'*', '0', '#', 'D'} // Quarta riga
};
byte pin_rows[ROW_NUM] = {9, 8, 7, 6}; // Pin delle righe
byte pin_cols[COLUMN_NUM] = {5, 4, 3, 2}; // Pin delle colonne
const byte relaySignalPin = 10; // Pin segnale del modulo relè SRD-05VDC-SL-C
const String correctPassword = "1234"; // Password corretta
String inputPassword = ""; // Password inserita
bool relayActive = false; // Stato del relè
bool clearNext = false; // Cancella dopo la conferma
void setRelay(bool active) { // Controlla il modulo relè attivo LOW
relayActive = active; // Salva lo stato del relè
digitalWrite(relaySignalPin, active ? LOW : HIGH); // LOW attiva il modulo relè
}
void setup() {
pinMode(relaySignalPin, OUTPUT); // Imposta il segnale del relè come uscita
setRelay(false); // Mantiene il relè spento all'avvio
for (byte i = 0; i < ROW_NUM; i++) { // Imposta le righe
pinMode(pin_rows[i], INPUT_PULLUP); // Righe con pull-up interno
}
for (byte i = 0; i < COLUMN_NUM; i++) { // Imposta le colonne
pinMode(pin_cols[i], OUTPUT); // Colonne come uscite
digitalWrite(pin_cols[i], HIGH); // Colonne inattive
}
}
char getKey() { // Legge il tastierino manualmente
for (byte col = 0; col < COLUMN_NUM; col++) { // Scansiona le colonne
for (byte i = 0; i < COLUMN_NUM; i++) { // Ripristina le colonne
digitalWrite(pin_cols[i], HIGH); // Colonna inattiva
}
digitalWrite(pin_cols[col], LOW); // Attiva la colonna corrente
for (byte row = 0; row < ROW_NUM; row++) { // Scansiona le righe
if (digitalRead(pin_rows[row]) == LOW) { // Tasto premuto
return keys[row][col]; // Restituisce il tasto premuto
}
}
}
return 0; // Nessun tasto premuto
}
void loop() {
if (clearNext) { // Reset richiesto
inputPassword = ""; // Cancella la password
clearNext = false; // Azzera il flag
}
char key = getKey(); // Legge il tasto
if (!key) { // Nessun tasto premuto
return; // Esce subito
}
delay(150); // Semplice ritardo di debounce
if (key == '*') { // Cancella l'input
inputPassword = ""; // Cancella la password
}
else if (key == '#') { // Conferma l'input
if (inputPassword == correctPassword) { // Controlla la password
setRelay(!relayActive); // Commuta lo stato del relè
}
clearNext = true; // Cancella l'input dopo la conferma
}
else if (key >= '0' && key <= '9') { // Accetta solo numeri
inputPassword += key; // Aggiunge la cifra alla password
}
while (getKey() != 0) { // Attende il rilascio del tasto
delay(10); // Piccola pausa
}
}Codice con Keypad.h:
// https://nemiatools.com
#include <Keypad.h> // Include la libreria Keypad
const byte ROW_NUM = 4; // Numero di righe del tastierino
const byte COLUMN_NUM = 4; // Numero di colonne del tastierino
char keys[ROW_NUM][COLUMN_NUM] = { // Mappa dei tasti
{'1', '2', '3', 'A'}, // Prima riga
{'4', '5', '6', 'B'}, // Seconda riga
{'7', '8', '9', 'C'}, // Terza riga
{'*', '0', '#', 'D'} // Quarta riga
};
byte pin_rows[ROW_NUM] = {9, 8, 7, 6}; // Pin delle righe
byte pin_cols[COLUMN_NUM] = {5, 4, 3, 2}; // Pin delle colonne
const byte relaySignalPin = 10; // Pin segnale del modulo relè SRD-05VDC-SL-C
const String correctPassword = "1234"; // Password corretta
String inputPassword = ""; // Password inserita
bool relayActive = false; // Stato del relè
bool clearNext = false; // Cancella dopo la conferma
Keypad keypad = Keypad(makeKeymap(keys), pin_rows, pin_cols, ROW_NUM, COLUMN_NUM); // Crea l'oggetto tastierino
void setRelay(bool active) { // Controlla il modulo relè attivo LOW
relayActive = active; // Salva lo stato del relè
digitalWrite(relaySignalPin, active ? LOW : HIGH); // LOW attiva il modulo relè
}
void setup() {
pinMode(relaySignalPin, OUTPUT); // Imposta il segnale del relè come uscita
setRelay(false); // Mantiene il relè spento all'avvio
}
void loop() {
if (clearNext) { // Reset richiesto
inputPassword = ""; // Cancella la password
clearNext = false; // Azzera il flag
}
char key = keypad.getKey(); // Legge il tasto
if (!key) { // Nessun tasto premuto
return; // Esce subito
}
if (key == '*') { // Cancella l'input
inputPassword = ""; // Cancella la password
}
else if (key == '#') { // Conferma l'input
if (inputPassword == correctPassword) { // Controlla la password
setRelay(!relayActive); // Commuta lo stato del relè
}
clearNext = true; // Cancella l'input dopo la conferma
}
else if (key >= '0' && key <= '9') { // Accetta solo numeri
inputPassword += key; // Aggiunge la cifra alla password
}
}Come funziona:
Questo progetto usa Arduino, un tastierino matriciale 4x4 e un modulo relè 5V SRD-05VDC-SL-C per creare una serratura controllata da password. Il tastierino serve per inserire il codice, mentre il modulo relè funziona da interruttore elettrico per la serratura o per il carico esterno.
Il tastierino è una matrice formata da 4 righe e 4 colonne. Quando un tasto viene premuto, collega una riga a una colonna. Per questo Arduino riesce a leggere 16 tasti usando solo 8 pin invece di un pin per ogni tasto.
Gli array pin_rows e pin_cols definiscono come il tastierino è collegato ai pin Arduino da 2 a 9. L’array keys dice al programma quale carattere corrisponde a ogni posizione di riga e colonna.
La riga const byte relaySignalPin = 10; definisce il pin Arduino collegato all’ingresso di segnale del modulo relè. Questo modulo relè è attivo LOW, quindi il relè si attiva quando il pin di segnale è LOW e si disattiva quando il pin di segnale è HIGH.
Questo funzionamento attivo LOW è molto importante. Nella funzione setRelay(bool active), la riga digitalWrite(relaySignalPin, active ? LOW : HIGH); scrive LOW quando il relè deve essere attivo e HIGH quando deve essere inattivo.
All’avvio, setRelay(false); mantiene il modulo relè spento. Questo è più sicuro perché la serratura o il carico collegato non si attiva automaticamente quando Arduino viene alimentato.
La variabile correctPassword contiene la password valida, mentre inputPassword contiene le cifre inserite dall’utente. La variabile relayActive ricorda se il relè è attualmente attivo oppure inattivo.
Nella versione manuale del codice, il tastierino viene letto dalla funzione getKey(). Arduino mantiene tutte le colonne HIGH, poi porta una colonna alla volta a LOW e controlla gli ingressi delle righe. Siccome le righe usano INPUT_PULLUP, un tasto premuto viene rilevato come LOW.
Quando una riga legge LOW durante la scansione, il codice sa che il tasto premuto si trova all’incrocio tra la colonna attiva e quella riga. La funzione restituisce quindi il carattere corretto dall’array keys.
Nel ciclo principale, il tasto asterisco '*' cancella la password inserita, i tasti numerici vengono aggiunti a inputPassword e il tasto cancelletto '#' conferma l’input.
Quando viene premuto '#', la condizione if (inputPassword == correctPassword) controlla se la password inserita è corretta. Se è corretta, setRelay(!relayActive); commuta lo stato del relè: se era spento si accende, se era acceso si spegne.
La riga while (getKey() != 0) nella versione manuale attende il rilascio del tasto. Questo evita che una singola pressione lunga venga letta molte volte.
La seconda versione usa la libreria Keypad.h. La riga Keypad keypad = Keypad(makeKeymap(keys), pin_rows, pin_cols, ROW_NUM, COLUMN_NUM); crea l’oggetto tastierino e lascia alla libreria la gestione interna della scansione.
Con la versione con libreria, il codice può usare semplicemente char key = keypad.getKey(); per leggere il tasto premuto. Questo rende il programma più corto e più facile da modificare, mantenendo la stessa logica di password e relè.
Il modulo relè ha i pin logici VCC, GND e IN, più i morsetti per il circuito commutato. Arduino controlla solo il pin IN; la serratura o il carico va collegato ai morsetti del modulo relè in base al contatto normalmente aperto o normalmente chiuso necessario al progetto.
Nel complesso, il sistema legge il tastierino, costruisce la password cifra per cifra, controlla il codice quando l’utente preme '#', e cambia lo stato del modulo relè attivo LOW quando la password è corretta.
Assicurati che l’ingresso del modulo relè sia davvero attivo LOW. Se si usa un modulo diverso con logica attiva HIGH, la riga dentro setRelay() deve essere invertita. Inoltre collega la massa di Arduino alla massa del modulo relè e rispetta i limiti di tensione e corrente dei contatti del relè.