Uncategorized

Intelligent access control based on STONE TFT LCD and ESP32

Brief Introduction

Smart home is becoming more and more common with the development of technology, this article will focus on the security aspects of the intelligent access control project.

This article uses STONE’s touch screen to send commands to the MCU to control the relay and MFRC522 module.

The principle of card reading: by driving the RFID-RC522 module, identify the ID card ID close to the ID card, and then determine whether the ID exists in the database of the word typical, ID is the typical value of the word, if the existence of the verification through, and then print out the corresponding name, and then drive the electromagnetic lock in the same way.

Required materials

Realized function

  1. card registration.
  2. username and password registration.
  3. card swipe to unlock the electronic lock.
  4. User name and password to unlock the electronic lock.

The main hardware Description

RFID Module

This module can be directly loaded into various reader modules. It utilizes a voltage of 3.3V, through the SPI interface with simply a few wires. Directly connected with a CPU motherboard, the module can work in a stable and reliable manner as a distance card reader.

Intelligent access control based on STONE TFT LCD and ESP32 Uncategorized PlatoAiStream PlatoAiStream. Data Intelligence. Vertical Search. Ai.
Intelligent access control based on STONE TFT LCD and ESP32

The STWI070WT-01 has been conceived as TFT monitor & Touch controller. It includes processor, control program, driver, flash memory, RS232/RS422/RS485/TTL/LAN port, Wi-Fi/Bluetooth, touch screen, power supply etc., so it is a whole display system based on the powerful & easy operating system, which can be controlled by Any MCU.

GUI design

Intelligent access control based on STONE TFT LCD and ESP32 Uncategorized PlatoAiStream PlatoAiStream. Data Intelligence. Vertical Search. Ai.
Intelligent access control based on STONE TFT LCD and ESP32

Code sharing

Intelligent access control based on STONE TFT LCD and ESP32 Uncategorized PlatoAiStream PlatoAiStream. Data Intelligence. Vertical Search. Ai.
Intelligent access control based on STONE TFT LCD and ESP32

import mfrc522

import time

import _thread

from os import uname

from machine import Pin, UART

#from pyb import UART

#import machine

suos = Pin(32,Pin.OUT)

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 = False

password_flag = False

temp_id = ”

temp_mima = ”

personnel_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]

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():

try:

(stat, tag_type) = rdr.request(rdr.REQIDL)

if stat == rdr.OK:

(stat, raw_uid) = rdr.anticoll()

if stat == rdr.OK:

print(“New card detected”)

print(”  – tag type: 0x%02x” % tag_type)

print(”  – uid : 0x%02x%02x%02x%02x” % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))

print(“”)

if rdr.select_tag(raw_uid) == rdr.OK:

key = [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(“Data written to card”)

else:

print(“Failed to write data to card”)

else:

print(“Authentication error”)

else:

print(“Failed to select tag”)

except KeyboardInterrupt:

print(“write error”)

def do_read():

while True:

try:

(stat, tag_type) = rdr.request(rdr.REQIDL)

if stat == rdr.OK:

(stat, raw_uid) = rdr.anticoll()

if stat == rdr.OK:

print(“New card detected”)

print(”  – tag type: 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])

print(“”)

if rdr.select_tag(raw_uid) == rdr.OK:

key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]

if rdr.auth(rdr.AUTHENT1A, 8, key, raw_uid) == rdr.OK:

print(“Address 8 data: %s” % rdr.read(8))

for ps in personnel_id:

if raw_uid[0:4:1] == personnel_id.get(ps):

suos.value(1)

print(ps)

uart_write(ps, *raw_uid[0:4:1])

time.sleep(3)

uart2.sendbreak()

break

rdr.stop_crypto1()

time.sleep(3)

suos.value(0)

else:

print(“Authentication error”)

else:

print(“Failed to select tag”)

if uart2.any()>1:

rx2 = []

data_name2 = ”

bin_data = uart2.read(40)

uart2.sendbreak()

rx1 = list(bin_data)

for item in rx1:

rx2.append(chr(item))

print(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)

print(data_name2)

if data_name2 == ‘back3’:

return

except KeyboardInterrupt:

print(“read error”)

def do_read2 (idd):

print(idd)

while True:

try:

(stat, tag_type) = rdr.request(rdr.REQIDL)

if stat == rdr.OK:

(stat, raw_uid) = rdr.anticoll()

if stat == rdr.OK:

print(“New card detected”)

print(”  – tag type: 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])

print(“”)

if rdr.select_tag(raw_uid) == rdr.OK:

key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]

if rdr.auth(rdr.AUTHENT1A, 8, key, raw_uid) == rdr.OK:

print(“Address 8 data: %s” % rdr.read(8))

personnel_id[idd] = raw_uid[0:4:1]

uart_write3(*raw_uid[0:4:1])

rdr.stop_crypto1()

else:

print(“Authentication error”)

else:

print(“Failed to select tag”)

if uart2.any()>1:

rx2 = []

data_name2 = ”

bin_data = uart2.read(40)

uart2.sendbreak()

rx1 = list(bin_data)

for item in 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)

print(data_name2)

if data_name2 == ‘back1’:

return

except KeyboardInterrupt:

print(“read error”)

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’)

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(text,text2):

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(text,text2):

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():

while True:

if uart2.any():

user_id = ”

password = ”

rx2 = []

rx_num = 0

bin_data = uart2.read(40)

uart2.sendbreak()

rx1 = list(bin_data)

for item in 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)

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 = True

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_password:

admin = True

uart_write2(‘Verification passed!’,’Please place the card!’)

do_read2(data_id_st4)

return

def mima_zuce():

temp_id3 = ”

temp_mima3 = ”

while True:

if uart2.any():

user_id = ”

password = ”

rx2 = []

rx_num = 0

#                                              data_end = 0

bin_data = uart2.read(40)

uart2.sendbreak()

rx1 = list(bin_data)

for item in rx1:

rx2.append(chr(item))

rx_num += 1

#                                                              if (rx2[rx_num] == ‘T’) and (rx2[rx_num-1] == ‘E’) and (rx2[rx_num-2] == ‘>’):

#                                                                              break

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

data_name = rx2[7:data_name_len+7:1]

data_name2 = ”.join(data_name)

print(data_name2)

if data_name2 == ‘back2’:

return

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 = True

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)

print(data_id_st6)

#                                                              if personnel_ps.get(temp_id) == data_id_st6:

password_flag = True

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) and (password_flag == True) and (user_id_flag == True):

admin = True

personnel_ps[temp_id3] = temp_mima3

password_flag = False

user_id_flag = False

uart_write4(‘Verification passed!’,’login was successful!’)

def password_loin():

temp_id2 = ”

temp_mima = ”

while True:

if uart2.any():

user_id = ”

password = ”

rx2 = []

rx_num = 0

#                                              data_end = 0

bin_data = uart2.read(40)

uart2.sendbreak()

rx1 = list(bin_data)

for item in rx1:

rx2.append(chr(item))

rx_num += 1

#                                                              if (rx2[rx_num] == ‘T’) and (rx2[rx_num-1] == ‘E’) and (rx2[rx_num-2] == ‘>’):

#                                                                              break

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

data_name = rx2[7:data_name_len+7:1]

data_name2 = ”.join(data_name)

print(data_name2)

if data_name2 == ‘back4’:

return

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 personnel_ps:

user_id_flag = True

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(personnel_ps)

if personnel_ps.get(temp_id2) == data_id_st6:

password_flag = True

#                                              print(rx2,user_id_flag,password_flag)

print(user_id_flag,password_flag)

if (password_flag == True) and (user_id_flag == True):

uart_write(temp_id2,temp_id2)

password_flag = False

user_id_flag = False

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(‘student’,”)

suos.value(0)

uart2.write(‘ST<{“cmd_code”:”set_visible”,”type”:”widget”,”widget”:”lock2″,”visible”:false}>ET’)

uart2.sendbreak()

while True:

if uart2.any()>1:

rx2 = []

data_name2 = ”

bin_data = uart2.read(40)

#                              time.sleep(1)

