Breve introducción
El hogar inteligente se está volviendo cada vez más común con el desarrollo de la tecnología, este artículo se centrará en los aspectos de seguridad del proyecto de control de acceso inteligente.
Este artículo utiliza Pantalla táctil de STONE para enviar comandos a la MCU para controlar el relé y el módulo MFRC522.
El principio de lectura de cartas: Al conducir el módulo RFID-RC522, identifique la identificación de la tarjeta de identificación cerca de la tarjeta de identificación y luego determine si la identificación existe en la base de datos de la palabra típica, la identificación es el valor típico de la palabra, si la existencia de la verificación a través de , y luego imprima el nombre correspondiente, y luego accione la cerradura electromagnética de la misma manera.
Los materiales requeridos
- ESP32
- Cerradura electrónica KOB
- Relé
- Pantalla de panel táctil STONE STWI070WT-01
- Módulo MFRC522
Función realizada
- registro de tarjeta.
- registro de nombre de usuario y contraseña.
- deslizar la tarjeta para desbloquear la cerradura electrónica.
- Nombre de usuario y contraseña para desbloquear la cerradura electrónica.
La descripción principal del hardware
Módulo RFID
Este módulo se puede cargar directamente en varios módulos de lectura. Utiliza un voltaje de 3.3V, a través de la interfaz SPI con solo unos pocos cables. Conectado directamente con una placa base de CPU, el módulo puede funcionar de manera estable y confiable como un lector de tarjetas a distancia.
El STWI070WT-01 ha sido concebido como monitor TFT y controlador táctil. Incluye procesador, programa de control, controlador, memoria flash, puerto RS232 / RS422 / RS485 / TTL / LAN, Wi-Fi / Bluetooth, pantalla táctil, fuente de alimentación, etc., por lo que es un sistema de visualización completo basado en el potente y sencillo sistema operativo, que puede ser controlado por cualquier MCU.
Diseño de GUI
Compartir código
importar mfrc522
tiempo de importación
importar _thread
desde os import uname
desde el Pin de importación de la máquina, UART
#desde pyb import UART
#máquina de importación
suos = Pin (32, Pin.OUT)
uart2 = UART (2, velocidad en baudios = 115200, rx = 16, tx = 17, tiempo de espera = 10)
ESP32_HSPI_CLOCK = 14
ESP32_HSPI_ESCLAVO_SELECT = 15
ESP32_HSPI_MISO = 12
ESP32_HSPI_MOSI = 13
ESP32_MFRC522_RST = 5
rx3 = []
nombre_rx = []
user_id_flag = Falso
password_flag = Falso
id_temp = ”
temp_mima=”
id_personal = {'zbw': [236,230,169,47], 'lbw': [19,165,93,4]}
personal_ps = {'zbw': 'zbw3366 ′,' lbw ':' lbwnb '}
admin_password = ('yyds')
botón_cmd = [16,1]
editar1_cmd = [16,112]
editar2_cmd = [16,113]
editar3_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 ():
tratar:
(estadística, tipo_etiqueta) = rdr.request (rdr.REQIDL)
si stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll ()
si stat == rdr.OK:
imprimir ("Nueva tarjeta detectada")
print ("- tipo de etiqueta: 0x% 02x"% tag_type)
print (”- uid: 0x% 02x% 02x% 02x% 02x”% (raw_uid [0], raw_uid [1], raw_uid [2], raw_uid [3]))
impresión("")
si rdr.select_tag (raw_uid) == rdr.OK:
clave = [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 ()
si stat == rdr.OK:
imprimir ("Datos escritos en la tarjeta")
más:
imprimir ("Error al escribir datos en la tarjeta")
más:
imprimir ("Error de autenticación")
más:
imprimir ("No se pudo seleccionar la etiqueta")
excepto KeyboardInterrupt:
imprimir ("error de escritura")
def do_read ():
mientras cierto:
tratar:
(estadística, tipo_etiqueta) = rdr.request (rdr.REQIDL)
si stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll ()
si stat == rdr.OK:
imprimir ("Nueva tarjeta detectada")
print ("- tipo de etiqueta: 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])
impresión("")
si rdr.select_tag (raw_uid) == rdr.OK:
clave = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth (rdr.AUTHENT1A, 8, key, raw_uid) == rdr.OK:
print ("Datos de la dirección 8:% s"% rdr.read (8))
para ps en personal_id:
si raw_uid [0: 4: 1] == staff_id.get (ps):
suos.value (1)
imprimir (ps)
uart_write (ps, * raw_uid [0: 4: 1])
tiempo de sueño (3)
uart2.sendbreak ()
romper
rdr.stop_crypto1 ()
tiempo de sueño (3)
suos.value (0)
más:
imprimir ("Error de autenticación")
más:
imprimir ("No se pudo seleccionar la etiqueta")
si uart2.any ()> 1:
rx2 = []
nombre_datos2 = ”
bin_data = uart2.read (40)
uart2.sendbreak ()
rx1 = lista (bin_data)
para el artículo en rx1:
rx2.append (chr (elemento))
imprimir (rx2)
si rx1 [3: 5: 1] == button_cmd:
data_name_len = rx1 [6] - 1
nombre_datos = rx2 [7: nombre_datos_len + 7: 1]
data_name2 = ”.join (data_name)
imprimir (nombre_datos2)
si data_name2 == 'back3':
volvemos
excepto KeyboardInterrupt:
imprimir ("error de lectura")
def do_read2 (idd):
imprimir (idd)
mientras cierto:
tratar:
(estadística, tipo_etiqueta) = rdr.request (rdr.REQIDL)
si stat == rdr.OK:
(stat, raw_uid) = rdr.anticoll ()
si stat == rdr.OK:
imprimir ("Nueva tarjeta detectada")
print ("- tipo de etiqueta: 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])
impresión("")
si rdr.select_tag (raw_uid) == rdr.OK:
clave = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
if rdr.auth (rdr.AUTHENT1A, 8, key, raw_uid) == rdr.OK:
print ("Datos de la dirección 8:% s"% rdr.read (8))
staff_id [idd] = raw_uid [0: 4: 1]
uart_write3 (* raw_uid [0: 4: 1])
rdr.stop_crypto1 ()
más:
imprimir ("Error de autenticación")
más:
imprimir ("No se pudo seleccionar la etiqueta")
si uart2.any ()> 1:
rx2 = []
nombre_datos2 = ”
bin_data = uart2.read (40)
uart2.sendbreak ()
rx1 = lista (bin_data)
para el artículo en rx1:
rx2.append (chr (elemento))
si rx1 [3: 5: 1] == button_cmd:
data_name_len = rx1 [6] - 1
nombre_datos = rx2 [7: nombre_datos_len + 7: 1]
data_name2 = ”.join (data_name)
imprimir (nombre_datos2)
si data_name2 == 'back1':
volvemos
excepto KeyboardInterrupt:
imprimir ("error de lectura")
def uart_write (texto, * ids):
# print (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')
tiempo de sueño (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')
tiempo de sueño (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' )
tiempo de sueño (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”, ”tipo”: ”etiqueta”, ”widget”: ”inicio de sesión”, ”texto”: ”' + texto + '”}> ET')
tiempo de sueño (1)
uart2.write ('ST <{“cmd_code”: ”set_text”, ”type”: ”label”, ”widget”: ”login”, ”text”: ”' + text2 + '”}> ET')
tiempo de sueño (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' )
tiempo de sueño (3)
uart2.write ('ST <{“cmd_code”: ”set_text”, ”type”: ”label”, ”widget”: ”cardid”, ”text”: ”” ”}> ET')
def card_zhuce ():
mientras cierto:
si uart2.any ():
id_usuario = ”
contraseña = "
rx2 = []
núm_rx = 0
bin_data = uart2.read (40)
uart2.sendbreak ()
rx1 = lista (bin_data)
para el artículo en rx1:
rx2.append (chr (elemento))
rx_num + = 1
fin_datos = rx_num-5
data_id_st = rx2 [8: 13: 1]
data_id_st2 = ”.join (data_id_st)
imprimir (data_id_st2)
si 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! = ”:
nombre = Verdadero
elif data_id_st2 == 'editar2':
data_id_st5 = rx2 [15: data_end: 1]
data_id_st6 = ”.join (data_id_st5)
si data_id_st6 == admin_password:
admin = Verdadero
uart_write2 ('¡Verificación aprobada!', '¡Coloque la tarjeta!')
do_read2 (id_datos_st4)
volvemos
def mima_zuce ():
temp_id3=”
temp_mima3=”
mientras cierto:
si uart2.any ():
id_usuario = ”
contraseña = "
rx2 = []
núm_rx = 0
# data_end = 0
bin_data = uart2.read (40)
uart2.sendbreak ()
rx1 = lista (bin_data)
para el artículo en rx1:
rx2.append (chr (elemento))
rx_num + = 1
# if (rx2 [rx_num] == 'T') y (rx2 [rx_num-1] == 'E') y (rx2 [rx_num-2] == '>'):
# rotura
fin_datos = rx_num-5
data_id_st = rx2 [8: 13: 1]
data_id_st2 = ”.join (data_id_st)
imprimir (data_id_st2)
si rx1 [3: 5: 1] == button_cmd:
data_name_len = rx1 [6] - 1
nombre_datos = rx2 [7: nombre_datos_len + 7: 1]
data_name2 = ”.join (data_name)
imprimir (nombre_datos2)
si data_name2 == 'back2':
volvemos
si 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 = Verdadero
temp_id3 = datos_id_st4
# staff_ps [temp_id] = raw_uid [0: 4: 1]
elif data_id_st2 == 'editar4':
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:
password_flag = Verdadero
temp_mima3 = data_id_st6
# staff_ps [temp_id] = password_flag
# print (rx2, user_id_flag, password_flag)
elif data_id_st2 == 'editar7':
data_id_st5 = rx2 [15: data_end: 1]
data_id_st6 = ”.join (data_id_st5)
si (data_id_st6 == admin_password) y (password_flag == True) y (user_id_flag == True):
admin = Verdadero
staff_ps [temp_id3] = temp_mima3
password_flag = Falso
user_id_flag = Falso
uart_write4 ('¡Verificación aprobada!', '¡El inicio de sesión fue exitoso!')
def password_loin ():
temp_id2=”
temp_mima=”
mientras cierto:
si uart2.any ():
id_usuario = ”
contraseña = "
rx2 = []
núm_rx = 0
# data_end = 0
bin_data = uart2.read (40)
uart2.sendbreak ()
rx1 = lista (bin_data)
para el artículo en rx1:
rx2.append (chr (elemento))
rx_num + = 1
# if (rx2 [rx_num] == 'T') y (rx2 [rx_num-1] == 'E') y (rx2 [rx_num-2] == '>'):
# rotura
fin_datos = rx_num-5
data_id_st = rx2 [8: 13: 1]
data_id_st2 = ”.join (data_id_st)
imprimir (data_id_st2)
si rx1 [3: 5: 1] == button_cmd:
data_name_len = rx1 [6] - 1
nombre_datos = rx2 [7: nombre_datos_len + 7: 1]
data_name2 = ”.join (data_name)
imprimir (nombre_datos2)
si data_name2 == 'back4':
volvemos
si data_id_st2 == 'edit5':
data_id_st3 = rx2 [15: data_end: 1]
data_id_st4 = ”.join (data_id_st3)
imprimir (data_id_st4)
si data_id_st4 en staff_ps:
user_id_flag = Verdadero
temp_id2 = datos_id_st4
elif data_id_st2 == 'editar6':
data_id_st5 = rx2 [15: data_end: 1]
data_id_st6 = ”.join (data_id_st5)
imprimir (data_id_st6)
imprimir (temp_id2)
imprimir (personal_ps)
si staff_ps.get (temp_id2) == data_id_st6:
password_flag = Verdadero
# print (rx2, user_id_flag, password_flag)
imprimir (bandera_id_usuario, bandera_contraseña)
si (password_flag == True) y (user_id_flag == True):
uart_write (temp_id2, temp_id2)
password_flag = Falso
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')
tiempo de sueño (3)
# uart_write ('estudiante', ”)
suos.value (0)
uart2.write ('ST <{“cmd_code”: ”set_visible”, ”type”: ”widget”, ”widget”: ”lock2 ″,” visible ”: false}> ET')
uart2.sendbreak ()
mientras cierto:
si uart2.any ()> 1:
rx2 = []
nombre_datos2 = ”
bin_data = uart2.read (40)
# time.sleep (1)
uart2.sendbreak ()
# time.sleep (1)
rx1 = lista (bin_data)
para el artículo en rx1:
rx2.append (chr (elemento))
imprimir (rx2)
si rx1 [3: 5: 1] == button_cmd:
data_name_len = rx1 [6] - 1
nombre_datos = rx2 [7: nombre_datos_len + 7: 1]
data_name2 = ”.join (data_name)
imprimir (nombre_datos2)
si data_name2 == 'card1':
card_zhuce ()
elif nombre_datos2 == 'contraseña1':
mima_zuce ()
elif nombre_datos2 == 'tarjeta2':
do_read ()
elif nombre_datos2 == 'contraseña2':
lomo_contraseña ()
MFRC522.py
desde el Pin de importación de la máquina, SPI
desde os import uname
clase MFRC522:
Aceptar = 0
NOTAGERR = 1
ERROR = 2
REQUISITOS = 0x26
REQUISICIÓN = 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 (primero, Pin.OUT)
self.cs = Pin (cs, Pin.OUT)
self.rst.value (0)
self.cs.value (1)
tablero = uname () [0]
si tablero == 'WiPy' o tablero == 'LoPy' o tablero == 'FiPy':
self.spi = SPI (0)
self.spi.init (SPI.MASTER, velocidad en baudios = 1000000, pines = (self.sck, self.mosi, self.miso))
tablero elif == 'esp32':
self.spi = SPI (velocidad en baudios = 100000, polaridad = 0, fase = 0, sck = self.sck, mosi = self.mosi, miso = self.miso)
self.spi.init ()
más:
subir RuntimeError ("Plataforma no admitida")
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) & (~ máscara))
def _tocard (self, cmd, enviar):
recibo = []
bits = irq_en = esperar_irq = n = 0
estadística = self.ERR
si cmd == 0x0E:
irq_es = 0x12
esperar_irq = 0x10
cmd elif == 0x0C:
irq_es = 0x77
esperar_irq = 0x30
self._wreg (0x02, irq_en | 0x80)
self._cflags (0x04, 0x80)
self._sflags (0x0A, 0x80)
self._wreg (0x01, 0x00)
para c en enviar:
self._wreg (0x09, c)
self._wreg (0x01, cmd)
si cmd == 0x0C:
self._sflags (0x0D, 0x80)
i = 2000
mientras cierto:
n = self._rreg (0x04)
yo - = 1
si ~ ((i! = 0) y ~ (n & 0x01) y ~ (n & wait_irq)):
romper
self._cflags (0x0D, 0x80)
si yo:
si (self._rreg (0x06) y 0x1B) == 0x00:
estadística = self.OK
si n & irq_en & 0x01:
estadística = self.NOTAGERR
cmd elif == 0x0C:
n = self._rreg (0x0A)
lbits = self._rreg (0x0C) y 0x07
si lbits! = 0:
bits = (n - 1) * 8 + libras
más:
bits = n * 8
si n == 0:
n = 1
elif n> 16:
n = 16
para _ en rango (n):
recv.append (self._rreg (0x09))
más:
estadística = self.ERR
estadísticas de retorno, recv, bits
def _crc (self, data):
self._cflags (0x05, 0x04)
self._sflags (0x0A, 0x80)
para c en datos:
self._wreg (0x09, c)
self._wreg (0x01, 0x03)
yo = 0xFF
mientras cierto:
n = self._rreg (0x05)
yo - = 1
si no ((i! = 0) y no (n & 0x04)):
romper
return [self._rreg (0x22), self._rreg (0x21)]
def init (yo):
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 = True):
si está activado y ~ (self._rreg (0x14) & 0x03):
self._sflags (0x14, 0x03)
más:
self._cflags (0x14, 0x03)
def request (self, mode):
self._wreg (0x0D, 0x07)
(stat, recv, bits) = self._tocard (0x0C, [modo])
if (stat! = self.OK) | (bits! = 0x10):
estadística = self.ERR
retorno estadístico, bits
def anticoll (yo):
ser_chk = 0
ser = [0x93, 0x20]
self._wreg (0x0D, 0x00)
(stat, recv, bits) = self._tocard (0x0C, ser)
si stat == self.OK:
si len (recv) == 5:
para i en el rango (4):
ser_chk = ser_chk ^ recv [i]
si ser_chk! = recv [4]:
estadística = self.ERR
más:
estadística = self.ERR
retorno estadístico, recv
def select_tag (self, ser):
buf = [0x93, 0x70] + ser [: 5]
buf + = self._crc (buf)
(stat, recv, bits) = self._tocard (0x0C, buf)
devuelve self.OK si (stat == self.OK) y (bits == 0x18) else self.ERR
def auth (self, mode, addr, sect, ser):
return self._tocard (0x0E, [mode, addr] + sect + ser [: 4]) [0]
def stop_crypto1 (auto):
self._cflags (0x08, 0x08)
def read (self, addr):
datos = [0x30, addr]
datos + = self._crc (datos)
(stat, recv, _) = self._tocard (0x0C, datos)
return recv if stat == self.OK else Ninguno
def write (self, addr, data):
buf = [0xA0, dirección]
buf + = self._crc (buf)
(stat, recv, bits) = self._tocard (0x0C, buf)
si no (stat == self.OK) o no (bits == 4) o no ((recv [0] & 0x0F) == 0x0A):
estadística = self.ERR
más:
bufo = []
para i en el rango (16):
buf.append (datos [i])
buf + = self._crc (buf)
(stat, recv, bits) = self._tocard (0x0C, buf)
si no (stat == self.OK) o no (bits == 4) o no ((recv [0] & 0x0F) == 0x0A):
estadística = self.ERR
estadísticas de retorno
Fuente: Platón Data Intelligence