Python实现——CAN报文转换工具

最新推荐文章于 2024-03-05 22:48:44 发布
最新推荐文章于 2024-03-05 22:48:44 发布
阅读量2.8w 收藏 219
点赞数 20
分类专栏： Python 文章标签： Python CAN报文
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rectsuly/article/details/76126269
版权

一.CAN报文简介


CAN是控制器局域网络(Controller Area Network, CAN)的简称，是由以研发和生产汽车电子产品著称的德国BOSCH公司开发的，并最终成为国际标准（ISO 11898），是国际上应用最广泛的 现场总线 之一。 在北美和西欧，CAN总线 协议 已经成为 汽车计算机控制系统 和嵌入式工业控制局域网的标准总线，并且拥有以CAN为底层协议专为大型货车和重工机械车辆设计的J1939协议。

CAN总线以报文为单位进行数据传送。CAN报文按照帧格式可分为标准帧和扩展帧，标准帧是具有11位标识符的CAN帧，扩展帧是具有29位标识符的CAN帧。按照帧类型可分为：1.从发送节点向其它节点发送数据；2.远程帧：向其它节点请求发送具有同一识别符的数据帧；3.错误帧：指明已检测到总线错误；4.过载帧：过载帧用以在数据帧（或远程帧）之间提供一附加的延时。共有两种编码格式：Intel格式和Motorola格式，在编码优缺点上，Motorola格式与Intel格式并没有孰优孰劣之分，只不过根据设计者的习惯，由用户自主选择罢了。当然，对于使用者来讲，在进行解析之前，就必须要知道编码的格式是哪一种，否则，就不能保证正确地解析信号的含义。以下就以8位字节编码方式的CAN总线信号为例，详细分析一下两者之间的区别。

Intel编码格式
当一个信号的数据长度不超过1个字节（8位）并且信号在一个字节内实现（即该信号没有跨字节实现）：该信号的高位（S_msb）将被放在该字节的高位，信号的低位（S_lsb）将被放在该字节的低位。
当一个信号的数据长度超过1个字节（8位）或者数据长度不超过一个字节但是采用跨字节方式实现时：该信号的高位（S_msb）将被放在高字节（MSB）的高位，信号的低位（S_lsb）将被放在低字节（LSB）的低位。
Motorola编码格式
当一个信号的数据长度不超过1个字节（8位）并且信号在一个字节内实现（即该信号没有跨字节实现）：该信号的高位（S_msb）将被放在该字节的高位，信号的低位（S_lsb）将被放在该字节的低位。
当一个信号的数据长度超过1个字节（8位）或者数据长度不超过一个字节但是采用跨字节方式实现时：该信号的高位（S_msb）将被放在低字节（MSB）的高位，信号的低位（S_lsb）将被放在高字节（LSB）的低位。
可以看出，当一个信号的数据长度不超过1Byte时，Intel与Motorola两种格式的编码结果没有什么不同，完全一样。当信号的数据长度超过1Byte时，两者的编码结果出现了明显的不同。

二.CAN报文转换工具需求分析


1、 支持标准帧的CAN报文的转换，扩展帧暂不支持
2、 CAN报文支持Intel、motorola两种编码，先支持motorola格式，后期追加Intel格式
3、 工具具有一定的容错处理能力、报告生成能力
4、 制定统一格式，方便使用者修改测试脚本
5、增加交互模式，键盘输入，控制台输出；例如：
提示语：startBit:length:minValue:maxValue:setValue
输入：35:1:0:1:1
或：35:1:::1
控制台输出：00 00 00 00 08 00 00 00

Intel和Motorola编码举例：




三.交互模式


代码如下： 
import sys
print("----------------欢迎使用CAN报文转换工具交互模式----------------")
print("请输入CAN信号,格式为:startBit:length:minValue:maxValue:setValue")
print("例如：32:1:0:1:1")
print("或者省略minValue和maxValue：35：1：：：1")
print("信号输入结束请再按一次回车")

#十进制转换成二进制list
def octToBin(octNum, bit):
    while(octNum != 0):
        bit.append(octNum%2)
        octNum = int(octNum/2)
    for i in range(64-len(bit)):
        bit.append(0)

