嵌入式开发日记（6）——对串口数据读取的优化以及处理程序的改写

最新推荐文章于 2023-01-04 21:57:48 发布
最新推荐文章于 2023-01-04 21:57:48 发布
阅读量905 收藏 5
点赞数 2
分类专栏： 嵌入式开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wulitaotao96/article/details/89476291
版权

改进版代码的github地址如下，读取并记录到本地文件。https://github.com/hanjintao1996/jy61-/tree/master

如有帮助请在github点赞，感激不尽。

#define IOBEGIN 22 
#define IOEND 53               //定义初始化的IO口
// the setup function runs once when you press reset or power the board
void setup() {
    Serial.begin(9600);         //初始化端口
    Serial.print("Ready");
    for(int i=IOBEGIN;i<=IOEND;i++)
    {  
        
        pinMode(i,OUTPUT);
    } 
}
 
// the loop function runs over and over again forever
void loop() {
  if(Serial.available()){
   char ch = Serial.read();        //读取串口
   Serial.print(ch);
   switch(ch){                     //根据传入信息判断工作模式
   case'1':
   digitalWrite(22,HIGH);
   digitalWrite(23,HIGH);
   digitalWrite(24,HIGH);
   digitalWrite(25,HIGH);
   digitalWrite(26,HIGH);
   digitalWrite(27,HIGH);
   break;
   case'2':
   digitalWrite(22,LOW);
   digitalWrite(23,LOW);
   digitalWrite(24,LOW);
   digitalWrite(25,LOW);
   digitalWrite(26,LOW);
   digitalWrite(27,LOW);
   break;
}}}

因为之前用原始的方法进行数据的读取，导致在出现丢包之类的情况发生的时候会出现程序错误，在实验室师兄的帮助下，改写了之前的程序，具体情况参见注释：

import serial

ACCData=[0.0]*8
GYROData=[0.0]*8
AngleData=[0.0]*8         #定义三个数组，分别存储加速度角速度与角度的值

FrameState = 0            #通过0x后面的值判断属于哪一种情况
Bytenum = 0               #读取到这一段的第几位
CheckSum = 0              #求和校验位         

def DueData(inputdata):   #新增的核心程序，对读取的数据进行划分，各自读到对应的数组里
    global  FrameState    #在局部修改全局变量，要进行global的定义
    global  Bytenum
    global  CheckSum
    for data in inputdata:  #在输入的数据进行遍历
        if FrameState==0:   #当未确定状态的时候，进入以下判断
            if data==0x55 and Bytenum==0: #0x55位于第一位时候，开始读取数据，增大bytenum
                CheckSum=data
                Bytenum=1
                continue
            elif data==0x51 and Bytenum==1:#在byte不为0 且 识别到 0x51 的时候，改变frame
                CheckSum+=data
                FrameState=1
                Bytenum=2
            elif data==0x52 and Bytenum==1: #同理
                CheckSum+=data
                FrameState=2
                Bytenum=2
            elif data==0x53 and Bytenum==1:
                CheckSum+=data
                FrameState=3
                Bytenum=2
        elif FrameState==1: # acc    #已确定数据代表加速度
            if Bytenum<10:            # 读取8个数据
                ACCData[Bytenum-2]=data # 从0开始
                CheckSum+=data
                Bytenum+=1
            else:
                if data == (CheckSum&0xff):  #假如校验位正确
                    print(get_acc(ACCData))
                CheckSum=0                  #各数据归零，进行新的循环判断
                Bytenum=0
                FrameState=0
        elif FrameState==2: # gyro
            if Bytenum<10:
                GYROData[Bytenum-2]=data
                CheckSum+=data
                Bytenum+=1
            else:
                if data == (CheckSum&0xff):
                    print(get_gyro(GYROData))
                CheckSum=0
                Bytenum=0
                FrameState=0
        elif FrameState==3: # angle
            if Bytenum<10:
                AngleData[Bytenum-2]=data
                CheckSum+=data
                Bytenum+=1
            else:
                if data == (CheckSum&0xff):
                    print(get_angle(AngleData))
                CheckSum=0
                Bytenum=0
                FrameState=0


