PYQT5:基于QsciScintilla的代码编辑器分析9--STC51烧写协议及实现

最新推荐文章于 2021-12-01 15:00:53 发布

hwd00001

最新推荐文章于 2021-12-01 15:00:53 发布

阅读量1k

点赞数

分类专栏： PYQT5 文章标签： PYQT5 QsciScintilla 代码编辑器 SDCC STC51

本文链接：https://blog.csdn.net/hwd00001/article/details/103140833

版权

PYQT5 专栏收录该内容

16 篇文章 11 订阅

订阅专栏

# stcflash  Copyright (C) 2013  laborer (laborer@126.com)

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

这里提到这是一个免费的软件，只要遵守《GNU GPL》开源的精神，我们就可以发行，修改该软件。说实话，这些我都不太懂。反正本着学习的精神拿来用，并做一些修改就是了。

1.烧写hex文件流程

烧写流程在源码中注释得很清楚，函数名也说明了自己的功能，所以直接看源码：

    def  MyProgram(self, prog, code, erase_eeprom=None):   
        #下面的语句是打印调试信息到 《test.log》文件，有需要就取消注释
        #logging.basicConfig(filename="test.log", filemode="w", 
        #                            format="%(asctime)s %(name)s:%(levelname)s:%(message)s", 
        #                            datefmt="%d-%M-%Y %H:%M:%S", level=logging.DEBUG)
        #0.判断是否发送下载指令
        if self.downloadWay == '2':
            prog.sendISPcmd(self.baudArray[self.baudIndex])
        elif self.downloadWay == '3':
            prog.sendISPcmd(self.baudArray[self.baudIndex], self.DIYString)
        #1.开始检测芯片
        self.SetTipString( '正在检测 MCU,请给芯片上电。'   )
        ok=prog.detect()        
        if not ok:
            self.SetTipString("检测芯片失败. 请重试...")
            return
        self.SetTipString("检测芯片完成. done")    
        self.Myprint_info(prog) #打印检测芯片的结果：1 】晶振频率；2】芯片型号；3】ROMM
        
        if prog.protocol is None:
            self.SetTipString("目标芯片无法识别. 终止下载。")
            return       
        if code is None:
            self.SetTipString("下载文件内容为空。 终止下载。")
            return
        prog.comfirm_MCU_model() 
        #2.建立更高波特率       
        self.SetTipString("尝试更高波特率...")
        prog.handshake()        
        self.SetTipString("波特率为 %d " % prog.baudrate)
        
        #3.擦除芯片
        prog.prepare_for_erase()
        self.SetTipString("开始擦除芯片......" )
        prog.erase()
        self.SetTipString("擦除芯片成功。")
        
        #4.开始写入程序数据
        self.SetTipString("开始写入，程序数据大小为%d bytes... " %  len(code))
        oldbar = 0
        for progress in prog.flash(code):
            bar = progress
            self.SetTipString("#%d -  %d bytes 已完成..." %( oldbar,bar ))
            oldbar = bar       
        self.SetTipString("全部写入完毕，运行程序...") 

        prog.unknown_packet_3()
        #5.结束整个流程
        prog.terminate()

prog就是把软件《stcflash.py》封装起来的一个类。

2.STC51烧写协议介绍

  PC命令        说明            		MCU回应					 	对应源码函数			
	7F    引导MCU进入ISP并测量时钟   	50    MCU选项信息			detect()
	50    设置MCU型号等           	8F    应答					comfirm_MCU_model()
	8F/01 新波特率测试            	8F/01 测试应答				handshake() 
	8E    正式修改波特率           	84    修改波特率应答			包含在handshake()的末尾，STC15，STC8没有用到此指令
	80/05准备擦除					80/05 应答					prepare_for_erase()
	84/03 擦除芯片         			00/03    应答				prog.erase()
	00/02 下载程序               	00/02    应答校验和			flash(code)
	69    型号等                		8D    应答(部分芯片需要)		unknown_packet_3()
	8D    设置选项                	50    应答选项				本软件不提供此功能
	82/FF    退出                   运行程序					terminate()

