Componenti · 9 min di lettura

Serratura solenoide Arduino: 12V con MOSFET, tastierino e RFID

Serratura solenoide con Arduino: come funziona quella a 12V, pilotaggio con MOSFET o relè, diodo di ricircolo, calore, tastierino e RFID, fail-safe ed ESP32.

Una serratura solenoide è un chiavistello elettrico che ritrae il suo scrocco quando la corrente attraversa la bobina interna e lascia che una molla lo spinga di nuovo fuori quando la corrente si interrompe. Con una serratura solenoide e Arduino puoi costruire un armadietto con codice, una porta che si apre con una tessera RFID, un cassetto che si apre con l'impronta o una cassetta delle lettere che sblocchi dal telefono. Il tipo più diffuso nei progetti hobbistici è la piccola "serratura da mobile" a 12 V che assorbe circa 0,5-1 A. È da 25 a 50 volte quello che un pin di Arduino può fornire, quindi la serratura non si collega direttamente a un pin ma si pilota tramite un MOSFET o un relè.

In questa guida spiego cosa c'è dentro una serratura solenoide, come calcolarne corrente e potenza, due modi per pilotarla con un MOSFET o un relè, il diodo di ricircolo indispensabile per non danneggiare la scheda e perché la bobina va alimentata solo per poco. Poi scriveremo il codice per una serratura con tastierino, una con tessera RC522 e una con ESP32 da aprire dal telefono. Infine vedremo i concetti di fail-safe e fail-secure, che decidono cosa succede quando manca la corrente. Se i MOSFET sono nuovi per te, come usare un MOSFET con Arduino è un buon punto di partenza.

Cos'è una serratura solenoide e come funziona?

La parola "solenoide" indica una bobina di filo avvolta attorno a un tubo. Quando la corrente attraversa la bobina, al suo interno si forma un campo magnetico che attira verso di sé il nucleo di ferro (pistone) al centro. Nella serratura il pistone è collegato a uno scrocco con la faccia inclinata. Senza corrente una molla tiene lo scrocco fuori e la porta resta chiusa; applicando 12 V il pistone viene richiamato, lo scrocco rientra e la porta si apre. Grazie alla faccia inclinata, chiudendo la porta lo scrocco viene spinto dentro e torna in posizione da solo, quindi chiudere non richiede energia. Se ti interessa come si comportano le bobine, leggi cos'è un induttore.

CaratteristicaTipica serratura solenoide da 12 VNota
Tensione di lavoro12 V DCA 9 V tira poco; a 5 V di solito non si apre
Corrente0,5-1 A (spesso 0,6-0,8 A)Controlla l'etichetta o misura la resistenza della bobina
Resistenza della bobinaCirca 12-24 ΩI = V / R; 0,75 A con 16 Ω
Potenza6-12 WP = V × I; 12 V × 0,75 A = 9 W
Tempo di eccitazionePochi secondi (max 10 s sulla maggior parte)Si scalda se tenuta aperta a lungo
Quando manca la correnteResta chiusa (fail-secure)Le serrature elettromagnetiche invece si aprono

Se non conosci la corrente della tua serratura, metti il multimetro in ohm, misura la resistenza tra i due fili della bobina e calcola la corrente con il calcolatore della legge di Ohm. Se misuri 16 Ω a 12 V, la serratura assorbe 0,75 A; scegli un alimentatore di almeno il doppio, cioè 12 V 2 A. Al primo richiamo la corrente può salire per un attimo, e se la tensione di un alimentatore debole cala, la serratura non si apre del tutto.

Pilotare la serratura solenoide con un MOSFET o un relè