sig = []
startBit = []
length = []
setValue = []
#输入CAN信号
while True:
    input_str = input()
    if not len(input_str):
        break
    if(input_str.count(":")<4):
        print("输入格式错误，参数缺少setValue,请重新输入！")
        continue
    if(input_str.split(":")[4]==""):
        print("setValue参数不能为空，请重新输入！")
        continue
    sig.append(input_str)
#解析CAN信号
for i in range(len(sig)):
    startBit.append(int(sig[i].split(":")[0]))
    length.append(int(sig[i].split(":")[1]))
    setValue.append(int(sig[i].split(":")[4]))
#CAN数组存放CAN报文值   
CAN = []
for i in range(64):
    CAN.append(-1)
for i in range(len(startBit)):
    #长度超过1Byte的情况，暂不支持
    if(length[i]>16):
        print("CAN信号长度超过2Byte，暂不支持！！！")
        sys.stdin.readline()
        sys.exit()
    #长度未超过1Byte的情况且未跨字节的信号
    if((startBit[i]%8 + length[i])<=8):
        for j in range(length[i]):
            bit = []
            #setValue的二进制值按字节位从低到高填
            octToBin(setValue[i],bit)
            #填满字节长度值
            if(CAN[startBit[i]+j]==-1):
                CAN[startBit[i]+j] = bit[j]
            #字节存在冲突
            else:
                print(sig[i] + "字节位存在冲突，生成CAN报文失败！！！")
                sys.stdin.readline()
                sys.exit()
    #跨字节的信号
    else:
        #高位位数和低位位数
        highLen = 8 - startBit[i]%8
        lowLen = length[i] - highLen
        bit = []
        #setValue的二进制值按字节位从低到高填
        octToBin(setValue[i],bit)
        #先填进信号的高位
        for j1 in range(highLen):
            if(CAN[startBit[i]+j1]==-1):
                CAN[startBit[i]+j1] = bit[j1]
            #字节存在冲突
            else:
                print(sig[i] + "字节位存在冲突，生成CAN报文失败！！！")
                sys.stdin.readline()
                sys.exit()
        #再填进信号的低位
        for j2 in range(lowLen):
            if(CAN[(int(startBit[i]/8)-1)*8+j2]==-1):
                CAN[(int(startBit[i]/8)-1)*8+j2] = bit[highLen+j2]
            #字节存在冲突
            else:
                print(sig[i] + "字节位存在冲突，生成CAN报文失败！！！")
                sys.stdin.readline()
                sys.exit()
#剩余位默认值设为0
for i in range(64):
    if(CAN[i]==-1):
        CAN[i] = 0