3.指令帧格式

3.1检测芯片指令0x7F

这个指令就是一个单独的字节，二进制就是0b0111 1111，对应电平就是开始一个低电平，后面7个高电平，这个方便MCU计算上位机的波特率。

3.2 其它指令的格式

协议帧的构成如下：

Head	Sign	Length	command	Data	Checksum	Trail

各个部分的详细说明：

名称	长度	功能
Head	2 Byte	帧头(0x46,0x49)
Sign	1 Byte	方向标识：【0x6A：PC发出】【0x68：MCU应答】
Length	2 Byte	除去帧头，其它数据的总字节数
command	1 Byte	第2节中的命令
Data	最大160Byte	数据
Checksum	2 Byte	校验和
Trail	1Byte	帧尾(0x16)

下面举例子说明，以STC15的准备擦除指令0x05为例，PC发出的指令如下：

[序号]0  1  2  3  4  5  6  7  8  9  10 11 12
[数据]46 B9 6A 00 0B 05 00 00 5A A5 01 79 16

为了说明方便，假设数据存于一个Python列表list[]中，于是有Head = list[0:1]=[0x46,0xB9], Sign = list[2]=[0x6A], Length = list[3:4]=[0x00,0x0B], command = list[5]=[0x05], data = list[6:9]=[0x00,0x00,0x5A,0xA5], Checksum=list[10:11]=[0x01,0x79], Trail=list[12]=[0x16].

3.3 调试时的一些原始数据

下面给出我调试时监控串口的一些原始数据，供读者参考：

一、检测	
WRITE gth: 1, Data: 7F 	
READ  gth: 0, Data: 	
WRITE gth: 1, Data: 7F 	
READ  gth: 0, Data: 	
WRITE  1, Data: 7F 	
READ  gth: 1, Data:  [序号][数据]
0  1  2  3  4  5  6  7  8  9  10 11 12[13 14 15]16 17 18 19 20 21[22 23]24[25 26]27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
46 B9 68 00 34 50 90 05 6B 93 F7 BB 9F 01 51 CF B0 FD 26 D8 00 00 72 53 00 F4 08 05 06 70 93 02 18 1F 22 23 21 00 F4 F0 04 D5 FF 6F 7F FF FF 16 03 23 60 13 4E 16(15F2K60S2)
46 B9 68 00 34 50 8E C6 71 99 F7 BB 9F 00 A8 70 50 FD 26 E2 00 00 72 54 00 F2 A4 05 06 70 99 02 14 19 1B 1D 22 80 14 10 04 E8 EA 72 BF FF FF 18 06 08 00 12 D0 16(15W104)
46 B9 68 00 34 50 8E C6 71 99 F7 BB 9F 01 51 5A 80 FD 26 DD 00 00 72 54 00 F2 A4 05 06 70 99 02 14 19 1B 1D 22 80 14 10 04 E8 EA 72 7F FF FF 18 06 08 00 12 4F 16(15W104,22.1184M)

46 B9 68 00 30 50[01 51 43]10 6C 03 01 FF FF 8F BF FF 26 E1 F7 73 73 55 00 F6 44 0A 85 E3 6C 8D 08 20 20 20 01 00 00 80 05 38 18 12 07 70 FF 0F EC 16(8F2K32S2,22.1184) 
46 B9 68 00 30 50[00 A8 CB]B8 6D 01 02 FF FF 8F BF FF 26 E1 F7 73 73 55 00 F6 44 0A 85 E3 6C 8D 08 20 20 20 01 00 00 80 05 38 18 12 07 70 FF 11 72 16(8F2K32S2,11.0592)  	
46 B9 68 00 30 50[01 51 6D]40 66 02 01 FF FF 8B BF FF 26 CF F7 FE[73 55]00[F6 28]0A 86 2E 63 86 08 20 20 20 01 00 00 FE 05 42 19 09 17 70 FF 10 64 16(8F8K64S4A12,22.1184) 	
	
