Blocare electronica pentru arduino uno. Blocare cu combinație neobișnuită pe Arduino

În acest articol vă voi arăta cum să faceți o lacăt cu combinație din arduino. Pentru a face acest lucru, avem nevoie de LED-uri roșii și verzi, un sonerie, un arduino nano, un afișaj LCD cu convertor I2C, un servomotor și o tastatură cu matrice 4x4. Când este pornit, afișajul va scrie „Introduceți codul”.

LED-ul roșu se va aprinde,

iar verdele se stinge, servo-ul va fi setat la 0°. Când sunt introduse numere, * se va aprinde pe afișaj.

Dacă codul este introdus incorect, pe ecran va apărea „Introducere cod.”. Dacă codul este corect, se va auzi un bip, servo-ul se va întoarce la 180°, pe afișaj va apărea „Open”.

LED-ul verde se va aprinde,

iar roșul se va stinge. După 3 secunde, servo-ul va reveni în poziția de start, LED-ul roșu se va aprinde și LED-ul verde se va stinge, afișajul va scrie „Închidere”.

apoi pe afișaj se va scrie „Introduceți codul.”. Acum despre schema. Mai întâi, conectăm arduino cu fire la placa de breadboard (contacte de alimentare).

Apoi conectăm o tastatură matriceală la contactele D9 - D2.

Apoi servo. Îl conectăm la pinul 10.

LED roșu la pinul 11.

Verde - la pinul 12.

Buzzer - la pinul 13.

Acum încărcați schița.

#include #include #include #include iarduino_KB KB(9, 8, 7, 6, 5, 4, 3, 2); LiquidCrystal_I2C lcd(0x27, 16, 2); Servo servo int trece = (3, 6, 1, 8); int în; int r = 11; int g = 12; void setup() ( KB.begin(KB1); pinMode(r, OUTPUT); pinMode(g, OUTPUT); lcd.init(); lcd.backlight(); digitalWrite(g, LOW); digitalWrite(r, HIGH); ); servo.attach(10); servo.write(0); lcd.setCursor(0, 0); ) void loop() (lcd.clear(); lcd.print(„Introduceți codul.”); while ( !KB.check(KEY_DOWN)) ( întârziere(1); ) în = KB.getNum; lcd.clear(); lcd.setCursor(0, 0); lcd.print("*"); în timp ce (!KB. check(KEY_DOWN)) ( delay(1); ) in = KB.getNum; lcd.print("*"); în timp ce (!KB.check(KEY_DOWN)) ( delay(1); ) in = KB.getNum; lcd.print("*"); în timp ce (!KB.check(KEY_DOWN)) (întârziere(1); ) in = KB.getNum; lcd.print("*"); dacă (în == trece) (dacă (în == trece) ( dacă (în == trece) ( dacă (în == trece) ( lcd.clear(); lcd.setCursor(0, 0); lcd.print(„Deschis.”); tone( 13, 400, 750); servo.write(180); digitalWrite(r, LOW); digitalWrite(g, HIGH); delay(3000); lcd.clear(); lcd.setCursor(0, 0); lcd. print("Închidere."); tone(13, 300, 700); servo.write(0); digitalWrite(g, LOW); digitalWrite(r, HIGH); delay(1000); ) ) ) ) )

Asta e tot. Bucurați-vă de blocarea codului!

Lista elementelor radio

Arduino este cel mai bun sistem pentru copierea oricărui tip de echipament. Majoritatea ideilor nu ar fi fost posibile fără ea. A existat de mult o astfel de idee: de a crea o încuietoare cu combinație specială pe arduino. Pentru a-l deschide, trebuie să țineți apăsată o anumită tastă. În acest caz, încuietoarea nu ar trebui să se deschidă, chiar dacă cunoașteți butonul corect. Pentru a-l deschide, trebuie să menții anumite intervale folosind memoria musculară. Un criminal nu poate face așa ceva. Dar toate acestea sunt doar o teorie.

Pentru a-l asambla, trebuie să utilizați un dispozitiv special de impulsuri dreptunghiulare, precum și mai multe contoare și o grămadă. Dar dispozitivul finit ar avea dimensiuni mari de gabarit și ar fi incomod de utilizat. De regulă, astfel de gânduri nu dă odihnă. Primul pas în realizarea visului a fost crearea unui program pentru Arduino. Va servi ca încuietoare cu combinație. Pentru a-l deschide, va trebui să apăsați nu o tastă, ci mai multe și să faceți acest lucru în același timp. Circuitul terminat arată astfel:

Calitatea imaginii nu este cea mai bună, dar conexiunea se face la masă, D3, D5, D7, D9 și D11.

