संक्षिप्त परिचय
प्रौद्योगिकी के विकास के साथ स्मार्ट होम अधिक से अधिक आम होता जा रहा है, यह लेख बुद्धिमान अभिगम नियंत्रण परियोजना के सुरक्षा पहलुओं पर ध्यान केंद्रित करेगा।
यह लेख उपयोग करता है स्टोन की टच स्क्रीन रिले और MFRC522 मॉड्यूल को नियंत्रित करने के लिए MCU को कमांड भेजने के लिए।
कार्ड पढ़ने का सिद्धांत: RFID-RC522 मॉड्यूल को चलाकर, आईडी कार्ड आईडी को आईडी कार्ड के करीब पहचानें, और फिर निर्धारित करें कि क्या आईडी विशिष्ट शब्द के डेटाबेस में मौजूद है, आईडी शब्द का विशिष्ट मूल्य है, यदि सत्यापन के माध्यम से अस्तित्व में है , और फिर संबंधित नाम का प्रिंट आउट लें, और फिर उसी तरह विद्युत चुम्बकीय लॉक को चलाएं।
आवश्यक सामग्री
- ESP32
- KOB इलेक्ट्रॉनिक लॉक
- रिले
- स्टोन STWI070WT-01 टच पैनल डिस्प्ले
- MFRC522 मॉड्यूल
एहसास समारोह
- कार्ड पंजीकरण।
- उपयोगकर्ता नाम और पासवर्ड पंजीकरण।
- इलेक्ट्रॉनिक लॉक अनलॉक करने के लिए कार्ड स्वाइप करें।
- इलेक्ट्रॉनिक लॉक को अनलॉक करने के लिए यूजर नेम और पासवर्ड।
मुख्य हार्डवेयर विवरण
आरएफआईडी मॉड्यूल
इस मॉड्यूल को सीधे विभिन्न रीडर मॉड्यूल में लोड किया जा सकता है। यह केवल कुछ तारों के साथ SPI इंटरफ़ेस के माध्यम से 3.3V के वोल्टेज का उपयोग करता है। सीपीयू मदरबोर्ड के साथ सीधे जुड़ा, मॉड्यूल एक स्थिर और विश्वसनीय तरीके से एक दूरस्थ कार्ड रीडर के रूप में काम कर सकता है।
STWI070WT-01 की कल्पना TFT मॉनिटर और टच कंट्रोलर के रूप में की गई है। इसमें प्रोसेसर, कंट्रोल प्रोग्राम, ड्राइवर, फ्लैश मेमोरी, RS232/RS422/RS485/TTL/LAN पोर्ट, वाई-फाई/ब्लूटूथ, टच स्क्रीन, बिजली की आपूर्ति आदि शामिल हैं, इसलिए यह शक्तिशाली और आसान पर आधारित एक संपूर्ण डिस्प्ले सिस्टम है। ऑपरेटिंग सिस्टम, जिसे किसी भी एमसीयू द्वारा नियंत्रित किया जा सकता है।
जीयूआई डिजाइन
गुप्त भाषा बांटना
आयात एमएफआरसी522
आयात समय
आयात _धागा
ओएस आयात uname . से
मशीन आयात पिन से, UART
#pyb आयात UART . से
#आयात मशीन
सुओस = पिन (32, पिन.आउट)
uart2 = UART(2, बॉड्रेट=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
आरएक्स3 = []
आरएक्स_नाम = []
user_id_flag = गलत
पासवर्ड_फ्लैग = झूठा
temp_id = "
अस्थायी_मिमा = "
कर्मियों_आईडी = {'zbw': [236,230,169,47], 'एलबीडब्ल्यू': [19,165,93,4]}
कार्मिक_पीएस = {'zbw':'zbw3366′,'lbw':'lbwnb'}
admin_password = ('yyds')
बटन_सीएमडी = [16,1]
संपादित करें1_cmd = [16,112]
संपादित करें2_cmd = [16,113]
संपादित करें3_cmd = [16,114]
अगर uname () [0] == 'esp32':
rdr = mfrc522.MFRC522 (ESP32_HSPI_CLOCK, ESP32_HSPI_MOSI, ESP32_HSPI_MISO, ESP32_MFRC522_RST, ESP32_HSPI_SLAVE_SELECT)
डीईएफ़ do_write ():
प्रयास करें:
(स्टेट, टैग_टाइप) = rdr.request(rdr.REQIDL)
अगर स्टेट == rdr.OK:
(स्टेट, रॉ_यूआईडी) = rdr.anticoll ()
अगर स्टेट == rdr.OK:
प्रिंट ("नए कार्ड का पता चला")
प्रिंट ("- टैग प्रकार: 0x% 02x"% tag_type)
प्रिंट ("- यूआईडी: 0x%02x%02x%02x%02x"% (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
प्रिंट ("")
अगर rdr.select_tag(raw_uid) == rdr.OK:
कुंजी = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
अगर 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”)
आरडीआर.stop_crypto1()
अगर स्टेट == rdr.OK:
प्रिंट ("कार्ड पर लिखा गया डेटा")
अन्य:
प्रिंट ("कार्ड में डेटा लिखने में विफल")
अन्य:
प्रिंट ("प्रमाणीकरण त्रुटि")
अन्य:
प्रिंट ("टैग का चयन करने में विफल")
KeyboardInterrupt को छोड़कर:
प्रिंट ("त्रुटि लिखें")
डीईएफ़ do_read ():
जबकि सच:
प्रयास करें:
(स्टेट, टैग_टाइप) = rdr.request(rdr.REQIDL)
अगर स्टेट == rdr.OK:
(स्टेट, रॉ_यूआईडी) = rdr.anticoll ()
अगर स्टेट == rdr.OK:
प्रिंट ("नए कार्ड का पता चला")
प्रिंट ("- टैग प्रकार: 0x% 02x"% tag_type)
प्रिंट ("- यूआईडी: 0x%02x%02x%02x%02x"% (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
प्रिंट (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3])
प्रिंट ("")
अगर rdr.select_tag(raw_uid) == rdr.OK:
कुंजी = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
अगर rdr.auth(rdr.AUTHENT1A, 8, key, raw_uid) == rdr.OK:
प्रिंट ("पता 8 डेटा:% s"% rdr.read (8))
कार्मिक_आईडी में पीएस के लिए:
अगर कच्चा_यूआईडी [0: 4: 1] == कार्मिक_आईडी। प्राप्त करें (पीएस):
स्वत: मूल्य(1)
प्रिंट (पीएस)
uart_write(ps, *raw_uid[0:4:1])
time.sleep (3)
uart2.sendbreak ()
तोड़ना
आरडीआर.stop_crypto1()
time.sleep (3)
स्वत: मूल्य(0)
अन्य:
प्रिंट ("प्रमाणीकरण त्रुटि")
अन्य:
प्रिंट ("टैग का चयन करने में विफल")
अगर uart2.any()>1:
आरएक्स2 = []
डेटा_नाम 2 = ”
बिन_डेटा = uart2.read (40)
uart2.sendbreak ()
rx1 = सूची (bin_data)
rx1 में आइटम के लिए:
rx2.append (chr (आइटम))
प्रिंट (आरएक्स 2)
अगर rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] - 1
डेटा_नाम = rx2[7:डेटा_नाम_लेन+7:1]
data_name2 = ".शामिल हों (data_name)
प्रिंट (डेटा_नाम 2)
अगर data_name2 == 'बैक3':
वापसी
KeyboardInterrupt को छोड़कर:
प्रिंट ("त्रुटि पढ़ें")
डीईएफ़ do_read2 (आईडीडी):
प्रिंट (आईडीडी)
जबकि सच:
प्रयास करें:
(स्टेट, टैग_टाइप) = rdr.request(rdr.REQIDL)
अगर स्टेट == rdr.OK:
(स्टेट, रॉ_यूआईडी) = rdr.anticoll ()
अगर स्टेट == rdr.OK:
प्रिंट ("नए कार्ड का पता चला")
प्रिंट ("- टैग प्रकार: 0x% 02x"% tag_type)
प्रिंट ("- यूआईडी: 0x%02x%02x%02x%02x"% (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
प्रिंट (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3])
प्रिंट ("")
अगर rdr.select_tag(raw_uid) == rdr.OK:
कुंजी = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
अगर rdr.auth(rdr.AUTHENT1A, 8, key, raw_uid) == rdr.OK:
प्रिंट ("पता 8 डेटा:% s"% rdr.read (8))
कार्मिक_आईडी [आईडीडी] = रॉ_यूआईडी [0:4:1]
uart_write3(*raw_uid[0:4:1])
आरडीआर.stop_crypto1()
अन्य:
प्रिंट ("प्रमाणीकरण त्रुटि")
अन्य:
प्रिंट ("टैग का चयन करने में विफल")
अगर uart2.any()>1:
आरएक्स2 = []
डेटा_नाम 2 = ”
बिन_डेटा = uart2.read (40)
uart2.sendbreak ()
rx1 = सूची (bin_data)
rx1 में आइटम के लिए:
rx2.append (chr (आइटम))
अगर rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] - 1
डेटा_नाम = rx2[7:डेटा_नाम_लेन+7:1]
data_name2 = ".शामिल हों (data_name)
प्रिंट (डेटा_नाम 2)
अगर data_name2 == 'बैक1':
वापसी
KeyboardInterrupt को छोड़कर:
प्रिंट ("त्रुटि पढ़ें")
def uart_write (पाठ, * आईडी):
# प्रिंट (पाठ, * आईडी)
uart2.write('ST<{"cmd_code":"set_text",,"type":"लेबल",,"विजेट":"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 (पाठ, पाठ 2):
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')
डीईएफ़ 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 (पाठ, पाठ 2):
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')
डीईएफ़ 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 ():
जबकि सच:
अगर uart2.any ():
user_id = "
पासवर्ड = "
आरएक्स2 = []
आरएक्स_संख्या = 0
बिन_डेटा = uart2.read (40)
uart2.sendbreak ()
rx1 = सूची (bin_data)
rx1 में आइटम के लिए:
rx2.append (chr (आइटम))
आरएक्स_संख्या + = 1
डेटा_एंड = rx_num-5
data_id_st = rx2 [8:13:1]
data_id_st2 = ”। शामिल हों (data_id_st)
प्रिंट (data_id_st2)
अगर data_id_st2 == 'edit1':
data_id_st3 = rx2 [15:data_end:1]
data_id_st4 = ”। शामिल हों (data_id_st3)
प्रिंट (data_id_st4)
अगर data_id_st4 != ”:
नाम = सत्य
elif data_id_st2 == 'edit2':
data_id_st5 = rx2 [15:data_end:1]
data_id_st6 = ”। शामिल हों (data_id_st5)
अगर data_id_st6 == admin_password:
व्यवस्थापक = सच
uart_write2('सत्यापन पास हो गया!', 'कृपया कार्ड डालें!')
do_read2(data_id_st4)
वापसी
def mima_zuce ():
temp_id3 = "
temp_mima3 = "
जबकि सच:
अगर uart2.any ():
user_id = "
पासवर्ड = "
आरएक्स2 = []
आरएक्स_संख्या = 0
# डेटा_एंड = 0
बिन_डेटा = uart2.read (40)
uart2.sendbreak ()
rx1 = सूची (bin_data)
rx1 में आइटम के लिए:
rx2.append (chr (आइटम))
आरएक्स_संख्या + = 1
# अगर (rx2[rx_num] == 'T') और (rx2[rx_num-1] == 'E') और (rx2[rx_num-2] == '>'):
# टूटना
डेटा_एंड = rx_num-5
data_id_st = rx2 [8:13:1]
data_id_st2 = ”। शामिल हों (data_id_st)
प्रिंट (data_id_st2)
अगर rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] - 1
डेटा_नाम = rx2[7:डेटा_नाम_लेन+7:1]
data_name2 = ".शामिल हों (data_name)
प्रिंट (डेटा_नाम 2)
अगर data_name2 == 'बैक2':
वापसी
अगर data_id_st2 == 'edit3':
data_id_st3 = rx2 [15:data_end:1]
data_id_st4 = ”। शामिल हों (data_id_st3)
प्रिंट (data_id_st4)
user_id_flag = सही
temp_id3 = data_id_st4
# कार्मिक_पीएस[temp_id] = रॉ_यूआईडी[0:4:1]
elif data_id_st2 == 'edit4':
data_id_st5 = rx2 [15:data_end:1]
data_id_st6 = ”। शामिल हों (data_id_st5)
प्रिंट (data_id_st6)
# अगर कर्मियों_ps.get(temp_id) == data_id_st6:
पासवर्ड_फ्लैग = सत्य
temp_mima3 = data_id_st6
# कार्मिक_ps[temp_id] = पासवर्ड_ध्वज
# प्रिंट (rx2,user_id_flag,password_flag)
elif data_id_st2 == 'edit7':
data_id_st5 = rx2 [15:data_end:1]
data_id_st6 = ”। शामिल हों (data_id_st5)
अगर (data_id_st6 == admin_password) और (password_flag == True) और (user_id_flag == True):
व्यवस्थापक = सच
कार्मिक_पीएस [temp_id3] = temp_mima3
पासवर्ड_फ्लैग = झूठा
user_id_flag = गलत
uart_write4 ('सत्यापन पास हो गया!', 'लॉगिन सफल रहा!')
डीईएफ़ पासवर्ड_लॉइन ():
temp_id2 = "
अस्थायी_मिमा = "
जबकि सच:
अगर uart2.any ():
user_id = "
पासवर्ड = "
आरएक्स2 = []
आरएक्स_संख्या = 0
# डेटा_एंड = 0
बिन_डेटा = uart2.read (40)
uart2.sendbreak ()
rx1 = सूची (bin_data)
rx1 में आइटम के लिए:
rx2.append (chr (आइटम))
आरएक्स_संख्या + = 1
# अगर (rx2[rx_num] == 'T') और (rx2[rx_num-1] == 'E') और (rx2[rx_num-2] == '>'):
# टूटना
डेटा_एंड = rx_num-5
data_id_st = rx2 [8:13:1]
data_id_st2 = ”। शामिल हों (data_id_st)
प्रिंट (data_id_st2)
अगर rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] - 1
डेटा_नाम = rx2[7:डेटा_नाम_लेन+7:1]
data_name2 = ".शामिल हों (data_name)
प्रिंट (डेटा_नाम 2)
अगर data_name2 == 'बैक4':
वापसी
अगर data_id_st2 == 'edit5':
data_id_st3 = rx2 [15:data_end:1]
data_id_st4 = ”। शामिल हों (data_id_st3)
प्रिंट (data_id_st4)
अगर कर्मियों_पीएस में data_id_st4:
user_id_flag = सही
temp_id2 = data_id_st4
elif data_id_st2 == 'edit6':
data_id_st5 = rx2 [15:data_end:1]
data_id_st6 = ”। शामिल हों (data_id_st5)
प्रिंट (data_id_st6)
प्रिंट (temp_id2)
प्रिंट (कार्मिक_पीएस)
अगर कर्मियों_ps.get(temp_id2) == data_id_st6:
पासवर्ड_फ्लैग = सत्य
# प्रिंट (rx2,user_id_flag,password_flag)
प्रिंट (user_id_flag, password_flag)
अगर (password_flag == True) और (user_id_flag == True):
uart_write (temp_id2, temp_id2)
पासवर्ड_फ्लैग = झूठा
user_id_flag = गलत
स्वत: मूल्य(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 ('छात्र',")
स्वत: मूल्य(0)
uart2.write('ST<{"cmd_code":"set_visible",,"type":"widget",,"widget":"lock2″,"visible":false}>ET')
uart2.sendbreak ()
जबकि सच:
अगर uart2.any()>1:
आरएक्स2 = []
डेटा_नाम 2 = ”
बिन_डेटा = uart2.read (40)
# समय सो जाओ(1)
uart2.sendbreak ()
# समय सो जाओ(1)
rx1 = सूची (bin_data)
rx1 में आइटम के लिए:
rx2.append (chr (आइटम))
प्रिंट (आरएक्स 2)
अगर rx1[3:5:1] == button_cmd:
data_name_len = rx1[6] - 1
डेटा_नाम = rx2[7:डेटा_नाम_लेन+7:1]
data_name2 = ".शामिल हों (data_name)
प्रिंट (डेटा_नाम 2)
अगर data_name2 == 'card1':
card_zhuce ()
elif data_name2 == 'पासवर्ड1':
मीमा_ज़ुस ()
elif data_name2 == 'card2':
do_read ()
elif data_name2 == 'पासवर्ड2':
पासवर्ड_लॉइन ()
एमएफआरसी522.py
मशीन से आयात पिन, एसपीआई
ओएस आयात uname . से
कक्षा एमएफआरसी522:
ठीक = 0
नोटगेर = 1
ईआरआर = 2
आरईक्यूआईडीएल = 0x26
रिकॉल = 0x52
AUTHENT1A = 0x60
AUTHENT1B = 0x61
def __init__(स्वयं, sck, mosi, miso, rst, cs):
self.sck = पिन (sck, Pin.OUT)
स्व.मोसी = पिन (मोसी, पिन.आउट)
स्व.मिसो = पिन (मिसो)
self.rst = पिन (पहली, पिन.आउट)
self.cs = पिन (cs, Pin.OUT)
स्व.पहला मूल्य(0)
स्वयं.सीएस.मूल्य(1)
बोर्ड = अनाम () [0]
अगर बोर्ड == 'वाईपीई' या बोर्ड == 'लोपी' या बोर्ड == 'फाईपी':
स्वयं.स्पी = एसपीआई(0)
self.spi.init(SPI.Master, baudrate=1000000, pins=(self.sck, self.mosi, self.miso))
एलिफ बोर्ड == 'esp32':
Self.spi = SPI (बॉड्रेट = 100000, ध्रुवता = 0, चरण = 0, sck = self.sck, mosi = self.mosi, miso = self.miso)
स्वयं.spi.init ()
अन्य:
RuntimeError बढ़ाएँ ("असमर्थित प्लेटफ़ॉर्म")
स्व.पहला मूल्य(1)
स्वयं.इनिट ()
def _wreg (स्वयं, reg, वैल):
स्वयं.सीएस.मूल्य(0)
self.spi.write(b'%c'% int(0xff & ((reg << 1) & 0x7e)))
self.spi.write(b'%c'% int(0xff & val))
स्वयं.सीएस.मूल्य(1)
def _rreg (स्वयं, reg):
स्वयं.सीएस.मूल्य(0)
self.spi.write(b'%c'% int(0xff & (((reg << 1) और 0x7e) | 0x80)))
वैल = सेल्फ.स्पि.रीड(1)
स्वयं.सीएस.मूल्य(1)
वापसी वैल [0]
def _sflags (स्वयं, reg, मुखौटा):
self._wreg(reg, self._rreg(reg) | मास्क)
def _cflags (स्वयं, reg, मुखौटा):
self._wreg(reg, self._rreg(reg) और (~mask))
def _tocard (स्वयं, cmd, भेजें):
आरईवी = []
बिट्स = irq_en = wait_irq = n = 0
स्टेट = स्व.ERR
अगर cmd == 0x0E:
irq_en = 0x12
प्रतीक्षा_आईआरक्यू = 0x10
एलिफ सीएमडी == 0x0C:
irq_en = 0x77
प्रतीक्षा_आईआरक्यू = 0x30
self._wreg(0x02, irq_en | 0x80)
स्वयं._cflags(0x04, 0x80)
स्व._sflags(0x0A, 0x80)
स्व._wreg(0x01, 0x00)
सी में भेजने के लिए:
स्वयं._wreg(0x09, ग)
स्वयं._wreg (0x01, cmd)
अगर cmd == 0x0C:
स्व._sflags (0x0D, 0x80)
मैं = 2000
जबकि सच:
n = स्व._rreg(0x04)
मैं - = 1
अगर ~((i!= 0) और ~(n & 0x01) और ~(n & Wait_irq)):
तोड़ना
स्वयं._cflags(0x0D, 0x80)
अगर मुझे:
अगर (self._rreg (0x06) और 0x1B) == 0x00:
स्टेट = स्वयं। ठीक है
अगर एन और irq_en और 0x01:
स्टेट = स्व.NOTAGERR
एलिफ सीएमडी == 0x0C:
n = स्व._rreg(0x0A)
एलबिट्स = स्व._रेग (0x0C) और 0x07
अगर एलबिट्स!= 0:
बिट्स = (एन -1) * 8 + एलबीआईटी
अन्य:
बिट्स = एन * 8
अगर एन == 0:
एन = 1
एलिफ एन> 16:
एन = 16
सीमा में _ के लिए (एन):
recv.append (self._rreg (0x09))
अन्य:
स्टेट = स्व.ERR
रिटर्न स्टेट, आरईवी, बिट्स
def _crc (स्वयं, डेटा):
स्वयं._cflags(0x05, 0x04)
स्व._sflags(0x0A, 0x80)
डेटा में सी के लिए:
स्वयं._wreg(0x09, ग)
स्व._wreg(0x01, 0x03)
मैं = 0xFF
जबकि सच:
n = स्व._rreg(0x05)
मैं - = 1
यदि नहीं ((i!= 0) और नहीं (n & 0x04)):
तोड़ना
वापसी [self._rreg(0x22), self._rreg(0x21)]
डीईएफ़ इनिट (स्वयं):
स्वयं रीसेट ()
स्वयं._wreg(0x2A, 0x8D)
स्वयं._wreg(0x2B, 0x3E)
स्वयं._wreg(0x2D, 30)
स्व._wreg(0x2C, 0)
स्व._wreg(0x15, 0x40)
स्वयं._wreg(0x11, 0x3D)
स्व.एंटेना_ऑन ()
डीईएफ़ रीसेट (स्वयं):
स्व._wreg(0x01, 0x0F)
def एंटीना_ऑन (स्वयं, चालू = सत्य):
अगर चालू है और ~(self._rreg(0x14) और 0x03):
स्व._sflags(0x14, 0x03)
अन्य:
स्वयं._cflags(0x14, 0x03)
डीईएफ़ अनुरोध (स्वयं, मोड):
स्व._wreg(0x0D, 0x07)
(स्टेट, आरईवी, बिट्स) = self._tocard(0x0C, [मोड])
अगर (स्टेट! = स्वयं। ठीक है) | (बिट्स! = 0x10):
स्टेट = स्व.ERR
रिटर्न स्टेट, बिट्स
डीईएफ़ एंटीकॉल (स्व):
सेर_चक = 0
सेर = [0x93, 0x20]
स्व._wreg(0x0D, 0x00)
(स्टेट, आरईवी, बिट्स) = self._tocard(0x0C, ser)
अगर स्टेट == स्वयं। ठीक है:
अगर लेन (आरईवी) == 5:
मैं सीमा में (4):
Ser_chk = ser_chk ^ recv [i]
अगर ser_chk!= recv[4]:
स्टेट = स्व.ERR
अन्य:
स्टेट = स्व.ERR
रिटर्न स्टेट, आरईवी
def select_tag (स्वयं, सेवा):
बफ = [0x93, 0x70] + सेर [:5]
बफ + = स्व._crc(buf)
(स्टेट, आरईवी, बिट्स) = self._tocard(0x0C, buf)
स्वयं लौटाएं। ठीक है अगर (स्टेट == स्वयं। ठीक है) और (बिट्स == 0x18) अन्य स्वयं। ईआरआर
डीईएफ़ ऑथ (स्व, मोड, एडीआर, संप्रदाय, सेर):
वापसी self._tocard(0x0E, [मोड, एडीआर] + संप्रदाय + सेर [: 4]) [0]
def stop_crypto1 (स्वयं):
स्वयं._cflags(0x08, 0x08)
डीईएफ़ पढ़ें (स्वयं, एडीआर):
डेटा = [0x30, अतिरिक्त]
डेटा + = स्वयं._crc (डेटा)
(स्टेट, आरईवी, _) = self._tocard(0x0C, डेटा)
वापसी आरईवी अगर स्टेट == स्वयं। ठीक है और कोई नहीं
डीईएफ़ लिखना (स्वयं, एडीआर, डेटा):
बफ = [0xA0, अतिरिक्त]
बफ + = स्व._crc(buf)
(स्टेट, आरईवी, बिट्स) = self._tocard(0x0C, buf)
यदि नहीं (stat == self.OK) या नहीं (बिट्स == 4) या नहीं ((recv [0] और 0x0F) == 0x0A):
स्टेट = स्व.ERR
अन्य:
बफ = []
मैं सीमा में (16):
buf.append (डेटा [i])
बफ + = स्व._crc(buf)
(स्टेट, आरईवी, बिट्स) = self._tocard(0x0C, buf)
यदि नहीं (stat == self.OK) या नहीं (बिट्स == 4) या नहीं ((recv [0] और 0x0F) == 0x0A):
स्टेट = स्व.ERR
वापसी की स्थिति
स्रोत: प्लेटो डेटा इंटेलिजेंस