uart2.sendbreak()

#                              time.sleep(1)

rx1 = list(bin_data)

for item in rx1:

rx2.append(chr(item))

print(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)

print(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

from machine import Pin, SPI

from os import uname

class 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.rst.value(0)

self.cs.value(1)

board = 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’:

self.spi = SPI(baudrate=100000, polarity=0, phase=0, sck=self.sck, mosi=self.mosi, miso=self.miso)

self.spi.init()

else:

raise RuntimeError(“Unsupported platform”)

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) | mask)

def _cflags(self, reg, mask):

self._wreg(reg, self._rreg(reg) & (~mask))

def _tocard(self, cmd, send):

recv = []

bits = irq_en = wait_irq = n = 0

stat = self.ERR

if cmd == 0x0E:

irq_en = 0x12

wait_irq = 0x10

elif cmd == 0x0C:

irq_en = 0x77

wait_irq = 0x30

self._wreg(0x02, irq_en | 0x80)

self._cflags(0x04, 0x80)

self._sflags(0x0A, 0x80)

self._wreg(0x01, 0x00)

for c in send:

self._wreg(0x09, c)

self._wreg(0x01, cmd)

if cmd == 0x0C:

self._sflags(0x0D, 0x80)

i = 2000

while True:

n = self._rreg(0x04)

i -= 1

if ~((i != 0) and ~(n & 0x01) and ~(n & wait_irq)):

break

self._cflags(0x0D, 0x80)

if i:

if (self._rreg(0x06) & 0x1B) == 0x00:

stat = self.OK

if n & irq_en & 0x01:

stat = self.NOTAGERR

elif cmd == 0x0C:

n = self._rreg(0x0A)

lbits = self._rreg(0x0C) & 0x07

if lbits != 0:

bits = (n – 1) * 8 + lbits

else:

bits = n * 8

if n == 0:

n = 1

elif n > 16:

n = 16

for _ in range(n):

recv.append(self._rreg(0x09))

else:

stat = self.ERR

return stat, recv, bits

def _crc(self, data):

self._cflags(0x05, 0x04)

self._sflags(0x0A, 0x80)

for c in data:

self._wreg(0x09, c)

self._wreg(0x01, 0x03)

i = 0xFF

while True:

n = self._rreg(0x05)

i -= 1

if not ((i != 0) and not (n & 0x04)):

break

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(self):

self._wreg(0x01, 0x0F)

def antenna_on(self, on=True):

if on and ~(self._rreg(0x14) & 0x03):

self._sflags(0x14, 0x03)

else:

self._cflags(0x14, 0x03)

def request(self, mode):

self._wreg(0x0D, 0x07)

(stat, recv, bits) = self._tocard(0x0C, [mode])

if (stat != self.OK) | (bits != 0x10):

stat = self.ERR

return stat, bits

def anticoll(self):

ser_chk = 0

ser = [0x93, 0x20]

self._wreg(0x0D, 0x00)

(stat, recv, bits) = self._tocard(0x0C, ser)

if stat == self.OK:

if len(recv) == 5:

for i in range(4):

ser_chk = ser_chk ^ recv[i]

if ser_chk != recv[4]:

stat = self.ERR

else:

stat = self.ERR

return stat, recv

def select_tag(self, ser):

buf = [0x93, 0x70] + ser[:5]

buf += self._crc(buf)

(stat, recv, bits) = self._tocard(0x0C, buf)

return self.OK if (stat == self.OK) and (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(self):

self._cflags(0x08, 0x08)

def read(self, addr):

data = [0x30, addr]

data += self._crc(data)

(stat, recv, _) = self._tocard(0x0C, data)

return recv if stat == self.OK else None

def write(self, addr, data):

buf = [0xA0, addr]

buf += self._crc(buf)

(stat, recv, bits) = self._tocard(0x0C, buf)

if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A):

stat = self.ERR

else:

buf = []

for i in range(16):

buf.append(data[i])

buf += self._crc(buf)

(stat, recv, bits) = self._tocard(0x0C, buf)

if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A):

stat = self.ERR

return stat

Source: Plato Data Intelligence