def get_acc(datahex):  #加速度
    axl = datahex[0]                                        
    axh = datahex[1]
    ayl = datahex[2]                                        
    ayh = datahex[3]
    azl = datahex[4]                                        
    azh = datahex[5]
    
    k_acc = 16

    acc_x = (axh << 8 | axl) / 32768 * k_acc
    acc_y = (ayh << 8 | ayl) / 32768 * k_acc
    acc_z = (azh << 8 | azl) / 32768 * k_acc
    if acc_x >= k_acc:
        acc_x -= 2 * k_acc
    if acc_y >= k_acc:
        acc_y -= 2 * k_acc
    if acc_z >= k_acc:
        acc_z-= 2 * k_acc
    
    return acc_x,acc_y,acc_z


def get_gyro(datahex):                                          #陀螺仪
    wxl = datahex[0]                                        
    wxh = datahex[1]
    wyl = datahex[2]                                        
    wyh = datahex[3]
    wzl = datahex[4]                                        
    wzh = datahex[5]
    k_gyro = 2000

    gyro_x = (wxh << 8 | wxl) / 32768 * k_gyro
    gyro_y = (wyh << 8 | wyl) / 32768 * k_gyro
    gyro_z = (wzh << 8 | wzl) / 32768 * k_gyro
    if gyro_x >= k_gyro:
        gyro_x -= 2 * k_gyro
    if gyro_y >= k_gyro:
        gyro_y -= 2 * k_gyro
    if gyro_z >=k_gyro:
        gyro_z-= 2 * k_gyro
    return gyro_x,gyro_y,gyro_z


def get_angle(datahex):                                 #角度
    rxl = datahex[0]                                        
    rxh = datahex[1]
    ryl = datahex[2]                                        
    ryh = datahex[3]
    rzl = datahex[4]                                        
    rzh = datahex[5]
    k_angle = 180

    angle_x = (rxh << 8 | rxl) / 32768 * k_angle
    angle_y = (ryh << 8 | ryl) / 32768 * k_angle
    angle_z = (rzh << 8 | rzl) / 32768 * k_angle
    if angle_x >= k_angle:
        angle_x -= 2 * k_angle
    if angle_y >= k_angle:
        angle_y -= 2 * k_angle
    if angle_z >=k_angle:
        angle_z-= 2 * k_angle

    return angle_x,angle_y,angle_z
 
 
if __name__=='__main__':  #主函数
    ser = serial.Serial("com8", 115200, timeout=0.5)  # 打开端口，改到循环外
    print(ser.is_open)
    while(1):
        #datahex = (ser.read(33).hex()) #之前转换成了字符串，一位变成了两位
        datahex = ser.read(33)       #不用hex()转化，直接用read读取的即是16进制
        DueData(datahex)            #调用程序进行处理

主要设计到数据读取的格式问题，进制问题，以及如何找到头数据，如何利用校验位。

另外，shift + tab可以往前缩进

#define IOBEGIN 22 
#define IOEND 53               //定义初始化的IO口
// the setup function runs once when you press reset or power the board
void setup() {
    Serial.begin(9600);         //初始化端口
    Serial.print("Ready");
    for(int i=IOBEGIN;i<=IOEND;i++)
    {  
        
        pinMode(i,OUTPUT);
    } 
}
 
// the loop function runs over and over again forever
void loop() {
  if(Serial.available()){
   char ch = Serial.read();        //读取串口
   Serial.print(ch);
   switch(ch){                     //根据传入信息判断工作模式
   case'1':
   digitalWrite(22,HIGH);
   digitalWrite(24,HIGH);
   break;
   case'2':
   digitalWrite(22,LOW);
   digitalWrite(24,LOW);
   break;
}}}

import serial
import time
import easygui

ACCData=[0.0]*8
GYROData=[0.0]*8
AngleData=[0.0]*8

FrameState = 0
Bytenum = 0
CheckSum = 0

shakedegree = 0