46 B9 68 00 34 50 90 05 6B 93 F7 BB 9F 00 A8 87 C0 FD 26 D3 00 00 72 53 00 F4 08 05 06 70 93 02 18 1F 22 23 21 00 F4 F0 04 D5 FF 6D BF FF FF 16 03 23 60 13 A5 16 	

[13:15]=  01 51 CF  内部晶振=0x0151CF * 256=22.1184M   0x00A870*256 =11.068M  
[22:23]=0x72,0x53 表示MCU版本号，0x72意思是7.2，0x49对应'R'，合起来就是7.2R
[24]=0x00,配置ALE引脚，看门狗，时钟倍速等等
[25:26]=0xF4,0x08  --- mcu Model(15F2K60S2)     [25:26]=0xF2,0xA4  --- mcu Model(15W104) 
以下两条指令忽略	
WRITE  34, Data: 46 B9 6A 00 20 00 0B 00 C0 80 C0 FF C0 00 80 80 80 FF 80 00 40 80 40 FF 40 00 00 80 00 00 00 0A 12 16 	

WRITE gth: 1, Data: FE 	
READ  gth: 0, Data: 	
WRITE gth: 1, Data: FE 	
READ  gth: 1, Data: 46 B9 68 00 20 00 0B 0D 38 12 D8 18 7D 1A 53 25 61 30 65 35 15 4A 91 5F 54 53 6A 73 A4 00 00 07 8B 16 
	
WRITE gth: 34, Data: 46 B9 6A 00 20 00 0C 6D 40 6E 40 6F 40 70 40 71 40 72 40 6D 40 6E 40 6F 40 70 40 71 40 72 40 08 D0 16 	
		
WRITE gth: 1, Data: FE 	
READ  gth: 1, Data: 46  B9 68 00 20 00 0C 47 C6 47 F3 48 20 48 5C 48 7F 48 B1 47 C1 47 F3 48 20 48 52 48 7A 48 AC 0A A1 16 
	
二、尝试更高波特率0x01
WRITE gth: 16, Data: 46 B9 6A 00 0E 01 		6E 40 	FF D0 	40 6F 	81 04 26 16 (22.1184MHz)
WRITE gth: 16, Data: 46 B9 6A 00 0E 01 		6E 40 	FF D0 	40 28 	81 03 DF 16 (18.432MHz)	

WRITE gth: 16, Data: 46 B9 6A 00 0E 01 		6E 40 	FF D0 	80 6E 	81 04 65 16 (11.0592MHz)	
WRITE gth: 16, Data: 46 B9 6A 00 0E 01 		6F 40 	FF D0 	C0 67 	81 04 9F 16 (05.5296MHz)
以上为15F2K60S2																				  
WRITE  th: 16, Data: 46 B9 6A 00 0E 01 		73 40 	FD BF 	FC 9F 	81 05 04 16 
WRITE gth: 16, Data: 46 B9 6A 00 0E 01 		72 40 	FD C0 	FC A0 	81 05 05 16 (11.0592MHz)15F104	
WRITE gth: 16, Data: 46 B9 6A 00 0E 01 		72 40 	FD C1 	FC A1 	81 05 07 16	(22.1184MHz)15F104 波特率38400
  ============以下为STC8F2K32S2====================
WRITE gth: 16, Data: 46 B9 6A 00 0E 01 		00 00 	FF CC 	01 6B 	81 03 31 16 (22.1184MHz)
WRITE gth: 16, Data: 46 B9 6A 00 0E 01 		00 00 	FF CC 	01 6A 	81 03 30 16	(11.0592MHz)
WRITE gth: 16, Data: 46 B9 6A 00 0E 01 		00 00 	FF CC 	01 06 	81 02 CC 16 (05.5296MHz)
WRITE gth: 16, Data: 46 B9 6A 00 0E 01 		00 00 	FF CC 	01 28 	81 02 EE 16 (18.432MHz) 	

READ  gth: 1, Data: 46 B9 68 00 07 	
READ  gth: 4, Data: 01 00 70 16 	
ERIAL_d Rate: 115200       ERIAL_pBits: 1, Parity: Even, DataBits: 8	
三、准备指令 0x05
WRITE gth: 13, Data: 46 B9 6A 00 0B 05 00 00 5A A5 01 79 16 
  ============以下为STC8F2K32S2====================	   		
