Apriporta con Arduino, Keypad, Display LCD e Relè
Realizziamo un controllo accessi con password usando una tastiera a membrana 3×4 o 4×4, un display LCD 16×2 I2C e un relè che può comandare una serratura elettrica o un altro dispositivo.
Sistema con Arduino, keypad, display LCD e relè. L’immagine mantiene una larghezza massima di 558 px.
Keypad 3×4 oppure 4×4
Le tastiere a membrana sono organizzate come una matrice di righe e colonne. Un keypad 3×4 dispone di 12 tasti, mentre un modello 4×4 ne offre 16 aggiungendo normalmente i tasti A, B, C e D.
Confronto tra keypad 3×4 e 4×4. L’immagine mantiene una larghezza massima di 302 px.
Cosa imparerai
- come leggere una tastiera a matrice con Arduino;
- come configurare un keypad 3×4 e uno 4×4;
- come acquisire e confrontare una password;
- come mostrare messaggi su un LCD 16×2 I2C;
- come comandare un modulo relè;
- come mascherare sul display i caratteri digitati.
Materiale necessario
🧰 Kit Arduino consigliato
Un kit completo è utile per avere breadboard, cavetti, resistenze, pulsanti e molti componenti di base per sperimentare con Arduino.
👉 Guarda il kit Arduino consigliatoLink di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.
📘 Vuoi imparare Arduino passo dopo passo?
Se vuoi approfondire e realizzare progetti più completi, puoi dare un’occhiata anche ai miei libri dedicati ad Arduino. All’interno troverai spiegazioni semplici, schemi chiari e molti progetti pratici pensati per chi parte da zero.
👉 Scopri i miei libri su ArduinoLink di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.
Librerie necessarie
Il keypad viene gestito dalla libreria Keypad, mentre il display utilizza LiquidCrystal_I2C.
⬇️ Scarica keypad.zip ⬇️ Scarica liquidcrystal_i2c.zip
Video dimostrativo
Schema con tastiera 3×4
| Keypad 3×4 | Arduino |
|---|---|
| Righe | D9, D8, D7, D6 |
| Colonne | D5, D4, D3 |
| Relè | D12 |
Codice per keypad 3×4
/*
APRIPORTA CON ARDUINO, KEYPAD 3x4, LCD I2C E RELÈ
Funzionamento:
- digita una password di 7 caratteri;
- i caratteri inseriti vengono mascherati con *;
- se la password è corretta il relè si attiva per 1,5 secondi;
- se è errata compare un messaggio sul display.
Collegamenti keypad 3x4:
righe -> D9, D8, D7, D6
colonne -> D5, D4, D3
Relè -> D12
LCD I2C -> SDA/SCL
Password impostata nell'esempio: 1234567
NOTA:
molti moduli relè sono "active LOW":
LOW = relè attivo
HIGH = relè disattivo
*/
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>
// ---------------------------
// Configurazione password
// ---------------------------
const byte PASSWORD_LENGTH = 7;
// +1 per il terminatore '\0' della stringa C
char dati[PASSWORD_LENGTH + 1] = "";
const char passwordMaster[PASSWORD_LENGTH + 1] = "1234567";
byte indice = 0;
// ---------------------------
// Uscita relè
// ---------------------------
const byte PIN_RELE = 12;
const byte RELE_ATTIVO = LOW;
const byte RELE_SPENTO = HIGH;
// ---------------------------
// Keypad 3x4
// ---------------------------
const byte RIGHE = 4;
const byte COLONNE = 3;
char tasti[RIGHE][COLONNE] = {
{'1', '2', '3'},
{'4', '5', '6'},
{'7', '8', '9'},
{'*', '0', '#'}
};
byte pinRighe[RIGHE] = {9, 8, 7, 6};
byte pinColonne[COLONNE] = {5, 4, 3};
Keypad tastiera = Keypad(
makeKeymap(tasti),
pinRighe,
pinColonne,
RIGHE,
COLONNE
);
// Indirizzo I2C usato nel circuito.
// Se il display non risponde, prova 0x27.
LiquidCrystal_I2C lcd(0x3F, 16, 2);
void setup() {
lcd.init();
lcd.backlight();
pinMode(PIN_RELE, OUTPUT);
digitalWrite(PIN_RELE, RELE_SPENTO);
mostraRichiestaPassword();
}
void loop() {
char tasto = tastiera.getKey();
// Nessun tasto premuto
if (!tasto) {
return;
}
// Salva il carattere finché non raggiungiamo
// la lunghezza prevista della password.
if (indice < PASSWORD_LENGTH) {
dati[indice] = tasto;
indice++;
// Mantiene sempre valida la stringa C.
dati[indice] = '\0';
// Non mostriamo la password in chiaro.
lcd.setCursor(indice - 1, 1);
lcd.print('*');
}
// Quando sono stati inseriti 7 caratteri,
// confrontiamo la stringa con la password MASTER.
if (indice == PASSWORD_LENGTH) {
lcd.clear();
if (strcmp(dati, passwordMaster) == 0) {
lcd.setCursor(0, 0);
lcd.print("Password corretta");
// Impulso di apertura
digitalWrite(PIN_RELE, RELE_ATTIVO);
delay(1500);
digitalWrite(PIN_RELE, RELE_SPENTO);
}
else {
lcd.setCursor(0, 0);
lcd.print("Password errata");
delay(3000);
}
cancellaDati();
mostraRichiestaPassword();
}
}
// ------------------------------------------------------
// Cancella il buffer usato per la password
// ------------------------------------------------------
void cancellaDati() {
for (byte i = 0; i <= PASSWORD_LENGTH; i++) {
dati[i] = '\0';
}
indice = 0;
}
// ------------------------------------------------------
// Messaggio iniziale
// ------------------------------------------------------
void mostraRichiestaPassword() {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("PASSWORD...");
lcd.setCursor(0, 1);
}⬇️ Scarica keypad_rele_3x4.zip
Schema con tastiera 4×4
| Keypad 4×4 | Arduino |
|---|---|
| Righe | D9, D8, D7, D6 |
| Colonne | D5, D4, D3, D2 |
| Relè | D12 |
Codice per keypad 4×4
/*
APRIPORTA CON ARDUINO, KEYPAD 4x4, LCD I2C E RELÈ
Collegamenti keypad 4x4:
righe -> D9, D8, D7, D6
colonne -> D5, D4, D3, D2
Relè -> D12
LCD I2C -> SDA/SCL
Password impostata nell'esempio: 1234567
*/
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>
const byte PASSWORD_LENGTH = 7;
char dati[PASSWORD_LENGTH + 1] = "";
const char passwordMaster[PASSWORD_LENGTH + 1] = "1234567";
byte indice = 0;
const byte PIN_RELE = 12;
const byte RELE_ATTIVO = LOW;
const byte RELE_SPENTO = HIGH;
const byte RIGHE = 4;
const byte COLONNE = 4;
char tasti[RIGHE][COLONNE] = {
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};
byte pinRighe[RIGHE] = {9, 8, 7, 6};
byte pinColonne[COLONNE] = {5, 4, 3, 2};
Keypad tastiera = Keypad(
makeKeymap(tasti),
pinRighe,
pinColonne,
RIGHE,
COLONNE
);
LiquidCrystal_I2C lcd(0x3F, 16, 2);
void setup() {
lcd.init();
lcd.backlight();
pinMode(PIN_RELE, OUTPUT);
digitalWrite(PIN_RELE, RELE_SPENTO);
mostraRichiestaPassword();
}
void loop() {
char tasto = tastiera.getKey();
if (!tasto) {
return;
}
if (indice < PASSWORD_LENGTH) {
dati[indice] = tasto;
indice++;
dati[indice] = '\0';
lcd.setCursor(indice - 1, 1);
lcd.print('*');
}
if (indice == PASSWORD_LENGTH) {
lcd.clear();
if (strcmp(dati, passwordMaster) == 0) {
lcd.setCursor(0, 0);
lcd.print("Password corretta");
digitalWrite(PIN_RELE, RELE_ATTIVO);
delay(1500);
digitalWrite(PIN_RELE, RELE_SPENTO);
}
else {
lcd.setCursor(0, 0);
lcd.print("Password errata");
delay(3000);
}
cancellaDati();
mostraRichiestaPassword();
}
}
void cancellaDati() {
for (byte i = 0; i <= PASSWORD_LENGTH; i++) {
dati[i] = '\0';
}
indice = 0;
}
void mostraRichiestaPassword() {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("PASSWORD...");
lcd.setCursor(0, 1);
}⬇️ Scarica keypad_rele_4x4.zip
Impostare la password
Nell’esempio la password è composta da sette caratteri:
const char passwordMaster[8] = "1234567";Puoi sostituire 1234567 con un’altra combinazione di sette tasti. Nel codice la password digitata non viene mostrata in chiaro: sul display compare un asterisco per ogni carattere inserito.
Perché abbiamo corretto la gestione della stringa
Per confrontare correttamente due stringhe C con strcmp(), il buffer deve terminare con il carattere nullo \0. Il codice riportato sopra mantiene sempre il terminatore nella posizione corretta e azzera completamente il buffer dopo ogni tentativo.
Il relè è active LOW?
Molti moduli relè da 5 V si attivano portando l’ingresso a LOW. Per questo lo sketch utilizza due costanti separate:
const byte RELE_ATTIVO = LOW;
const byte RELE_SPENTO = HIGH;Se il tuo modulo lavora con logica opposta, basta invertire i due valori.
Indirizzo I2C del display
Nel codice viene usato l’indirizzo 0x3F. Alcuni moduli LCD I2C utilizzano invece 0x27. Se il display rimane vuoto, verifica l’indirizzo del tuo adattatore.
Usare il relè per una serratura
Per una semplice dimostrazione puoi collegare al relè un carico a bassa tensione. In un’applicazione reale è inoltre opportuno prevedere protezioni elettriche e una logica di sicurezza adatta al tipo di porta o cancello.
Debug rapido
- se il keypad non risponde, controlla l’ordine di righe e colonne;
- se i tasti restituiscono valori sbagliati, verifica la disposizione dei fili del keypad;
- se il display rimane vuoto, prova a verificare gli indirizzi 0x3F e 0x27;
- se il relè resta sempre attivo, controlla se il modulo è active LOW;
- se la password non viene riconosciuta, controlla lunghezza e caratteri impostati;
- non alimentare una serratura direttamente dal pin D12.
Varianti del progetto
- aggiungere un buzzer per confermare password corretta o errata;
- usare il tasto # come conferma invece di una lunghezza fissa;
- usare * per cancellare l’ultima cifra;
- memorizzare la password nella EEPROM;
- aggiungere RFID come secondo metodo di autenticazione;
- registrare i tentativi di accesso;
- aggiungere un timeout dopo più password errate.
Cosa devi ricordare
- Il keypad può essere 3×4 oppure 4×4.
- Il relè è collegato al pin D12.
- Il display LCD comunica tramite I2C.
- La password di esempio è
1234567. - Il relè viene attivato per circa 1,5 secondi quando la password è corretta.
- Il codice maschera i caratteri inseriti e mantiene correttamente terminata la stringa.
Domande frequenti
Posso usare una password più corta o più lunga?
Sì. Modifica PASSWORD_LENGTH e la stringa passwordMaster mantenendo lo spazio aggiuntivo per il terminatore \0.
Posso usare un keypad 4×4 senza cambiare il resto del circuito?
Il principio è lo stesso, ma serve un pin aggiuntivo per la quarta colonna. Nel codice 4×4 viene utilizzato D2.
Perché il relè si attiva con LOW?
Molti moduli relè sono progettati come active LOW. Se il tuo modulo è active HIGH, inverti le costanti relative allo stato acceso e spento.
Posso collegare direttamente una serratura elettrica ad Arduino?
No. Arduino deve fornire soltanto il segnale di comando al relè o a un circuito di potenza adeguato. La serratura deve essere alimentata separatamente secondo le sue specifiche.