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.

STONE STWI070WT-01 display

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.

Connection diagram

GUI design

Code sharing

Main.py

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

Leave a Comment

Your email address will not be published.

This site uses Akismet to reduce spam. Learn how your comment data is processed.