Ci sono due metodi comuni. Un MOSFET è silenzioso, veloce, non si usura e occupa poco spazio; scelto bene non si scalda nemmeno. La caratteristica da cercare è il "livello logico": il gate deve portarlo in piena conduzione a 5 V, o a 3,3 V se usi un ESP32. L'IRLZ44N ha circa 0,025 Ω a 5 V; a 0,75 A dissipa P = I² × R ≈ 14 mW, quindi non serve dissipatore. I diffusissimi moduli IRF520, invece, sono pensati per un gate a 10 V e a 5 V restano a metà conduzione e scaldano. Un modulo relè è semplice e in più isola i due circuiti; i difetti sono il clic, l'usura dei contatti e la corrente assorbita dalla sua bobina. Per scegliere transistor o MOSFET guarda i valori nello strumento transistor.

Collegamento (circuito MOSFET)Dove?Perché?
Serratura rosso (+)+ dell'alimentatore a 12 VLa bobina resta sempre sul positivo
Serratura nero (-)Drain (D) del MOSFETIl MOSFET commuta il lato negativo
Source (S) del MOSFET- dell'alimentatore a 12 V e GND di ArduinoMassa comune
Gate (G) del MOSFETArduino D10 tramite 220 ΩLimita il picco di corrente di carica del pin
Resistenza da 10 kΩTra gate e GNDEvita che la serratura si apra all'accensione
Diodo 1N4007In inversa ai capi della serratura; banda verso +12 VAssorbe il picco di tensione inversa della bobina
Condensatore da 470 µFTra + e - dei 12 V, vicino alla serraturaRiduce il calo di tensione al richiamo
Non saltare mai il diodo di ricircolo. Quando la corrente di una bobina si interrompe di colpo, il campo magnetico collassa e la bobina genera ai suoi capi un picco di tensione inversa di centinaia di volt per mantenere la corrente. Senza diodo quel picco fora il MOSFET, resetta Arduino o brucia il pin. Collega il diodo ai capi della serratura con l'estremità a banda argentata (catodo) verso +12 V; nel funzionamento normale non conduce e riporta solo il picco di spegnimento nella bobina, dove si esaurisce. Anche con un relè serve lo stesso diodo, altrimenti i contatti si consumano con una scintilla a ogni apertura. Dettagli in cos'è un diodo.

Alimentare Arduino e serratura con lo stesso adattatore a 12 V è pratico: puoi dare 12 V all'Uno tramite il jack DC. Però la tensione cala per un attimo quando la serratura richiama e il regolatore dell'Uno si scalda scendendo da 12 V a 5 V; una soluzione più robusta è abbassare i 12 V a 5 V con un modulo LM2596 e alimentare la scheda dal pin 5V. In ogni caso il source del MOSFET, il negativo dell'adattatore e il GND di Arduino devono incontrarsi in un punto; spiego perché in dettaglio in GND e massa comune.

Eccitazione breve e calore: per quanto tempo puoi tenere aperta la serratura?

Dissipare 9 W in una bobina piccola è come tenere acceso un piccolo saldatore nello spazio del palmo della mano. Le serrature da mobile economiche di solito sono progettate per un servizio intermittente: aprirsi per qualche secondo non è un problema, ma tenuta aperta per minuti la bobina diventa troppo calda da toccare, la vernice isolante si degrada e la serratura col tempo perde forza. Per questo definisci sempre nel software un tempo massimo di apertura; nei codici di questo articolo è di 3 secondi. Se la porta deve restare aperta a lungo ci sono due soluzioni: scegliere una serratura che trattiene lo scrocco meccanicamente o dare piena potenza al richiamo e poi ridurla con il PWM. La bobina ha bisogno di molta più forza per richiamare lo scrocco che per trattenerlo; dopo 200 ms a piena potenza, un PWM del 30-40% lo trattiene nella maggior parte delle serrature e riduce di parecchie volte il riscaldamento. Come funziona il PWM lo trovi in cos'è il PWM.

Serratura a codice con tastierino e solenoide

Tastierino a membrana 4x4
Tastierino a membrana 4x4: legge 16 tasti con 4 pin di riga e 4 di colonna; la libreria Keypad fa la scansione al posto tuo.