def DueData(inputdata):
    global  FrameState
    global  Bytenum
    global  CheckSum
    for data in inputdata:
        if FrameState==0:
            if data==0x55 and Bytenum==0:
                CheckSum=data
                Bytenum=1
                continue
            elif data==0x51 and Bytenum==1:
                CheckSum+=data
                FrameState=1
                Bytenum=2
            elif data==0x52 and Bytenum==1:
                CheckSum+=data
                FrameState=2
                Bytenum=2
            elif data==0x53 and Bytenum==1:
                CheckSum+=data
                FrameState=3
                Bytenum=2
        elif FrameState==1: # acc
            if Bytenum<10:
                ACCData[Bytenum-2]=data
                CheckSum+=data
                Bytenum+=1
            else:
                if data == (CheckSum&0xff):
                    #print(get_acc(ACCData))
                    accvalue = get_acc(ACCData)
                    return accvalue 
                CheckSum=0
                Bytenum=0
                FrameState=0
        elif FrameState==2: # gyro
            if Bytenum<10:
                GYROData[Bytenum-2]=data
                CheckSum+=data
                Bytenum+=1
            else:
                if data == (CheckSum&0xff):
                    pass
                    #print(get_gyro(GYROData))
                CheckSum=0
                Bytenum=0
                FrameState=0
        elif FrameState==3: # angle
            if Bytenum<10:
                AngleData[Bytenum-2]=data
                CheckSum+=data
                Bytenum+=1
            else:
                if data == (CheckSum&0xff):
                    pass#print(get_angle(AngleData))
                CheckSum=0
                Bytenum=0
                FrameState=0


def get_acc(datahex):  #加速度
    axl = datahex[0]                                        
    axh = datahex[1]
    ayl = datahex[2]                                        
    ayh = datahex[3]
    azl = datahex[4]                                        
    azh = datahex[5]
    
    k_acc = 16

    acc_x = (axh << 8 | axl) / 32768 * k_acc
    acc_y = (ayh << 8 | ayl) / 32768 * k_acc
    acc_z = (azh << 8 | azl) / 32768 * k_acc
    if acc_x >= k_acc:
        acc_x -= 2 * k_acc
    if acc_y >= k_acc:
        acc_y -= 2 * k_acc
    if acc_z >= k_acc:
        acc_z-= 2 * k_acc
    
    acc = [acc_x,acc_y,acc_z]
    return acc


def get_gyro(datahex):                                          #陀螺仪
    wxl = datahex[0]                                        
    wxh = datahex[1]
    wyl = datahex[2]                                        
    wyh = datahex[3]
    wzl = datahex[4]                                        
    wzh = datahex[5]
    k_gyro = 2000

    gyro_x = (wxh << 8 | wxl) / 32768 * k_gyro
    gyro_y = (wyh << 8 | wyl) / 32768 * k_gyro
    gyro_z = (wzh << 8 | wzl) / 32768 * k_gyro
    if gyro_x >= k_gyro:
        gyro_x -= 2 * k_gyro
    if gyro_y >= k_gyro:
        gyro_y -= 2 * k_gyro
    if gyro_z >=k_gyro:
        gyro_z-= 2 * k_gyro
    return gyro_x,gyro_y,gyro_z


def get_angle(datahex):                                 #角度
    rxl = datahex[0]                                        
    rxh = datahex[1]
    ryl = datahex[2]                                        
    ryh = datahex[3]
    rzl = datahex[4]                                        
    rzh = datahex[5]
    k_angle = 180

    angle_x = (rxh << 8 | rxl) / 32768 * k_angle
    angle_y = (ryh << 8 | ryl) / 32768 * k_angle
    angle_z = (rzh << 8 | rzl) / 32768 * k_angle
    if angle_x >= k_angle:
        angle_x -= 2 * k_angle
    if angle_y >= k_angle:
        angle_y -= 2 * k_angle
    if angle_z >=k_angle:
        angle_z-= 2 * k_angle

    return angle_x,angle_y,angle_z
 
