Lühike sissejuhatus
Tark kodu muutub tehnoloogia arenguga üha tavalisemaks, see artikkel keskendub intelligentse juurdepääsukontrolli projekti turvalisuse aspektidele.
See artikkel kasutab STONE'i puutetundlik ekraan käskude saatmiseks MCU-le relee ja MFRC522 mooduli juhtimiseks.
Kaardi lugemise põhimõte: RFID-RC522 mooduli juhtimisega tuvastage ID-kaardi ID-kaardi lähedal ID-kaardi ID ja seejärel tehke kindlaks, kas ID on andmebaasis olemas sõna tüüpiline, ID on sõna tüüpiline väärtus, kui kinnituse olemasolu läbi , ja seejärel printige välja vastav nimi ning seejärel ajage samamoodi elektromagnetlukku.
Nõutavad materjalid
- ESP32
- KOB elektrooniline lukk
- Relee
- STONE STWI070WT-01 puutetundlik ekraan
- MFRC522 moodul
Realiseeritud funktsioon
- kaardi registreerimine.
- kasutajanime ja parooli registreerimine.
- elektroonilise luku avamiseks pühkige kaardiga.
- Kasutajanimi ja parool elektroonilise luku avamiseks.
Peamise riistvara kirjeldus
RFID -moodul
Seda moodulit saab otse laadida erinevatesse lugejamoodulitesse. See kasutab SPI-liidese kaudu vaid mõne juhtmega pinget 3.3 V. Otse CPU emaplaadiga ühendatud moodul võib töötada stabiilselt ja töökindlalt kaugkaardilugejana.
STWI070WT-01 on loodud TFT-monitori ja puutetundliku kontrollerina. See sisaldab protsessorit, juhtimisprogrammi, draiverit, välkmälu, RS232/RS422/RS485/TTL/LAN-porti, Wi-Fi/Bluetoothi, puutetundlikku ekraani, toiteallikat jne, nii et see on terve kuvasüsteem, mis põhineb võimsal ja lihtsal. operatsioonisüsteem, mida saab juhtida mis tahes MCU-ga.
GUI disain
Koodi jagamine
import mfrc522
impordiaeg
import _lõng
os import uname
masinimpordist Pin, UART
#pyb-impordist UART
#impordimasin
suos = Pin(32,Pin.OUT)
uart2 = UART(2, baudikiirus = 115200, rx = 16, tx = 17, ajalõpp = 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 = Vale
password_flag = Vale
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 XNUMX]
edit2_cmd = [16,113 XNUMX]
edit3_cmd = [16,114 XNUMX]
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():
proovige:
(stat, sildi_tüüp) = rdr.request(rdr.REQIDL)
kui stat == rdr.OK:
(stat, töötlemata_uid) = rdr.anticoll()
kui stat == rdr.OK:
print ("Tuvastati uus kaart")
print(” – sildi tüüp: 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (toore_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
print (“”)
if rdr.select_tag(raw_uid) == rdr.OK:
võti = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth(rdr.AUTHENT1A, 8, võti, 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()
kui stat == rdr.OK:
print ("kaardile kirjutatud andmed")
muu:
print ("Andmete kaardile kirjutamine ebaõnnestus")
muu:
print (“Autentimisviga”)
muu:
print ("Märgendi valimine ebaõnnestus")
välja arvatud KeyboardInterrupt:
print ("kirjutusviga")
def do_read():
tõsi:
proovige:
(stat, sildi_tüüp) = rdr.request(rdr.REQIDL)
kui stat == rdr.OK:
(stat, töötlemata_uid) = rdr.anticoll()
kui stat == rdr.OK:
print ("Tuvastati uus kaart")
print(” – sildi tüüp: 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (toore_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
print (toores_uid[0], toores_uid[1], toores_uid[2], toores_uid[3])
print (“”)
if rdr.select_tag(raw_uid) == rdr.OK:
võti = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth(rdr.AUTHENT1A, 8, võti, raw_uid) == rdr.OK:
print("Aadress 8 andmed: %s" % rdr.read(8))
ps jaoks personal_id:
if raw_uid[0:4:1] == personal_id.get(ps):
suos.value(1)
print (ps)
uart_write(ps, *raw_uid[0:4:1])
aeg. magama (3)
uart2.sendbreak()
murdma
rdr.stop_crypto1()
aeg. magama (3)
suos.value(0)
muu:
print (“Autentimisviga”)
muu:
print ("Märgendi valimine ebaõnnestus")
kui uart2.any()>1:
rx2 = []
data_name2 = ”
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = loend(bin_data)
rx1 üksuse jaoks:
rx2.append(chr(üksus))
print (rx2)
if rx1 [3:5:1] == button_cmd:
andmete_nimi_len = rx1[6] – 1
andmete_nimi = rx2[7:andmete_nimi_len+7:1]
andmete_nimi2 = .join(andmete_nimi)
print(andmete_nimi2)
if data_name2 == 'tagasi3':
tagasipöördumine
välja arvatud KeyboardInterrupt:
print ("lugemisviga")
def do_read2 (idd):
print (idd)
tõsi:
proovige:
(stat, sildi_tüüp) = rdr.request(rdr.REQIDL)
kui stat == rdr.OK:
(stat, töötlemata_uid) = rdr.anticoll()
kui stat == rdr.OK:
print ("Tuvastati uus kaart")
print(” – sildi tüüp: 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (toore_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
print (toores_uid[0], toores_uid[1], toores_uid[2], toores_uid[3])
print (“”)
if rdr.select_tag(raw_uid) == rdr.OK:
võti = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth(rdr.AUTHENT1A, 8, võti, raw_uid) == rdr.OK:
print("Aadress 8 andmed: %s" % rdr.read(8))
personali_id[idd] = töötlemata_uid[0:4:1]
uart_write3(*raw_uid[0:4:1])
rdr.stop_crypto1()
muu:
print (“Autentimisviga”)
muu:
print ("Märgendi valimine ebaõnnestus")
kui uart2.any()>1:
rx2 = []
data_name2 = ”
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = loend(bin_data)
rx1 üksuse jaoks:
rx2.append(chr(üksus))
if rx1 [3:5:1] == button_cmd:
andmete_nimi_len = rx1[6] – 1
andmete_nimi = rx2[7:andmete_nimi_len+7:1]
andmete_nimi2 = .join(andmete_nimi)
print(andmete_nimi2)
if data_name2 == 'tagasi1':
tagasipöördumine
välja arvatud KeyboardInterrupt:
print ("lugemisviga")
def uart_write(tekst, *ids):
# print(tekst, *id)
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"kaardinimi1",tekst":"'+str(tekst)+'"}>ET' )
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"cardid1",tekst":"'+str(ids)+'"}>ET' )
uart2.write('ST<{"cmd_code":"set_visible","type":"vidin","vidin":"lock1","visible":true}>ET')
aeg. magama (3)
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"kaardinimi1",tekst":"""}>ET')
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"cardid1",tekst":"""}>ET')
uart2.write('ST<{"cmd_code":"set_visible","type":"vidin","vidin":"lock1","visible":false}>ET')
def uart_write2(tekst,tekst2):
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"cardid","tekst":"'+tekst+'"}>ET')
aeg. magama (3)
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"cardid","text":"'+text2+'"}>ET')
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"redigeeri2",tekst":"""}>ET')
def uart_write3(*id2):
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"cardid","text":"'+str(id2)+'"}>ET' )
aeg. magama (3)
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"cardid","text":"""}>ET')
def uart_write4(tekst,tekst2):
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"sisselogimine","tekst":"'+tekst+'"}>ET')
aeg. magama (1)
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"sisselogimine","tekst":"'+text2+'"}>ET')
aeg. magama (1)
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"redigeeri3",tekst":"""}>ET')
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"redigeeri4",tekst":"""}>ET')
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"redigeeri7",tekst":"""}>ET')
def uart_write5():
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"cardid","text":"'+str(id2)+'"}>ET' )
aeg. magama (3)
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"cardid","text":"""}>ET')
def card_zhuce():
tõsi:
kui uart2.any():
kasutaja_id = ”
parool = ”
rx2 = []
rx_num = 0
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = loend(bin_data)
rx1 üksuse jaoks:
rx2.append(chr(üksus))
rx_num += 1
andmete_lõpp = rx_num-5
data_id_st = rx2[8:13:1]
data_id_st2 = .join(data_id_st)
print(andmete_id_st2)
if data_id_st2 == 'redigeeri1':
data_id_st3 = rx2[15:data_end:1]
data_id_st4 = .join(data_id_st3)
print(andmete_id_st4)
if data_id_st4 != ”:
nimi = tõsi
elif data_id_st2 == 'redigeeri2':
data_id_st5 = rx2[15:data_end:1]
data_id_st6 = .join(data_id_st5)
if data_id_st6 == admin_password:
admin = tõsi
uart_write2('Kinnitus läbitud!','Palun asetage kaart!')
do_read2(data_id_st4)
tagasipöördumine
def mima_zuce():
temp_id3 = ”
temp_mima3 = ”
tõsi:
kui uart2.any():
kasutaja_id = ”
parool = ”
rx2 = []
rx_num = 0
# andme_lõpp = 0
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = loend(bin_data)
rx1 üksuse jaoks:
rx2.append(chr(üksus))
rx_num += 1
# if (rx2[rx_num] == 'T') ja (rx2[rx_num-1] == 'E') ja (rx2[rx_num-2] == '>'):
#paus
andmete_lõpp = rx_num-5
data_id_st = rx2[8:13:1]
data_id_st2 = .join(data_id_st)
print(andmete_id_st2)
if rx1 [3:5:1] == button_cmd:
andmete_nimi_len = rx1[6] – 1
andmete_nimi = rx2[7:andmete_nimi_len+7:1]
andmete_nimi2 = .join(andmete_nimi)
print(andmete_nimi2)
if data_name2 == 'tagasi2':
tagasipöördumine
if data_id_st2 == 'redigeeri3':
data_id_st3 = rx2[15:data_end:1]
data_id_st4 = .join(data_id_st3)
print(andmete_id_st4)
user_id_flag = Tõene
temp_id3 = data_id_st4
# personal_ps[temp_id] = raw_uid[0:4:1]
elif data_id_st2 == 'redigeeri4':
data_id_st5 = rx2[15:data_end:1]
data_id_st6 = .join(data_id_st5)
print(andmete_id_st6)
# if personal_ps.get(temp_id) == data_id_st6:
password_flag = Tõene
temp_mima3 = data_id_st6
# personal_ps[temp_id] = parooli_lipp
# print(rx2,kasutaja_id_lipp,parooli_lipp)
elif data_id_st2 == 'redigeeri7':
data_id_st5 = rx2[15:data_end:1]
data_id_st6 = .join(data_id_st5)
if (data_id_st6 == admin_password) ja (password_flag == True) ja (user_id_flag == True):
admin = tõsi
personal_ps[temp_id3] = temp_mima3
password_flag = Vale
user_id_flag = Vale
uart_write4('Kinnitus läbitud!','sisselogimine õnnestus!')
def password_loin():
temp_id2 = ”
temp_mima = ”
tõsi:
kui uart2.any():
kasutaja_id = ”
parool = ”
rx2 = []
rx_num = 0
# andme_lõpp = 0
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = loend(bin_data)
rx1 üksuse jaoks:
rx2.append(chr(üksus))
rx_num += 1
# if (rx2[rx_num] == 'T') ja (rx2[rx_num-1] == 'E') ja (rx2[rx_num-2] == '>'):
#paus
andmete_lõpp = rx_num-5
data_id_st = rx2[8:13:1]
data_id_st2 = .join(data_id_st)
print(andmete_id_st2)
if rx1 [3:5:1] == button_cmd:
andmete_nimi_len = rx1[6] – 1
andmete_nimi = rx2[7:andmete_nimi_len+7:1]
andmete_nimi2 = .join(andmete_nimi)
print(andmete_nimi2)
if data_name2 == 'tagasi4':
tagasipöördumine
if data_id_st2 == 'redigeeri5':
data_id_st3 = rx2[15:data_end:1]
data_id_st4 = .join(data_id_st3)
print(andmete_id_st4)
if data_id_st4 personal_ps:
user_id_flag = Tõene
temp_id2 = data_id_st4
elif data_id_st2 == 'redigeeri6':
data_id_st5 = rx2[15:data_end:1]
data_id_st6 = .join(data_id_st5)
print(andmete_id_st6)
print(temp_id2)
print(personal_ps)
if personal_ps.get(temp_id2) == data_id_st6:
password_flag = Tõene
# print(rx2,kasutaja_id_lipp,parooli_lipp)
print(kasutaja_id_lipp,parooli_lipp)
if (password_flag == True) ja (user_id_flag == True):
uart_write(temp_id2,temp_id2)
password_flag = Vale
user_id_flag = Vale
suos.value(1)
uart2.write('ST<{"cmd_code":"set_visible","type":"vidin","vidin":"lock2","visible":true}>ET')
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"redigeeri5",tekst":"""}>ET')
uart2.write('ST<{"cmd_code":"set_text","type":"silt","vidin":"redigeeri6",tekst":"""}>ET')
aeg. magama (3)
# uart_write('õpilane'")
suos.value(0)
uart2.write('ST<{"cmd_code":"set_visible","type":"vidin","vidin":"lock2","visible":false}>ET')
uart2.sendbreak()
tõsi:
kui uart2.any()>1:
rx2 = []
data_name2 = ”
bin_data = uart2.read(40)
# aeg.uni (1)
uart2.sendbreak()
# aeg.uni (1)
rx1 = loend(bin_data)
rx1 üksuse jaoks:
rx2.append(chr(üksus))
print (rx2)
if rx1 [3:5:1] == button_cmd:
andmete_nimi_len = rx1[6] – 1
andmete_nimi = rx2[7:andmete_nimi_len+7:1]
andmete_nimi2 = .join(andmete_nimi)
print(andmete_nimi2)
if data_name2 == 'kaart1':
card_zhuce()
elif data_name2 == 'password1':
mima_zuce()
elif data_name2 == 'kaart2':
do_read()
elif data_name2 == 'password2':
password_loin()
MFRC522.py
masinimpordist Pin, SPI
os import uname
klass 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(rst, Pin.OUT)
self.cs = Pin(cs, Pin.OUT)
self.esm.value(0)
self.cs.value (1)
tahvel = uname()[0]
if board == 'WiPy' or board == 'LoPy' or board == 'FiPy':
self.spi = SPI(0)
self.spi.init(SPI.MASTER, baudrate=1000000, pins=(self.sck, self.mosi, self.miso))
elif board == 'esp32':
ise.spi = SPI(baudrate=100000, polaarsus=0, faas=0, sck=self.sck, mosi=self.mosi, miso=self.miso)
self.spi.init()
muu:
tõsta RuntimeError ("Toetamata platvorm")
self.esm.value(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)
tagastamisväärtus[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 = []
bitid = irq_en = oota_irq = n = 0
stat = ise.ERR
kui cmd == 0x0E:
irq_en = 0x12
oota_irq = 0x10
elif cmd == 0x0C:
irq_en = 0x77
oota_irq = 0x30
self._wreg(0x02, irq_en | 0x80)
self._cflags(0x04, 0x80)
self._sflags(0x0A, 0x80)
self._wreg(0x01, 0x00)
c saatmisel:
self._wreg(0x09, c)
self._wreg(0x01, cmd)
kui cmd == 0x0C:
self._sflags(0x0D, 0x80)
i = 2000
tõsi:
n = ise._rreg(0x04)
i - = 1
kui ~((i != 0) ja ~(n & 0x01) ja ~(n & oota_irq)):
murdma
self._cflags(0x0D, 0x80)
kui ma:
if (self._rreg(0x06) & 0x1B) == 0x00:
stat = ise.OK
kui n & irq_en & 0x01:
stat = ise.NOTAGERR
elif cmd == 0x0C:
n = ise._rreg(0x0A)
lbits = ise._rreg(0x0C) & 0x07
kui lbits != 0:
bitti = (n – 1) * 8 + naela
muu:
bitid = n * 8
kui n == 0:
n = 1
elif n > 16:
n = 16
_ jaoks vahemikus (n):
recv.append(self._rreg(0x09))
muu:
stat = ise.ERR
return stat, recv, bits
def _crc(self, data):
self._cflags(0x05, 0x04)
self._sflags(0x0A, 0x80)
c andmetes:
self._wreg(0x09, c)
self._wreg(0x01, 0x03)
i = 0xFF
tõsi:
n = ise._rreg(0x05)
i - = 1
kui mitte ((i != 0) ja mitte (n & 0x04)):
murdma
return [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 (ise):
self._wreg(0x01, 0x0F)
def antenna_on(self, on=True):
kui sees ja ~(self._rreg(0x14) & 0x03):
self._sflags(0x14, 0x03)
muu:
self._cflags(0x14, 0x03)
def päring (ise, režiim):
self._wreg(0x0D, 0x07)
(stat, recv, bits) = self._tocard(0x0C, [mode])
if (stat != ise.OK) | (bitid != 0x10):
stat = ise.ERR
tagastamise stat, bitid
def anticoll (ise):
ser_chk = 0
ser = [0x93, 0x20]
self._wreg(0x0D, 0x00)
(stat, recv, bits) = self._tocard(0x0C, ser)
kui stat == ise.OK:
kui len(recv) == 5:
i jaoks vahemikus (4):
ser_chk = ser_chk ^ recv[i]
if ser_chk != recv[4]:
stat = ise.ERR
muu:
stat = ise.ERR
tagastamise stat, rev
def select_tag(self, ser):
buf = [0x93, 0x70] + ser[:5]
buf += ise._crc(buf)
(stat, recv, bits) = self._tocard(0x0C, buf)
tagasta self.OK if (stat == self.OK) ja (bits == 0x18) else self.ERR
def auth(self, mode, addr, sekt, ser):
return self._tocard(0x0E, [režiim, adr] + sect + ser[:4])[0]
def stop_crypto1(self):
self._cflags(0x08, 0x08)
def loe (ise, adr):
andmed = [0x30, aadress]
andmed += ise._crc(data)
(stat, recv, _) = self._tocard(0x0C, data)
return recv if stat == self.OK else Puudub
def write (self, addr, data):
buf = [0xA0, adr]
buf += ise._crc(buf)
(stat, recv, bits) = self._tocard(0x0C, buf)
kui mitte (stat == ise.OK) või mitte (bitti == 4) või mitte ((recv[0] & 0x0F) == 0x0A):
stat = ise.ERR
muu:
buf = []
i jaoks vahemikus (16):
buf.append(data[i])
buf += ise._crc(buf)
(stat, recv, bits) = self._tocard(0x0C, buf)
kui mitte (stat == ise.OK) või mitte (bitti == 4) või mitte ((recv[0] & 0x0F) == 0x0A):
stat = ise.ERR
tagastamise stat
Allikas: Platon Data Intelligence