Il primo progetto usa un tastierino 4x4 per inserire il codice. Collega i pin di riga a D9, D8, D7, D6 e quelli di colonna a D5, D4, D3, D2; il gate del MOSFET va su D10 e un piccolo buzzer attivo su A0. Installa la libreria Keypad di Mark Stanley dal Gestore librerie. Digiti il codice e confermi con #, mentre * cancella l'inserimento. Dopo tre tentativi sbagliati il tastierino si blocca per 30 secondi; questa piccola misura rende praticamente impossibile indovinare il codice per tentativi. Il funzionamento interno del tastierino lo trovi nell'articolo sul tastierino.

C++ (Arduino IDE)
1// Keypad şifreli solenoid kilit / keypad-code solenoid lock
2#include <Keypad.h>
3
4const int LOCK_PIN = 10;                 // MOSFET gate (220 ohm üzerinden / via 220 ohm)
5const int BUZZER_PIN = A0;               // aktif buzzer / active buzzer
6const unsigned long OPEN_MS = 3000;      // kilit açık süresi / unlock time
7const unsigned long LOCKOUT_MS = 30000;  // 3 hatadan sonra bekleme / lockout after 3 errors
8const char* PASSWORD = "2580";           // şifreyi değiştir / change the code
9
10const byte ROWS = 4, COLS = 4;
11char keys[ROWS][COLS] = {
12  {'1', '2', '3', 'A'},
13  {'4', '5', '6', 'B'},
14  {'7', '8', '9', 'C'},
15  {'*', '0', '#', 'D'}
16};
17byte rowPins[ROWS] = {9, 8, 7, 6};
18byte colPins[COLS] = {5, 4, 3, 2};
19Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
20
21String input = "";
22int wrongCount = 0;
23bool lockedOut = false;
24unsigned long lockoutStart = 0;
25
26void beep(int ms) {
27  digitalWrite(BUZZER_PIN, HIGH);
28  delay(ms);
29  digitalWrite(BUZZER_PIN, LOW);
30}
31
32void unlock() {
33  digitalWrite(LOCK_PIN, HIGH);   // bobine enerji ver, dil çekilir / energise coil, bolt retracts
34  delay(OPEN_MS);                 // yalnız kısa süre / short time only
35  digitalWrite(LOCK_PIN, LOW);    // yay dili geri iter / spring pushes the bolt back
36}
37
38void setup() {
39  pinMode(LOCK_PIN, OUTPUT);
40  digitalWrite(LOCK_PIN, LOW);    // açılışta kilitli / locked at power-up
41  pinMode(BUZZER_PIN, OUTPUT);
42}
43
44void loop() {
45  char k = keypad.getKey();
46  if (!k) return;
47
48  if (lockedOut) {
49    if (millis() - lockoutStart < LOCKOUT_MS) { beep(300); return; }
50    lockedOut = false;
51  }
52  beep(30);
53
54  if (k == '*') { input = ""; return; }          // temizle / clear
55  if (k == '#') {                                 // onayla / confirm
56    if (input == PASSWORD) {
57      wrongCount = 0;
58      unlock();
59    } else {
60      beep(600);
61      if (++wrongCount >= 3) {                    // kaba kuvvete karşı / against brute force
62        lockedOut = true;
63        lockoutStart = millis();
64        wrongCount = 0;
65      }
66    }
67    input = "";
68    return;
69  }
70  if (input.length() < 8) input += k;            // en fazla 8 hane / max 8 digits
71}

Serratura che si apre con tessera RFID (RC522)

Modulo lettore RFID RC522
RC522: legge tessere e portachiavi MIFARE a 13,56 MHz da pochi centimetri; si collega via SPI e si alimenta a 3,3 V.

Nel secondo progetto la serratura si apre quando si avvicina una tessera RFID registrata. Collega l'RC522 all'Uno così: SDA → D10, SCK → D13, MOSI → D11, MISO → D12, RST → D9, 3.3V → 3.3V e GND → GND; poiché l'SPI occupa D10-D13, questa volta il gate del MOSFET va su D6. Installa la libreria MFRC522, carica il codice, avvicina la tessera e copia nella lista ALLOWED l'UID mostrato nel Monitor seriale. Dato che gli UID delle tessere si possono clonare, questo metodo va bene per armadietti e cassetti; da solo non basta dove serve alta sicurezza, come una porta esterna. Per i dettagli sull'RC522 leggi la guida all'RFID RC522.