def shakecharge(self):                #震颤判断函数
    ifshake = 0           #震颤次数
    ifshake_0 =0          #是否归零
    limit_a1 = 0.5
    limit_a2 = 0.8
    limit_a3 = 1.2        #震动分级
    interval_a = 5        #更新间隔
    acc_fre[0] = acc_fre[0] + 1 #重要！不能用变量，要用list
    global shakedegree
    shakedegree= shakedegree - 0.1    #十次平稳后切断
    print(acc_fre[0])
    if acc_fre[0] % interval_a == 0:  #采样
        acc_old[0] = acc[0]
        acc_old[1] = acc[1]
        acc_old[2] = acc[2]
    if acc_fre[0] % (interval_a * 10) == 0: #重置
        if ifshake == ifshake_0:           #如果没更新
            ifshake = ifshake_0 = 0
            print('——————重置！')
        else:                              #更新归零阈值
            ifshake_0 = ifshake
            print('******更新! ')
    else:
        pass
 
    if acc_fre[0] > interval_a*2 and (abs(acc[0] - acc_old[0]) > limit_a3 or acc[1] - acc_old[1] > limit_a3 or acc[2] - acc_old[2] > limit_a3) :
        print("===重度震颤!!!!!")   #LED灯亮
        shakedegree = 1
        #time.sleep(1)
        demo = b"1"
        ser1.write(demo)
        s = ser1.read(1)
        print(s)
    elif acc_fre[0] > interval_a*2 and (abs(acc[0] - acc_old[0]) > limit_a2 or acc[1] - acc_old[1] > limit_a2 or acc[2] - acc_old[2] > limit_a2):
        print("===中度震颤!!!!!")
        shakedegree = 1
        demo2 = b"1"
        ser1.write(demo2)
        #time.sleep(1)
        s = ser1.read(1)
        print(s)
        ifshake = 0
 
    elif acc_fre[0] > interval_a*2 and (abs(acc[0] - acc_old[0]) > limit_a1 or acc[1] - acc_old[1] > limit_a1 or acc[2] - acc_old[2] > limit_a1):
        print("===轻度震颤!!!!!")
        shakedegree = 1
        demo3 = b"1"
        ser1.write(demo3)
        #time.sleep(1)
        s = ser1.read(1)
        print(s)
        ifshake = 0
    else:
        shakedegree = shakedegree - 0.5
        print(shakedegree)
        if shakedegree < 0:
            demo4 = b"2"
            ser1.write(demo4)

if __name__=='__main__':
    ser1 = serial.Serial("com9", 9600)  # 打开Arduino端口
    #ser = serial.Serial("com8", 115200)  # 打开端口，改到循环外，避免一直开闭串口
    print(ser1.is_open)
    demo3 = b"1"
    ser1.write(demo3)
    acc_old = [0,0,0]
    acc_fre = [1]
    
    while(1):
        ser = serial.Serial("com8", 115200)  # 打开端口，放在循环内，可以避免连接不畅导致掉线
        datahex = ser.read(33)
        acc = DueData(datahex)
        if acc:
            print(acc)
            shakecharge(acc)
        #print(acc_fre)
        ser.close()
        time.sleep(0.2)

读取并记录到本地csv文件。

import pandas as pd
import numpy as np

#txt = np.loadtxt('2020-05-31.txt')
import serial
import os
import time
import csv
ACCData = [0.0] * 8
GYROData = [0.0] * 8
AngleData = [0.0] * 8  # 定义三个数组，分别存储加速度角速度与角度的值

FrameState = 0  # 通过0x后面的值判断属于哪一种情况
Bytenum = 0  # 读取到这一段的第几位
CheckSum = 0  # 求和校验位


def DueData(inputdata):  # 新增的核心程序，对读取的数据进行划分，各自读到对应的数组里
    global FrameState  # 在局部修改全局变量，要进行global的定义
    global Bytenum
    global CheckSum
    for data in inputdata:  # 在输入的数据进行遍历
        if FrameState == 0:  # 当未确定状态的时候，进入以下判断
            if data == 0x55 and Bytenum == 0:  # 0x55位于第一位时候，开始读取数据，增大bytenum
                CheckSum = data
                Bytenum = 1
                continue
            elif data == 0x51 and Bytenum == 1:  # 在byte不为0 且 识别到 0x51 的时候，改变frame
                CheckSum += data
                FrameState = 1
                Bytenum = 2
            elif data == 0x52 and Bytenum == 1:  # 同理
                CheckSum += data
                FrameState = 2
                Bytenum = 2
            elif data == 0x53 and Bytenum == 1:
                CheckSum += data
                FrameState = 3
                Bytenum = 2
        elif FrameState == 1:  # acc    #已确定数据代表加速度
            if Bytenum < 10:  # 读取8个数据
                ACCData[Bytenum - 2] = data  # 从0开始
                CheckSum += data
                Bytenum += 1
            else:
                if data == (CheckSum & 0xff):  # 假如校验位正确
                    print('加速度',get_acc(ACCData))
                    newacc = get_acc(ACCData)
                    file_write_obj.writelines(newacc)
                 #   file_write_obj.write('\n')
                CheckSum = 0  # 各数据归零，进行新的循环判断
                Bytenum = 0
                FrameState = 0
        elif FrameState == 2:  # gyro
            if Bytenum < 10:
                GYROData[Bytenum - 2] = data
                CheckSum += data
                Bytenum += 1
            else:
                if data == (CheckSum & 0xff):
                    print('角速度',get_gyro(GYROData))
                    newgyro = get_gyro(GYROData) #文件写入
                    file_write_obj.writelines(newgyro)
                   # file_write_obj.write('\n')
                CheckSum = 0
                Bytenum = 0
                FrameState = 0
        elif FrameState == 3:  # angle
            if Bytenum < 10:
                AngleData[Bytenum - 2] = data
                CheckSum += data
                Bytenum += 1
            else:
                if data == (CheckSum & 0xff):
                    print('角度',get_angle(AngleData))
                    newangle = get_angle(AngleData)
                    file_write_obj.writelines(newangle)
                    file_write_obj.write('\n')
                CheckSum = 0
                Bytenum = 0
                FrameState = 0


