Courte introduction
La maison intelligente devient de plus en plus courante avec le développement de la technologie, cet article se concentrera sur les aspects de sécurité du projet de contrôle d'accès intelligent.
Cet article utilise L'écran tactile de STONE pour envoyer des commandes au MCU pour contrôler le relais et le module MFRC522.
Le principe de lecture de carte : en pilotant le module RFID-RC522, identifiez l'ID de la carte d'identité à proximité de la carte d'identité, puis déterminez si l'ID existe dans la base de données du mot typique, ID est la valeur typique du mot, si l'existence de la vérification par , puis imprimez le nom correspondant, puis pilotez le verrou électromagnétique de la même manière.
Matériaux nécessaires
- ESP32
- Serrure électronique KOB
- Relais
- Écran tactile STONE STWI070WT-01
- module MFRC522
Fonction réalisée
- enregistrement de la carte.
- enregistrement du nom d'utilisateur et du mot de passe.
- glisser la carte pour déverrouiller la serrure électronique.
- Nom d'utilisateur et mot de passe pour déverrouiller la serrure électronique.
Le matériel principal Description
Module RFID
Ce module peut être directement chargé dans différents modules lecteurs. Il utilise une tension de 3.3 V, via l'interface SPI avec simplement quelques fils. Directement connecté à une carte mère CPU, le module peut fonctionner de manière stable et fiable en tant que lecteur de carte à distance.
Le STWI070WT-01 a été conçu comme moniteur TFT et contrôleur tactile. Il comprend un processeur, un programme de contrôle, un pilote, une mémoire flash, un port RS232/RS422/RS485/TTL/LAN, Wi-Fi/Bluetooth, un écran tactile, une alimentation, etc., il s'agit donc d'un système d'affichage complet basé sur le puissant et facile système d'exploitation, qui peut être contrôlé par n'importe quel MCU.
conception de l'interface graphique
Partage de Code
importer mfrc522
temps d'importation
importer _thread
depuis os importer uname
à partir de la broche d'importation de la machine, UART
#de pyb importer UART
#importer la machine
suos = Pin (32, Pin.OUT)
uart2 = UART(2, débit en bauds=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 = []
nom_rx = []
user_id_flag = Faux
password_flag = Faux
id_temp = "
temp_mima = "
personnel_id = {'zbw':[236,230,169,47],'lbw':[19,165,93,4]}
personnel_ps = {'zbw':'zbw3366′,'lbw':'lbwnb'}
admin_password = ('yyds')
bouton_cmd = [16,1]
edit1_cmd = [16,112 XNUMX]
edit2_cmd = [16,113 XNUMX]
edit3_cmd = [16,114 XNUMX]
si 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() :
Essai:
(stat, tag_type) = rdr.request(rdr.REQIDL)
si stat == rdr.OK :
(stat, raw_uid) = rdr.anticoll()
si stat == rdr.OK :
print ("Nouvelle carte détectée")
print(” – type de balise : 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
impression ("")
si rdr.select_tag(raw_uid) == rdr.OK :
clé = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
si rdr.auth(rdr.AUTHENT1A, 8, clé, 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()
si stat == rdr.OK :
print ("Données écrites sur la carte")
autre:
print("Impossible d'écrire les données sur la carte")
autre:
print ("Erreur d'authentification")
autre:
print("Impossible de sélectionner la balise")
sauf KeyboardInterrupt:
print ("erreur d'écriture")
def do_read() :
tandis que True:
Essai:
(stat, tag_type) = rdr.request(rdr.REQIDL)
si stat == rdr.OK :
(stat, raw_uid) = rdr.anticoll()
si stat == rdr.OK :
print ("Nouvelle carte détectée")
print(” – type de balise : 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
imprimer (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3])
impression ("")
si rdr.select_tag(raw_uid) == rdr.OK :
clé = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
si rdr.auth(rdr.AUTHENT1A, 8, clé, raw_uid) == rdr.OK :
print("Données de l'adresse 8 : %s" % rdr.read(8))
pour ps dans personnel_id :
si raw_uid[0:4:1] == personnel_id.get(ps):
suos.valeur(1)
imprimer(ps)
uart_write(ps, *raw_uid[0:4:1])
time.sleep (3)
uart2.sendbreak()
pause
rdr.stop_crypto1()
time.sleep (3)
suos.valeur(0)
autre:
print ("Erreur d'authentification")
autre:
print("Impossible de sélectionner la balise")
si uart2.any()>1 :
rx2 = []
nom_données2 = "
bin_data = uart2.read (40)
uart2.sendbreak()
rx1 = liste(bin_data)
pour l'article dans rx1 :
rx2.append(chr(élément))
imprimer (rx2)
si rx1[3:5:1] == button_cmd :
nom_données_len = rx1[6] – 1
nom_données = rx2[7:nom_données_len+7:1]
data_name2 = .join(data_name)
imprimer(nom_données2)
if data_name2 == 'back3' :
retourner
sauf KeyboardInterrupt:
print ("erreur de lecture")
def do_read2 (idd):
imprimer (idd)
tandis que True:
Essai:
(stat, tag_type) = rdr.request(rdr.REQIDL)
si stat == rdr.OK :
(stat, raw_uid) = rdr.anticoll()
si stat == rdr.OK :
print ("Nouvelle carte détectée")
print(” – type de balise : 0x%02x” % tag_type)
print(” – uid : 0x%02x%02x%02x%02x” % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
imprimer (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3])
impression ("")
si rdr.select_tag(raw_uid) == rdr.OK :
clé = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
si rdr.auth(rdr.AUTHENT1A, 8, clé, raw_uid) == rdr.OK :
print("Données de l'adresse 8 : %s" % rdr.read(8))
personnel_id[idd] = raw_uid[0:4:1]
uart_write3(*raw_uid[0:4:1])
rdr.stop_crypto1()
autre:
print ("Erreur d'authentification")
autre:
print("Impossible de sélectionner la balise")
si uart2.any()>1 :
rx2 = []
nom_données2 = "
bin_data = uart2.read (40)
uart2.sendbreak()
rx1 = liste(bin_data)
pour l'article dans rx1 :
rx2.append(chr(élément))
si rx1[3:5:1] == button_cmd :
nom_données_len = rx1[6] – 1
nom_données = rx2[7:nom_données_len+7:1]
data_name2 = .join(data_name)
imprimer(nom_données2)
if data_name2 == 'back1' :
retourner
sauf KeyboardInterrupt:
print ("erreur de lecture")
def uart_write(texte, *ids) :
# print(texte, *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(texte,texte2) :
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(texte,texte2) :
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() :
tandis que True:
si uart2.any() :
id_utilisateur = "
mot de passe = "
rx2 = []
rx_num = 0
bin_data = uart2.read (40)
uart2.sendbreak()
rx1 = liste(bin_data)
pour l'article dans rx1 :
rx2.append(chr(élément))
rx_num += 1
fin_données = rx_num-5
data_id_st = rx2[8:13:1]
data_id_st2 = .join(data_id_st)
imprimer(data_id_st2)
if data_id_st2 == 'edit1' :
data_id_st3 = rx2[15:data_end:1]
data_id_st4 = .join(data_id_st3)
imprimer(data_id_st4)
si data_id_st4 != " :
nom = vrai
elif data_id_st2 == 'edit2' :
data_id_st5 = rx2[15:data_end:1]
data_id_st6 = .join(data_id_st5)
si data_id_st6 == admin_password :
administrateur = vrai
uart_write2('Vérification réussie !','Veuillez placer la carte !')
do_read2(data_id_st4)
retourner
def mima_zuce() :
temp_id3 = "
temp_mima3 = "
tandis que True:
si uart2.any() :
id_utilisateur = "
mot de passe = "
rx2 = []
rx_num = 0
# fin_données = 0
bin_data = uart2.read (40)
uart2.sendbreak()
rx1 = liste(bin_data)
pour l'article dans rx1 :
rx2.append(chr(élément))
rx_num += 1
# si (rx2[rx_num] == 'T') et (rx2[rx_num-1] == 'E') et (rx2[rx_num-2] == '>'):
# Pause
fin_données = rx_num-5
data_id_st = rx2[8:13:1]
data_id_st2 = .join(data_id_st)
imprimer(data_id_st2)
si rx1[3:5:1] == button_cmd :
nom_données_len = rx1[6] – 1
nom_données = rx2[7:nom_données_len+7:1]
data_name2 = .join(data_name)
imprimer(nom_données2)
if data_name2 == 'back2' :
retourner
if data_id_st2 == 'edit3' :
data_id_st3 = rx2[15:data_end:1]
data_id_st4 = .join(data_id_st3)
imprimer(data_id_st4)
user_id_flag = Vrai
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)
imprimer(data_id_st6)
# si personnel_ps.get(temp_id) == data_id_st6 :
password_flag = Vrai
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)
if (data_id_st6 == admin_password) et (password_flag == True) et (user_id_flag == True):
administrateur = vrai
personnel_ps[temp_id3] = temp_mima3
password_flag = Faux
user_id_flag = Faux
uart_write4('Vérification réussie !','La connexion a réussi !')
def password_loin() :
temp_id2 = "
temp_mima = "
tandis que True:
si uart2.any() :
id_utilisateur = "
mot de passe = "
rx2 = []
rx_num = 0
# fin_données = 0
bin_data = uart2.read (40)
uart2.sendbreak()
rx1 = liste(bin_data)
pour l'article dans rx1 :
rx2.append(chr(élément))
rx_num += 1
# si (rx2[rx_num] == 'T') et (rx2[rx_num-1] == 'E') et (rx2[rx_num-2] == '>'):
# Pause
fin_données = rx_num-5
data_id_st = rx2[8:13:1]
data_id_st2 = .join(data_id_st)
imprimer(data_id_st2)
si rx1[3:5:1] == button_cmd :
nom_données_len = rx1[6] – 1
nom_données = rx2[7:nom_données_len+7:1]
data_name2 = .join(data_name)
imprimer(nom_données2)
if data_name2 == 'back4' :
retourner
if data_id_st2 == 'edit5' :
data_id_st3 = rx2[15:data_end:1]
data_id_st4 = .join(data_id_st3)
imprimer(data_id_st4)
si data_id_st4 dans personnel_ps :
user_id_flag = Vrai
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)
imprimer(data_id_st6)
impression(temp_id2)
imprimer(personnel_ps)
si personnel_ps.get(temp_id2) == data_id_st6 :
password_flag = Vrai
# print(rx2,user_id_flag,password_flag)
imprimer(user_id_flag,password_flag)
if (password_flag == True) et (user_id_flag == True):
uart_write(temp_id2,temp_id2)
password_flag = Faux
user_id_flag = Faux
suos.valeur(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('étudiant',")
suos.valeur(0)
uart2.write('ST<{“cmd_code”:”set_visible”,”type”:”widget”,”widget”:”lock2″,”visible”:false}>ET')
uart2.sendbreak()
tandis que True:
si uart2.any()>1 :
rx2 = []
nom_données2 = "
bin_data = uart2.read (40)
# temps.sommeil(1)
uart2.sendbreak()
# temps.sommeil(1)
rx1 = liste(bin_data)
pour l'article dans rx1 :
rx2.append(chr(élément))
imprimer (rx2)
si rx1[3:5:1] == button_cmd :
nom_données_len = rx1[6] – 1
nom_données = rx2[7:nom_données_len+7:1]
data_name2 = .join(data_name)
imprimer(nom_données2)
if data_name2 == 'card1' :
card_zhuce()
elif data_name2 == 'password1' :
mima_zuce()
elif data_name2 == 'card2' :
faire_lire()
elif data_name2 == 'password2' :
mot_de_passe_loin()
CRFM522.py
à partir de la broche d'importation de la machine, SPI
depuis os importer uname
classe MFRC522 :
D'accord = 0
NOTAGER = 1
TRE = 2
REQIDL = 0x26
REQALL = 0x52
AUTHENT1A = 0x60
AUTHENT1B = 0x61
def __init__(self, sck, mosi, miso, premier, cs) :
self.sck = Pin(sck, Pin.OUT)
self.mosi = Pin(mosi, Pin.OUT)
self.miso = Pin(miso)
self.rst = Pin(premier, Pin.OUT)
self.cs = Pin(cs, Pin.OUT)
self.première.valeur(0)
self.cs.value(1)
tableau = uname()[0]
if board == 'WiPy' ou board == 'LoPy' ou board == 'FiPy' :
soi.spi = SPI(0)
self.spi.init(SPI.MASTER, débit en bauds=1000000 XNUMX XNUMX, pins=(self.sck, self.mosi, self.miso))
tableau elif == 'esp32' :
self.spi = SPI(baudrate=100000, polarité=0, phase=0, sck=self.sck, mosi=self.mosi, miso=self.miso)
self.spi.init()
autre:
augmenter RuntimeError ("Plateforme non prise en charge")
self.première.valeur(1)
auto.init()
def _wreg(soi, 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(soi, 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)
valeur de retour[0]
def _sflags(self, reg, masque) :
self._wreg(reg, self._rreg(reg) | masque)
def _cflags(self, reg, masque) :
self._wreg(reg, self._rreg(reg) & (~mask))
def _tocard(self, cmd, envoyer):
recv = []
bits = irq_en = attendre_irq = n = 0
stat = soi.ERR
si cmd == 0x0E :
irq_fr = 0x12
attendre_irq = 0x10
elif cmd == 0x0C :
irq_fr = 0x77
attendre_irq = 0x30
self._wreg(0x02, irq_fr | 0x80)
self._cflags (0x04, 0x80)
self._sflags (0x0A, 0x80)
soi._wreg(0x01, 0x00)
pour c dans envoyer :
soi._wreg(0x09, c)
soi._wreg(0x01, cmd)
si cmd == 0x0C :
self._sflags (0x0D, 0x80)
i = 2000
tandis que True:
n = soi._rreg(0x04)
je -= 1
si ~((i != 0) et ~(n & 0x01) et ~(n & wait_irq)):
pause
self._cflags(0x0D, 0x80)
si je:
if (self._rreg(0x06) & 0x1B) == 0x00 :
stat = soi.OK
si n & irq_en & 0x01 :
stat = soi.NOTAGER
elif cmd == 0x0C :
n = soi._rreg(0x0A)
lbits = self._rreg(0x0C) & 0x07
si lbits != 0 :
bits = (n – 1) * 8 + lbits
autre:
bits = n * 8
si n == 0 :
n = 1
elif n > 16 :
n = 16
pour _ dans la plage (n):
recv.append(self._rreg(0x09))
autre:
stat = soi.ERR
retour stat, recv, bits
def _crc(soi, données):
self._cflags (0x05, 0x04)
self._sflags (0x0A, 0x80)
pour c dans les données :
soi._wreg(0x09, c)
soi._wreg(0x01, 0x03)
je = 0xFF
tandis que True:
n = soi._rreg(0x05)
je -= 1
sinon ((i != 0) et non (n & 0x04)):
pause
renvoie [self._rreg(0x22), self._rreg(0x21)]
def init(auto):
auto.reset()
soi._wreg(0x2A, 0x8D)
soi._wreg(0x2B, 0x3E)
self._wreg(0x2D, 30)
soi._wreg(0x2C, 0)
soi._wreg(0x15, 0x40)
soi._wreg(0x11, 0x3D)
self.antenna_on()
def réinitialiser (auto):
soi._wreg(0x01, 0x0F)
def antenna_on(self, on=True) :
si activé et ~(self._rreg(0x14) & 0x03):
self._sflags (0x14, 0x03)
autre:
self._cflags (0x14, 0x03)
requête def (soi, mode):
soi._wreg(0x0D, 0x07)
(stat, recv, bits) = self._tocard (0x0C, [mode])
si (stat != self.OK) | (bits != 0x10) :
stat = soi.ERR
retour stat, bits
def anticoll(auto):
ser_chk = 0
ser = [0x93, 0x20]
soi._wreg(0x0D, 0x00)
(stat, recv, bits) = self._tocard (0x0C, ser)
si stat == self.OK :
si len(recv) == 5:
pour i dans la plage (4):
ser_chk = ser_chk ^ recv[i]
si ser_chk != recv[4] :
stat = soi.ERR
autre:
stat = soi.ERR
retour stat, recv
def select_tag(soi, ser):
buf = [0x93, 0x70] + ser[:5]
buf += soi._crc(buf)
(stat, recv, bits) = self._tocard (0x0C, buf)
renvoie self.OK si (stat == self.OK) et (bits == 0x18) sinon self.ERR
def auth (soi, mode, adresse, secte, ser) :
return self._tocard(0x0E, [mode, addr] + secte + ser[:4])[0]
def stop_crypto1(soi) :
self._cflags (0x08, 0x08)
def read (soi, adresse):
données = [0x30, adresse]
données += self._crc(données)
(stat, recv, _) = self._tocard (0x0C, données)
renvoie recv if stat == self.OK else None
def écrire (soi, adresse, données):
buf = [0xA0, adresse]
buf += soi._crc(buf)
(stat, recv, bits) = self._tocard (0x0C, buf)
si non (stat == self.OK) ou non (bits == 4) ou non ((recv[0] & 0x0F) == 0x0A) :
stat = soi.ERR
autre:
buf = []
pour i dans la plage (16):
buf.append(données[i])
buf += soi._crc(buf)
(stat, recv, bits) = self._tocard (0x0C, buf)
si non (stat == self.OK) ou non (bits == 4) ou non ((recv[0] & 0x0F) == 0x0A) :
stat = soi.ERR
retour statistique
Source : Platon Data Intelligence