WRITE gth: 13, Data: 46 B9 6A 00 0B 05 00 00 5A A5 01 79 16 
READ  gth: 1, Data: 46 B9 68 00 07 05 00 74 16 
四、擦除指令 0x03	
WRITE gth: 13, Data: 46 B9 6A 00 0B 03 00 00 5A A5 01 77 16 
WRITE gth: 13, Data: 46 B9 6A 00 0B 03 00 00 5A A5 01 77 16	   (STC8F2K32S2)	   		

READ  gth: 1, Data: 46 B9 68 00 0E 03 F4 08 01 78 07 E8 2C 03 09 16 
READ  gth: 1, Data: 46 B9 68 00 0E 03 F6 44 43 D3 01 21 9A 03 85 16   (STC8F2K32S2)
五、写入程序数据 0x02	
WRITE gth: 141, Data: 46 B9 6A 00 8B 02 00 00 5A A5 02 00 2E E4 FF FE E4 FD FC 0D BD 00 01 0C BC 01 F8 BD F4 F5 0F BF 00 01 0E EF 64 64 4E 70 E7 22 E4 F5 90 12 00 03 75 90 FF 12 00 03 80 F2 78 7F E4 F6 D8 FD 75 81 	
WRITE gth: 141, Data: 46 B9 6A 00 8B 22 00 00 5A A5 02 00 2E E4 FF FE E4 FD FC 0D BD 00 01 0C BC 01 F8 BD F4 F5 0F BF 00 01 0E EF 64 64 4E 70 E7 22 E4 F5 90 12 00 03 75 90 FF 12 00 03 80 F2 78 7F E4 F6 D8 FD 75 81 	

READ  gth: 0, Data:   46 B9 6A 00 8D 00 00 00 00 00 00 80	
READ  gth: 1, Data: 46 B9 68 00 08 02 54 00 C6 16 	
WRITE gth: 141, Data: 46 B9 6A 00 8B 02 00 80 5A A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 	

READ  gth: 1, Data: 46 B9 68 00 08 02 54 00 C6 16 	
WRITE gth: 141, Data: 46 B9 6A 00 8B 02 01 00 5A A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 	

READ  gth: 1, Data: 46 B9 68 00 08 02 54 00 C6 16	
WRITE gth: 141, Data: 46 B9 6A 00 8B 02 01 80 5A A5 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 	

READ  gth: 1, Data: 46 B9 68 00 08 02 54 00 C6 16
六、写入配置 0x04	  （可忽略）
WRITE gth: 77, Data: 46 B9 6A 00 4B 04 00 00 5A A5 FF FF FF 00 FF FF 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 00 01 FF 51 FF 43 FF 10 FF FD 03 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 	
	
READ  gth: 1, Data: 46 B9 68 00 08 04 54 00 C8 16 
七、启动芯片	
WRITE gth: 9, Data: 46 B9 6A 00 07 FF 01 70 16 	
CLOSE t Closed

说了这么多，不知道有没有成功的把读者绕晕，反正我自己说得昏昏沉沉；让我想起调试这部分程序时，也是昏昏沉沉，所幸最后调试成功了。

4.《stcflash.py》源码阅读重点

4.1 detect()

