Breve introdução
A casa inteligente está se tornando cada vez mais comum com o desenvolvimento da tecnologia. Este artigo se concentrará nos aspectos de segurança do projeto de controle de acesso inteligente.
Este artigo usa Tela sensível ao toque de STONE para enviar comandos ao MCU para controlar o relé e o módulo MFRC522.
O princípio da leitura de cartas: conduzindo o módulo RFID-RC522, identifique o ID do cartão de identificação próximo ao cartão de identificação e, em seguida, determine se o ID existe no banco de dados da palavra típica, ID é o valor típico da palavra, se a existência da verificação por meio e, em seguida, imprima o nome correspondente e acione a fechadura eletromagnética da mesma maneira.
Materiais requeridos
- ESP32
- Fechadura eletrônica KOB
- Retransmissão
- Visor de painel de toque STONE STWI070WT-01
- Módulo MFRC522
Função realizada
- registro do cartão.
- registro de nome de usuário e senha.
- passe o cartão para desbloquear a fechadura eletrônica.
- Nome de usuário e senha para desbloquear a fechadura eletrônica.
A descrição do hardware principal
Módulo RFID
Este módulo pode ser carregado diretamente em vários módulos de leitor. Utiliza uma tensão de 3.3 V, através da interface SPI com apenas alguns fios. Conectado diretamente a uma placa-mãe da CPU, o módulo pode funcionar de maneira estável e confiável como um leitor de cartão à distância.
O STWI070WT-01 foi concebido como monitor TFT e controlador de toque. Inclui processador, programa de controle, driver, memória flash, porta RS232 / RS422 / RS485 / TTL / LAN, Wi-Fi / Bluetooth, tela sensível ao toque, fonte de alimentação, etc., por isso é um sistema de exibição completo baseado no poderoso e fácil sistema operacional, que pode ser controlado por qualquer MCU.
Design GUI
Compartilhamento de código
importar mfrc522
tempo de importação
importar _thread
de os import uname
de importação de máquina Pin, UART
#from pyb importar UART
#máquina de importação
suos = Pin (32, Pin.OUT)
uart2 = UART (2, baudrate = 115200, rx = 16, tx = 17, tempo limite = 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
senha_flag = False
id_temp = ”
temp_mima = ”
personal_id = {'zbw': [236,230,169,47], 'lbw': [19,165,93,4]}
personal_ps = {'zbw': 'zbw3366 ′,' lbw ':' lbwnb '}
admin_password = ('yyds')
botão_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 ():
tente:
(stat, tag_type) = rdr.request (rdr.REQIDL)
se stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll ()
se stat == rdr.OK:
imprimir (“Novo cartão detectado”)
imprimir (”- tipo de tag: 0x% 02x”% tag_type)
print (”- uid: 0x% 02x% 02x% 02x% 02x”% (raw_uid [0], raw_uid [1], raw_uid [2], raw_uid [3]))
imprimir("")
if rdr.select_tag (raw_uid) == rdr.OK:
chave = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth (rdr.AUTHENT1A, 8, chave, 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:
imprimir ("Dados gravados no cartão")
outro:
imprimir (“Falha ao gravar dados no cartão”)
outro:
imprimir (“Erro de autenticação”)
outro:
imprimir (“Falha ao selecionar tag”)
exceto KeyboardInterrupt:
imprimir (“erro de gravação”)
def do_read ():
enquanto True:
tente:
(stat, tag_type) = rdr.request (rdr.REQIDL)
se stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll ()
se stat == rdr.OK:
imprimir (“Novo cartão detectado”)
imprimir (”- tipo de tag: 0x% 02x”% tag_type)
print (”- uid: 0x% 02x% 02x% 02x% 02x”% (raw_uid [0], raw_uid [1], raw_uid [2], raw_uid [3]))
imprimir (raw_uid [0], raw_uid [1], raw_uid [2], raw_uid [3])
imprimir("")
if rdr.select_tag (raw_uid) == rdr.OK:
chave = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth (rdr.AUTHENT1A, 8, chave, raw_uid) == rdr.OK:
imprimir (“Dados do endereço 8:% s”% rdr.read (8))
para ps em staff_id:
if raw_uid [0: 4: 1] == staff_id.get (ps):
suos.value (1)
imprimir (ps)
uart_write (ps, * raw_uid [0: 4: 1])
time.sleep (3)
uart2.sendbreak ()
quebrar
rdr.stop_crypto1 ()
time.sleep (3)
suos.value (0)
outro:
imprimir (“Erro de autenticação”)
outro:
imprimir (“Falha ao selecionar tag”)
se uart2.any ()> 1:
rx2 = []
nome_dados2 = ”
bin_data = uart2.read (40)
uart2.sendbreak ()
rx1 = lista (bin_data)
para o item em rx1:
rx2.append (chr (item))
imprimir (rx2)
if 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)
imprimir (data_name2)
if data_name2 == 'back3':
retorno
exceto KeyboardInterrupt:
imprimir (“erro de leitura”)
def do_read2 (idd):
imprimir (idd)
enquanto True:
tente:
(stat, tag_type) = rdr.request (rdr.REQIDL)
se stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll ()
se stat == rdr.OK:
imprimir (“Novo cartão detectado”)
imprimir (”- tipo de tag: 0x% 02x”% tag_type)
print (”- uid: 0x% 02x% 02x% 02x% 02x”% (raw_uid [0], raw_uid [1], raw_uid [2], raw_uid [3]))
imprimir (raw_uid [0], raw_uid [1], raw_uid [2], raw_uid [3])
imprimir("")
if rdr.select_tag (raw_uid) == rdr.OK:
chave = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth (rdr.AUTHENT1A, 8, chave, raw_uid) == rdr.OK:
imprimir (“Dados do endereço 8:% s”% rdr.read (8))
personal_id [idd] = raw_uid [0: 4: 1]
uart_write3 (* raw_uid [0: 4: 1])
rdr.stop_crypto1 ()
outro:
imprimir (“Erro de autenticação”)
outro:
imprimir (“Falha ao selecionar tag”)
se uart2.any ()> 1:
rx2 = []
nome_dados2 = ”
bin_data = uart2.read (40)
uart2.sendbreak ()
rx1 = lista (bin_data)
para o item em rx1:
rx2.append (chr (item))
if 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)
imprimir (data_name2)
if data_name2 == 'back1':
retorno
exceto KeyboardInterrupt:
imprimir (“erro de leitura”)
def uart_write (text, * ids):
# imprimir (texto, * 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 (texto, texto2):
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 (texto, texto2):
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 ():
enquanto True:
if uart2.any ():
id_usuário = ”
senha = ”
rx2 = []
núm_rx = 0
bin_data = uart2.read (40)
uart2.sendbreak ()
rx1 = lista (bin_data)
para o item em rx1:
rx2.append (chr (item))
rx_num + = 1
data_end = rx_num-5
data_id_st = rx2 [8: 13: 1]
data_id_st2 = ”.join (data_id_st)
imprimir (data_id_st2)
if data_id_st2 == 'edit1':
data_id_st3 = rx2 [15: data_end: 1]
data_id_st4 = ”.join (data_id_st3)
imprimir (data_id_st4)
if data_id_st4! = ”:
nome = verdadeiro
elif data_id_st2 == 'edit2':
data_id_st5 = rx2 [15: data_end: 1]
data_id_st6 = ”.join (data_id_st5)
se data_id_st6 == admin_password:
administrador = Verdadeiro
uart_write2 ('Verificação aprovada!', 'Coloque o cartão!')
do_read2 (data_id_st4)
retorno
def mima_zuce ():
temp_id3 = ”
temp_mima3 = ”
enquanto True:
if uart2.any ():
id_usuário = ”
senha = ”
rx2 = []
núm_rx = 0
# data_end = 0
bin_data = uart2.read (40)
uart2.sendbreak ()
rx1 = lista (bin_data)
para o item em rx1:
rx2.append (chr (item))
rx_num + = 1
# if (rx2 [rx_num] == 'T') e (rx2 [rx_num-1] == 'E') e (rx2 [rx_num-2] == '>'):
# pausa
data_end = rx_num-5
data_id_st = rx2 [8: 13: 1]
data_id_st2 = ”.join (data_id_st)
imprimir (data_id_st2)
if 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)
imprimir (data_name2)
if data_name2 == 'back2':
retorno
if data_id_st2 == 'edit3':
data_id_st3 = rx2 [15: data_end: 1]
data_id_st4 = ”.join (data_id_st3)
imprimir (data_id_st4)
user_id_flag = Verdadeiro
temp_id3 = data_id_st4
# staff_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)
imprimir (data_id_st6)
# if staff_ps.get (temp_id) == data_id_st6:
senha_flag = Verdadeiro
temp_mima3 = data_id_st6
# staff_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) e (password_flag == True) e (user_id_flag == True):
administrador = Verdadeiro
pessoal_ps [temp_id3] = temp_mima3
senha_flag = False
user_id_flag = Falso
uart_write4 ('Verificação aprovada!', 'login bem-sucedido!')
def password_loin ():
temp_id2 = ”
temp_mima = ”
enquanto True:
if uart2.any ():
id_usuário = ”
senha = ”
rx2 = []
núm_rx = 0
# data_end = 0
bin_data = uart2.read (40)
uart2.sendbreak ()
rx1 = lista (bin_data)
para o item em rx1:
rx2.append (chr (item))
rx_num + = 1
# if (rx2 [rx_num] == 'T') e (rx2 [rx_num-1] == 'E') e (rx2 [rx_num-2] == '>'):
# pausa
data_end = rx_num-5
data_id_st = rx2 [8: 13: 1]
data_id_st2 = ”.join (data_id_st)
imprimir (data_id_st2)
if 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)
imprimir (data_name2)
if data_name2 == 'back4':
retorno
if data_id_st2 == 'edit5':
data_id_st3 = rx2 [15: data_end: 1]
data_id_st4 = ”.join (data_id_st3)
imprimir (data_id_st4)
se data_id_st4 em staff_ps:
user_id_flag = Verdadeiro
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)
imprimir (data_id_st6)
imprimir (temp_id2)
imprimir (staff_ps)
if staff_ps.get (temp_id2) == data_id_st6:
senha_flag = Verdadeiro
# print (rx2, user_id_flag, password_flag)
imprimir (user_id_flag, password_flag)
if (password_flag == True) e (user_id_flag == True):
uart_write (temp_id2, temp_id2)
senha_flag = False
user_id_flag = Falso
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')
time.sleep (3)
# uart_write ('aluno', ”)
suos.value (0)
uart2.write ('ST <{“cmd_code”: ”set_visible”, ”type”: ”widget”, ”widget”: ”lock2 ″,” visible ”: false}> ET')
uart2.sendbreak ()
enquanto True:
se uart2.any ()> 1:
rx2 = []
nome_dados2 = ”
bin_data = uart2.read (40)
# time.sleep (1)
uart2.sendbreak ()
# time.sleep (1)
rx1 = lista (bin_data)
para o item em rx1:
rx2.append (chr (item))
imprimir (rx2)
if 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)
imprimir (data_name2)
if data_name2 == 'card1':
card_zhuce ()
elif data_name2 == 'password1':
mima_zuce ()
elif data_name2 == 'card2':
do_read ()
elif data_name2 == 'password2':
password_loin ()
MFRC522.py
de importação de máquina Pin, SPI
de os import uname
classe MFRC522:
OK = 0
NOTAGERR = 1
ER = 2
REQIDL = 0x26
REQALL = 0x52
AUTENT1A = 0x60
AUTENT1B = 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 (primeiro, Pin.OUT)
self.cs = Pin (cs, Pin.OUT)
self.rst.value (0)
self.cs.value (1)
placa = uname () [0]
if board == 'WiPy' ou board == 'LoPy' ou board == 'FiPy':
self.spi = SPI (0)
self.spi.init (SPI.MASTER, baudrate = 1000000, pins = (self.sck, self.mosi, self.miso))
placa elif == 'esp32':
self.spi = SPI (baudrate = 100000, polaridade = 0, fase = 0, sck = self.sck, mosi = self.mosi, miso = self.miso)
self.spi.init ()
outro:
raise RuntimeError (“Plataforma não suportada”)
self.rst.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)
return val [0]
def _sflags (self, reg, mask):
self._wreg (reg, self._rreg (reg) | máscara)
def _cflags (self, reg, mask):
self._wreg (reg, self._rreg (reg) & (~ mask))
def _tocard (self, cmd, send):
receb = []
bits = irq_en = wait_irq = n = 0
estatística = self.ERR
se cmd == 0x0E:
irq_pt = 0x12
espere_irq = 0x10
elif cmd == 0x0C:
irq_pt = 0x77
espere_irq = 0x30
self._wreg (0x02, irq_en | 0x80)
self._cflags (0x04, 0x80)
self._sflags (0x0A, 0x80)
self._wreg (0x01, 0x00)
para c em enviar:
self._wreg (0x09, c)
self._wreg (0x01, cmd)
se cmd == 0x0C:
self._sflags (0x0D, 0x80)
i = 2000
enquanto True:
n = self._rreg (0x04)
i - = 1
if ~ ((i! = 0) e ~ (n & 0x01) e ~ (n & wait_irq)):
quebrar
self._cflags (0x0D, 0x80)
se eu:
if (self._rreg (0x06) & 0x1B) == 0x00:
estatística = self.OK
se n & irq_en & 0x01:
stat = self.NOTAGERR
elif cmd == 0x0C:
n = self._rreg (0x0A)
lbits = self._rreg (0x0C) & 0x07
se lbits! = 0:
bits = (n - 1) * 8 + lbits
outro:
bits = n * 8
se n == 0:
n = 1
elif n> 16:
n = 16
para _ no intervalo (n):
recv.append (self._rreg (0x09))
outro:
estatística = self.ERR
retornar stat, recv, bits
def _crc (self, data):
self._cflags (0x05, 0x04)
self._sflags (0x0A, 0x80)
para c nos dados:
self._wreg (0x09, c)
self._wreg (0x01, 0x03)
eu = 0xFF
enquanto True:
n = self._rreg (0x05)
i - = 1
se não ((i! = 0) e não (n & 0x04)):
quebrar
retornar [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 antena_on (self, on = True):
se ligado e ~ (self._rreg (0x14) & 0x03):
self._sflags (0x14, 0x03)
outro:
self._cflags (0x14, 0x03)
pedido def (self, mode):
self._wreg (0x0D, 0x07)
(stat, recv, bits) = self._tocard (0x0C, [modo])
if (stat! = self.OK) | (bits! = 0x10):
estatística = self.ERR
retornar stat, bits
def anticoll (self):
ser_chk = 0
ser = [0x93, 0x20]
self._wreg (0x0D, 0x00)
(stat, recv, bits) = self._tocard (0x0C, ser)
se stat == self.OK:
se len (recv) == 5:
para i no intervalo (4):
ser_chk = ser_chk ^ recv [i]
se ser_chk! = recv [4]:
estatística = self.ERR
outro:
estatística = self.ERR
estatísticas de retorno, recv
def select_tag (self, ser):
buf = [0x93, 0x70] + ser [: 5]
buf + = self._crc (buf)
(stat, recv, bits) = self._tocard (0x0C, buf)
retorna self.OK if (stat == self.OK) e (bits == 0x18) else self.ERR
def auth (self, mode, addr, sect, ser):
return self._tocard (0x0E, [modo, addr] + sect + ser [: 4]) [0]
def stop_crypto1 (self):
self._cflags (0x08, 0x08)
def read (self, addr):
dados = [0x30, addr]
dados + = self._crc (dados)
(stat, recv, _) = self._tocard (0x0C, dados)
return recv if stat == self.OK else Nenhum
def write (self, addr, data):
buf = [0xA0, endereço]
buf + = self._crc (buf)
(stat, recv, bits) = self._tocard (0x0C, buf)
se não (stat == self.OK) ou não (bits == 4) ou não ((recv [0] & 0x0F) == 0x0A):
estatística = self.ERR
outro:
buf = []
para i no intervalo (16):
buf.append (data [i])
buf + = self._crc (buf)
(stat, recv, bits) = self._tocard (0x0C, buf)
se não (stat == self.OK) ou não (bits == 4) ou não ((recv [0] & 0x0F) == 0x0A):
estatística = self.ERR
status de retorno
Fonte: Plato Data Intelligence