C++ (Arduino IDE)
1// RFID kartla solenoid kilit / RFID card solenoid lock
2#include <SPI.h>
3#include <MFRC522.h>
4
5const int SS_PIN = 10;              // RC522 SDA
6const int RST_PIN = 9;              // RC522 RST
7const int LOCK_PIN = 6;             // MOSFET gate
8const unsigned long OPEN_MS = 3000;
9
10// Yetkili kart UID'leri, Seri Monitör'den oku / authorised UIDs, read them from the Serial Monitor
11const byte ALLOWED[][4] = {
12  {0xDE, 0xAD, 0xBE, 0xEF},
13  {0x12, 0x34, 0x56, 0x78}
14};
15const int ALLOWED_COUNT = sizeof(ALLOWED) / sizeof(ALLOWED[0]);
16
17MFRC522 rfid(SS_PIN, RST_PIN);
18
19bool isAllowed(const byte* uid, byte size) {
20  if (size != 4) return false;
21  for (int i = 0; i < ALLOWED_COUNT; i++) {
22    if (memcmp(uid, ALLOWED[i], 4) == 0) return true;
23  }
24  return false;
25}
26
27void setup() {
28  Serial.begin(9600);
29  pinMode(LOCK_PIN, OUTPUT);
30  digitalWrite(LOCK_PIN, LOW);
31  SPI.begin();
32  rfid.PCD_Init();
33}
34
35void loop() {
36  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;
37
38  Serial.print("UID:");
39  for (byte i = 0; i < rfid.uid.size; i++) {
40    Serial.print(rfid.uid.uidByte[i] < 0x10 ? " 0" : " ");
41    Serial.print(rfid.uid.uidByte[i], HEX);
42  }
43  Serial.println();
44
45  if (isAllowed(rfid.uid.uidByte, rfid.uid.size)) {
46    Serial.println("Açıldı / unlocked");
47    digitalWrite(LOCK_PIN, HIGH);
48    delay(OPEN_MS);
49    digitalWrite(LOCK_PIN, LOW);
50  } else {
51    Serial.println("Yetkisiz kart / unknown card");
52  }
53  rfid.PICC_HaltA();               // kartı beklemeye al / halt the card
54}
Con la stessa logica puoi costruire una serratura a impronta: basta chiamare la funzione di apertura quando il sensore di impronte AS608 trova un dito corrispondente. Combinare tastierino, tessera e impronta in una verifica a due passaggi (prima tessera, poi codice) aumenta molto la sicurezza.

Cosa succede se manca la corrente? Fail-safe e fail-secure

La prima domanda da porsi scegliendo una serratura elettrica è: se manca la corrente, la porta deve restare aperta o chiusa? Le serrature fail-secure restano chiuse senza energia; così funzionano i solenoidi tipo serratura da mobile, la scelta giusta per casseforti, cassetti e cassette per pacchi. Le serrature fail-safe invece si aprono quando manca la corrente; così funzionano gli elettromagneti delle porte negli edifici, perché in caso di incendio o blackout le persone devono poter uscire. Montare una serratura fail-secure su una porta di emergenza è pericoloso e nella maggior parte dei casi è vietato dalle norme.

Tipo di serraturaSe manca la correnteUso adatto
Serratura solenoide da mobileResta chiusa (fail-secure)Armadietti, casseforti, cassetti, scatole
Elettromagnete per porteSi apre (fail-safe)Ingressi di edifici, vie di fuga
Incontro elettricoL'uno o l'altro secondo il modelloIn aggiunta a una serratura esistente
Serratura motorizzataResta nell'ultima posizioneSerrature smart, sistemi a batteria

