Breve introduzione
La casa intelligente sta diventando sempre più comune con lo sviluppo della tecnologia, questo articolo si concentrerà sugli aspetti di sicurezza del progetto di controllo degli accessi intelligente.
Questo articolo usa Il touch screen di STONE per inviare comandi all'MCU per controllare il relè e il modulo MFRC522.
Il principio della lettura delle carte: guidando il modulo RFID-RC522, identificare l'ID della carta d'identità vicino alla carta d'identità, quindi determinare se l'ID esiste nel database della parola tipica, ID è il valore tipico della parola, se l'esistenza della verifica tramite , quindi stampare il nome corrispondente, quindi azionare la serratura elettromagnetica allo stesso modo.
Materiali richiesti
- ESP32
- Serratura elettronica KOB
- staffetta
- Display con pannello a sfioramento STONE STWI070WT-01
- Modulo MFRC522
Funzione realizzata
- registrazione della carta.
- registrazione nome utente e password.
- scorrere la carta per sbloccare la serratura elettronica.
- Nome utente e password per sbloccare la serratura elettronica.
La descrizione dell'hardware principale
Modulo RFID
Questo modulo può essere caricato direttamente in vari moduli lettore. Utilizza una tensione di 3.3 V, tramite l'interfaccia SPI con pochi fili. Collegato direttamente a una scheda madre CPU, il modulo può funzionare in modo stabile e affidabile come lettore di schede a distanza.
Lo STWI070WT-01 è stato concepito come monitor TFT e controller Touch. Include processore, programma di controllo, driver, memoria flash, porta RS232/RS422/RS485/TTL/LAN, Wi-Fi/Bluetooth, touch screen, alimentatore ecc., quindi è un intero sistema di visualizzazione basato sul potente e facile sistema operativo, che può essere controllato da qualsiasi MCU.
Progettazione dell'interfaccia grafica
Condivisione codice
importa mfrc522
tempo di importazione
import_thread
da os import uname
da importazione macchina Pin, UART
#da pyb import UART
#import macchina
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 = []
nome_rx = []
user_id_flag = Falso
password_flag = Falso
temp_id = "
temp_mima = "
id_personale = {'zbw':[236,230,169,47],'lbw':[19,165,93,4]}
personal_ps = {'zbw':'zbw3366′,'lbw':'lbwnb'}
admin_password = ('yyds')
pulsante_cmd = [16,1]
modifica1_cmd = [16,112]
modifica2_cmd = [16,113]
modifica3_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():
provare:
(stat, tag_type) = rdr.request(rdr.REQIDL)
se stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll()
se stat == rdr.OK:
print(“Rilevata nuova carta”)
print(” – tipo di tag: 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
Stampa("")
se rdr.select_tag(raw_uid) == rdr.OK:
chiave = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth(rdr.AUTHENT1A, 8, chiave, 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()
se stat == rdr.OK:
print(“Dati scritti sulla carta”)
altro:
print(“Impossibile scrivere i dati sulla scheda”)
altro:
print(“Errore di autenticazione”)
altro:
print(“Impossibile selezionare il tag”)
tranne KeyboardInterrupt:
print("errore di scrittura")
def do_read():
mentre vero:
provare:
(stat, tag_type) = rdr.request(rdr.REQIDL)
se stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll()
se stat == rdr.OK:
print(“Rilevata nuova carta”)
print(” – tipo di tag: 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
stampa (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3])
Stampa("")
se rdr.select_tag(raw_uid) == rdr.OK:
chiave = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth(rdr.AUTHENT1A, 8, chiave, raw_uid) == rdr.OK:
print(“Dati indirizzo 8: %s” % rdr.read(8))
per ps in id_personale:
if raw_uid[0:4:1] == personal_id.get(ps):
suos.valore(1)
stampa (ps)
uart_write(ps, *raw_uid[0:4:1])
time.sleep (3)
uart2.sendbreak()
rompere
rdr.stop_crypto1()
time.sleep (3)
suos.valore(0)
altro:
print(“Errore di autenticazione”)
altro:
print(“Impossibile selezionare il tag”)
if uart2.any()>1:
rx2 = []
data_name2 = "
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = lista (bin_data)
per l'articolo in rx1:
rx2.append(chr(elemento))
stampa(rx2)
se rx1[3:5:1] == pulsante_cmd:
nome_dati_len = rx1[6] – 1
nome_dati = rx2[7:nome_dati_len+7:1]
data_name2 = .join(data_name)
stampa(data_name2)
if data_name2 == 'back3':
ritorno
tranne KeyboardInterrupt:
print("errore di lettura")
def do_read2 (idd):
stampa (idd)
mentre vero:
provare:
(stat, tag_type) = rdr.request(rdr.REQIDL)
se stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll()
se stat == rdr.OK:
print(“Rilevata nuova carta”)
print(” – tipo di tag: 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
stampa (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3])
Stampa("")
se rdr.select_tag(raw_uid) == rdr.OK:
chiave = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth(rdr.AUTHENT1A, 8, chiave, raw_uid) == rdr.OK:
print(“Dati indirizzo 8: %s” % rdr.read(8))
personal_id[idd] = raw_uid[0:4:1]
uart_write3(*raw_uid[0:4:1])
rdr.stop_crypto1()
altro:
print(“Errore di autenticazione”)
altro:
print(“Impossibile selezionare il tag”)
if uart2.any()>1:
rx2 = []
data_name2 = "
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = lista (bin_data)
per l'articolo in rx1:
rx2.append(chr(elemento))
se rx1[3:5:1] == pulsante_cmd:
nome_dati_len = rx1[6] – 1
nome_dati = rx2[7:nome_dati_len+7:1]
data_name2 = .join(data_name)
stampa(data_name2)
if data_name2 == 'back1':
ritorno
tranne KeyboardInterrupt:
print("errore di lettura")
def uart_write(testo, *id):
# print(testo, *id)
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(testo,testo2):
uart2.write('ST<{“codice_cmd”:”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(testo,testo2):
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 carta_zhuce():
mentre vero:
se uart2.any():
id_utente = "
password = "
rx2 = []
numero_rx = 0
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = lista (bin_data)
per l'articolo in rx1:
rx2.append(chr(elemento))
num_rx += 1
fine_dati = rx_num-5
id_dati_st = rx2[8:13:1]
data_id_st2 = .join(data_id_st)
stampa(data_id_st2)
if data_id_st2 == 'edit1':
data_id_st3 = rx2[15:data_end:1]
data_id_st4 = .join(data_id_st3)
stampa(data_id_st4)
se data_id_st4 != ”:
nome = Vero
elif data_id_st2 == 'modifica2':
data_id_st5 = rx2[15:data_end:1]
data_id_st6 = .join(data_id_st5)
se data_id_st6 == admin_password:
admin = Vero
uart_write2('Verifica superata!','Si prega di inserire la carta!')
do_read2(data_id_st4)
ritorno
def mima_zuce():
temp_id3 = "
temp_mima3 = ”
mentre vero:
se uart2.any():
id_utente = "
password = "
rx2 = []
numero_rx = 0
# data_end = 0
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = lista (bin_data)
per l'articolo in rx1:
rx2.append(chr(elemento))
num_rx += 1
# if (rx2[rx_num] == 'T') and (rx2[rx_num-1] == 'E') and (rx2[rx_num-2] == '>'):
# rottura
fine_dati = rx_num-5
id_dati_st = rx2[8:13:1]
data_id_st2 = .join(data_id_st)
stampa(data_id_st2)
se rx1[3:5:1] == pulsante_cmd:
nome_dati_len = rx1[6] – 1
nome_dati = rx2[7:nome_dati_len+7:1]
data_name2 = .join(data_name)
stampa(data_name2)
if data_name2 == 'back2':
ritorno
if data_id_st2 == 'edit3':
data_id_st3 = rx2[15:data_end:1]
data_id_st4 = .join(data_id_st3)
stampa(data_id_st4)
user_id_flag = Vero
temp_id3 = dati_id_st4
# personal_ps[temp_id] = raw_uid[0:4:1]
elif data_id_st2 == 'modifica4':
data_id_st5 = rx2[15:data_end:1]
data_id_st6 = .join(data_id_st5)
stampa(data_id_st6)
# if personal_ps.get(temp_id) == data_id_st6:
password_flag = Vero
temp_mima3 = data_id_st6
# personal_ps[temp_id] = password_flag
# print(rx2,user_id_flag,password_flag)
elif data_id_st2 == 'modifica7':
data_id_st5 = rx2[15:data_end:1]
data_id_st6 = .join(data_id_st5)
if (data_id_st6 == admin_password) e (password_flag == True) e (user_id_flag == True):
admin = Vero
personal_ps[temp_id3] = temp_mima3
password_flag = Falso
user_id_flag = Falso
uart_write4('Verifica superata!','accesso riuscito!')
def password_loin():
temp_id2 = "
temp_mima = "
mentre vero:
se uart2.any():
id_utente = "
password = "
rx2 = []
numero_rx = 0
# data_end = 0
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = lista (bin_data)
per l'articolo in rx1:
rx2.append(chr(elemento))
num_rx += 1
# if (rx2[rx_num] == 'T') and (rx2[rx_num-1] == 'E') and (rx2[rx_num-2] == '>'):
# rottura
fine_dati = rx_num-5
id_dati_st = rx2[8:13:1]
data_id_st2 = .join(data_id_st)
stampa(data_id_st2)
se rx1[3:5:1] == pulsante_cmd:
nome_dati_len = rx1[6] – 1
nome_dati = rx2[7:nome_dati_len+7:1]
data_name2 = .join(data_name)
stampa(data_name2)
if data_name2 == 'back4':
ritorno
if data_id_st2 == 'edit5':
data_id_st3 = rx2[15:data_end:1]
data_id_st4 = .join(data_id_st3)
stampa(data_id_st4)
se data_id_st4 in personal_ps:
user_id_flag = Vero
temp_id2 = dati_id_st4
elif data_id_st2 == 'modifica6':
data_id_st5 = rx2[15:data_end:1]
data_id_st6 = .join(data_id_st5)
stampa(data_id_st6)
stampa(temp_id2)
print(personal_ps)
if personal_ps.get(temp_id2) == data_id_st6:
password_flag = Vero
# print(rx2,user_id_flag,password_flag)
print(flag_id_utente,flag_password)
if (password_flag == True) e (user_id_flag == True):
uart_write(id_temp2,id2_temp)
password_flag = Falso
user_id_flag = Falso
suos.valore(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('studente',”)
suos.valore(0)
uart2.write('ST<{“cmd_code”:”set_visible”,”type”:”widget”,”widget”:”lock2″”,visible”:false}>ET')
uart2.sendbreak()
mentre vero:
if uart2.any()>1:
rx2 = []
data_name2 = "
bin_data = uart2.read(40)
# tempo.sonno(1)
uart2.sendbreak()
# tempo.sonno(1)
rx1 = lista (bin_data)
per l'articolo in rx1:
rx2.append(chr(elemento))
stampa(rx2)
se rx1[3:5:1] == pulsante_cmd:
nome_dati_len = rx1[6] – 1
nome_dati = rx2[7:nome_dati_len+7:1]
data_name2 = .join(data_name)
stampa(data_name2)
if data_name2 == 'carta1':
card_zuce()
elif data_name2 == 'password1':
mima_zuce()
elif data_name2 == 'carta2':
fai_leggere()
elif data_name2 == 'password2':
password_lombo()
MFRC522.py
dall'importazione della macchina Pin, SPI
da os import uname
classe MFRC522:
OK = 0
NOTAGER = 1
ERR = 2
REQIDL = 0x26
REQALL = 0x52
AUT.1A = 0x60
AUT.1B = 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(primo, Pin.OUT)
self.cs = Pin(cs, Pin.OUT)
self.primo.valore(0)
self.cs.valore(1)
tavola = uname()[0]
if board == 'WiPy' o board == 'LoPy' o board == 'FiPy':
self.spi = SPI(0)
self.spi.init(SPI.MASTER, baudrate=1000000, pins=(self.sck, self.mosi, self.miso))
elif board == ‘esp32’:
self.spi = SPI(baudrate=100000, polarità=0, fase=0, sck=self.sck, mosi=self.mosi, miso=self.miso)
self.spi.init()
altro:
sollevare RuntimeError ("Piattaforma non supportata")
self.primo.valore(1)
self.init()
def _wreg(self, reg, val):
self.cs.valore(0)
self.spi.write(b'%c' % int(0xff & ((reg << 1) & 0x7e)))
self.spi.write(b'%c' % int(0xff & val))
self.cs.valore(1)
def _rreg(sé, reg):
self.cs.valore(0)
self.spi.write(b'%c' % int(0xff & (((reg << 1) & 0x7e) | 0x80)))
val = self.spi.read(1)
self.cs.valore(1)
ritorno val[0]
def _sflags(self, reg, maschera):
self._wreg(reg, self._rreg(reg) | maschera)
def _cflags(self, reg, maschera):
self._wreg(reg, self._rreg(reg) & (~mask))
def _tocard(self, cmd, invia):
rev = []
bit = irq_en = wait_irq = n = 0
stat = self.ERR
se cmd == 0x0E:
irq_it = 0x12
wait_irq = 0x10
elif cmd == 0x0C:
irq_it = 0x77
wait_irq = 0x30
self._wreg(0x02, irq_it | 0x80)
self._cflags(0x04, 0x80)
self._sflags(0x0A, 0x80)
self._wreg(0x01, 0x00)
per c in invio:
self._wreg(0x09, c)
self._wreg(0x01,cmd)
se cmd == 0x0C:
self._sflags(0x0D, 0x80)
i = 2000
mentre vero:
n = self._rreg(0x04)
io -= 1
if ~((i != 0) e ~(n & 0x01) e ~(n & wait_irq)):
rompere
self._cflags(0x0D, 0x80)
se io:
if (self._rreg(0x06) & 0x1B) == 0x00:
stat = auto.OK
se n & irq_en & 0x01:
stat = self.NOTAGERR
elif cmd == 0x0C:
n = self._rreg(0x0A)
lbits = self._rreg(0x0C) & 0x07
se lbit != 0:
bit = (n – 1) * 8 + lbit
altro:
bit = n * 8
se n == 0:
n = 1
elif n > 16:
n = 16
per _ nell'intervallo (n):
recv.append(self._rreg(0x09))
altro:
stat = self.ERR
restituisce stat, recv, bit
def _crc(auto, dati):
self._cflags(0x05, 0x04)
self._sflags(0x0A, 0x80)
per c nei dati:
self._wreg(0x09, c)
self._wreg(0x01, 0x03)
io = 0xFF
mentre vero:
n = self._rreg(0x05)
io -= 1
if not ((i != 0) and not (n & 0x04)):
rompere
ritorno [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 (auto):
self._wreg(0x01, 0x0F)
def antenna_on(self, on=Vero):
se attivo e ~(self._rreg(0x14) & 0x03):
self._sflags(0x14, 0x03)
altro:
self._cflags(0x14, 0x03)
def richiesta (auto, modalità):
self._wreg(0x0D, 0x07)
(stat, recv, bit) = self._tocard(0x0C, [mode])
if (stat != self.OK) | (bit != 0x10):
stat = self.ERR
statistica di ritorno, bit
def anticoll(self):
ser_chk = 0
ser = [0x93, 0x20]
self._wreg(0x0D, 0x00)
(stat, recv, bit) = self._tocard(0x0C, ser)
se stat == self.OK:
se len(recv) == 5:
per i nell'intervallo (4):
ser_chk = ser_chk ^ recv[i]
se ser_chk != recv[4]:
stat = self.ERR
altro:
stat = self.ERR
stat di ritorno, recv
def select_tag(self, ser):
buf = [0x93, 0x70] + ser[:5]
buf += self._crc(buf)
(stat, recv, bit) = self._tocard(0x0C, buf)
restituisce self.OK if (stat == self.OK) e (bit == 0x18) else self.ERR
def auth(self, modalità, addr, sect, ser):
return self._tocard(0x0E, [mode, addr] + sect + ser[:4])[0]
def stop_cripto1(self):
self._cflags(0x08, 0x08)
def leggi(self, indirizzo):
dati = [0x30, indirizzo]
dati += self._crc(dati)
(stat, recv, _) = self._tocard(0x0C, dati)
return recv if stat == self.OK else Nessuno
def write(self, addr, dati):
buf = [0xA0, indir]
buf += self._crc(buf)
(stat, recv, bit) = self._tocard(0x0C, buf)
se no (stat == self.OK) o no (bit == 4) o no ((recv[0] & 0x0F) == 0x0A):
stat = self.ERR
altro:
bu = []
per i nell'intervallo (16):
buf.append(dati[i])
buf += self._crc(buf)
(stat, recv, bit) = self._tocard(0x0C, buf)
se no (stat == self.OK) o no (bit == 4) o no ((recv[0] & 0x0F) == 0x0A):
stat = self.ERR
stato di ritorno
Fonte: Plato Data Intelligence