Kurze Einleitung
Smart Home wird mit der Entwicklung der Technologie immer häufiger, dieser Artikel konzentriert sich auf die Sicherheitsaspekte des intelligenten Zutrittskontrollprojekts.
Dieser Artikel verwendet STONEs Touchscreen um Befehle an die MCU zu senden, um das Relais und das MFRC522-Modul zu steuern.
Das Prinzip des Kartenlesens: Durch Ansteuern des RFID-RC522-Moduls identifizieren Sie die ID-Karten-ID in der Nähe der ID-Karte und stellen Sie dann fest, ob die ID in der Datenbank des Wortes typisch vorhanden ist, ID ist der typische Wert des Wortes, wenn das Vorhandensein der Überprüfung durch , und drucken Sie dann den entsprechenden Namen aus und fahren Sie dann das elektromagnetische Schloss auf die gleiche Weise.
Benötigtes Material
- ESP32
- KOB elektronisches Schloss
- Relais
- STONE STWI070WT-01 Touchpanel-Display
- MFRC522-Modul
Realisierte Funktion
- Kartenregistrierung.
- Registrierung von Benutzername und Passwort.
- Ziehen Sie die Karte, um das elektronische Schloss zu entsperren.
- Benutzername und Passwort zum Entsperren des elektronischen Schlosses.
Die Haupthardwarebeschreibung
RFID-Modul
Dieses Modul kann direkt in verschiedene Lesemodule geladen werden. Es verwendet eine Spannung von 3.3 V über die SPI-Schnittstelle mit nur wenigen Drähten. Direkt mit einem CPU-Motherboard verbunden, kann das Modul stabil und zuverlässig als Distanzkartenleser arbeiten.
Der STWI070WT-01 ist als TFT-Monitor & Touch-Controller konzipiert. Es enthält Prozessor, Steuerungsprogramm, Treiber, Flash-Speicher, RS232/RS422/RS485/TTL/LAN-Port, Wi-Fi/Bluetooth, Touchscreen, Netzteil usw Betriebssystem, das von jeder MCU gesteuert werden kann.
GUI-Design
Code-Sharing
mfrc522 importieren
Importzeit
_thread importieren
von os importieren uname
aus Maschinenimport Pin, UART
#von pyb importieren UART
#Maschine importieren
suos = Pin(32,Pin.AUS)
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 = Falsch
password_flag = Falsch
temp_id = ”
temp_mima = ”
personal_id = {'zbw':[236,230,169,47],'lbw':[19,165,93,4]}
personal_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():
Versuchen:
(stat, tag_type) = rdr.request(rdr.REQIDL)
if stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll()
if stat == rdr.OK:
print("Neue Karte erkannt")
print(” – Tag-Typ: 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
drucken ("")
wenn rdr.select_tag(raw_uid) == rdr.OK:
Taste = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth(rdr.AUTHENT1A, 8, key, 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()
if stat == rdr.OK:
print("Auf Karte geschriebene Daten")
sonst:
print("Fehler beim Schreiben der Daten auf die Karte")
sonst:
print("Authentifizierungsfehler")
sonst:
print("Tag konnte nicht ausgewählt werden")
außer KeyboardInterrupt:
print("Schreibfehler")
def do_read():
während wahr:
Versuchen:
(stat, tag_type) = rdr.request(rdr.REQIDL)
if stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll()
if stat == rdr.OK:
print("Neue Karte erkannt")
print(” – Tag-Typ: 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
print (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3])
drucken ("")
wenn rdr.select_tag(raw_uid) == rdr.OK:
Taste = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth(rdr.AUTHENT1A, 8, key, raw_uid) == rdr.OK:
print(“Adresse 8 Daten: %s” % rdr.read(8))
für ps in personal_id:
if raw_uid[0:4:1] == personal_id.get(ps):
suos.value(1)
drucken (ps)
uart_write(ps, *raw_uid[0:4:1])
Zeitschlaf (3)
uart2.sendbreak()
brechen
rdr.stop_crypto1()
Zeitschlaf (3)
suos.value(0)
sonst:
print("Authentifizierungsfehler")
sonst:
print("Tag konnte nicht ausgewählt werden")
wenn uart2.any()>1:
rx2 = []
data_name2 = ”
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = list(bin_data)
für Artikel in rx1:
rx2.append (chr (Element))
drucken (rx2)
if rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] – 1
Datenname = rx2[7:Datenname_länge+7:1]
data_name2 = .join(data_name)
print(daten_name2)
if data_name2 == 'back3':
Rückkehr
außer KeyboardInterrupt:
print("Lesefehler")
def do_read2 (idd):
drucken (idd)
während wahr:
Versuchen:
(stat, tag_type) = rdr.request(rdr.REQIDL)
if stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll()
if stat == rdr.OK:
print("Neue Karte erkannt")
print(” – Tag-Typ: 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
print (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3])
drucken ("")
wenn rdr.select_tag(raw_uid) == rdr.OK:
Taste = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth(rdr.AUTHENT1A, 8, key, raw_uid) == rdr.OK:
print(“Adresse 8 Daten: %s” % rdr.read(8))
personal_id[idd] = raw_uid[0:4:1]
uart_write3(*raw_uid[0:4:1])
rdr.stop_crypto1()
sonst:
print("Authentifizierungsfehler")
sonst:
print("Tag konnte nicht ausgewählt werden")
wenn uart2.any()>1:
rx2 = []
data_name2 = ”
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = list(bin_data)
für Artikel in rx1:
rx2.append (chr (Element))
if rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] – 1
Datenname = rx2[7:Datenname_länge+7:1]
data_name2 = .join(data_name)
print(daten_name2)
if data_name2 == 'back1':
Rückkehr
außer KeyboardInterrupt:
print("Lesefehler")
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')
Zeitschlaf (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')
Zeitschlaf (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' )
Zeitschlaf (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')
Zeitschlaf (1)
uart2.write('ST<{“cmd_code”:”set_text””,type”:”label””,widget”:”login””,text”:”'+text2+'”}>ET')
Zeitschlaf (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' )
Zeitschlaf (3)
uart2.write('ST<{“cmd_code”:”set_text””,type”:”label””,widget”:”cardid””,text”:”””}>ET')
def card_zhuce():
während wahr:
wenn uart2.any():
user_id = ”
Passwort = ”
rx2 = []
rx_num = 0
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = list(bin_data)
für Artikel in rx1:
rx2.append (chr (Element))
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)
if 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 != ”:
name = wahr
elif data_id_st2 == 'edit2':
data_id_st5 = rx2[15:data_end:1]
data_id_st6 = .join(data_id_st5)
if data_id_st6 == admin_passwort:
admin = wahr
uart_write2('Verifizierung bestanden!','Bitte legen Sie die Karte ein!')
do_read2(data_id_st4)
Rückkehr
def mima_zuce():
temp_id3 = ”
temp_mima3 = ”
während wahr:
wenn uart2.any():
user_id = ”
Passwort = ”
rx2 = []
rx_num = 0
# data_end = 0
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = list(bin_data)
für Artikel in rx1:
rx2.append (chr (Element))
rx_num += 1
# if (rx2[rx_num] == 'T') und (rx2[rx_num-1] == 'E') und (rx2[rx_num-2] == '>'):
# brechen
data_end = rx_num-5
data_id_st = rx2[8:13:1]
data_id_st2 = .join(data_id_st)
print(data_id_st2)
if rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] – 1
Datenname = rx2[7:Datenname_länge+7:1]
data_name2 = .join(data_name)
print(daten_name2)
if data_name2 == 'back2':
Rückkehr
if 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 = Wahr
temp_id3 = data_id_st4
#personal_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)
# if personal_ps.get(temp_id) == data_id_st6:
password_flag = Wahr
temp_mima3 = data_id_st6
#personal_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)
if (data_id_st6 == admin_password) und (password_flag == True) und (user_id_flag == True):
admin = wahr
personal_ps[temp_id3] = temp_mima3
password_flag = Falsch
user_id_flag = Falsch
uart_write4('Verifizierung bestanden!','Anmeldung war erfolgreich!')
def passwort_loin():
temp_id2 = ”
temp_mima = ”
während wahr:
wenn uart2.any():
user_id = ”
Passwort = ”
rx2 = []
rx_num = 0
# data_end = 0
bin_data = uart2.read(40)
uart2.sendbreak()
rx1 = list(bin_data)
für Artikel in rx1:
rx2.append (chr (Element))
rx_num += 1
# if (rx2[rx_num] == 'T') und (rx2[rx_num-1] == 'E') und (rx2[rx_num-2] == '>'):
# brechen
data_end = rx_num-5
data_id_st = rx2[8:13:1]
data_id_st2 = .join(data_id_st)
print(data_id_st2)
if rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] – 1
Datenname = rx2[7:Datenname_länge+7:1]
data_name2 = .join(data_name)
print(daten_name2)
if data_name2 == 'back4':
Rückkehr
if data_id_st2 == 'edit5':
data_id_st3 = rx2[15:data_end:1]
data_id_st4 = .join(data_id_st3)
print(data_id_st4)
if data_id_st4 in personal_ps:
user_id_flag = Wahr
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(temp_id2)
print(personal_ps)
if personal_ps.get(temp_id2) == data_id_st6:
password_flag = Wahr
# print(rx2,user_id_flag,password_flag)
print(user_id_flag,passwort_flag)
if (password_flag == True) und (user_id_flag == True):
uart_write(temp_id2,temp_id2)
password_flag = Falsch
user_id_flag = Falsch
suos.value(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')
Zeitschlaf (3)
# uart_write('student',”)
suos.value(0)
uart2.write('ST<{“cmd_code”:”set_visible””,type”:”widget””,widget”:”lock2″”,visible”:false}>ET')
uart2.sendbreak()
während wahr:
wenn uart2.any()>1:
rx2 = []
data_name2 = ”
bin_data = uart2.read(40)
# time.sleep(1)
uart2.sendbreak()
# time.sleep(1)
rx1 = list(bin_data)
für Artikel in rx1:
rx2.append (chr (Element))
drucken (rx2)
if rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] – 1
Datenname = rx2[7:Datenname_länge+7:1]
data_name2 = .join(data_name)
print(daten_name2)
if data_name2 == 'card1':
card_zhuce()
elif data_name2 == 'password1':
mima_zuce()
elif data_name2 == 'card2':
do_read()
elif data_name2 == 'password2':
passwort_loin()
MFRC522.py
aus Maschinenimport Pin, SPI
von os importieren uname
Klasse MFRC522:
OK = 0
NOTAGERR = 1
FEHLER = 2
REQIDL = 0x26
ANFORDERN = 0x52
AUTHENT1A = 0x60
AUTHENT1B = 0x61
def __init__(self, sck, mosi, miso, rst, cs):
self.sck = Pin(sck, Pin.AUS)
self.mosi = Pin(mosi, Pin.AUS)
self.miso = Pin(miso)
self.rst = Pin(erst, Pin.OUT)
self.cs = Pin (cs, Pin.OUT)
selbsterstwert(0)
self.cs.value(1)
Brett = uname()[0]
if Board == 'WiPy' oder Board == 'LoPy' oder Board == 'FiPy':
self.spi = SPI(0)
self.spi.init (SPI.MASTER, Baudrate=1000000, Pins=(self.sck, self.mosi, self.miso))
Elifboard == 'esp32':
self.spi = SPI (Baudrate=100000, Polarität=0, Phase=0, sck=self.sck, mosi=self.mosi, miso=self.miso)
self.spi.init()
sonst:
RuntimeError ("Nicht unterstützte Plattform") erhöhen
selbsterstwert(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(selbst, 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)
Rückgabewert[0]
def _sflags(self, reg, mask):
self._wreg(reg, self._rreg(reg) | Maske)
def _cflags(self, reg, mask):
self._wreg(reg, self._rreg(reg) & (~maske))
def _tocard(selbst, cmd, senden):
Empf = []
Bits = irq_en = wait_irq = n = 0
stat = self.ERR
wenn cmd == 0x0E:
irq_de = 0x12
wait_irq = 0x10
elif-Befehl == 0x0C:
irq_de = 0x77
wait_irq = 0x30
self._wreg(0x02, irq_de | 0x80)
self._cflags(0x04, 0x80)
self._sflags(0x0A, 0x80)
self._wreg(0x01, 0x00)
für c in senden:
self._wreg(0x09, c)
self._wreg(0x01, cmd)
wenn cmd == 0x0C:
self._sflags(0x0D, 0x80)
i = 2000
während wahr:
n = selbst._rreg(0x04)
ich -= 1
if ~((i != 0) und ~(n & 0x01) und ~(n & wait_irq)):
brechen
self._cflags(0x0D, 0x80)
wenn ich:
if (self._rreg(0x06) & 0x1B) == 0x00:
stat = self.OK
wenn n & irq_en & 0x01:
stat = self.NOTAGERR
elif-Befehl == 0x0C:
n = selbst._rreg(0x0A)
lbits = self._rreg(0x0C) & 0x07
wenn lbits != 0:
Bits = (n – 1) * 8 + lbits
sonst:
Bit = n * 8
wenn n == 0:
n = 1
elif n > 16:
n = 16
für _ im Bereich(n):
recv.append(self._rreg(0x09))
sonst:
stat = self.ERR
Rückgabewert, Recv, Bits
def _crc(selbst, Daten):
self._cflags(0x05, 0x04)
self._sflags(0x0A, 0x80)
für c in Daten:
self._wreg(0x09, c)
self._wreg(0x01, 0x03)
ich = 0xFF
während wahr:
n = selbst._rreg(0x05)
ich -= 1
wenn nicht ((i != 0) und nicht (n & 0x04)):
brechen
return [self._rreg(0x22), self._rreg(0x21)]
def init (selbst):
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.antenne_on()
def reset(selbst):
self._wreg(0x01, 0x0F)
def antenne_on(self, on=True):
wenn an und ~(self._rreg(0x14) & 0x03):
self._sflags(0x14, 0x03)
sonst:
self._cflags(0x14, 0x03)
def-Anfrage (selbst, Modus):
self._wreg(0x0D, 0x07)
(stat, recv, bits) = self._tocard(0x0C, [mode])
if (stat != self.OK) | (Bits != 0x10):
stat = self.ERR
Rückgabewert, Bits
def anticoll(selbst):
ser_chk = 0
ser = [0x93, 0x20]
self._wreg(0x0D, 0x00)
(stat, recv, bits) = self._tocard(0x0C, ser)
if stat == self.OK:
wenn len(recv) == 5:
für i im Bereich (4):
ser_chk = ser_chk ^ recv[i]
wenn ser_chk != recv[4]:
stat = self.ERR
sonst:
stat = self.ERR
Rückgabewert, Recv
def select_tag(selbst, ser):
buf = [0x93, 0x70] + ser[:5]
buf += selbst._crc(buf)
(stat, recv, bits) = self._tocard(0x0C, buf)
return self.OK if (stat == self.OK) und (bits == 0x18) else self.ERR
def auth(self, mode, addr, sekt, ser):
return self._tocard(0x0E, [mode, addr] + sekt + ser[:4])[0]
def stop_crypto1 (selbst):
self._cflags(0x08, 0x08)
def read(selbst, Adresse):
Daten = [0x30, Adresse]
Daten += self._crc(Daten)
(stat, recv, _) = self._tocard(0x0C, data)
recv zurückgeben if stat == self.OK else None
def write(selbst, Adresse, Daten):
buf = [0xA0, Adresse]
buf += selbst._crc(buf)
(stat, recv, bits) = self._tocard(0x0C, buf)
wenn nicht (stat == self.OK) oder nicht (bits == 4) oder nicht ((recv[0] & 0x0F) == 0x0A):
stat = self.ERR
sonst:
buf = []
für i im Bereich (16):
buf.append(data[i])
buf += selbst._crc(buf)
(stat, recv, bits) = self._tocard(0x0C, buf)
wenn nicht (stat == self.OK) oder nicht (bits == 4) oder nicht ((recv[0] & 0x0F) == 0x0A):
stat = self.ERR
Rückgabestatistik
Quelle: Plato Data Intelligence