Se usi una serratura fail-secure, prevedi un piano B per non restare chiuso fuori: una chiave meccanica di riserva, un pulsante di apertura di emergenza nascosto o una batteria tampone che alimenti serratura e Arduino per un po'. Per esempio una piccola batteria al piombo da 12 V o un pacco al litio 3S con circuito di ricarica basta per qualche centinaio di aperture durante un blackout.

Aprire la serratura solenoide dal telefono con un ESP32

L'ESP32 è il modo più semplice per aprire la serratura via WiFi. Il codice seguente crea un piccolo web server; quando apri nel browser del telefono l'indirizzo IP mostrato nel Monitor seriale, ti chiede nome utente e password e poi mostra un grande pulsante APRI. Premendolo, la serratura si apre per 3 secondi e si richiude da sola grazie a millis(), mentre il server continua a funzionare. Una differenza importante: i pin dell'ESP32 danno 3,3 V. Un IRLZ44N potrebbe non andare in piena conduzione a questa tensione; usa un MOSFET specificato per commutare a 2,5-4,5 V come l'IRLB8721 o l'AO3400, oppure pilota la serratura con un modulo relè che scatti a 3,3 V. Per alimentare l'ESP32 dai 12 V, abbassali a 5 V con un LM2596 e collegali al pin 5V (VIN).

C++ (Arduino IDE)
1// ESP32: telefondan solenoid kilit açma / open the solenoid lock from your phone
2#include <WiFi.h>
3#include <WebServer.h>
4
5const char* WIFI_SSID = "AgAdi";        // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123";     // Wi-Fi şifren / your Wi-Fi password
7const char* WEB_USER  = "kapi";         // sayfa kullanıcı adı / page user name
8const char* WEB_PASS  = "degistir-beni"; // sayfa şifresi, değiştir / page password, change it
9const int LOCK_PIN = 26;                // MOSFET gate (3,3 V ile tam açılan / fully on at 3.3 V)
10const unsigned long OPEN_MS = 3000;
11
12WebServer server(80);
13bool isOpen = false;
14unsigned long openedAt = 0;
15
16const char PAGE[] = R"html(<!DOCTYPE html><html><head>
17<meta name="viewport" content="width=device-width,initial-scale=1"><title>Kapi</title></head>
18<body style="font-family:sans-serif;text-align:center;margin-top:40px">
19<h2>Solenoid kilit / lock</h2>
20<form method="POST" action="/open"><button style="font-size:28px;padding:20px 40px">AC / OPEN</button></form>
21</body></html>)html";
22
23bool checkAuth() {
24  if (server.authenticate(WEB_USER, WEB_PASS)) return true;
25  server.requestAuthentication();         // tarayıcı şifre sorar / browser asks for a password
26  return false;
27}
28
29void handleRoot() {
30  if (!checkAuth()) return;
31  server.send(200, "text/html", PAGE);
32}
33
34void handleOpen() {
35  if (!checkAuth()) return;
36  if (!isOpen) {
37    digitalWrite(LOCK_PIN, HIGH);         // kilidi aç / unlock
38    isOpen = true;
39    openedAt = millis();
40  }
41  server.sendHeader("Location", "/");
42  server.send(303);                       // ana sayfaya dön / back to the main page
43}
44
45void setup() {
46  pinMode(LOCK_PIN, OUTPUT);
47  digitalWrite(LOCK_PIN, LOW);
48  Serial.begin(115200);
49  WiFi.mode(WIFI_STA);
50  WiFi.begin(WIFI_SSID, WIFI_PASS);
51  while (WiFi.status() != WL_CONNECTED) delay(500);
52  Serial.println(WiFi.localIP());         // bu adresi telefonda aç / open this on your phone
53
54  server.on("/", HTTP_GET, handleRoot);
55  server.on("/open", HTTP_POST, handleOpen);
56  server.begin();
57}
58
59void loop() {
60  server.handleClient();
61  if (isOpen && millis() - openedAt >= OPEN_MS) {   // süre dolunca kilitle / relock when time is up
62    digitalWrite(LOCK_PIN, LOW);
63    isOpen = false;
64  }
65}
  • Il server è raggiungibile solo dalla rete di casa; per aprire da fuori usa un intermediario come un bot Telegram o MQTT invece di aprire una porta sul router.
  • La password chiesta dal browser viaggia quasi in chiaro sulla rete; in casa è accettabile, ma la password del WiFi deve essere robusta e WEB_PASS va assolutamente cambiata.
  • Il comando di apertura viene inviato in POST, così il browser non può far scattare la serratura precaricando la pagina o riaprendola dalla cronologia.
  • Per approfondire la pagina web e mostrare lo stato in tempo reale leggi web server e WebSocket con ESP32.