Codul este prezentat mai jos:

Const intina = 3; const int inb = 5; const int inc = 9; const int ledPin = 13; int i = 1000; octet a = 0; octet b = 0; octet c = 0; octet d = 0; timp lung nesemnat = 0; //nu uita nimic care ia valoarea millis() unsigned long temp = 0; //stocare în cheie de octeți lungi nesemnați = ( 0, 0, 0, 0, 0, 0, 0, 0); //codează de fapt byte keyb = ( 1, 1, 1, 1, 0, 1, 0, 0); tasta octetc = ( 1, 0, 1, 0, 1, 1, 1, 0); octet k = 0; void setup() ( pinMode(ina, INPUT_PULLUP); //3 intrări conectate la butoane pinMode(inb, INPUT_PULLUP); pinMode(inc, INPUT_PULLUP); pinMode(ledPin, OUTPUT); //LED încorporat pe pin 13 pinMode (7, OUTPUT); pinMode(11, OUTPUT); digitalWrite(7, LOW); //înlocuiește ground digitalWrite(11, LOW); time = millis(); //necesar pentru sincronizare ) void blinktwice() ( // dublă clipire a LED-ului digitalWrite (ledPin, HIGH); întârziere (100); digitalWrite (ledPin, LOW); întârziere (100); digitalWrite (ledPin, HIGH); delay (100); digitalWrite (ledPin, LOW); întârziere ( 200); ) void loop() ( if(k==0) ( blinktwice(); // solicită introducerea codului ) if (k == 8) ( digitalWrite(ledPin, HIGH); delay(3000); k = 0 ; ) a = digitalRead(ina); //citește nivelurile semnalului de la butoane - apăsat/nepăsat b = digitalRead(inb); c = digitalRead(inc); delay(100); //next if - protecție împotriva false pozitive, if((digitalRead(ina) == a)&&(digitalRead(inb) ==b)&&(digitalRead(inc)==c)) ( dacă (a == keya[k]) ( dacă (b == keyb[k]) ( dacă (c == keyc[k]) ( k++; ) ) ) ) dacă (k==1) ( dacă (d ==0) ( timp = milis (); d++; ) ) temp = milis(); temp = temp - timp; dacă (temp > 10000) ( k= 0; d=0; timp = milis (); ) )

Pentru a evita întrebările inutile despre cod, unele puncte ar trebui clarificate. Funcția de configurare este utilizată pentru a atribui porturi. Următoarea funcție este Input_Pullup, care este necesară pentru a crește tensiunea pinului cu 5 V. Acest lucru se face folosind un rezistor. Din acest motiv, diferite scurtcircuite nu vor avea loc. Pentru un confort sporit, se recomandă utilizarea funcției blinktwice. În general, atunci când creați diferite programe, trebuie să încercați și alte funcții.

După atribuirea funcțiilor, semnalul este citit de la porturi. Dacă butonul este apăsat, atunci acest lucru va fi indicat de numărul 1, iar dacă nu - 2. În continuare, toate valorile sunt analizate. De exemplu, există o astfel de combinație ca 0,1,1. Aceasta înseamnă că prima tastă este apăsată, iar celelalte două nu. Dacă toate valorile sunt adevărate, atunci condiția 8 este, de asemenea, adevărată. Acest lucru este indicat de LED-ul aprins de pe panoul frontal. Apoi, trebuie să introduceți un cod specific care va servi la deschiderea ușii.

Ultimele elemente ale codului sunt folosite pentru a reseta valorile contorului. Această funcție este executată dacă au trecut mai mult de 10 secunde de la ultima apăsare a tastei. Fără acest cod, a fost posibil să se rezolve toate opțiunile posibile, deși există destul de multe. După crearea acestui dispozitiv, trebuie să-l testați. Mai mult

Progresul nu stă pe loc și „încuietori inteligente” apar din ce în ce mai mult pe ușile apartamentelor, garajelor și caselor.

O blocare similară se deschide atunci când apăsați un buton de pe smartphone. Din fericire, smartphone-urile și tabletele au intrat deja în viața noastră de zi cu zi. În unele cazuri, „lacătele inteligente” sunt conectate la „servicii cloud” precum Google Drive și sunt deschise de la distanță. În plus, această opțiune face posibilă acordarea accesului la deschiderea ușii altor persoane.

În acest proiect, va fi implementată o versiune DIY a unei încuietori inteligente pe Arduino, care poate fi controlată de la distanță de oriunde în lume.

În plus, proiectul a adăugat capacitatea de a deschide încuietoarea după recunoașterea amprentei. Pentru aceasta, va fi integrat un senzor de amprentă. Ambele opțiuni pentru deschiderea ușilor vor funcționa pe baza platformei Adafruit IO.