#----------------将二进制list每隔8位转换成十六进制输出----------------
#其中，map()将list中的数字转成字符串，按照Motorola格式每隔8位采用了逆序
# ''.join()将二进制list转换成二进制字符串，int()将二进制字符串转换成十进制
#hex()再将十进制转换成十六进制，upper()转换成大写，两个lstrip()将"0X"删除,
#zfill()填充两位，输出不换行，以空格分隔
print(hex(int(''.join(map(str,CAN[7::-1])),2)).upper().lstrip("0").lstrip("X").zfill(2) + " ",end="")
print(hex(int(''.join(map(str,CAN[15:7:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2) + " ",end="")
print(hex(int(''.join(map(str,CAN[23:15:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2) + " ",end="")
print(hex(int(''.join(map(str,CAN[31:23:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2) + " ",end="")
print(hex(int(''.join(map(str,CAN[39:31:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2) + " ",end="")
print(hex(int(''.join(map(str,CAN[47:39:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2) + " ",end="")
print(hex(int(''.join(map(str,CAN[55:47:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2) + " ",end="")
print(hex(int(''.join(map(str,CAN[63:55:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2))

运行截图：


错误提示：


四.配置项模式


配置文件如下： 

##注释
::start
#编码格式：0=Intel；1=Motorola
encodeType=1
#帧格式：0=标准帧；1=扩展帧；
canMode=0
#帧类型：0=数据帧；...
canType=0
#默认初始值(0~1)
defaultValue=0
#MSG定义
msgName=BCM_FrP01
msgID=0x2CD
#长度（BYTE）
msgLength=8
#signal定义
#sigName=name:startBit:length:minValue:maxValue:setValue
#sigName=ReverseSw:25:6:0:1:13
#sigName=Trunk_BackDoor_Sts:33:2:0:1:2
#sigName=DRVUnlockState:37:2:0:1:3
#sigName=HeadLampLowBeam:40:8:0:1:60
#sigName=HoodStatus:51:1:0:1:0
#sigName=HeadLampHighBeam:52:1:0:1:0
#sigName=RLDoorStatus:59:1:0:1:0
#sigName=RRDoorStatus:58:1:0:1:0
#sigName=PsgDoorStatus:57:2:0:1:0
sigName=One:0:8:0:255:165
sigName=Two:24:12:0:4095:1701
sigName=Three:54:5:0:31:25
::end
::start
#编码格式：0=Intel；1=Motorola
encodeType=1
#帧格式：0=标准帧；1=扩展帧；
canMode=0
#帧类型：0=数据帧；...
canType=0
#默认初始值(0~1)
defaultValue=0
#MSG定义
msgName=BCM_FrP
msgID=0x2CD
#长度（BYTE）
msgLength=8
#signal定义
#sigName=name:startBit:length:minValue:maxValue:setValue
#sigName=ReverseSw:25:6:0:1:13
#sigName=Trunk_BackDoor_Sts:33:2:0:1:2
#sigName=DRVUnlockState:37:2:0:1:3
#sigName=HeadLampLowBeam:40:8:0:1:60
#sigName=HoodStatus:51:1:0:1:0
#sigName=HeadLampHighBeam:52:1:0:1:0
#sigName=RLDoorStatus:59:1:0:1:0
#sigName=RRDoorStatus:58:1:0:1:0
#sigName=PsgDoorStatus:57:2:0:1:0
sigName=One:35:1:0:1:1
::end
代码如下： 

#!/usr/bin/python
defaultValue = 0
sigName = []
startBit = []
length = []
minValue = []
maxValue = []
setValue = []
#CAN数组存放CAN报文值
CAN = []
logFile = open("log.txt","w")
def parseConfig():
    config = open("Config.txt","r")
    
    count = 0
    isError = False
    for line in config:
        line = line.strip()
        #注释
        if(line.find("#")>=0):
            continue
        #开始标记
        elif(line.find("::start")>=0):
            count = count + 1
            isError = False
            if(count>1):
                sigName.clear()
                startBit.clear()
                length.clear()
                setValue.clear()
                continue
            else:
                continue
        elif(isError == True):
            continue
        #编码格式
        elif(line.find("encodeType")>=0):
            encodeType = line.split("=")[1]
            if(encodeType != "1"):
                isError = True
                print(str(count) + ". CAN报文生成失败！！！目前仅支持Motorola编码格式，暂不支持Intel编码格式！")
                logFile.write("%d. CAN报文生成失败！！！目前仅支持Motorola编码格式，暂不支持Intel编码格式！\n" % count)
                continue
        #帧格式
        elif(line.find("canMode")>=0):
            canMode = line.split("=")[1]
            if(canMode != "0"):
                isError = True
                print(str(count) + ". CAN报文生成失败！！！目前仅支持标准帧，暂不支持扩展帧！")
                logFile.write("%d. CAN报文生成失败！！！目前仅支持标准帧，暂不支持扩展帧！\n" % count)
                continue
        #帧类型
        elif(line.find("canType")>=0):
            canType = line.split("=")[1]
            if(canType != "0"):
                isError = True
                print(str(count) + ". CAN报文生成失败！！！目前仅支持数据帧，暂不支持其他帧！")
                logFile.write("%d. CAN报文生成失败！！！目前仅支持数据帧，暂不支持其他帧！\n" % count)
                continue
        #默认初始值
        elif(line.find("defaultValue")>=0):
            global defaultValue
            defaultValue = int(line.split("=")[1])
        #MSG名称
        elif(line.find("msgName")>=0):
            msgName = line.split("=")[1]
        #MSGID
        elif(line.find("msgID")>=0):
            msgID = line.split("=")[1]
        #MSG长度
        elif(line.find("msgLength")>=0):
            msgLength = line.split("=")[1]
        #signal定义
        elif(line.find("sigName")>=0):
            sigName.append(line.split(":")[0].split("=")[1])
            startBit.append(int(line.split(":")[1]))
            length.append(int(line.split(":")[2]))
            #minValue.append(int(line.split(":")[3]))
            #maxValue.append(int(line.split(":")[4]))
            setValue.append(int(line.split(":")[5]))
        elif(line.find("::end")>=0):
            
            rV,errMsg = getCANMessage()
            if(rV == "-1"):
                isError = True
                print(str(count) + ". CAN报文生成失败！！！" + errMsg)
                logFile.write("%d. CAN报文生成失败！！！%s\n" % (count,errMsg))
                continue
            
            print(str(count) + ". CAN报文生成成功！！！")
            logFile.write("%d. CAN报文生成成功！！！\n" % count)
            #----------------------------输出标题信息----------------------------
            print("msgName\t\tmsgID\t\tmsgLen\t\tmsgData")
            logFile.write("msgName\t\tmsgID\t\tmsgLen\t\tmsgData\n")
            if(len(msgName)<8):
                print(msgName + "\t\t",end="")
                logFile.write("%s\t\t" % msgName)
            else:
                print(msgName + "\t",end="")
                logFile.write("%s\t" % msgName)
            print(msgID + "\t\t",end="")
            logFile.write("%s\t\t" % msgID)
            print(msgLength + "\t\t",end="")
            logFile.write("%s\t\t" % msgLength)
            #----------------将二进制list每隔8位转换成十六进制输出----------------
            #其中，map()将list中的数字转成字符串，按照Motorola格式每隔8位采用了逆序
            # ''.join()将二进制list转换成二进制字符串，int()将二进制字符串转换成十进制
            #hex()再将十进制转换成十六进制，upper()转换成大写，两个lstrip()将"0X"删除,
            #zfill()填充两位，输出不换行，以空格分隔
            print(hex(int(''.join(map(str,CAN[7::-1])),2)).upper().lstrip("0").lstrip("X").zfill(2) + " ",end="")
            print(hex(int(''.join(map(str,CAN[15:7:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2) + " ",end="")
            print(hex(int(''.join(map(str,CAN[23:15:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2) + " ",end="")
            print(hex(int(''.join(map(str,CAN[31:23:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2) + " ",end="")
            print(hex(int(''.join(map(str,CAN[39:31:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2) + " ",end="")
            print(hex(int(''.join(map(str,CAN[47:39:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2) + " ",end="")
            print(hex(int(''.join(map(str,CAN[55:47:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2) + " ",end="")
            print(hex(int(''.join(map(str,CAN[63:55:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2))
            logFile.write("%s " % hex(int(''.join(map(str,CAN[7::-1])),2)).upper().lstrip("0").lstrip("X").zfill(2))
            logFile.write("%s " % hex(int(''.join(map(str,CAN[15:7:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2))
            logFile.write("%s " % hex(int(''.join(map(str,CAN[23:15:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2))
            logFile.write("%s " % hex(int(''.join(map(str,CAN[31:23:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2))
            logFile.write("%s " % hex(int(''.join(map(str,CAN[39:31:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2))
            logFile.write("%s " % hex(int(''.join(map(str,CAN[47:39:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2))
            logFile.write("%s " % hex(int(''.join(map(str,CAN[55:47:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2))
            logFile.write("%s\n" % hex(int(''.join(map(str,CAN[63:55:-1])),2)).upper().lstrip("0").lstrip("X").zfill(2))
            
    config.close()

#十进制转换成二进制list            
def octToBin(octNum, bit):
    while(octNum != 0):
        bit.append(octNum%2)
        octNum = int(octNum/2)
    for i in range(64-len(bit)):
        bit.append(0)

#获取CAN报文值
def getCANMessage():
    CAN.clear()
    for i in range(64):
        CAN.append(-1)
    for i in range(len(startBit)):
        #长度超过1Byte的情况，暂不支持
        if(length[i]>16):
            errMsg = " CAN信号长度超过2Byte，暂不支持！！！"
            #print(sigName[i] + errMsg)
            return "-1",errMsg
        #长度未超过1Byte的情况且未跨字节的信号
        if((startBit[i]%8 + length[i])<=8):
            for j in range(length[i]):
                bit = []
                #setValue的二进制值按字节位从低到高填
                octToBin(setValue[i],bit)
                #填满字节长度值
                if(CAN[startBit[i]+j]==-1):
                    CAN[startBit[i]+j] = bit[j]
                #字节存在冲突
                else:
                    errMsg = " 字节位存在冲突，生成CAN报文失败！！！"
                    #print(sigName[i] + errMsg)
                    return "-1",errMsg
        #跨字节的信号
        else:
            #高位位数和低位位数
            highLen = 8 - startBit[i]%8
            lowLen = length[i] - highLen
            bit = []
            #setValue的二进制值按字节位从低到高填
            octToBin(setValue[i],bit)
            #先填进信号的高位
            for j1 in range(highLen):
                if(CAN[startBit[i]+j1]==-1):
                    CAN[startBit[i]+j1] = bit[j1]
                #字节存在冲突
                else:
                    errMsg = " 字节位存在冲突，生成CAN报文失败！！！"
                    #print(sigName[i] + errMsg)
                    return "-1",errMsg
            #再填进信号的低位
            for j2 in range(lowLen):
                if(CAN[(int(startBit[i]/8)-1)*8+j2]==-1):
                    CAN[(int(startBit[i]/8)-1)*8+j2] = bit[highLen+j2]
                #字节存在冲突
                else:
                    errMsg = " 字节位存在冲突，生成CAN报文失败！！！"
                    #print(sigName[i] + errMsg)
                    return "-1",errMsg
    #剩余位设为默认值
    for i in range(64):
        if(CAN[i]==-1):
            CAN[i] = defaultValue
    
    #若无错误则返回正确值
    return "0","success!"

if __name__ == "__main__":
    #调用parseConfig()函数开始执行程序
    parseConfig()

运行结果： 

1. CAN报文生成成功！！！
msgName		msgID		msgLen		msgData
BCM_FrP01	0x2CD		8		A5 00 06 A5 00 06 40 00
2. CAN报文生成成功！！！
msgName		msgID		msgLen		msgData
BCM_FrP		0x2CD		8		00 00 00 00 08 00 00 00








rectsuly
关注
  • 20
    点赞
  • 踩
  • 219
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Python实现CAN报文转换工具教程
09-16
主要介绍了Python实现CAN报文转换工具教程，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
【CAN信号解析】使用python-can/cantools解析CAN数据
All_In_gzx_cc的博客
09-27 3940
用python分析asc，blf等格式数据，python-can这个包是必备的cantools这个包虽然理论上非必须，但用它处理起来更方便。另外cantools这个包本身依赖python-can，所以直接装个cantools就能直接上手干了。另外，要分析asc, blf格式的数据，还得需要相应的数据库文件，也就是.dbc或.arxml文件。DBC（Database Container）是一种CAN数据定义文件，用于描述车辆网络系统中的消息、信号和节点之间的关系和通信规则。
如何用python实现Can总线通讯
willluckysmile的博客
03-05 567
今天去广交会参展， 里面关于工业， 有很多基于profinet、can等总线通讯协议的硬件网关， 好像总线协议一般都用于硬件嵌入式层面， 纯软方面很少涉及， 那如何使用python进行Can总线通讯呢？在Python中实现CAN通讯，可以使用现成的库来简化这个过程。此外，CAN协议是复杂的，有很多细节，比如帧类型（数据帧、远程帧、错误帧等）、错误处理、同步等。在实际应用中，你需要根据CAN总线的具体协议和你的应用场景来调整代码。）取决于你的硬件设备。你可能需要查看你的硬件文档来确定正确的接口名称。
Python库 | cantools-28.19.0.tar.gz
05-12
资源分类：Python库 所属语言：Python 资源全名：cantools-28.19.0.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
BLF文件格式介绍文档
11-05
vector blf文件格式介绍文档，参考博文：https://blog.csdn.net/zhyongquan/article/details/80459099
Python库 | cantools-22.0.1.tar.gz
04-07
资源分类：Python库 所属语言：Python 资源全名：cantools-22.0.1.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
python-can简述
qq_21649903的博客
04-21 1万+
摘要：最近用到python-can，发现网上参考资料实在不多，也缺乏一定的系统性，特此进行一番整理。——by catmemo 1、简述 python-can库为Python提供了控制器局域网的支持，为不同的硬件设备提供了通用的抽象，并提供了一套实用程序，用于在CAN总线上发送和接收消息。 python-可以在Python运行的任何地方运行； 从具有商用CAN的高功率计算机到USB设备，再到运行Linux的低功率设备（例如BeagleBone或RaspberryPi）。 更具体地说，该库的一些示例用法如下.
Python之python-can
PlutoZuo的博客
10-07 1542
Python-can介绍
python-can介绍
qq_45303968的博客
08-02 8428
python-can 库为 Python 提供控制器局域网支持，为不同的硬件设备提供通用抽象，以及一套用于在 CAN 总线上发送和接收消息的实用程序。python-can 可以在任何 Python 运行的地方运行；从 CAN 的高功率计算机到 USB 设备，再到运行 linux 的低功率设备，例如 BeagleBone 或 RaspberryPi。............
Python实现CAN通讯
sinat_35773915的博客
07-25 3459
CAN通讯是一种高可靠性、高效率的通信协议，具有抗干扰能力强、高可靠性、高效率和支持多节点等特点。它在汽车、工业控制、航空航天和医疗设备等领域得到广泛应用，成为实时应用通信的重要技术。Python-can 是一个功能强大的 Python 库，用于控制和通信汽车网络。它提供了一组简单易用的接口和工具，用于发送和接收 CAN 消息，以及解析和处理 CAN 数据。通过它，可以轻松地与 CAN 总线进行通信，并与汽车和工业领域的电子控制单元进行交互。
python-can使用总结
小仙女的博客
10-10 6257
python-can的使用，cantools解析DBC数据
一阶卡尔曼滤波python实现——已封装
07-19
一阶卡尔曼滤波python实现——已封装
python项目——智慧校园考试系统.zip
04-15
python项目——智慧校园考试系统.zip python项目——智慧校园考试系统.zip python项目——智慧校园考试系统.zip python项目——智慧校园考试系统.zip python项目——智慧校园考试系统.zip python项目——智慧校园...
二项堆python实现——eager binomial heap
06-21
eager binomial heaps python实现。使用双向链表，make_heap, insert, merge, find_min, extractMin.
Python实现凯撒密码的加密与解密
热门推荐
Bonjour~
10-17 3万+
在密码学中，我们把想要加密的消息叫做明文(plain text)。把明文转换成加密后的消息叫做对明文加密(encrypting)，明文加密后变成(cipher text)。凯撒密码的密钥是1到26之间的一个数字。除非知道这个键（即用于加密消息的数字），否则无法对这个保密的代码进行解密。凯撒密码是人类最早发明的密码之一，原理是获取消息中的每个字母，并用一个“移位后的”字母来代替它，如果把字母A移动1格
200行Python代码实现躲方块游戏
Bonjour~
10-21 1万+
在这个游戏中，玩家操纵一个小人，躲避从屏幕顶部掉落的一大堆敌人，玩家躲避敌人的时间越久，得到的分数越高。 为了好玩，我们还会为游戏加入一些作弊模式，如果玩家按下“x”键，每一个敌人的速度就会降低到最慢，如果玩家按下“z”键，敌人就会反转方向，沿着屏幕向上移动而不是往下落。
Python实现火车票查询小工具
Bonjour~
10-22 4126
这个小工具通过抓取12306网站提供的数据并进行解析，从而实现通过命令行的方式查询火车票余票数的功能。主要运用了docopt，requests，prettytable，colorama的库函数，达到简单熟悉Python3网络编程的目的。 运行效果如下： 首先，我们用docopt这个库来解析Python的命令行参数，docopt可以按我们在文档字符串中定义的格式来解析参数，比如我们在代码
名人档案（辛弃疾、李清照）(1).docx
最新发布
04-23
名人档案（辛弃疾、李清照）(1).docx
如何实现用python进行can报文的收发
05-31
在Python中实现CAN报文的收发需要使用CAN总线通信库，比如python-can和socketcan等。以下是一个使用python-can库进行CAN报文收发的示例： ```python import can # 打开CAN总线通信设备 bus = can.interface.Bus(channel='can0', bustype='socketcan') # 发送CAN报文 msg = can.Message(arbitration_id=0x123, data=[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08], extended_id=False) bus.send(msg) # 接收CAN报文 msgReceived = bus.recv(timeout=1.0) # 等待1秒钟 if msgReceived is not None: print("Received CAN message with ID 0x{:x} and data: {}".format(msgReceived.arbitration_id, msgReceived.data)) else: print("Failed to receive CAN message") # 关闭CAN总线通信设备 bus.shutdown() ``` 以上代码片段只是一个简单的示例，实际使用时需要根据实际情况进行修改和调整。同时，需要注意的是，CAN总线通信需要硬件支持，因此需要连接CAN总线适配器和CAN总线通信设备才能进行测试和使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值