这个函数就是以较低的波特率（一般是1200或者2400，本程序采用2400）尝试发送一个字节0x7F，不停的发送，直到单片机有数据返回，然后对返回的数据分析。分析数据的关键就是要知道每个字节的含义。
返回的数据中，在程序中用到的就是晶振频率，MCU型号代码，固件版本。
STC12的返回数据有16个字节是8次测量0x7F的高电平宽度数据，把这8个数据取平均后，代入公式 f = 脉宽 x 波特率 x 12 / 7，就可以得到晶振频率。比如在波特率1200下，获得一串测量数据为16 05 16 05 16 05 16 05 16 05 16 05 16 05 16 05，就是0x1605 = 5637（十进制），代入公式得 f = 5637 x 1200 x 12 / 7 = 11,596,114 Hz 。
STC15的返回数据中直接给出晶振频率，只要把该数放大256倍就是晶振频率。比如上面3.3节的原始数据有一个是[13:15]= 01 51 CF ，那么可以得到晶振频率=0x0151CF * 256=22.1184MHz。
STC8的晶振频率也是直接给出的，只是数据位置和STC15不同，可以从原始数据中看出来。
晶振频率数据在接下来的“新波特率测试”指令要用到，用来确定更高速的波特率。

    def detect(self):
        #1. 不停发送 0x7F，等待应答
        for i in range(500):
            try:
                self.__conn_write([0x7F, 0x7F])
                cmd, dat = self.recv(0.03, [0x68])
                break
            except IOError:
                pass
        else:            
            return False            #raise IOError()
        #2. 计算MCU 的晶振频率
        if self.protocol in PROTOSET_15F2K: # dat[7:9] *0x100 Hz,/ 1000000 =MHz
            self.fosc = (dat[7]*0x1000000 +dat[8]*0x10000+dat[9]*0x100) /1000000
            
            logging.info("dat[7]:%02X dat[8]:%02X dat[9]%02X" % (dat[7], dat[8], dat[9]))
            logging.info("self.fosc:%04f" % (self.fosc))
        elif self.protocol in PROTOSET_8F2K: # dat[0:2] *0x100 Hz,/ 1000000 =MHz
            self.fosc = (dat[0]*0x1000000 +dat[1]*0x10000+dat[2]*0x100) /1000000
        else:
            self.fosc = (float(sum(dat[0:16:2]) * 256 + sum(dat[1:16:2])) / 8
                         * self.conn.baudrate / 580974)
        #3. 分析MCU 型号，固件版本，ROM容量
        self.info = dat[16:]
        self.version = "%d.%d%c" % (self.info[0] >> 4,
                                    self.info[0] & 0x0F,
                                    self.info[1])
        self.model = self.info[3:5]

        self.name, self.romsize = self.__model_database(self.model)

        logging.info("Model ID: %02X %02X" % tuple(self.model))
        logging.info("Model name: %s" % self.name)
        logging.info("ROM size: %s" % self.romsize)
        #4. 假如事先未知型号，现在确定，
        if self.protocol is None:
            try:
                self.protocol = {0xF0: PROTOCOL_89,       #STC89/90C5xRC
                                 0xF1: PROTOCOL_89,       #STC89/90C5xRD+
                                 0xF2: PROTOCOL_12Cx052,  #STC12Cx052
                                 0xD1: PROTOCOL_12C5A,    #STC12C5Ax
                                 0xD2: PROTOCOL_12C5A,    #STC10Fx
                                 0xE1: PROTOCOL_12C52,    #STC12C52x
                                 0xE2: PROTOCOL_12C5A,    #STC11Fx
                                 0xE6: PROTOCOL_12C52,    #STC12C56x
                                 0X72:PROTOCOL_12Cx052,   #stc12Cx052
                                 0X74:PROTOCOL_15F2K,   #stc15F2K
                                 0X76:PROTOCOL_8F2K,   #stc15F2K
                                 }[self.model[0]]
            except KeyError:
                pass
        #5. 根据MCU型号，确定校验和的是1 Byte还是 2Byte；还有串口的奇偶模式
        if self.protocol in PROTOSET_PARITY or self.protocol in PROTOSET_15F2K \
                        or self.protocol in PROTOCOL_8F2K:
            self.chkmode = 2
            self.conn.parity = serial.PARITY_EVEN
        else:
            self.chkmode = 1
            self.conn.parity = serial.PARITY_NONE

        if self.protocol is not None:
            del self.info[-self.chkmode:]

            logging.info("Protocol ID: %s" % self.protocol)
            logging.info("Checksum mode: %d" % self.chkmode)
            logging.info("UART Parity: %s"
                         % {serial.PARITY_NONE: "NONE",
                            serial.PARITY_EVEN: "EVEN",
                            }[self.conn.parity])

        for i in range(0, len(self.info), 16):
            logging.info("Info string [%d]: %s"
                         % (i // 16,
                            " ".join(["%02X" % j for j in self.info[i:i+16]])))
        return True