O încuietoare ca aceasta poate fi un prim pas grozav în proiectul dvs. Smart Home.

Configurarea senzorului de amprentă

Pentru a lucra cu senzorul de amprentă, există o bibliotecă excelentă pentru Arduino, care simplifică foarte mult procesul de configurare a senzorului. Acest proiect folosește un Arduino Uno. Placa Adafruit CC3000 este folosită pentru conectarea la internet.

Să începem prin a conecta puterea:

• Conectați pinul de 5V de la placa Arduino la șina roșie de alimentare;
• Pinul GND de la Arduino se conectează la șina albastră de pe placa de circuite fără lipire.

Să trecem la conectarea senzorului de amprentă:

• Conectați mai întâi alimentarea. Pentru a face acest lucru, firul roșu este conectat la șina +5 V, iar firul negru la șina GND;
• Firul alb al senzorului se conectează la pinul 4 de pe Arduino.
• Firul verde merge la pinul 3 al microcontrolerului.

Acum să aruncăm o privire la modulul CC3000:

• Conectați pinul IRQ de la placa CC3000 la pinul 2 de pe Arduino.
• VBAT - la pinul 5.
• CS - la pinul 10.
• După aceea, trebuie să conectați pinii SPI la Arduino: MOSI, MISO și CLK - la pinii 11, 12 și, respectiv, 13.

Și, în sfârșit, trebuie să furnizați energie: Vin - la Arduino 5V (șină roșie pe placa dvs. de circuit) și GND la GND (șină albastră pe placa).

O fotografie a proiectului complet asamblat este prezentată mai jos:

Înainte de a dezvolta o schiță care va încărca date în Adafruit IO, trebuie să transmiteți datele dvs. de amprentă senzorului. Altfel, nu te va recunoaște pe viitor;). Vă recomandăm să calibrați senzorul de amprentă folosind Arduino separat. Dacă lucrați cu acest senzor pentru prima dată, vă recomandăm să citiți procesul de calibrare și instrucțiuni detaliate pentru lucrul cu senzorul de amprentă.

Dacă nu ați făcut acest lucru deja, atunci creați un cont Adafruit IO.

După aceea, putem trece la următoarea etapă de dezvoltare a unui „smart lock” pe Arduino: și anume, dezvoltarea unei schițe care va transmite date către Adafruit IO. Deoarece programul este destul de voluminos, în articol vom evidenția și luăm în considerare doar părțile sale principale, apoi vom oferi un link către GitHub, de unde puteți descărca schița completă.

Schița începe prin încărcarea tuturor bibliotecilor necesare:

#include

#include

#include

#include „Adafruit_MQTT.h”

#include „Adafruit_MQTT_CC3000.h”

#include

#include >

După aceea, trebuie să corectați ușor schița inserând parametrii rețelei WiFi, specificând SSID-ul și parola (parola):

#define WLAN_SECURITY WLAN_SEC_WPA2>

În plus, trebuie să introduceți un nume și o cheie AIO (cheie) pentru a vă introduce contul Adafruit IO:

#define AIO_SERVERPORT 1883

#define AIO_USERNAME „adafruit_io_name”

#define AIO_KEY "adafruit_io_key">

Următoarele linii sunt responsabile pentru interacțiunea și procesarea datelor de la senzorul de amprentă. Dacă senzorul a fost activat (amprenta digitală potrivită), acesta va fi „1”:

const char FINGERPRINT_FEED PROGMEM = AIO_USERNAME "/feeds/fingerprint";

Adafruit_MQTT_Publish fingerprint = Adafruit_MQTT_Publish(&mqtt, FINGERPRINT_FEED);

În plus, trebuie să creăm o instanță a obiectului SoftwareSerial pentru senzorul nostru:

SoftwareSerial mySerial(3, 4);

După aceea, putem crea un obiect pentru senzorul nostru:

Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);

În interiorul schiței, specificăm ce fingerID ar trebui să activeze blocarea în viitor. În acest exemplu, se utilizează 0, care corespunde ID-ului primei amprente digitale utilizate de senzor:

int fingerID = 0;

După aceea, inițializam contorul și întârzierea (întârzierea) în proiectul nostru. Practic, dorim ca încuietoarea să funcționeze automat după deschidere. Acest exemplu utilizează o întârziere de 10 secunde, dar puteți ajusta această valoare pentru a se potrivi nevoilor dvs.:

int activationCounter = 0;

int lastActivation = 0;

int activationTime = 10 * 1000;