Errori comuni e soluzioni

SintomoCausaSoluzione
La serratura fa clic ma non si apreCorrente dell'alimentatore insufficiente o tensione che calaUsa un alimentatore 12 V 2 A e un condensatore da 470 µF
Arduino si resetta all'aperturaManca il diodo di ricircolo o le masse non sono comuniMetti il diodo e unisci le masse in un punto
Il MOSFET scaldaNon è a livello logico (es. IRF520) o resistenza di gate troppo grandeUsa un IRLZ44N, o IRLB8721/AO3400 con ESP32
La serratura si apre un attimo all'accensioneGate flottanteAggiungi 10 kΩ tra gate e GND
La serratura non si chiude maiMOSFET bruciato (spesso per uso senza diodo)Sostituisci il MOSFET e aggiungi il diodo
La bobina scalda moltoResta alimentata troppo a lungoLimita il tempo di apertura o riduci la potenza di mantenimento con PWM
Alla prima prova lascia da parte il codice e tocca per un secondo i due fili della serratura direttamente sull'alimentatore a 12 V. Se lo scrocco rientra, serratura e alimentatore sono a posto e il problema è nel circuito di pilotaggio. Se non rientra, controlla prima con il multimetro che l'alimentatore dia davvero 12 V e abbastanza corrente.

Con un MOSFET, un diodo e poche righe di codice, una serratura solenoide può essere uno dei tuoi primi progetti che apre e chiude qualcosa nel mondo reale. Nell'app BlueGrays trovi progetti come l'autenticazione RFID, una serratura a codice con tastierino e LCD, una cassaforte elettronica intelligente e una serratura RFID con ESP32, ognuno con schema e codice passo passo, a cui aggiungere il circuito di pilotaggio del solenoide di questo articolo.

Domande frequenti

Una serratura solenoide si può collegare direttamente ad Arduino?