def get_acc(datahex):  # 加速度
    axl = datahex[0]
    axh = datahex[1]
    ayl = datahex[2]
    ayh = datahex[3]
    azl = datahex[4]
    azh = datahex[5]

    k_acc = 16

    acc_x = (axh << 8 | axl) / 32768 * k_acc
    acc_y = (ayh << 8 | ayl) / 32768 * k_acc
    acc_z = (azh << 8 | azl) / 32768 * k_acc
    if acc_x >= k_acc:
        acc_x -= 2 * k_acc
    if acc_y >= k_acc:
        acc_y -= 2 * k_acc
    if acc_z >= k_acc:
        acc_z -= 2 * k_acc

    return str(acc_x)+',', str(acc_y)+',', str(acc_z)+','


def get_gyro(datahex):  # 陀螺仪
    wxl = datahex[0]
    wxh = datahex[1]
    wyl = datahex[2]
    wyh = datahex[3]
    wzl = datahex[4]
    wzh = datahex[5]
    k_gyro = 2000

    gyro_x = (wxh << 8 | wxl) / 32768 * k_gyro
    gyro_y = (wyh << 8 | wyl) / 32768 * k_gyro
    gyro_z = (wzh << 8 | wzl) / 32768 * k_gyro
    if gyro_x >= k_gyro:
        gyro_x -= 2 * k_gyro
    if gyro_y >= k_gyro:
        gyro_y -= 2 * k_gyro
    if gyro_z >= k_gyro:
        gyro_z -= 2 * k_gyro
    return str(gyro_x)+',', str(gyro_y)+',', str(gyro_z)+','


def get_angle(datahex):  # 角度
    rxl = datahex[0]
    rxh = datahex[1]
    ryl = datahex[2]
    ryh = datahex[3]
    rzl = datahex[4]
    rzh = datahex[5]
    k_angle = 180

    angle_x = (rxh << 8 | rxl) / 32768 * k_angle
    angle_y = (ryh << 8 | ryl) / 32768 * k_angle
    angle_z = (rzh << 8 | rzl) / 32768 * k_angle
    if angle_x >= k_angle:
        angle_x -= 2 * k_angle
    if angle_y >= k_angle:
        angle_y -= 2 * k_angle
    if angle_z >= k_angle:
        angle_z -= 2 * k_angle

    return str(angle_x)+',', str(angle_y)+',', str(angle_z)+','


if __name__ == '__main__':  # 主函数
    ser = serial.Serial("com8", 115200, timeout=0.5)  # 打开端口，改到循环外
    print(ser.is_open)
    Time = time.strftime("%Y-%m-%d") #记录当前时间
    file_write_obj = open(Time+".txt", 'w') #建立记录文件
    file_write_obj.write('ax,ay,az,gx,gy,gz,anx,any,anz')
    file_write_obj.write('\n')
    while (1):
        # datahex = (ser.read(33).hex()) #之前转换成了字符串，一位变成了两位
        datahex = ser.read(33)  # 不用hex()转化，直接用read读取的即是16进制
        print(len(datahex))
        print('原始数据',datahex[0:15])
        print('        ', datahex[15:])
        DueData(datahex)  # 调用程序进行处理
        with open('csv数据2.csv', 'w+', newline='') as csvfile:
            spamwriter = csv.writer(csvfile, dialect='excel')
            # 读要转换的txt文件，文件每行各词间以字符分隔
            with open(Time+".txt", 'r', encoding='utf-8') as filein:
                for line in filein:
                    line_list = line.strip('\n').split(',')  # 我这里的数据之间是以 ; 间隔的
                    spamwriter.writerow(line_list)
    file_write_obj.close()

 