În corpul funcției setup(), inițializam senzorul de amprentă și ne asigurăm că cipul CC3000 este conectat la rețeaua WiFi.

În corpul funcției loop(), ne conectăm la Adafruit IO. Următoarea linie este responsabilă pentru aceasta:

După conectarea la platforma Adafruit IO, verificăm ultima amprentă. Dacă se potrivește și blocarea nu este activată, trimitem un „1” către Adafruit IO pentru procesare:

if (fingerprintID == fingerID && lockState == false) (

Serial.println(F("Acces acordat!"));

lockState=true;

Serial.println(F("Eșuat"));

Serial.println(F("OK!"));

lastActivation = milis();

Dacă, în cadrul funcției loop(), blocarea este activată și am atins valoarea de întârziere indicată mai sus, trimitem „0”:

if ((activationCounter - lastActivation> activationTime) && lockState == true) (

lockState=false;

dacă (! amprentă.publicați(stat)) (

Serial.println(F("Eșuat"));

Serial.println(F("OK!"));

Puteți descărca cea mai recentă versiune a codului de pe GitHub.

Este timpul să ne testăm proiectul! Nu uitați să descărcați și să instalați toate bibliotecile Arduino necesare!

Asigurați-vă că ați făcut toate modificările necesare schiței și încărcați-o pe Arduino. Apoi deschideți fereastra monitorului serial.

Când Arduino se conectează la rețeaua WiFi, senzorul de amprentă va clipi în roșu. Pune degetul pe senzor. Fereastra monitorului serial ar trebui să afișeze numărul ID. Dacă se potrivește, va apărea un mesaj „OK!”. Aceasta înseamnă că datele au fost trimise către serverele Adafruit IO.

Schemă și schiță pentru configurarea în continuare a încuietorii folosind exemplul unui LED

Acum, să ne ocupăm de partea din proiect care este direct responsabilă cu controlul încuietorului ușii. Pentru a vă conecta la o rețea wireless și a activa/dezactiva blocarea, veți avea nevoie de un modul suplimentar Adafruit ESP8266 (modulul ESP8266 nu trebuie să fie de la Adafruit). Exemplul de mai jos vă va arăta cât de ușor este să comunicați între două platforme (Arduino și ESP8266) folosind Adafruit IO.

În această secțiune, nu vom lucra direct cu blocarea. În schimb, vom conecta pur și simplu LED-ul la pinul la care încuietoarea va fi conectată mai târziu. Acest lucru va face posibilă testarea codului nostru fără a explora specificul designului lacătului.

Circuitul este destul de simplu: mai întâi instalați ESP8266 pe placa. Apoi instalați LED-ul. Nu uitați că piciorul lung (pozitiv) al LED-ului este conectat printr-un rezistor. Al doilea picior al rezistenței este conectat la pinul 5 al modulului ESP8266. Al doilea LED (catod) este conectat la pinul GND de pe ESP8266.

Circuitul complet asamblat este prezentat în fotografia de mai jos.

Acum să aruncăm o privire la schița pe care o folosim pentru acest proiect. Din nou, codul este destul de mare și complex, așa că vom acoperi doar părțile principale ale acestuia:

Începem prin a include bibliotecile necesare:

#include

#include „Adafruit_MQTT.h”

#include „Adafruit_MQTT_Client.h”

Configurați setările WiFi:

#define WLAN_SSID „your_wifi_ssid”

#define WLAN_PASS „parola_wifi”

#define WLAN_SECURITY WLAN_SEC_WPA2

Configuram si parametrii Adafruit IO. La fel ca în secțiunea anterioară:

#define AIO_SERVER „io.adafruit.com”

#define AIO_SERVERPORT 1883

#define AIO_USERNAME „adafruit_io_username”

#define AIO_KEY „adafruit_io_key”

Indicăm la ce pin am conectat LED-ul (în viitor va fi încuietoarea sau releul nostru):

int relayPin = 5;

Interacțiunea cu senzorul de amprentă, ca în secțiunea anterioară:

const char LOCK_FEED PROGMEM = AIO_USERNAME "/feeds/lock";

Adafruit_MQTT_Subscribe lock = Adafruit_MQTT_Subscribe(&mqtt, LOCK_FEED);

În corpul funcției setup(), indicăm că pinul la care este conectat LED-ul ar trebui să funcționeze în modul OUTPUT:

pinMode(relayPin, OUTPUT);

În bucla loop(), verificăm mai întâi dacă ne-am conectat la Adafruit IO:

După aceea, verificăm ce semnal vine. Dacă se transmite „1”, activăm pinul pe care l-am declarat mai devreme, la care este conectat LED-ul nostru. Dacă am primit „0”, punem contactul în starea „low”:

Adafruit_MQTT_Subscribe *abonament;

while ((abonament = mqtt.readSubscription(1000))) (

dacă (abonament == &lock) (

Serial.print(F("Got: "));

Serial.println((char *)lock.lastread);

// Salvați comanda ca șir de date

Comanda String = String((char *)lock.lastread);

dacă (comanda == "0") (

digitalWrite(relayPin, LOW);

dacă (comandă == „1”) (

digitalWrite(relayPin, HIGH);

Puteți găsi cea mai recentă versiune a schiței pe GitHub.

Este timpul să ne testăm proiectul. Nu uitați să descărcați toate bibliotecile necesare pentru Arduino și să verificați dacă ați făcut modificările corecte schiței.

Un simplu convertor USB-FTDI poate fi folosit pentru a programa cipul ESP8266.

Încărcați schița pe Arduino și deschideți fereastra monitorului serial. În această etapă, tocmai am verificat dacă ne-am putut conecta la Adafruit IO: ne vom uita la funcționalitatea disponibilă în continuare.

Testarea proiectului

Acum să începem testarea! Accesați meniul utilizator al Adafruit IO, în meniul Feeds. Verificați dacă sunt create sau nu canale pentru amprentă și blocare (pe ecranul de imprimare de mai jos, acestea sunt liniile de amprentă și de blocare):

Dacă nu există, va trebui să le creați manual.

Acum trebuie să asigurăm schimbul de date între canalele de amprentă și de blocare. Canalul de blocare trebuie setat la „1” când canalul de amprentă este setat la „1” și invers.

Pentru a face acest lucru, folosim un instrument Adafruit IO foarte puternic: declanșatoarele. Declanșatoarele sunt în esență condiții pe care le puteți aplica canalelor configurate. Adică pot fi folosite pentru a interconecta două canale.

Creați un nou declanșator reactiv din secțiunea Declanșatoare din Adafruit IO. Acest lucru va oferi posibilitatea de a face schimb de date între canalele senzorului de amprentă și blocare:

Iată cum ar trebui să arate când ambele declanșatoare sunt configurate:

Toate! Acum ne putem testa cu adevărat proiectul! Punem degetul pe senzor și vedem cum Arduino a început să clipească cu LED-ul, care corespunde transferului de date. După aceea, LED-ul de pe modulul ESP8266 ar trebui să înceapă să clipească. Aceasta înseamnă că a început să primească date prin MQTT. LED-ul de pe placa de circuite ar trebui să se aprindă și în acest moment.

După întârzierea pe care ați setat-o ​​în schiță (implicit este de 10 secunde), LED-ul se va stinge. Felicitări! Puteți controla LED-ul cu amprenta dvs. de oriunde în lume!

Configurarea unei încuietori electronice

Am ajuns la ultima parte a proiectului: conectarea directă și controlul unei încuietori electronice folosind un Arduino și un senzor de amprentă. Proiectul nu este ușor, puteți folosi toate sursele în forma în care sunt prezentate mai sus, dar în loc de un LED, conectați un releu.

Pentru a conecta direct blocarea, veți avea nevoie de componente suplimentare: o sursă de alimentare de 12 V, o mufă de alimentare, un tranzistor (în acest exemplu, se folosește un MOSFET IRLB8721PbF, dar poate fi folosit altul, cum ar fi un tranzistor bipolar TIP102. Dacă utilizați un tranzistor bipolar, va trebui să adăugați un rezistor.

Schema de cablare pentru conectarea tuturor componentelor la modulul ESP8266 este prezentată mai jos:

Rețineți că, dacă utilizați un MOSFET, nu veți avea nevoie de un rezistor între ESP8266 pinul 5 și tranzistor.

Proiectul complet asamblat este prezentat în fotografia de mai jos:

Porniți modulul ESP8266 folosind modulul FTDI și conectați sursa de alimentare de 12 V la mufă. Dacă ați folosit pinii recomandați mai sus pentru conectare, nu va trebui să schimbați nimic în schiță.

Acum puteți pune degetul pe senzor: blocarea ar trebui să funcționeze ca răspuns la amprenta dvs. Videoclipul de mai jos arată proiectul de blocare inteligentă automată în acțiune:

Dezvoltarea în continuare a proiectului Smart Lock

În proiectul nostru, este eliberată controlul de la distanță al încuietorilor ușii folosind o amprentă.

Simțiți-vă liber să experimentați, să modificați schița și hamul. De exemplu, puteți înlocui o încuietoare electronică a ușii cu un releu pentru a controla puterea imprimantei 3D, a brațului robotizat sau a quadcopterului...

Îți poți dezvolta „casa inteligentă”. De exemplu, activați de la distanță un sistem de irigare pe un Arduino sau aprindeți o lumină într-o cameră... Rețineți că puteți activa simultan un număr aproape nelimitat de dispozitive folosind Adafruit IO.

Lasă-ți comentariile, întrebările și împărtășește-ți experiența personală mai jos. În discuție se nasc adesea idei și proiecte noi!

CABANĂ pentru mine, ca majoritatea celor care o au, este asociată cu cuvintele: odihnă, grătar, confort și alte mișcări care sunt plăcute spiritului și corpului, dar există și un dezavantaj: o grădină, săpă, reparație, construcție , etc.

De 10 ani, familia mea și cu mine încercăm să înnobilăm și să creăm confort maxim în casa noastră de la țară. Construim, reparam etc. O casă, un hambar, o baie... .. și în cele din urmă s-a ajuns la un gard stradal, o poartă și o poartă. Fă-o pe conștiință, buget și comoditate.

După ce am discutat câteva detalii, s-a decis ca poarta să fie automată, iar poarta să aibă unele proprietăți ACS. Cu poarta s-a rezolvat problema achizitionand un kit de automatizare (motor, sina, telecomanda etc.), iar cu poarta a fost necesara rezolvarea unor probleme, despre ele mai jos.

Sarcinile au fost următoarele:

1. Lacătul trebuia să funcționeze împreună cu un interfon video instalat anterior (deschideți poarta fără a părăsi casa)
2. Să poţi deschide uşa cu o cheie obişnuită şi fără cheie din stradă şi curte.
3. Păstrați în bugetul rămas până la 5000 r.

Căutările din Runet au prezentat următorul interval de preț de la 7000 la infinit. A dispărut achiziționarea unei soluții gata făcute și s-a conceput o alternativă cu posibilități largi și anume să tai singur ușa!

După câteva calcule și calcule, s-a decis să cumpere o încuietoare electromecanică pentru aproximativ 2000 de ruble, o tastatură rezistentă la apă pentru 350 de ruble și un MK care va conduce aici. Deoarece erau mai multe plăci Arduino nano, relee și piese libere și câteva fire, diferența dintre costul kit-ului finit a fost de peste 4000 de lei. Pentru mine, un mare bonus pentru portofel și autodezvoltare.

Ei bine, acum de la cuvinte la fapte:

După ce am cumpărat toate componentele necesare, am început să văd.

Schema de conectare a tastaturii

Indicarea suplimentară a LED-urilor (albe, verzi, roșii) ale panoului cu semnale de la tastatură (introducere, parolă corectă pentru deschiderea ușii, refuzată).

• pin 9 galben
• pin 10 verde
• pinul 11 ​​roșu

Panou din plexiglas (grilă), tăiat într-o cutie de ciocolată și zâmbește vecinii de birou. Dar cel mai mic tăietor s-a dovedit a fi puțin mai gras, a trebuit să lucrez cu o pilă cu ac.

Ei bine, ăsta e weekend, m-am mutat la țară.

Pentru a deschide încuietoarea electromecanică, aveți nevoie de 12 volți. Sursa de alimentare care alimenta MK a fost de 5 volți, decizia a fost de a pune un convertor boost dc-dc din cer pentru blocare. Am conectat totul și am început să verific, funcționează, dar când s-a aplicat tensiune la solenoidul broaștei, Dunya a repornit, scurtcircuit la sursa de alimentare. Mai mult, după conectarea panoului de apel de la videointerfon la încuietoare, când apăsați butonul pentru a deschide ușa, nu s-a întâmplat nimic, un mic curent la încuietoare. Tragerea de fire noi nu este o optiune, acestea erau deja betonate la iesirea din casa. Am decis să adaug un alt releu pentru panou și să pun o sursă suplimentară de 12v. pentru castel. După analizare/colectare, totul a funcționat, MK a oprit repornirea. Am ascuns totul într-o cutie de joncțiune impermeabilă, am ascuns firele, lipiciul, siliconul și gata!

Lecția de astăzi este despre cum să folosiți un cititor RFID cu Arduino pentru a crea un sistem de blocare simplu, cu cuvinte simple - o încuietoare RFID.

RFID (English Radio Frequency IDentification, identificarea prin radiofrecvență) este o metodă de identificare automată a obiectelor în care datele stocate în așa-numitele transpondere, sau etichete RFID, sunt citite sau scrise folosind semnale radio. Orice sistem RFID constă dintr-un cititor (cititor, cititor sau interogator) și un transponder (alias etichetă RFID, uneori se folosește și termenul etichetă RFID).

Tutorialul va folosi o etichetă RFID cu un Arduino. Dispozitivul citește identificatorul unic (UID) al fiecărei etichete RFID pe care o plasăm lângă cititor și îl afișează pe afișajul OLED. Dacă UID-ul etichetei este egal cu valoarea predefinită care este stocată în memoria Arduino, atunci vom vedea mesajul „Unlocked” pe afișaj. Dacă identificatorul unic nu este egal cu valoarea predefinită, mesajul „Deblocat” nu va apărea - vezi fotografia de mai jos.

Castelul este închis

Castelul este deschis

Detalii necesare pentru a crea acest proiect:

• Cititor RFID RC522
• Afișaj OLED
• Tabla de paine
• fire

Detalii suplimentare:

• Baterie (powerbank)

Costul total al componentelor proiectului a fost de aproximativ 15 USD.

Pasul 2: Cititor RFID RC522

Fiecare etichetă RFID are un mic cip (cartel alb în fotografie). Dacă îndreptați o lanternă spre acest card RFID, puteți vedea un mic cip și o bobină care îl înconjoară. Acest cip nu are o baterie pentru a genera energie. Primește putere de la cititor fără fir folosind această bobină mare. Este posibil să citiți un card RFID ca acesta de la o distanță de până la 20 mm.

Același cip există și în etichetele RFID pentru chei.

Fiecare etichetă RFID are un număr unic care o identifică. Acesta este UID-ul care este afișat pe afișajul OLED. Cu excepția acestui UID, fiecare etichetă poate stoca date. Acest tip de card poate stoca până la 1.000 de date. Impresionant, nu-i așa? Această funcție nu va fi utilizată astăzi. Astăzi, tot ceea ce interesează este identificarea unui anumit card prin UID-ul său. Cititorul RFID și aceste două carduri RFID costă aproximativ 4 USD.

Pasul 3 Display OLED

Tutorialul folosește un monitor OLED 128x64 I2C de 0,96 inchi.

Acesta este un afișaj foarte bun de utilizat cu Arduino. Este un display OLED și asta înseamnă că are un consum redus de energie. Consumul de energie al acestui display este de aproximativ 10-20mA și depinde de numărul de pixeli.

Display-ul are o rezoluție de 128 pe 64 de pixeli și are dimensiuni mici. Există două opțiuni de afișare. Unul dintre ele este monocrom, iar celălalt, ca cel folosit în tutorial, poate afișa două culori: galben și albastru. Partea de sus a ecranului poate fi doar galbenă, iar partea de jos albastră.

Acest afișaj OLED este foarte luminos și are o bibliotecă grozavă și foarte frumoasă pe care Adafruit a dezvoltat-o ​​pentru acest afișaj. În plus, afișajul folosește o interfață I2C, astfel încât conectarea la Arduino este incredibil de ușoară.

Trebuie doar să conectați două fire, cu excepția Vcc și GND. Dacă sunteți nou în Arduino și doriți să utilizați un afișaj ieftin și simplu în proiectul dvs., începeți de aici.

Pasul 4: Adunarea tuturor pieselor împreună

Comunicarea cu placa Arduino Uno este foarte simplă. Mai întâi, conectați alimentarea atât la cititor, cât și la afișaj.

Atenție, cititorul RFID trebuie conectat la ieșirea de 3,3V de la Arduino Uno sau se va deteriora.

Deoarece afișajul poate rula și la 3,3 V, conectăm VCC de la ambele module la șina pozitivă a plăcii. Această șină este apoi conectată la ieșirea de 3,3 V de la Arduino Uno. Apoi conectăm ambele legături (GND) la magistrala de masă a plăcii. Apoi conectăm magistrala GND a plăcii de breadboard la Arduino GND.

Afișaj OLED → Arduino

SCL → Pinul analogic 5

SDA → Pin analogic 4

Cititor RFID → Arduino

RST → Pinul digital 9

IRQ → Neconectat

MISO → Pinul digital 12

MOSI → Pin digital 11

SCK → Pinul digital 13

SDA → Pinul digital 10

Modulul cititor RFID folosește interfața SPI pentru a comunica cu Arduino. Deci vom folosi pinii SPI hardware Arduino UNO.

Pinul RST trece la pinul digital 9. Pinul IRQ rămâne deconectat. Pinul MISO merge la pinul digital 12. Pinul MOSI merge la pinul digital 11. Pinul SCK merge la pinul digital 13 și, în final, pinul SDA merge la pinul digital 10. Asta este.

Cititor RFID conectat. Acum trebuie să conectăm afișajul OLED la Arduino folosind interfața I2C. Deci pinul SCL de pe afișaj merge la pinul analogic 5 și SDA de pe afișaj la pinul analogic 4. Dacă acum pornim proiectul și punem cardul RFID lângă cititor, putem vedea că proiectul funcționează bine.

Pasul 5: Codul proiectului

Pentru ca codul proiectului să fie compilat, trebuie să includem câteva biblioteci. În primul rând, avem nevoie de biblioteca MFRC522 Rfid.

Pentru a-l instala, accesați Schiță -> Include biblioteci -> Gestionează biblioteci(Managementul bibliotecilor). Găsiți MFRC522 și instalați-l.

Avem nevoie și de biblioteca Adafruit SSD1306 și de biblioteca Adafruit GFX pentru afișare.

Instalați ambele biblioteci. Biblioteca Adafruit SSD1306 are nevoie de o mică modificare. Accesați folderul Arduino -> Biblioteci, deschideți folderul Adafruit SSD1306 și editați biblioteca Adafruit_SSD1306.h. Comentează linia 70 și anulează comentariile linia 69 pentru că Display-ul are o rezoluție de 128x64.

În primul rând, declarăm valoarea etichetei RFID pe care Arduino ar trebui să o recunoască. Aceasta este o matrice de numere întregi:

cod int = (69,141,8,136); // UID

Apoi inițializam cititorul RFID și afișăm:

RFID.PCD_Init(); display.begin(SSD1306_SWITCHCAPVCC, 0x3C);

După aceea, în funcția de buclă, verificăm eticheta de pe cititor la fiecare 100 ms.

Dacă cititorul are o etichetă, îi citim UID-ul și îl imprimăm pe afișaj. Apoi comparăm UID-ul etichetei pe care tocmai o citim cu valoarea stocată în variabila cod. Dacă valorile sunt aceleași, afișăm mesajul DEBLOCARE, altfel nu vom afișa acest mesaj.

If(potrivire) ( Serial.println("\nCunosc acest card!"); printUnlockMessage(); )else ( Serial.println("\nCartel necunoscut"); )

Desigur, puteți schimba acest cod pentru a stoca mai mult de 1 valoare UID, astfel încât proiectul să recunoască mai multe etichete RFID. Acesta este doar un exemplu.

Cod proiect:

#include #include #include #include #define OLED_RESET 4 Adafruit_SSD1306 display(OLED_RESET); #define SS_PIN 10 #define RST_PIN 9 MFRC522 rfid(SS_PIN, RST_PIN); // Instanța clasei MFRC522::MIFARE_Key key; cod int = (69,141,8,136); //Acesta este UID-ul stocat int codeRead = 0; String uidString; void setup() ( Serial.begin(9600); SPI.begin(); // Inițiază magistrala SPI rfid.PCD_Init(); // Inițiază MFRC522 display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // inițializează cu adresa I2C 0x3D (pentru 128x64) // Ștergeți buffer.display.clearDisplay(); display.display(); display.setTextColor(WHITE); // sau BLACK); display.setTextSize(2); display.setCursor(10,0); display.print("Blocare RFID"); display.display(); ) void loop() ( if(rfid.PICC_IsNewCardPresent()) ( readRFID(); ) delay(100); ) void readRFID() ( rfid.PICC_ReadCardSerial(); Serial.print(F("\nPICC tip: ") ); MFRC522::PICC_Type piccType = rfid.PICC_GetType(rfid.uid.sak); Serial.println(rfid.PICC_GetTypeName(piccType)); // Verificați este PICC de tipul Classic dacă (piccType != MFRFC_MIFRC_MINTYPE != _PICC_MIFRC_MINTYPE) && piccType != MFRC522::PICC_TYPE_MIFARE_1K && piccType != MFRC522::PICC_TYPE_MIFARE_4K) ( Serial.println(F("Eticheta dvs. nu este de tip MIFARE Classic.")); return; ) clearUID(); Serial.println UID-ul PICC scanat:"); printDec(rfid.uid.uidByte, rfid.uid.size); uidString = String(rfid.uid.uidByte)+" "+String(rfid.uid.uidByte)+" "+ String(rfid.uid.uidByte)+ " "+String(rfid.uid.uidByte); printUID(); int i = 0; potrivire booleană = adevărat; while(i

Pasul 6: Rezultatul final

După cum puteți vedea din lecție - pentru bani puțini puteți adăuga un cititor RFID la proiectele dvs. Puteți crea cu ușurință un sistem de securitate cu acest cititor sau puteți crea proiecte mai interesante, de exemplu, astfel încât datele de pe o unitate USB să fie citite numai după deblocare.