python 3下对stm32串口数据做解析

1、最近有个想做一个传感器数据实时显示的上位机，常规的数据打印太频繁了，无法直观的看出数据的变化。

python下的上位机实现起来简单一点，网上找了一些python界面Tkinter相关资料和python串口的demo.测试实现了简单的数据显示。

 

Mark 一下问题点：

最大的问题点在于对bytes型数据的拼接：之前的串口解析的代码是在python 2.7平台上实现的，

切换到python3.0之后，测试失踪无法通过。幸而找到了大神相助。

python 2.7code:

import os
import time
import sys, traceback
from serial.serialutil import SerialException
from serial import Serial

import struct
import binascii


class Arduino:
    def __init__(self, port="/dev/ttyUSB0", baudrate=115200, timeout=0.5):
        
        self.port = port
        self.baudrate = baudrate
        self.timeout = timeout
        self.encoder_count = 0
        self.writeTimeout = timeout
        self.interCharTimeout = timeout / 30.

        self.WAITING_FF = 0
        self.WAITING_AA = 1
        self.RECEIVE_LEN = 2
        self.RECEIVE_PACKAGE = 3
        self.RECEIVE_CHECK = 4
        self.HEADER0 = 0xff
        self.HEADER1 = 0xaa
        self.REC_CMD = 5
        self.count   = 0
        self.data1   = 0
        self.data2   = 0
        self.error_flag = 0
        self.SUCCESS = 0
        self.FAIL = -1

        self.receive_state_ = self.WAITING_FF
        self.receive_check_sum_ = 0
        self.payload_command = ''
        self.payload_ack = ''
        self.payload_args = ''
        self.payload_len = 0
        self.byte_count_ = 0
        self.receive_message_length_ = 0
    
        self.mutex = threading.Thread.allocate_lock()
            
        # An array to cache analog sensor readings
        self.analog_sensor_cache = [None] * self.N_ANALOG_PORTS
        
        # An array to cache digital sensor readings
        self.digital_sensor_cache = [None] * self.N_DIGITAL_PORTS
    
    def connect(self):
        try:
            print "Connecting to Arduino on port", self.port, "..."
            self.port = Serial(port=self.port, baudrate=self.baudrate, timeout=self.timeout, writeTimeout=self.writeTimeout)
            # The next line is necessary to give the firmware time to wake up.
            time.sleep(1)
            state_, val = self.get_baud()
            if val != self.baudrate:
                time.sleep(1)
                state_, val  = self.get_baud()   
                if val != self.baudrate:
                    raise SerialException
            print "Connected at", self.baudrate
            print "Arduino is ready."

        except SerialException:
            print "Serial Exception:"
            print sys.exc_info()
            print "Traceback follows:"
            traceback.print_exc(file=sys.stdout)
            print "Cannot connect to Arduino!"
            os._exit(1)

    def open(self): 
        self.port.open()

    def close(self): 
        self.port.close() 
    
    def send(self, cmd):
        self.port.write(cmd)

    def receiveFiniteStates(self, rx_data):
        if self.receive_state_ == self.WAITING_FF:
            #print str(binascii.b2a_hex(rx_data))
            if rx_data == '\xff':
                self.receive_state_ = self.WAITING_AA
                self.receive_check_sum_ =0
                self.receive_message_length_ = 0
                self.byte_count_=0
                self.payload_ack = ''
                self.payload_args = ''
                self.payload_len = 0
                self.count = 0

        elif self.receive_state_ == self.WAITING_AA :
             if rx_data == '\xaa':
                 self.receive_state_ = self.REC_CMD
             else:
                 self.receive_state_ = self.WAITING_FF
        elif self.receive_state_ == self.REC_CMD:
             self.count+=1
             if self.count == 1:
                self.data1,=struct.unpack("B",rx_data)
             elif self.count == 2:
                  self.data2,=struct.unpack("B",rx_data)
                  self.receive_state_ = self.RECEIVE_LEN
                  if self.error_flag == 0 and self.data1 != 0:
                     self.error_flag = 1
                  if self.data2 != 0 and self.error_flag == 0:
                     self.error_flag = 1   
        elif self.receive_state_ == self.RECEIVE_LEN:
             self.receive_message_length_, = struct.unpack("B",rx_data)
             self.receive_state_ = self.RECEIVE_PACKAGE
        elif self.receive_state_ == self.RECEIVE_PACKAGE:
             if self.byte_count_==0:
                 self.payload_ack = rx_data
             else:
                 self.payload_args += rx_data
             self.byte_count_ +=1
             #print "byte:"+str(byte_count_) +","+ "rece_len:"+str(receive_message_length_)
             if self.byte_count_ >= self.receive_message_length_:
                 self.receive_state_ = self.RECEIVE_CHECK

        elif self.receive_state_ == self.RECEIVE_CHECK:
            #if(rx_data == (unsigned char)receive_check_sum_)
            if 1:
                self.receive_state_ = self.WAITING_FF
                #print str(binascii.b2a_hex(value))
                #left, right, = struct.unpack('hh', value)
                #print "left:"+str(left)+", right:"+str(right)
                return 1 
            else:
                self.receive_state_ = self.WAITING_FF
        else:
            self.receive_state_ = self.WAITING_FF;
        return 0

    def recv(self, timeout=0.5):
        timeout = min(timeout, self.timeout)
        ''' This command should not be used on its own: it is called by the execute commands   
            below in a thread safe manner.  Note: we use read() instead of readline() since
            readline() tends to return garbage characters from the Arduino
        '''
        c = ''
        value = ''
        attempts = 0
        c = self.port.read(1)
        #print str(binascii.b2a_hex(c))
        while self.receiveFiniteStates(c) != 1:
            c = self.port.read(1)
            #print str(binascii.b2a_hex(c))
            attempts += 1
            if attempts * self.interCharTimeout > timeout:
                return 0
        return 1
            
    def recv_ack(self):
        ack = self.recv(self.timeout)
        return ack == 'OK'

    def execute(self, cmd):
        self.mutex.acquire()
        
        try:
            self.port.flushInput()
        except:
            pass
        
        ntries = 1
        attempts = 0
        
        try:
            self.port.write(cmd)
            res = self.recv(self.timeout)
            while attempts < ntries and res !=1 :
                try:
                    self.port.flushInput()
                    self.port.write(cmd)
                    res = self.recv(self.timeout)
                except:
                    print "Exception executing command: " + str(binascii.b2a_hex(cmd))
                attempts += 1
        except:
            self.mutex.release()
            print "Exception executing command: " + str(binascii.b2a_hex(cmd))
            return 0
        
        self.mutex.release()
        return 1

    def get_baud(self):
        ''' Get the current baud rate on the serial port.
        '''
        cmd_str=struct.pack("4B", self.HEADER0, self.HEADER1, 0x01, 0x00) + struct.pack("B", 0x01)
        if (self.execute(cmd_str))==1 and self.payload_ack == '\x00':
           val, = struct.unpack('I', self.payload_args)
           return  self.SUCCESS, val 
        else:
           return self.FAIL, 0

    def get_check_sum(self,list):
        list_len = len(list)
        cs = 0
        for i in range(list_len):
            #print i, list[i]
            cs += list[i]
        cs=cs%255
        return cs
        
    def stop(self):
        ''' Stop both motors.
        '''
        self.drive(0, 0)

在python 3.6 version 中就该修改部分代码：

 问题在于bytes类型的拼接：

以下的拼接是正确的：

bytes('','ascii')+bytes([1,2,3,4,5,6,7,8,9])
bytes('','ascii')+bytes([1,2,3,4,5,6,7,8,9])+bytes([1,2,3,4,5,6,7,8,9])

也即是：bytes类型的拼接的初始变量要声明为：bytes('','ascii')

如果声明为其它类型：比如字符串，执行时会直接报错。

即：python2.7代码块中：40行以及94行的声明：

（1）将：40行和94行的
self.payload_args = ''
改为：
self.payload_args = bytes('','ascii')
（2）将：121行赋值命令：
self.payload_args += rx_data
修改为：
self.payload_args +=  bytes（rx_data）

 源码已上传到github：链接

目前单纯实现了串口数据的查询：