4.2 handshake()

这个函数是以刚才发送0x7F的波特率通信的。用于指导单片机切换到目标波特率。原先作者所支持的单片机型号，是可以适应任意晶振频率的；我增加的STC15，STC8两种型号就只支持晶振频率为：5.5296M，11.0592M，18.432M，22.1184M 。因为我没有找到规律，只能监控串口，生搬硬套。具体请看代码。
握手成功后使用新的波特率，一直到结束。

    def handshake(self):
        baud0 = self.conn.baudrate

        if self.protocol in PROTOSET_15F2K or self.protocol in PROTOSET_8F2K:
            for baud in [115200, 57600, 38400, 28800, 19200,
                         14400, 9600, 4800, 2400, 1200]:
                t = self.fosc * 1000000 / baud / 2
                if self.protocol in PROTOSET_15F2K:
                    if self.fosc < 11.2 and self.fosc > 11:
                        baudstr = [0x6E, 0x40, 0xff,0xd0,    0x80,0x6E, 0x81]
                    elif self.fosc > 18.3 and self.fosc < 18.5:
                        baudstr = [0x6E, 0x40, 0xff,0xd0,   0x40,0x28, 0x81]
                    elif self.fosc > 5.4 and self.fosc < 5.6:
                        baudstr = [0x6f, 0x40, 0xff,0xd0,   0xC0,0x67, 0x81]
                    else:           #elif self.fosc < 22.5 and self.fosc > 22:     默认为22.1184MHz
                        baudstr = [0x6E, 0x40, 0xff,0xd0,   0x40,0x6f, 0x81]
                elif self.protocol in PROTOSET_8F2K:
                    if self.fosc < 11.2 and self.fosc > 11:
                        baudstr = [0x00, 0x00, 0xff,0xCC,   0x01,0x6A, 0x81]
                    elif self.fosc > 18.3 and self.fosc < 18.5:
                        baudstr = [0x00, 0x00, 0xff,0xCC,   0x01,0x28, 0x81]
                    elif self.fosc > 5.4 and self.fosc < 5.6:
                        baudstr = [0x00, 0x00, 0xff,0xCC,   0x01,0x06, 0x81]
                    else:               #elif self.fosc < 22.5 and self.fosc > 22:  默认为22.1184MHz
                        baudstr = [0x00, 0x00, 0xff,0xCC,   0x01,0x6B, 0x81]
                logging.info("Test baudrate %d (accuracy %0.4f) using config %s"
                             % (baud,
                                abs(round(t) - t) / t,
                                " ".join(["%02X" % i for i in baudstr])))
                self.send(0x01, baudstr )
                try:
                    cmd, dat = self.recv()
                    break
                except Exception:
                    logging.info("Cannot use baudrate %d" % baud)
                    time.sleep(0.2)
                    self.conn.flushInput()
                finally:
                    self.__conn_baudrate(baud0, False)
                    
            logging.info("Change baudrate to %d" % baud)
            self.__conn_baudrate(baud)
            self.baudrate = baud            
        else:
            for baud in [115200, 57600, 38400, 28800, 19200,
                         14400, 9600, 4800, 2400, 1200]:
                t = self.fosc * 1000000 / baud / 32
                if self.protocol not in PROTOSET_89:
                    t *= 2

                if abs(round(t) - t) / t > 0.03:
                    continue

                if self.protocol in PROTOSET_89:
                    tcfg = 0x10000 - int(t + 0.5)
                else:
                    if t > 0xFF:
                        continue
                    tcfg = 0xC000 + 0x100 - int(t + 0.5)

                baudstr = [tcfg >> 8,
                           tcfg & 0xFF,
                           0xFF - (tcfg >> 8),
                           min((256 - (tcfg & 0xFF)) * 2, 0xFE),
                           int(baud0 / 60)]

                logging.info("Test baudrate %d (accuracy %0.4f) using config %s"
                             % (baud,
                                abs(round(t) - t) / t,
                                " ".join(["%02X" % i for i in baudstr])))

                if self.protocol in PROTOSET_89:
                    freqlist = (40, 20, 10, 5)
                else:
                    freqlist = (30, 24, 20, 12, 6, 3, 2, 1)

                for twait in range(0, len(freqlist)):
                    if self.fosc > freqlist[twait]:
                        break

                logging.info("Waiting time config %02X" % (0x80 + twait))

                self.send(0x8F, baudstr + [0x80 + twait])

                try:
                    self.__conn_baudrate(baud)
                    cmd, dat = self.recv()
                    break
                except Exception:
                    logging.info("Cannot use baudrate %d" % baud)

                    time.sleep(0.2)
                    self.conn.flushInput()
                finally:
                    self.__conn_baudrate(baud0, False)

            else:                
                self.parent.SetTipString("IOError in stcflash.py handshake()")#raise IOError()

            logging.info("Change baudrate to %d" % baud)

            self.send(0x8E, baudstr)
            self.__conn_baudrate(baud)
            self.baudrate = baud

            cmd, dat = self.recv()