No. Una serratura solenoide a 12 V assorbe 0,5-1 A, mentre un pin di Arduino fornisce al massimo 20-40 mA a 5 V. Alimenta la serratura con una sorgente a 12 V separata tramite un MOSFET a livello logico (come l'IRLZ44N) o un modulo relè. Non dimenticare il diodo di ricircolo sulla bobina.

Quanti ampere assorbe una serratura solenoide?

Le serrature da mobile a 12 V usate nei progetti hobbistici assorbono di solito 0,5-1 A, più spesso 0,6-0,8 A. Puoi misurare la resistenza della bobina e calcolare con I = V / R; una bobina da 16 Ω assorbe 0,75 A a 12 V. Scegli un alimentatore da almeno il doppio.

Quale MOSFET usare per una serratura solenoide?

Sulle schede a 5 V come Arduino Uno vanno bene MOSFET a livello logico come IRLZ44N o IRL540N. Sulle schede a 3,3 V come ESP32 e Pico scegli modelli che vanno in piena conduzione a bassa tensione, come IRLB8721 o AO3400. I moduli IRF520 non sono consigliati perché richiedono 10 V sul gate.

Perché serve un diodo di ricircolo?

Quando la corrente di una bobina si interrompe, il campo magnetico collassa e genera un picco di tensione inversa di centinaia di volt. Quel picco danneggia il MOSFET, resetta Arduino o rovina il pin. Un diodo come l'1N4007, collegato in inversa ai capi della serratura, assorbe il picco in sicurezza.

Una serratura solenoide può restare aperta di continuo?

La maggior parte delle serrature da mobile economiche è progettata per servizio intermittente e si scalda molto in pochi minuti se alimentata di continuo. Limita via software il tempo di apertura a pochi secondi. Se deve restare aperta più a lungo, dai piena potenza al richiamo e poi riduci la potenza di mantenimento con il PWM.

La serratura solenoide si apre se manca la corrente?

Le serrature solenoidi da mobile sono fail-secure, cioè restano chiuse quando manca la corrente. Gli elettromagneti per porte sono fail-safe e si aprono senza energia. Sulle porte di emergenza si preferiscono quelle fail-safe, su casseforti e armadietti quelle fail-secure.

Vedi tutti i progetti
Cassaforte elettronica intelligente
AR-92Avanzato
Premium

Cassaforte elettronica intelligente

Una piccola cassaforte per le tue cose di valore che si apre con un codice. Digiti il tuo codice a quattro cifre sul tastierino; se è giusto, il servomotore apre la serratura, si accende la luce…

4.7(42)
63
Serratura con password, tastierino 4x4 e LCD
AR-64Avanzato
Premium

Serratura con password, tastierino 4x4 e LCD

Una piccola serratura elettronica che non fa entrare chi non conosce il codice. Premi il tasto cancelletto e digiti il codice sul tastierino; se è giusto, lo schermo indica accesso consentito, si…

4.8(59)
75
Autenticazione RFID
AR-54Intermedio
Premium

Autenticazione RFID

Come l'ingresso con tessera di un condominio: avvicini la tua tessera al lettore RFID e l'Arduino confronta il suo numero con quello salvato.

4.8(65)
84
Lettura del valore RFID
AR-53Principiante
Premium

Lettura del valore RFID

Il portachiavi del condominio o la tessera d'ingresso nascondono un numero di identificazione segreto, e questo progetto lo legge.

4.7(47)
61
Serratura RFID ESP32 (RC522 + servomotore + OLED + cicalino + LED)
ES-35Avanzato
Premium

Serratura RFID ESP32 (RC522 + servomotore + OLED + cicalino + LED)

Costruiamo una serratura smart con ESP32, modulo RFID RC522, servo SG90, display OLED SSD1306, buzzer attivo e 2 LED. Quando passi una tessera, il suo UID viene confrontato con quelle autorizzate definite nel codice; se corrisponde, il servo apre (LED verde + 2 bip brevi) e richiude dopo 5 secondi. Con una tessera sconosciuta si accende il LED rosso, suonano 3 bip rapidi e l'OLED mostra l'UID.

4.8(9)
16
Lettore di schede RFID RC522 per ESP32 (con LCD)
ES-21Intermedio

Lettore di schede RFID RC522 per ESP32 (con LCD)

In questo progetto collegheremo il modulo RFID RC522 basato su MFRC522 all'ESP32 tramite SPI per leggere l'UID della tessera o dell'etichetta. Costituisce la base per applicazioni quali serrature, sistemi di abbonamento e controllo degli accessi. Visualizzeremo l'UID letto su un display LCD; questa versione non lo confronta con un elenco di tessere autorizzate. ATTENZIONE: l'RC522 funziona solo a 3,3 V; a 5 V il modulo si brucerà!

4.8(21)
42
Funzionamento del tastierino 3x4
AR-61Principiante

Funzionamento del tastierino 3x4

L'Arduino capisce subito quale tasto premi su un tastierino da 12 tasti simile a quello di un telefono, e lo scrive sullo schermo del tuo computer.

4.5(24)
32
Lampadina 220V con pulsante (Push)
AR-19Avanzato
Premium

Lampadina 220V con pulsante (Push)

Finché tieni premuto il pulsante, una vera lampadina da 220 volt resta accesa, e si spegne appena lo lasci.

4.4(30)
38