Initial-T
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
python 实现RFID串口数据读取（csdn）————程序.pdf
12-03
python 实现RFID串口数据读取（csdn）————程序
python+嵌入式——串口通信篇(收发解包)
scarecrow_sun的博客
03-05 1万+
python利用pyserial读取串口数据，包含一些总结和官方文档参数的说明。 且包含利用struct模块进行解包操作
Espressif 玩转串口解析(FreeRTOS-Plus-CLI)
嵌入式攻城狮
11-30 1350
FreeRTOS-Plus-CLI (Command Line Interface) 简单点说就是提供了一种简单、小巧、易于扩展且占用 RAM 资源极少的方法，可以在 FREERTOS 的应用上处理命令行输入。
嵌入式系统开发环境下，STM32的USART串口通讯程序编译教程（查询方式）及波形时序状态分析
qq_53112972的博客
10-15 1050
在嵌入式系统开发环境下，通过STM32系统与上位机（win10）的连接，完成一个简单的“hello windows！”串口通讯程序
C 解析串口数据
weixin_40872563的博客
07-09 6790
最近面试，收到一份面试题，特此研究下C的串口解析 题目要求如下： 用C语言写一个程序，此程序持续从串口读取数据（串口速率是115200，偶校验），串口数据有可能包含DL-T 645协议格式或者DL-T 698协议格式的数据帧（协议见word文档）。 要求把收到的符合以上两种格式的数据帧检出来。 附加要求：注意程序的可扩展性（如果以后此程序再支持其他协议数据解析，要容易扩展）。* 由于文档比较...
学习日记---蓝桥杯嵌入式---串口通信之字符串接收（中断方式）
weixin_44650111的博客
08-15 1940
学习日记—蓝桥杯嵌入式—串口通信之字符串接收（中断方式） 上次学习了单字符接收触发标志位发送查询指令的方式，但是字符串的自己没调通，zhe现在看看大佬的写法！ 啊哈！！！基于原版改进辣！ 一、功能描述: 程序里设置的是如果收到10个字符或者收到字符’S’就会停止接收触发发送。同时收到的东西发送函数再发回来，屏幕上也会显示。 二、固件库相关文件 usart下面的interrupt文件夹和printf文件夹 interrupt函数内完成配置，在单字符串口通信讲过了。这里的接收中断函数依然需要调用it.c中的
C#上位机开发-串口通信，读取并处理数据
03-13
将串口传输的16进制数据转换成需要的数据的上位机，并且显示数据 适合需要读取串口数据的项目
IMU原始数据串口读取.rar_imu 数据接口_imu输出bin格式_串口数据读取_串口读取IMU
07-14
通过串口读取IMU输出的原始数据，并解析
读取串口数据并画实时曲线的VC++程序源码.rar_collegep6x_vc 曲线_vc 画图_vc++动态曲线_数据处理 曲
07-14
通过串口读取数据，将读取回来的数据分析处理，然后通过曲线形式显示出来。
Python实现对串口数据的读取以及界面显示
最新发布
04-28
Python实现对串口数据的读取以及界面显示，很简单，希望能对各位有帮助。
【嵌入式系统开发13】采用串口中断方式完成单字符接受与字符串接受
旺仔的鹏鹏
10-23 422
本文目的是主要介绍通过STM32F103C8T6接收到字符“s”时，停止持续发送“hello windows!”; 当接收到字符“t”时，持续发送“hello windows!”；接收到字符“stop stm32!”时，停止持续发送“hello windows!”; 当接收到字符“go stm32!”时，持续发送“hello windows!”。
串口系统调用(read，write)中的一些注意事项和优化
瞧，那小子真帅
06-01 1206
在使用涉及到系统调用的编程中，操作的文件描述符诸如管道之类的，获设备节点之类的(比如串口，USB口中讲usb作为camera的），涉及到内核态和用户态的数据读写，这时候经常遇到读写达不到 理想，本文编写方式先列出问题点，后面给出对应的解决方案。该文章主要针对系统调用注意事项，未完待续…在串口编程中， 即使使用方式获取到内核态有数据可读，也可能无法满足你想的结果。比如算出需要读10个字节(理论按照私有协议有10字节才是一个完整包)，有一定概率出现读小于10个字节的数据， 原因为因此针对该问题使用如下替代方案:
嵌入式系统与PC串口通讯的实现
yongye2007的专栏
02-23 1295
1、任务 PC端：windows XP操作系统，VS2005开发环境，使用C#制作一简单通讯程序。 嵌入式系统端：CPU内核为ARM9，运行嵌入式操作系统，编写串口驱动程序及通讯程序。   2、实现 PC端底层：windows驱动已很完善，直接调用库中的SerialPort，设置波特率等，即可实现简单收发。 PC端上层：C#实现简单的界面，包含系统连接按钮，通讯按钮，一个信息窗。 为
单片机多字节串口接收（转）
weixin_30859423的博客
01-23 7850
转自：http://bbs.ednchina.com/BLOG_ARTICLE_3007162.HTM 工作了一年多，写了不少单片机串口程序。感觉串口多字节接收部分的逻辑相对于配置寄存器跟串口回复来说，是有点难度的——寄存器配置基本上都是死的，串口回复多字节跟回复一字节只是多了一个循环。 串口接收程序是基于串口中断的，单片机的串口每次接收到一字节数据产生一次中断，然后...
arduino串口读取多个字节（USART_HMI屏示例）
热门推荐
huanghaoAudio的博客
03-13 1万+
1、读取多个字节用于读取字节，比读取字符串优势在于可以读取大于0x7f的数据，因为字符串读取法读取的数据不能大于0x7f。void setup() { Serial.begin(115200);//配置触摸屏通讯串口波特率 } void loop() { USART_HMI(); } void USART_HMI() { int i; byte comdata[20]...
单片机串口通信的多字节传输
You can do more than just get by.
04-24 5658
题目： 一个8XX51单片机的双机通信系统波特率为9600bps，fosc=12MHz，用中断方式编写程序，将甲机片内RAM 30H ~ 3FH的数据块通过串行口传送到乙机的片内RAM 40 ~ 4FH单元中。 串口通信是一个字节一个字节的发送与接收 那这怎么解决呢？ 我们单片机的晶振与我们设置的波特率有关了，采用时钟周期为11.0592Mhz的晶振时，误差为0；当我们采用12Mhz的晶振时，波特率越大误差越大， 这个时候一般常常使用波特率加倍减小误差。
嵌入式操作系统开发板中的串口编程——光敏电阻数据读取
zhm1949的博客
04-25 1144
嵌入式操作系统开发板中的串口编程——光敏电阻数据读取 在嵌入式操作系统开发板中一般都会拥有几个串口UART驱动，我们只需要应用程序中打开UART设备节点，初始化设置UART，比如设置停止位、数据位、奇偶校验位、波特率等，这些Linux操作系统给我们提供了现成的结构体，我们只需要调用结构体，设置相应的标志位即可。 下面的程序首先对串口进行初始化设置。 #include <stdio.h> #include <sys/types.h> #include <sys/stat.h&gt
嵌入式Linux串口应用编程之串口读写
gougouhai1212的专栏
08-27 1296
2013-08-27 在配置完串口的相关属性后，就可以对串口进行打开和读写操作了。它所使用的函数和普通文件的读写函数一样，都是open()、write()和read()。它们之间区别的只是串口是一个终端设备，因此在选择函数的具体参数时会有一些区别。另外，这里会用到一些附加的函数，用于测试终端设备的连接情况等。下面将对其进行具体讲解。     1．打开串口     打开串口和打开普通文件一样，
Python的串口通信（pyserial）
m0_59485658的博客
01-04 7300
串口通信是指外设和计算机间，通过数据信号线 、地线、控制线等，按位进行传输数据的一种通讯方式。这种通信方式使用的数据线少，在远距离通信中可以节约通信成本，但其传输速度比并行传输低。串口是计算机上一种非常通用的设备通信协议。pyserial模块封装了python对串口的访问，为多平台的使用提供了统一的接口。
嵌入式开发板接收串口数据
12-12
嵌入式开发板接收串口数据需要进行串口收发程序设计。以下是一个简单的串口接收程序的Python示例： ```python import serial ser = serial.Serial('/dev/ttyS0', 9600) # 打开串口，波特率为9600 while True: ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值