4.3 sendISPcmd()

在单片机运行时发送ISP命令，是要单片机程序配合的。这个函数有个特别说明的地方：发送命令后，不要有等待，立刻进入detect()函数。0.1秒的等待都不行。

    def sendISPcmd(self, baud=115200, cmdstr='5a 3a 6c'):   
        #1. 发送ISP命令的波特率是单片机运行时的波特率
        baud0 = self.conn.baudrate
        self.conn.parity = serial.PARITY_NONE        
        self.__conn_baudrate(baud)
        
        dat = []
        hexList=cmdstr.split(' ')
        for hex0 in hexList:
            dat += binascii.a2b_hex(hex0)
        self.__conn_write(dat)    
        #2.恢复原来波特率  ，即发送检测命令 0x7F 时的波特率 
        if self.protocol in PROTOSET_PARITY or self.protocol in PROTOSET_15F2K \
                    or self.protocol in PROTOSET_8F2K:
            self.conn.parity = serial.PARITY_EVEN
        self.__conn_baudrate(baud0,  flush=False)   #默认flush=True 将会产生0.2秒的延时
                
    def __conn_baudrate(self, baud, flush=True):
        logging.debug("baud: %d" % baud)
        #   这里特别注意，在芯片工作时发送下载指令，flush 必须为 False，因为不能有延时。
        if flush:       #               我调试了大半天才找到原因
            self.conn.flush()
            time.sleep(0.2)

        self.conn.baudrate = baud

单片机的串口接收程序要对命令进行处理才有效，以默认的命令为例：

#define RS_ISP  IAP_CONTR |= 0x60           // 热启动，准备下载程序
void UART1_Isr() __interrupt UART1_VECTOR
{
    if (TI) {
        TI = 0;
        if (txdData.index < txdData.len){
           SBUF = txdData.buf[txdData.index];
           txdData.index++;
        }else {
            txdData.busy=false;
            txdData.len = 0;
            txdData.index = 0;
        }
    }else if (RI){
		RI = 0;
		if(rxdData.len < RXD_LENGTH){
            rxdData.buf[rxdData.len] = SBUF;
            rxdData.len++;
            if(rxdData.len==3){	//接收到下载指令，进入bootload
                if((rxdData.buf[0]==0x5a)&&
                   (rxdData.buf[1]==0x3a)&&
                   (rxdData.buf[2]==0x6c))
                    RS_ISP;
            }
		}else{//   避免溢出处理
		    rxdData.len = 0;
		}
    }
}

参考文章：
1.STC12C系列的协议分析

hwd00001

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
PYQT5:基于QsciScintilla的代码编辑器分析9--STC51烧写协议及实现

STC51单片机烧写软件《stcflash.py》在第2章已经有简单的介绍，看看作者大神laborer的版权声明：# stcflash Copyright (C) 2013 laborer ([email protected])# This program is free software: you can redistribute it and/or modify# it under t...
复制链接

扫一扫