使用到的模块，pyserial pyqt5 pymysql
（我先是实现在命令行下通过串口进行对板子硬件的控制，比如Led ，beep等，在实现检测卡（是否选卡成功），连接卡（验证哪一个扇区），读卡，写卡）（对于m1卡的读写地址，在连接卡时就指定了，在没有halt操作或移开卡的操作之前，是没法更改扇区的)
后续慢慢加。。
先传几张，调试好的图（第三张图的 读区 显示少了一个s是因为在写的时候只写16个字符（不满16我直接填0了）
（所有于卡有关的操作都是通过硬件实现，程序只是实现串口交互和命令定义而已
界面的使用过程：1.先是（不必须）点击Check按钮，在INFO TIPS富文本区会显示当前选卡与否，选卡成功则显示 MIF card is ok(选卡是通过硬件操作的）
2.必须连接（Connect)成功才能读写操作,先输入扇区号，我这里是1号扇区，然后点Connect botton 如果验证成功 返回 验证成功
3.读操作和写操作必须先输入地址或数据，然后在点击Botton
贴上相关代码，仅供参考（注释没怎么搞，代码有过修改，所有有的地方注释还是错的，请不要介意）
需要注意的是，对于界面交互的程序而言，需要做到，界面文件和业务逻辑文件分开，比如界面文件demo.py（一般由demo.ui转过来），业务逻辑文件：calldemo.py
当然这下面的代码，缺少一个serconfig的文件（这个就因人而异了）还有我只给出C代码的命令处理的程序，只提供一个思路而已
还有一个扩展的功能，我没做，就是MIF_HALT这个功能，可以实现，不用移卡就切换扇区（当然这个命令是暂停卡的功能）
主界面的代码
1 import pyserial
2 import serconfig
3 import sys
4 from PyQt5.QtWidgets import QApplication,QMainWindow
5 #from PyQt5 import QtCore
6 #from test import *
7 from serguyui import *
8 from serconfig import command_win_code as commands #0:read 1:write 2:check 3:found
9
10 class MainWindow(QMainWindow,Ui_MainWindow):
11 def __init__(self,serguy,parent=None):
12 super(MainWindow,self).__init__(parent)
13 self.serguy=serguy
14 self.setupUi(self)
15 self.lineEdit.setPlaceholderText("enter section")
16 self.lineEdit_2.setPlaceholderText("enter read address")
17 self.lineEdit_3.setPlaceholderText("enter write address")
18 self.lineEdit_4.setPlaceholderText("enter data")
19 self.pushButton_3.clicked.connect(self.Connect_Btn_Handler)
20 self.pushButton.clicked.connect(self.Read_Btn_Handler)
21 self.pushButton_2.clicked.connect(self.Write_Btn_Handler)
22 self.pushButton_4.clicked.connect(self.Check_Btn_Handler)
23 self.pushButton_5.clicked.connect(self.Close_Btn_Handler)
24 self.read_mode="str"
25 self.radioButton.setChecked(True)
26 self.radioButton.toggled.connect(lambda :self.Read_Mode_Set(self.radioButton))
27 self.radioButton_2.toggled.connect(lambda :self.Read_Mode_Set(self.radioButton_2))
28
29 def Read_Mode_Set(self,btn):
30 if (btn.text() == "str"):
31 if btn.isChecked() == True:
32 self.read_mode="str"
33 if (btn.text() == "hex"):
34 if btn.isChecked() == True:
35 self.read_mode="hex"
36 def Connect_Btn_Handler(self):
37 Section = self.lineEdit.text()
38 feedback=self.serguy.MIF_Connect_Handler(commands.get("found"),Section)
39 self.textBrowser.setPlainText(feedback)
40
41 def Read_Btn_Handler(self):
42 block_addr=int(self.lineEdit_2.text())
43 mode = self.read_mode
44 feedback=self.serguy.MIF_Read_Handler(commands.get("read"),mode,block_addr)
45 self.textBrowser_2.setPlainText(feedback)
46
47 def Write_Btn_Handler(self):
48 block_addr=int(self.lineEdit_3.text())
49 block_data=self.lineEdit_4.text()
50 feedbake=self.serguy.MIF_Write_Handler(commands.get("write"),block_addr,block_data)
51 self.textBrowser.setPlainText(feedbake)
52
53 def Check_Btn_Handler(self):
54 feedback=self.serguy.MIF_Check_Handler(commands.get("check")) #attent the length of tuple
55 self.textBrowser.setPlainText(feedback) #feedback expect str type
56
57 def Close_Btn_Handler(self):
58 self.serguy.Close_serial()
59 self.close()
60 def Halt_Btn_Handler(self):
61 self.serguy.MIF_Halt_Handler(commands.get("halt"))
62
63
64 class CommandHandler(pyserial.Serial_Handler):
65 def __init__(self,port,baud,timeout):
66 super(CommandHandler, self).__init__(port, baud, timeout)
67 #the function of the communication with mifate card following:
68 def LedHandler(self, command_formal):
69 if (commands.get(command_formal[0], False)):
70 ctlobj = commands.get(command_formal[0])
71 # print(ctlobj,type(ctlobj))
72 if (ctlobj.get(command_formal[1], False)):
73 actflag = ctlobj[command_formal[1]]
74 self.Write_To_Serial(actflag[0].encode("utf-8"))
75 self.Write_To_Serial(actflag[1].encode("utf-8"))
76 self.Write_To_Serial(actflag[2].encode("utf-8"))
77 self.Write_To_Serial('\n'.encode("utf-8"))
78 else:
79 print("action singal is wrong")
80 else:
81 print("command singal is wrong")
82
83 # 0:read 1:write 2:check 3:found
84 def MIF_Read_Handler(self, command_formal,mode,block_addr):
85 self.Write_To_Serial(command_formal[0].encode("utf-8")) # send the 'M' flag
86 self.Write_To_Serial(command_formal[1].encode("utf-8")) # send the read/write flag
87 self.Write_To_Serial(chr(command_formal[2]).encode("utf-8")) # send the datalen
88 self.Write_To_Serial(chr(block_addr).encode("utf-8")) # send the block addr
89 self.Write_To_Serial('\n'.encode("utf-8")) # send the end of flag
90 data=self.Win_Read_From_Serial(mode)
91 return data
92
93 def MIF_Write_Handler(self, command_formal,block_addr,block_data):
94 if (len(block_data) < 16):
95 for i in range(len(block_data), 16):
96 block_data += "0" # write 0 when the length of data less then 16
97 self.Write_To_Serial(command_formal[0].encode("utf-8")) # send the 'M' flag
98 self.Write_To_Serial(command_formal[1].encode("utf-8")) # send the read/write flag
99 self.Write_To_Serial(chr(command_formal[2]).encode("utf-8")) # send the datalen
100 self.Write_To_Serial(chr(block_addr).encode("utf-8")) # send the block addr
101 self.Write_To_Serial(block_data.encode("utf-8")) # send the block addr
102 self.Write_To_Serial('\n'.encode("utf-8")) # send the end of flag
103 data=self.Win_Read_From_Serial("str")
104 return data
105
106 def MIF_Check_Handler(self, command_formal):
107 self.Write_To_Serial(command_formal[0].encode("utf-8")) # send the 'M' flag
108 self.Write_To_Serial(command_formal[1].encode("utf-8")) # send the read/write flag
109 self.Write_To_Serial('\n'.encode("utf-8")) # send the end of flag
110 info=self.Win_Read_From_Serial("str")
111 return info
112
113 def MIF_Connect_Handler(self, command_formal,section):
114 self.Write_To_Serial(command_formal[0].encode("utf-8")) # send the 'C' flag
115 self.Write_To_Serial(command_formal[1].encode("utf-8")) # send the check obj
116 self.Write_To_Serial(chr(int(section)).encode("utf-8")) # send the block addr
117 self.Write_To_Serial('\n'.encode("utf-8")) # send the end of flag
118 data=self.Win_Read_From_Serial("str")
119 return data
120
121
122 def MIF_Halt_Handler(self,command_formal):
123 pass
124
125
126 if __name__ == "__main__":
127 serguy= CommandHandler(serconfig.portx, serconfig.band, serconfig.timeout)
128 app = QApplication(sys.argv)
129 mywin = MainWindow(serguy)
130 mywin.show()
131 sys.exit(app.exec_())
1 '''
2 这是使用串口的类，
3 下面一部分代码是以前命令行用的
4 '''
5
6 import serial
7 from serconfig import color_mode as strcolor
8 #ser = serial.Serial(portx,bps,timeout=timeout)
9 class Serial_Handler(serial.Serial):
10 def __init__(self,port,baud,timeout):
11 self.portx=port
12 self.baud=baud
13 self.timeover=timeout
14 #Serial class will use the farther's class serialbase class initially
15 #and the serialbase have a arrtrubution of @port...that issue wiil be done immediately
16 #when the expression of "port=xxx" is happend,so here is only portx instead of port
17 super(Serial_Handler,self).__init__(self.portx,self.baud,timeout=self.timeover)
18 def Win_Read_From_Serial(self,mode):
19 data = super(Serial_Handler, self).readline()
20 if mode=="str":
21 return data.decode("utf-8")
22 elif mode =="hex":
23 return self.win_show_bytes_hex(data)
24
25 def Read_From_Serial(self,mode): #,block_addr,datalen
26 #data=super(Mifare_Interface,self).read(datalen)
27 data=super(Serial_Handler,self).readline()
28 if(mode=="hex"):
29 self.print_bytes_hex(data)#print(data) #the serial data is encode by gbk
30 elif(mode=="str"):
31 print(strcolor["blue"]%data)
32 def Write_To_Serial(self,data):
33 super(Serial_Handler,self).write(data)
34 def connect_to_Serial(self):
35 super(Serial_Handler,self).open()
36 def flush_buffer(self):
37 super(Serial_Handler,self).reset_input_buffer()
38 super(Serial_Handler,self).reset_output_buffer()
39 super(Serial_Handler,self).flush()
40 def print_bytes_hex(self,chardata):
41 hexdata=["%02X" % i for i in chardata]
42 print(" ".join([strcolor["light_green"]% i for i in hexdata]))
43 def win_show_bytes_hex(self,chardata):
44 hexdata = ["%02X" % i for i in chardata]
45 return (" ".join(hexdata))
46 def Close_serial(self):
47 super(Serial_Handler,self).close()
48
49
50 #print("serials: ",ser)
51 #print(ser.port)
52 #print(ser.baudrate)
53 def delay():
54 for i in range(10000):
55 for i in range(1000):
56 a=0
57 def SendCommand(ser):
58 while(1):
59 command=input("please entry the command:")
60 if(compareStr(command.split()[0],"led0")):
61 if(compareStr(command.split()[1],"on")):
62 #print("led0 on")
63 ser.Write_To_M1Block(chr(0x30).encode("utf-8"))
64 ser.Write_To_M1Block(chr(0x31).encode("utf-8"))
65 continue
66 elif(compareStr(command.split()[1],"off")):
67 #print("led0 off")
68 ser.Write_To_M1Block(chr(0x30).encode("utf-8"))
69 ser.Write_To_M1Block(chr(0x30).encode("utf-8"))
70 continue
71 else:
72 print("someting is wrong")
73 elif(compareStr(command.split()[0],"led1")):
74 if(compareStr(command.split()[1],"on")):
75 #print("led1 on")
76 ser.Write_To_M1Block(chr(0x31).encode("utf-8"))
77 ser.Write_To_M1Block(chr(0x31).encode("utf-8"))
78 continue
79 elif(compareStr(command.split()[1],"off")):
80 #print("led1 off")
81 ser.Write_To_M1Block(chr(0x31).encode("utf-8"))
82 ser.Write_To_M1Block(chr(0x30).encode("utf-8"))
83 continue
84 else:
85 print("someting is wrong")
86 elif command=="exit":
87 exit(0)
88 else:
89 print("command not found")
90 #while(1):
91 #ser.write("hello".encode("utf-8"))
92 #delay()
93 def compareStr(obj1,obj2):
94 for i,v in enumerate(obj1):
95 if(obj2[i]!=v):
96 return False
97 return True
98 if __name__ == "__main__":
99 #SendCommand()
100 portx = "COM3"
101 bps = 115200
102 timeout=5
103
104 m1=Serial_Handler(portx,bps,timeout) #the serial port will be open initially
105 SendCommand(m1)
106 #m1.connect_to_M1()
107 #m1.Read_From_M1Block(0,30)
108
109 '''
110 def SendCommand(ser):
111 while(1):
112 command=input("please entry the command:")
113 if(compareStr(command.split()[0],"led0")):
114 if(compareStr(command.split()[1],"on")):
115 #print("led0 on")
116 ser.write(chr(0x30).encode("utf-8"))
117 ser.write(chr(0x31).encode("utf-8"))
118 continue
119 elif(compareStr(command.split()[1],"off")):
120 #print("led0 off")
121 ser.write(chr(0x30).encode("utf-8"))
122 ser.write(chr(0x30).encode("utf-8"))
123 continue
124 else:
125 print("someting is wrong")
126 elif(compareStr(command.split()[0],"led1")):
127 if(compareStr(command.split()[1],"on")):
128 #print("led1 on")
129 ser.write(chr(0x31).encode("utf-8"))
130 ser.write(chr(0x31).encode("utf-8"))
131 continue
132 elif(compareStr(command.split()[1],"off")):
133 #print("led1 off")
134 ser.write(chr(0x31).encode("utf-8"))
135 ser.write(chr(0x30).encode("utf-8"))
136 continue
137 else:
138 print("someting is wrong")
139 elif command=="exit":
140 exit(0)
141 else:
142 print("command not found")
143 '''
1 //关于命令处理的程序
2 #include "led.h"
3 #include "serguys.h"
4 #include "FM1702.h"
5 #include "seriels.h"
6 #include "spi.h"
7 //static u8 str_to_char(u8 *str){
8 // u8 decode[]={0x00,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
9 // u8 dechar,tmp;
10 // if((str[0]>=0x30)&&(str[0]<=0x39)) dechar=str[0]-0x30;
11 // else dechar=str[0]&0x0f;
12 // if((str[1]>=0x30)&&(str[1]<=0x39)) tmp=str[1]-0x30;
13 // else tmp=str[1]&0x0f;
14 // dechar=(dechar<<4)+tmp;
15 // return dechar;
16 //}
17
18
19 static void ledctl(u8 *command_buffer){
20 u8 tmp;
21 tmp=*command_buffer;
22 switch(tmp){
23 case 0x30:{
24 tmp=*(command_buffer+1);
25 if(tmp==0x31) LED0=0;
26 else LED0=1;
27 break;
28 }
29 case 0x31:{
30 tmp=*(command_buffer+1);
31 if(tmp==0x31) LED1=0;
32 else LED1=1;
33 break;
34 }
35 default:break;
36 }
37 }
38
39 static void MIF_Read_Handler(u8 *command_buffer){
40 u8 block_addr,status,datalen;
41
42 //u8 uid[5]={0xdb,0x31,0x45,0xbc};
43
44 datalen=*command_buffer;
45 block_addr=*(command_buffer+1);
46 // section=*(command_buffer+2);
47 status=MIF_READ(command_buffer,block_addr);
48 if(status==FM1702_OK) {
49 Send_16bytes(command_buffer);
50 SendString("\n");
51 return;
52 }
53 else {
54 SendString("mifare card read fail\n");
55 return;
56 }
57 }
58 static void MIF_Write_Handler(u8 *command_buffer){
59 u8 block_addr,status,datalen;
60 datalen=*command_buffer;
61 block_addr=*(command_buffer+1);
62 status=MIF_Write(&command_buffer[2],block_addr);
63 if(status==FM1702_OK) {
64 SendString("mifare card write is ok \n");
65 return;
66 }
67 else {
68 SendString("mifare card write fail\n");
69 return;
70 }
71 }
72 static void MIF_Handler(u8 *command_buffer){
73 u8 tmp;
74 tmp=*command_buffer;
75 switch(tmp){
76 case '0':MIF_Read_Handler(&command_buffer[1]);break;
77 case '1':MIF_Write_Handler(&command_buffer[1]);break;
78 default:break;
79 }
80 return;
81 }
82
83 static void MIF_Check_Handler(u8 *command_buffer){
84 u8 tmp;
85 tmp=*command_buffer;
86 switch(tmp){
87 case 'm':{
88 if(check_mif_flag) SendString("MIF Card is ok\n");
89 else SendString("MIF Card is fail\n");
90 break;
91 }
92 default:break;
93 }
94 }
95
96 static void MIF_Connect_Handler (u8 *command_buffer){
97 u8 status,section;
98 u8 key[6],i;
99 u8 tmp;
100 tmp=*command_buffer;
101 section=*(command_buffer+1);
102 switch(tmp){
103 case 'm':{
104 if(check_conn_flag) {
105 SendString("MIF Card has been connected\n");
106 return;
107 }
108 else {
109 for(i=0;i<6;i++) key[i]=0xff;
110 status=LoadKeyCPY(key);
111 if(status==FM1702_OK) SendString("LoadKey is ok "); //sthe card have to autenticate at initial and only one time
112 else{
113 SendString("LoadKey fail \n");
114 return;
115 }
116 status=Authentication(UID,section,RF_CMD_AUTH_LA);
117 if(status==FM1702_OK) SendString("Authentication is ok ");
118 else if(status==FM1702_NOTAGERR){
119 SendString("mifare card test fail \n");
120 return;
121 }
122 else {
123 SendString("mifare card Authent fail \n");
124 return;
125 }
126 SendString("MIF Card connect is ok\n");
127 check_conn_flag=1;
128 return;
129 }
130 }
131 default:break;
132 }
133 }
134 void Command_Handler(u8 *command_buffer){
135 switch((*command_buffer)){
136 case 'L':ledctl(&command_buffer[1]);break;
137 case 'M':{
138 if(check_conn_flag){
139 MIF_Handler(&command_buffer[1]);
140 break;
141 }
142 else SendString("MIF Card connect have not be done\n");break;
143 }
144 case 'C':MIF_Check_Handler(&command_buffer[1]);break;
145 case 'F':MIF_Connect_Handler(&command_buffer[1]);break;
146 default:break;
147 }
148 return;
149 }
