Scurta introducere
Casa inteligentă devine din ce în ce mai comună odată cu dezvoltarea tehnologiei, acest articol se va concentra pe aspectele de securitate ale proiectului de control al accesului inteligent.
Acest articol folosește Ecranul tactil al lui STONE pentru a trimite comenzi către MCU pentru a controla releul și modulul MFRC522.
Principiul citirii cardului: prin conducerea modulului RFID-RC522, identificați ID-ul cărții de identitate aproape de cartea de identitate și apoi determinați dacă ID-ul există în baza de date a cuvântului tipic, ID-ul este valoarea tipică a cuvântului, dacă existența verificării prin , apoi tipăriți numele corespunzător și apoi conduceți blocarea electromagnetică în același mod.
Materiale necesare
- ESP32
- Broasca electronica KOB
- Releu
- Afișaj STONE STWI070WT-01 cu panou tactil
- modulul MFRC522
Funcție realizată
- înregistrarea cardului.
- înregistrarea numelui de utilizator și a parolei.
- glisați cardul pentru a debloca blocarea electronică.
- Nume de utilizator și parola pentru a debloca încuietoarea electronică.
Descrierea principală a hardware-ului
Modul RFID
Acest modul poate fi încărcat direct în diferite module de citire. Utilizează o tensiune de 3.3 V, prin interfața SPI cu doar câteva fire. Conectat direct cu o placă de bază a procesorului, modulul poate funcționa într-un mod stabil și fiabil ca cititor de carduri la distanță.
STWI070WT-01 a fost conceput ca monitor TFT și controler tactil. Include procesor, program de control, driver, memorie flash, port RS232/RS422/RS485/TTL/LAN, Wi-Fi/Bluetooth, ecran tactil, sursă de alimentare etc., deci este un întreg sistem de afișare bazat pe puternic și ușor sistem de operare, care poate fi controlat de orice MCU.
Design GUI
Distribuie codul
import mfrc522
timp de import
import _thread
din os import uname
din Pinul de import al mașinii, UART
#din pyb import UART
#mașină de import
suos = Pin(32,Pin.OUT)
uart2 = UART(2, baudrate=115200, rx=16,tx=17,timeout=10)
ESP32_HSPI_CLOCK = 14
ESP32_HSPI_SLAVE_SELECT = 15
ESP32_HSPI_MISO = 12
ESP32_HSPI_MOSI = 13
ESP32_MFRC522_RST = 5
rx3 = []
rx_name = []
user_id_flag = Fals
password_flag = Fals
temp_id = ”
temp_mima = ”
personal_id = {'zbw':[236,230,169,47],'lbw':[19,165,93,4]}
personnel_ps = {'zbw':'zbw3366′,'lbw':'lbwnb'}
admin_password = ('yyds')
button_cmd = [16,1]
edit1_cmd = [16,112]
edit2_cmd = [16,113]
edit3_cmd = [16,114]
if uname()[0] == 'esp32':
rdr = mfrc522.MFRC522(ESP32_HSPI_CLOCK, ESP32_HSPI_MOSI, ESP32_HSPI_MISO, ESP32_MFRC522_RST, ESP32_HSPI_SLAVE_SELECT)
def do_write():
încerca:
(stat, tag_type) = rdr.request(rdr.REQIDL)
dacă stat == rdr.OK:
(stat, raw_uid) = rdr.anticol()
dacă stat == rdr.OK:
print(„Cartel nou detectat”)
print(” – tip tag: 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
imprimare("")
dacă rdr.select_tag(raw_uid) == rdr.OK:
cheie = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
dacă rdr.auth(rdr.AUTHENT1A, 8, cheie, raw_uid) == rdr.OK:
stat = rdr.write(8, b”\x00\x53\x00\x54\x00\x4F\x00\x4E\x00\x45\x0a\x0b\x0c\x0d\x0e\x0f”)
rdr.stop_crypto1()
dacă stat == rdr.OK:
print(„Date scrise pe card”)
altceva:
print(„Nu s-au putut scrie datele pe card”)
altceva:
print(„Eroare de autentificare”)
altceva:
print(„Nu s-a putut selecta eticheta”)
cu excepția KeyboardInterrupt:
print(„eroare de scriere”)
def do_read():
pe când True:
încerca:
(stat, tag_type) = rdr.request(rdr.REQIDL)
dacă stat == rdr.OK:
(stat, raw_uid) = rdr.anticol()
dacă stat == rdr.OK:
print(„Cartel nou detectat”)
print(” – tip tag: 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
imprimare (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3])
imprimare("")
dacă rdr.select_tag(raw_uid) == rdr.OK:
cheie = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
dacă rdr.auth(rdr.AUTHENT1A, 8, cheie, raw_uid) == rdr.OK:
print(„Date adresa 8: %s” % rdr.read(8))
pentru ps în personal_id:
dacă raw_uid[0:4:1] == personal_id.get(ps):
valoarea lui (1)
print(ps)
uart_write(ps, *raw_uid[0:4:1])
time.sleep (3)
uart2.sendbreak()
rupe
rdr.stop_crypto1()
time.sleep (3)
valoarea lui (0)
altceva:
print(„Eroare de autentificare”)
altceva:
print(„Nu s-a putut selecta eticheta”)
dacă uart2.any()>1:
rx2 = []
data_name2 = ”
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = list(bin_data)
pentru articolul din rx1:
rx2.append(chr(articol))
imprimare(rx2)
dacă rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] – 1
data_name = rx2[7:data_name_len+7:1]
data_name2 = ”.join(data_name)
print(nume_date2)
if data_name2 == 'back3':
reveni
cu excepția KeyboardInterrupt:
print(„eroare de citire”)
def do_read2 (idd):
print(idd)
pe când True:
încerca:
(stat, tag_type) = rdr.request(rdr.REQIDL)
dacă stat == rdr.OK:
(stat, raw_uid) = rdr.anticol()
dacă stat == rdr.OK:
print(„Cartel nou detectat”)
print(” – tip tag: 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
imprimare (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3])
imprimare("")
dacă rdr.select_tag(raw_uid) == rdr.OK:
cheie = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
dacă rdr.auth(rdr.AUTHENT1A, 8, cheie, raw_uid) == rdr.OK:
print(„Date adresa 8: %s” % rdr.read(8))
personal_id[idd] = raw_uid[0:4:1]
uart_write3(*raw_uid[0:4:1])
rdr.stop_crypto1()
altceva:
print(„Eroare de autentificare”)
altceva:
print(„Nu s-a putut selecta eticheta”)
dacă uart2.any()>1:
rx2 = []
data_name2 = ”
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = list(bin_data)
pentru articolul din rx1:
rx2.append(chr(articol))
dacă rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] – 1
data_name = rx2[7:data_name_len+7:1]
data_name2 = ”.join(data_name)
print(nume_date2)
if data_name2 == 'back1':
reveni
cu excepția KeyboardInterrupt:
print(„eroare de citire”)
def uart_write(text, *ids):
# print(text, *ids)
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”cardname1″,”text”:”'+str(text)+'”}>ET' )
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”cardid1″,”text”:”'+str(ids)+'”}>ET' )
uart2.write('ST<{“cmd_code”:”set_visible”,”type”:”widget”,”widget”:”lock1″,”visible”:true}>ET')
time.sleep (3)
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”cardname1″,”text”:”””}>ET')
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”cardid1″,”text”:”””}>ET')
uart2.write('ST<{“cmd_code”:”set_visible”,”type”:”widget”,”widget”:”lock1″,”visible”:false}>ET')
def uart_write2(text,text2):
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”cardid”,”text”:”'+text+'”}>ET')
time.sleep (3)
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”cardid”,”text”:”'+text2+'”}>ET')
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”edit2″,”text”:”””}>ET')
def uart_write3(*id2):
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”cardid”,”text”:”'+str(id2)+'”}>ET' )
time.sleep (3)
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”cardid”,”text”:”””}>ET')
def uart_write4(text,text2):
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”login”,”text”:”'+text+'”}>ET')
time.sleep (1)
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”login”,”text”:”'+text2+'”}>ET')
time.sleep (1)
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”edit3″,”text”:”””}>ET')
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”edit4″,”text”:”””}>ET')
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”edit7″,”text”:”””}>ET')
def uart_write5():
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”cardid”,”text”:”'+str(id2)+'”}>ET' )
time.sleep (3)
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”cardid”,”text”:”””}>ET')
def card_zhuce():
pe când True:
dacă uart2.any():
user_id = ”
parola = ”
rx2 = []
rx_num = 0
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = list(bin_data)
pentru articolul din rx1:
rx2.append(chr(articol))
rx_num += 1
data_end = rx_num-5
data_id_st = rx2[8:13:1]
data_id_st2 = ”.join(data_id_st)
print(data_id_st2)
dacă data_id_st2 == 'edit1':
data_id_st3 = rx2[15:data_end:1]
data_id_st4 = ”.join(data_id_st3)
print(data_id_st4)
if data_id_st4 != ”:
nume = Adevărat
elif data_id_st2 == 'edit2':
data_id_st5 = rx2[15:data_end:1]
data_id_st6 = ”.join(data_id_st5)
dacă data_id_st6 == admin_password:
admin = Adevărat
uart_write2('Verificarea a trecut!','Vă rugăm să plasați cardul!')
do_read2(data_id_st4)
reveni
def mima_zuce():
temp_id3 = ”
temp_mima3 = ”
pe când True:
dacă uart2.any():
user_id = ”
parola = ”
rx2 = []
rx_num = 0
# data_end = 0
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = list(bin_data)
pentru articolul din rx1:
rx2.append(chr(articol))
rx_num += 1
# dacă (rx2[rx_num] == 'T') și (rx2[rx_num-1] == 'E') și (rx2[rx_num-2] == '>'):
# pauză
data_end = rx_num-5
data_id_st = rx2[8:13:1]
data_id_st2 = ”.join(data_id_st)
print(data_id_st2)
dacă rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] – 1
data_name = rx2[7:data_name_len+7:1]
data_name2 = ”.join(data_name)
print(nume_date2)
if data_name2 == 'back2':
reveni
dacă data_id_st2 == 'edit3':
data_id_st3 = rx2[15:data_end:1]
data_id_st4 = ”.join(data_id_st3)
print(data_id_st4)
user_id_flag = Adevărat
temp_id3 = data_id_st4
# personnel_ps[temp_id] = raw_uid[0:4:1]
elif data_id_st2 == 'edit4':
data_id_st5 = rx2[15:data_end:1]
data_id_st6 = ”.join(data_id_st5)
print(data_id_st6)
# dacă personnel_ps.get(temp_id) == data_id_st6:
password_flag = Adevărat
temp_mima3 = data_id_st6
# personnel_ps[temp_id] = password_flag
# print(rx2,user_id_flag,password_flag)
elif data_id_st2 == 'edit7':
data_id_st5 = rx2[15:data_end:1]
data_id_st6 = ”.join(data_id_st5)
dacă (data_id_st6 == admin_password) și (password_flag == True) și (user_id_flag == True):
admin = Adevărat
personal_ps[temp_id3] = temp_mima3
password_flag = Fals
user_id_flag = Fals
uart_write4('Verificarea a trecut!','autentificarea a avut succes!')
def password_loin():
temp_id2 = ”
temp_mima = ”
pe când True:
dacă uart2.any():
user_id = ”
parola = ”
rx2 = []
rx_num = 0
# data_end = 0
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = list(bin_data)
pentru articolul din rx1:
rx2.append(chr(articol))
rx_num += 1
# dacă (rx2[rx_num] == 'T') și (rx2[rx_num-1] == 'E') și (rx2[rx_num-2] == '>'):
# pauză
data_end = rx_num-5
data_id_st = rx2[8:13:1]
data_id_st2 = ”.join(data_id_st)
print(data_id_st2)
dacă rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] – 1
data_name = rx2[7:data_name_len+7:1]
data_name2 = ”.join(data_name)
print(nume_date2)
if data_name2 == 'back4':
reveni
dacă data_id_st2 == 'edit5':
data_id_st3 = rx2[15:data_end:1]
data_id_st4 = ”.join(data_id_st3)
print(data_id_st4)
dacă data_id_st4 în personal_ps:
user_id_flag = Adevărat
temp_id2 = data_id_st4
elif data_id_st2 == 'edit6':
data_id_st5 = rx2[15:data_end:1]
data_id_st6 = ”.join(data_id_st5)
print(data_id_st6)
print(id_temp2)
print(personal_ps)
dacă personnel_ps.get(temp_id2) == data_id_st6:
password_flag = Adevărat
# print(rx2,user_id_flag,password_flag)
print(steagul_id_utilizator, steagul_parolă)
dacă (password_flag == True) și (user_id_flag == True):
uart_write(temp_id2,temp_id2)
password_flag = Fals
user_id_flag = Fals
valoarea lui (1)
uart2.write('ST<{“cmd_code”:”set_visible”,”type”:”widget”,”widget”:”lock2″,”visible”:true}>ET')
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”edit5″,”text”:”””}>ET')
uart2.write('ST<{“cmd_code”:”set_text”,”type”:”label”,”widget”:”edit6″,”text”:”””}>ET')
time.sleep (3)
# uart_write('student',”)
valoarea lui (0)
uart2.write('ST<{“cmd_code”:”set_visible”,”type”:”widget”,”widget”:”lock2″,”visible”:false}>ET')
uart2.sendbreak()
pe când True:
dacă uart2.any()>1:
rx2 = []
data_name2 = ”
bin_data = uart2.read(40)
# timp.somn(1)
uart2.sendbreak()
# timp.somn(1)
rx1 = list(bin_data)
pentru articolul din rx1:
rx2.append(chr(articol))
imprimare(rx2)
dacă rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] – 1
data_name = rx2[7:data_name_len+7:1]
data_name2 = ”.join(data_name)
print(nume_date2)
if data_name2 == 'card1':
card_zhuce()
elif data_name2 == 'parola1':
mima_zuce()
elif data_name2 == 'card2':
do_read()
elif data_name2 == 'parola2':
password_loin()
MFRC522.py
de la importul mașinii Pin, SPI
din os import uname
clasa MFRC522:
OK = 0
NOTAGERR = 1
ERR = 2
REQIDL = 0x26
REQALL = 0x52
AUTHENT1A = 0x60
AUTHENT1B = 0x61
def __init__(self, sck, mosi, miso, rst, cs):
self.sck = Pin(sck, Pin.OUT)
self.mosi = Pin(mosi, Pin.OUT)
self.miso = Pin(miso)
self.rst = Pin(primul, Pin.OUT)
self.cs = Pin(cs, Pin.OUT)
auto.prima.valoare(0)
self.cs.value(1)
board = uname()[0]
if board == 'WiPy' sau board == 'LoPy' sau board == 'FiPy':
self.spi = SPI(0)
self.spi.init(SPI.MASTER, baudrate=1000000, pini=(self.sck, self.mosi, self.miso))
elif board == ‘esp32’:
self.spi = SPI(baudrate=100000, polarity=0, phase=0, sck=self.sck, mosi=self.mosi, miso=self.miso)
self.spi.init()
altceva:
generează RuntimeError ("Platformă neacceptată")
auto.prima.valoare(1)
self.init()
def _wreg(self, reg, val):
self.cs.value(0)
self.spi.write(b'%c' % int(0xff & ((reg << 1) & 0x7e)))
self.spi.write(b'%c' % int(0xff & val))
self.cs.value(1)
def _rreg(self, reg):
self.cs.value(0)
self.spi.write(b'%c' % int(0xff & (((reg << 1) & 0x7e) | 0x80)))
val = self.spi.read(1)
self.cs.value(1)
Val de retur[0]
def _sflags(self, reg, mask):
self._wreg(reg, self._rreg(reg) | mask)
def _cflags(self, reg, mask):
self._wreg(reg, self._rreg(reg) & (~mask))
def _tocard(self, cmd, send):
recv = []
biți = irq_en = wait_irq = n = 0
stat = self.ERR
dacă cmd == 0x0E:
irq_en = 0x12
wait_irq = 0x10
elif cmd == 0x0C:
irq_en = 0x77
wait_irq = 0x30
self._wreg(0x02, irq_en | 0x80)
self._cflags(0x04, 0x80)
self._sflags(0x0A, 0x80)
self._wreg(0x01, 0x00)
pentru c în trimite:
self._wreg(0x09, c)
self._wreg(0x01, cmd)
dacă cmd == 0x0C:
self._sflags(0x0D, 0x80)
i = 2000
pe când True:
n = self._rreg(0x04)
i -= 1
dacă ~((i != 0) și ~(n & 0x01) și ~(n & wait_irq)):
rupe
self._cflags(0x0D, 0x80)
dacă eu:
dacă (self._rreg(0x06) & 0x1B) == 0x00:
stat = sine.OK
dacă n & irq_en & 0x01:
stat = sine.NOTAGERR
elif cmd == 0x0C:
n = self._rreg(0x0A)
lbits = self._rreg(0x0C) & 0x07
dacă lbiți != 0:
biți = (n – 1) * 8 + lbiți
altceva:
biți = n * 8
dacă n == 0:
n = 1
elif n > 16:
n = 16
pentru _ în intervalul (n):
recv.append(self._rreg(0x09))
altceva:
stat = self.ERR
return stat, recv, biți
def _crc(self, data):
self._cflags(0x05, 0x04)
self._sflags(0x0A, 0x80)
pentru c în date:
self._wreg(0x09, c)
self._wreg(0x01, 0x03)
i = 0xFF
pe când True:
n = self._rreg(0x05)
i -= 1
dacă nu ((i != 0) și nu (n & 0x04)):
rupe
returnează [self._rreg(0x22), self._rreg(0x21)]
def init(self):
self.reset()
self._wreg(0x2A, 0x8D)
self._wreg(0x2B, 0x3E)
self._wreg(0x2D, 30)
self._wreg(0x2C, 0)
self._wreg(0x15, 0x40)
self._wreg(0x11, 0x3D)
self.antenna_on()
def reset(self):
self._wreg(0x01, 0x0F)
def antenna_on(self, on=True):
if on and ~(self._rreg(0x14) & 0x03):
self._sflags(0x14, 0x03)
altceva:
self._cflags(0x14, 0x03)
def request(self, mode):
self._wreg(0x0D, 0x07)
(stat, recv, biți) = self._tocard(0x0C, [mode])
dacă (stat != self.OK) | (biți != 0x10):
stat = self.ERR
returnează statistică, biți
def anticoll(self):
ser_chk = 0
ser = [0x93, 0x20]
self._wreg(0x0D, 0x00)
(stat, recv, biți) = self._tocard(0x0C, ser)
if stat == self.OK:
dacă len(recv) == 5:
pentru i în intervalul (4):
ser_chk = ser_chk ^ recv[i]
dacă ser_chk != recv[4]:
stat = self.ERR
altceva:
stat = self.ERR
return stat, recv
def select_tag(self, ser):
buf = [0x93, 0x70] + ser[:5]
buf += self._crc(buf)
(stat, recv, biți) = self._tocard(0x0C, buf)
return self.OK dacă (stat == self.OK) și (biți == 0x18) altfel self.ERR
def auth(self, mode, addr, sect, ser):
return self._tocard(0x0E, [mod, addr] + secta + ser[:4])[0]
def stop_crypto1(self):
self._cflags(0x08, 0x08)
def read(self, addr):
date = [0x30, adresa]
date += self._crc(date)
(stat, recv, _) = self._tocard(0x0C, date)
return recv if stat == self.OK else Nici unul
def write(self, addr, data):
buf = [0xA0, adresă]
buf += self._crc(buf)
(stat, recv, biți) = self._tocard(0x0C, buf)
dacă nu (stat == self.OK) sau nu (biți == 4) sau nu ((recv[0] & 0x0F) == 0x0A):
stat = self.ERR
altceva:
buf = []
pentru i în intervalul (16):
buf.append(date[i])
buf += self._crc(buf)
(stat, recv, biți) = self._tocard(0x0C, buf)
dacă nu (stat == self.OK) sau nu (biți == 4) sau nu ((recv[0] & 0x0F) == 0x0A):
stat = self.ERR
return stat
Sursa: Plato Data Intelligence