python-can的学习笔记

已于 2022-11-11 10:30:03 修改
阅读量2k 收藏 36
点赞数 4
分类专栏： 自动化测试 文章标签： python 学习 开发语言
于 2022-11-10 20:24:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ouguangqian/article/details/127795372
版权
本文介绍了如何安装Python CAN库，以及通过Kvaser软件、配置文件和环境变量进行CAN总线操作。重点讲解了BUS对象创建、消息发送与接收、配置文件使用和常用API应用，适合初学者快速上手CAN通信。
摘要由CSDN通过智能技术生成

实在不想那种中规中矩的写东西了，写的自己都看不下去了，想到啥就写啥吧！

聊两句

最近没事就看了一CAN总线相关的东西，平时工作上接触的不多，大部分时间都是在移动端的自动化上，服务端的自动化上面，针对这块了解的非常非常的少。不看就会焦虑。

因为平时工作用的不多，也就是看一下混个眼熟吧，记录下来一些自己觉得重要的信息，以便后面使用。

安装

一行命令吧

pip install python-can

没有CAN硬件咋办

我也是看到知乎上的一个帖子才知道Kvaser这个软件。链接地址

上个示例代码吧，看看是什么样子

  • 代码①
# coding:utf-8
"""
This example shows how sending a single message works
"""
import can

def send_one():
    """ Sends a single message."""

    # Using specific buses works similar:
    # bus = can.interface.Bus(bustype='socketcan', channel='vcan0', bitrate=250000)
    # bus = can.interface.Bus(bustype='pcan', channel='PCAN_USBBUS1', bitrate=250000)
    # bus = can.interface.Bus(bustype='ixxat', channel=0, bitrate=250000)

    bus = can.interface.Bus(bustype='kvaser', channel=0, bitrate=250000)
    msg = can.Message(arbitration_id=0xc0ffee, data=[0, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
    try:
        bus.send(msg)
        print("Message sent on {}".format(bus.channel_info))
    except can.CanError:
        print("Message NOT sent")


if __name__ == '__main__':
    send_one()
  • 代码②
# coding:utf-8
"""
通过代码设置实现
"""
import can
can.rc['interface'] = 'kvaser'
can.rc['channel'] = '0'
can.rc['bitrate'] = 250000

from can.interface import Bus

bus = Bus()
# 或者可以通过以下方式
# bus = Bus(bustype='kvaser', channel=0, bitrate=250000)
msg = can.Message(arbitration_id=0xc0ffee, data=[0, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
try:
    bus.send(msg)
    print("Message sent on {}".format(bus.channel_info))
except can.CanError:
    print("Message NOT sent")

上面两种示例代码主要是体现了两种bus的创建方式，针对CAN的配置还有更多的方式，比如配置文件，环境变量，还有刚才的代码中配置。下面看看有哪些配置方式。

配置方式

配置文件

在linux系统中，配置文件主要在以下路径中搜索：

  1. ~/can.conf
  2. /etc/can.conf
  3. $HOME/.can
  4. $HOME/.canrc

在Windows系统中的配置文件路径：

  1. %USERPROFILE%/can.conf
  2. can.ini (当前工作目录)
  3. %APPDATA%/can.ini

can.ini文件长啥样呢？

[default]
interface = kvaser
channel = 0
bitrate = 250000

除了设置default项，还可以设置别的项，比如可以配置更多的CAN硬件信息，配置文件样式如下：(没有的配置项可以共享default的配置)

[default]

interface = <the name of the interface to use>

channel = <the channel to use by default>

bitrate = <the bitrate in bits/s to use by default>

[HS]

*# All the values from the 'default' section are inherited*

channel = <the channel to use>

bitrate = <the bitrate in bits/s to use. i.e. 500000>

[MS]

*# All the values from the 'default' section are inherited*

channel = <the channel to use>

bitrate = <the bitrate in bits/s to use. i.e. 125000>

那怎么使用呢，在创建BUS对象的时候传入context参数就可以了

from can.interface import Bus

hs_bus = Bus(context='HS')
ms_bus = Bus(context='MS')

有了配置文件，就在创建BUS对象的时候不需要传递参数了

# coding: utf-8
"""
通过with语句执行can
"""
from can import CanError, Message
from can.interface import Bus

with Bus() as bus:
    msg = Message(arbitration_id=0xc0ffee, data=[0, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
    try:
        bus.send(msg)
    except CanError as e:
        print(e)

环境变量配置

也可以通过配置环境变量来配置can信息，主要有以下配置项：

  • CAN_INTERFACE
  • CAN_CHANNEL
  • CAN_BITRATE
  • CAN_CONFIG

CAN_CONFIG 环境变量可以通过json格式来设置任意的bug配置信息.

CAN_CONFIG = {"interface":"kvaser","channel":0,"bitrate":250000}

支持的CAN名称

名称描述信息
“socketcan”SocketCAN
“kvaser”Kvaser’s CANLIB
“serial”CAN over Serial
“slcan”CAN over Serial / SLCAN
“ixxat”IXXAT Virtual CAN Interface
“pcan”PCAN Basic API
“usb2can”USB2CAN Interface
“nican”NI-CAN
“iscan”isCAN
“neovi”neoVI
“vector”Vector
“virtual”Virtual
“canalystii”CANalyst-II
“systec”SYSTEC interface

基本上python-can的基本信息也就这么多，写法也比较简单，重要的就是怎么发消息，收消息之类的，下面就看一下常见的API信息。

常用API

直接上pycharm的代码吧，就当是笔记了，注释部分也是重点哦

BUS对象创建

有两种创建方式

  1. 可以通过with语句

此处展示不传递参数，通过读取配置文件或者环境变量

with Bus() as bus: # 具体参数可以通过环境变量或者配置文件进行配置
    pass

配置文件如下：

[default]
interface = kvaser
channel = 0
bitrate = 250000
  1. 通过普通方式创建

顺便展示一下通过传递参数方式

bus = Bus(bustype='kvaser', channel=0, bitrate=250000)

设置过滤器

  • set_filters(filters=None)

    设置过滤器可以接收指定的消息，如果参数是空或者长度为0 会接收所有消息
    参数格式: [{“can_id”:0x11, “can_mask”:0x21, “extended”: False}]
    可以在创建BUS对象的时候设置，也可以通过BUS对象调用此方法进行设置

filters = [{"can_id":0x123, "can_mask":0x21, "extended": False}]
bus.set_filters(filters)  
# 或者
bus = Bus(can_filters=filters)

CAN报文封装

通过调用Message类实现CAN报文的创建

  • Message(timestamp=0.0, arbitration_id=0, is_extended_id=True, is_remote_frame=False,is_error_frame=False, channel=None, dlc=None, data=None, is_fd=False, is_rx=True,bitrate_switch=False, error_state_indicator=False, check=False)

参数： 基本上数据帧结构中的字段都包含在内，具体可以根据实际情况设置
描述：

  • Message对象可用于CAN信号的发送，接收，和不同格式之间的转换
  • 同时也支持copy()和deepcopy()方法

消息的发送

两种方法send() 和send_periodic()

  • send(msg, timeout=None)
with Bus() as bus:
    msg = Message(arbitration_id=0xc0ffee, data=[0, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
    bus.send(msg)
  • send_periodic(msgs, period, duration=None, store_taks=True)

在特定的时间内每个特定时间发送消息，返回CyclicSendTaskABC类型的任务

  • 参数解释

    • msgs: CAN消息，数组的话 要保证id都是一样
    • period： 每条消息间隔时间（秒）
    • duration：消息发送的总时长，如果不设置，会一直发送
    • store_task: 默认设置为true，会附加到bus实例中管理，如果设置false，需要手动管理控制
    • 何时设置store_task为False呢?
      • 如果一个can任务是一个临时性的任务，发送后就结束了，就最好设置为False， 因为如果默认设置的话，这个任务就会存在bus实例中，还会占用一定的内存空间

什么场景下发送会停止呢？
在以下几种情况下，此任务会停止执行

  • duration字段设置的时间过期
  • Bus实例离开了作用域，也就是无效
  • Bus实例停止
  • BusABC.stop_all_periodic_tasks()被调用 bus对象方法
  • CyclicTask.stop()方法被调用，任务对象方法

基于上面提到的几种方法，顺便也说一下吧

  • shutdown()
    • 停止bus 在with语句中不需要使用此方法
  • stop_alll_perriodic_tasks(remove_tasks=True)
    • 停止发送任何消息，和send_periodic方法对应，如果在停止的时候任务出现异常，返回结果为None
    • 参数： remove_tasks: 停止跟进的任务

使用任务管理方法

with Bus() as bus:  # ①

    msg1 = Message(arbitration_id=0xc0ffaa, data=[3, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
    msg2 = Message(arbitration_id=0xc0ffaa, data=[4, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
    msg3 = Message(arbitration_id=0xc0ffaa, data=[5, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
    print("msgs是个消息数组")
    t1 = bus.send_periodic(msgs=[msg1, msg2, msg3], period=2, duration=30)
    print("msgs是单个消息")
    t2 = bus.send_periodic(msgs=msg, period=2, duration=30)
    print("在第十秒的时候停止")
    for i in range(10):
        print("第{}秒.............".format(i+1))
        time.sleep(1)
    # t1.stop()  # 通过任务来管理
    # t2.stop()  # 通过任务来管理
    bus.stop_all_periodic_tasks()  # 通过调用函数任务停止
    # bus.shutdown()  # 通过bus来管理 如果使用with语句初始化bus 此方法会报错

使用bus.shutdown方法

    bus = Bus()
    # 以下 ④
    msg = Message(arbitration_id=0xc0ffee, data=[0, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
    msg1 = Message(arbitration_id=0xc0ffaa, data=[3, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
    msg2 = Message(arbitration_id=0xc0ffaa, data=[4, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
    msg3 = Message(arbitration_id=0xc0ffaa, data=[5, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
    print("msgs是个消息数组")
    t1 = bus.send_periodic(msgs=[msg1, msg2, msg3], period=2, duration=30)
    print("msgs是单个消息")
    t2 = bus.send_periodic(msgs=msg, period=2, duration=30)
    print("在第十秒的时候停止")
    for i in range(10):
        print("第{}秒.............".format(i + 1))
        time.sleep(1)
    bus.shutdown()  # 通过bus来管理  停止bus ⑥ 在with语句中不需要使用shutdown函数

消息接收

消息接收有两种方法

  1. 调用recv()
  2. 直接在bus对象中迭代获取

这个没啥好说的，咱写作能力也就这水平（太差劲），上代码吧

with Bus() as bus:  # ①
    # recv(timeout=None) 在给定timeout时间内接受消息，超时未接到消息 返回None
    msg = bus.recv()
    # 或者如下方法
    for msg in bus:  # ⑩ 此类方法会一直循环下去,只要有消息就会执行打印
        print("发送的消息看一看吧：{}".format(msg))

监听 Listener

用于注册接收can消息的通知，可以通过两种方式使用

  1. 默认方式，新的can消息作为参数调用listener
  2. 通过调用on_message_received()

监听类必须继承Listener类并重写on_message_received方法
停止监听，调用stop()方法

class MyListener(Listener):

    def on_message_received(self, msg: Message) -> None:
        print("监听器收到消息咯----{}".format(msg))

if __name__ == '__main__':
    listener = MyListener() # ①② 定义监听器 必须要继承抽象类
    with Bus() as bus:  # ①
        msg = bus.recv()

        # listener(msg)  # ①② 结合MyListener一起来看  第一种方法
        listener.on_message_received(msg)  # ①② 结合MyListener一起来看  第二种方法
        listener.stop()  # 停止监听

以下选择性无视了

以上的代码都在一个文件里调试了，全都放上来吧(选择性无视）

# coding:utf-8
"""
针对python-can的api的学习示例
"""
import time

import can
from can import CanError, Message, Listener
from can.interface import Bus



class MyListener(Listener):

    def on_message_received(self, msg: Message) -> None:
        print("监听器收到消息咯----{}".format(msg))

# ①. bus对象创建
# 可以通过with语句
# with Bus() as bus: # 具体参数可以通过环境变量或者配置文件进行配置
#    pass
# 配置文件如下：
"""
[default]
interface = kvaser
channel = 0
bitrate = 250000
"""
# 可以通过传递参数的方式
# bus = Bus(bustype='kvaser', channel=0, bitrate=250000)

# ②. recv(timeout=None)
# 在给定timeout时间内接受消息，超时未接到消息 返回None

# ③ send(msg, timeout=None)
# 发送CAN消息
# ④ send_periodic(msgs, period, duration=None, store_taks=True)
# 在特定的时间内每个特定时间发送消息，返回CyclicSendTaskABC类型的任务
    # 参数解释
        # msgs: CAN消息，数组的话 要保证id都是一样
        # period： 每条消息间隔时间（秒）
        # duration：消息发送的总时长，如果不设置，会一直发送
        # store_task: 默认设置为true，会附加到bus实例中管理，如果设置false，需要手动管理控制
            # - 何时设置store_task为False呢，如果一个can任务是一个临时性的任务，发送后就结束了，就最好设置为False，
            # 因为如果默认设置的话，这个任务就会存在bus实例中，还会占用一定的内存空间

    # 在以下几种情况下，此任务会停止执行
    #   - duration字段设置的时间过期
    #   - Bus实例离开了作用域，也就是无效
    #   - Bus实例停止
    #   - BusABC.stop_all_periodic_tasks()被调用 bus对象方法
    #   - CyclicTask.stop()方法被调用，任务对象方法
# ⑤ set_filters(filters=None)
    # 设置过滤器可以接收指定的消息，如果参数是空或者长度为0 会接收所有消息
        # 参数：
            # filters：[{"can_id":0x11, "can_mask":0x21, "extended": False}]

# ⑥ shutdown()
    #  停止bus 在with语句中不需要使用此方法

# ⑦  state
    # 属性字段 获取当前硬件状态

# ⑧ stop_alll_perriodic_tasks(remove_tasks=True)
    # 停止发送任何消息，和send_periodic方法对应，如果在停止的时候任务出现异常，返回结果为None
        # 参数：
            # remove_tasks: 停止跟进的任务

# ⑨ 发送消息
    # 可以通过send()方法传递一个Message对象，发送一条独立的can信号

# ⑩ 接收消息
    # 两种方法用来接收消息，一种是调用recv()方法，第二种是直接在bus对象中迭代获取
    # 还可以通过Listener来实现

# ①① CAN报文
  # 对象结构
    # Message(timestamp=0.0, arbitration_id=0, is_extended_id=True, is_remote_frame=False,is_error_frame=False,
    # channel=None, dlc=None, data=None, is_fd=False, is_rx=True,bitrate_switch=False,
    # error_state_indicator=False, check=False)
        # 参数：基本上数据帧结构中的字段都包含在内，具体可以根据实际情况设置
    # 描述：
        #  Message对象可用于CAN信号的发送，接收，和不同格式之间的转换
        # 同时也支持copy()和deepcopy()方法

# ①② 监听 Listener
    # 用于注册接收can消息的通知，可以通过两种方式使用
        # 1. 默认方式，新的can消息作为参数调用listener
        # 2. 通过调用on_message_received()
    # 监听类必须继承Listener类并重写on_message_received方法
    # 停止监听，调用stop()方法

if __name__ == '__main__':
    filters = [{"can_id":0x123, "can_mask":0x21, "extended": False}]
    listener = MyListener() # ①② 定义监听器 必须要继承抽象类
    with Bus() as bus:  # ①

        msg = Message(arbitration_id=0xc0ffee, data=[0, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
        print("消息体的数据内容:{}".format(msg.data))  # ①①
        print("消息体的数据长度:{}".format(msg.dlc))  # ①①
        print("发送的消息体为：{}".format(msg))
        bus.send(msg)  # ③
        print(bus.state)  # ⑦  BusState.ACTIVE
        msg = bus.recv()

        # listener(msg)  # ①② 结合MyListener一起来看  第一种方法
        listener.on_message_received(msg)  # ①② 结合MyListener一起来看  第二种方法
        listener.stop()  # 停止监听


        """
        for msg in bus:  # ⑩ 此类方法会一直循环下去,只要有消息就会执行打印
            print("发送的消息看一看吧：{}".format(msg))
            can.CSVWriter("zz.txt", True).on_message_received(msg) # 将收到的can消息写入文件
        
        # 以下 ④
        msg1 = Message(arbitration_id=0xc0ffaa, data=[3, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
        msg2 = Message(arbitration_id=0xc0ffaa, data=[4, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
        msg3 = Message(arbitration_id=0xc0ffaa, data=[5, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
        print("msgs是个消息数组")
        t1 = bus.send_periodic(msgs=[msg1, msg2, msg3], period=2, duration=30)
        print("msgs是单个消息")
        t2 = bus.send_periodic(msgs=msg, period=2, duration=30)
        print("在第十秒的时候停止")
        for i in range(10):
            print("第{}秒.............".format(i+1))
            time.sleep(1)
        # t1.stop()  # 通过任务来管理
        # t2.stop()  # 通过任务来管理
        bus.stop_all_periodic_tasks()  # 通过调用函数任务停止
        # bus.shutdown()  # 通过bus来管理 如果使用with语句初始化bus 此方法会报错
        """

        # bus.set_filters(filters)  # ⑤ 设置过滤器 也可以在初始化bus时设置 如 Bus(can_filters=filters)
        # res = bus.recv(30)  # 30s的超时时间 ②
        # print("接收到的消息为：{res}".format(**locals()))


    """
    #  针对不使用with语句初始化bus的示例 ④
    bus = Bus()
    # 以下 ④
    msg = Message(arbitration_id=0xc0ffee, data=[0, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
    msg1 = Message(arbitration_id=0xc0ffaa, data=[3, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
    msg2 = Message(arbitration_id=0xc0ffaa, data=[4, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
    msg3 = Message(arbitration_id=0xc0ffaa, data=[5, 25, 0, 1, 3, 1, 4, 1], is_extended_id=False)
    print("msgs是个消息数组")
    t1 = bus.send_periodic(msgs=[msg1, msg2, msg3], period=2, duration=30)
    print("msgs是单个消息")
    t2 = bus.send_periodic(msgs=msg, period=2, duration=30)
    print("在第十秒的时候停止")
    for i in range(10):
        print("第{}秒.............".format(i + 1))
        time.sleep(1)
    bus.shutdown()  # 通过bus来管理  停止bus ⑥ 在with语句中不需要使用shutdown函数
    """

先写到这吧！最近太忙了！

Unknown Screwer
关注
专栏目录
python-MySQL学习笔记－第六章－Connector/Python连接池（Connection Pooling）
vseeker的专栏
04-16 2112
python-MySQL学习笔记－第六章－Connector/Python连接池（Connection Pooling）
opencv-python学习笔记（十）：实现人脸特征转换
submarineas的博客
04-23 8262
引言 本次实验来自实验楼，而实验楼代码的出处为如下GitHub链接，加上一些自己的理解与说明，总结成本文笔记。 https://github.com/matthewearl/faceswap 所需环境 Dlib是一个高级的机器学习库，它是为解决复杂的现实世界问题而创建的。这个库是用C++编程语言创建的，它与C/C++、Python和java一起工作。 本次因为有dlib库需要安装，个人更习惯于Linux系统，所以本次使用环境为个人腾讯云ubuntu 18.04，关于dlib库，它的安装需要cmake与b
python-can:can 包为 Python 开发者提供控制器局域网支持
08-03
Python罐头 ontroller甲REAÑetwork的C是设计成允许微控制器和设备彼此通信的总线标准。 它具有基于优先级的总线仲裁和可靠的确定性通信。 它用于汽车、卡车、船只、轮椅等。 can包为 Python 开发者提供控制器局域网支持； 为不同的硬件设备提供通用抽象，以及一套用于在 can 总线上发送和接收消息的实用程序。 该库目前支持 Python 3.6+ 以及 PyPy 3，可在 Mac、Linux 和 Windows 上运行。 图书馆版本 Python 2.x 2.6+、3.4+ 3.x 2.7+、3.5+ 4.x （目前正在开发中） 3.6+ 特征 CAN 通信的通用抽象 支持许多不同的后端（请参阅） 接收、发送和定期发送消息 正常和扩展仲裁 ID 支持 许多不同的记录器和阅读器支持回放：ASC（CANalyzer 格式）、BLF（矢量二进制记录
python语言进行can通信——python-can
sjh_sjh_sjh的博客
02-26 1万+
具体没有自己玩过，后期应该需要用到，先插个眼放在这里落灰 参考链接： https://zhuanlan.zhihu.com/p/135841135 https://python-can.readthedocs.io/en/master/ #!/usr/bin/env python # coding: utf-8 """ This example shows how sending a single message works. """ from __future__ import print_funct
基于Python的COM库控制CANoe同时打开多个.cfg工程方法案例
最新发布
qq_42746084的博客
10-09 638
SingleCOMClient=0: 允许多个客户端连接，可能导致多个应用程序实例同时运行，存在潜在的资源和状态管理问题。SingleCOMClient=1: 限制为单一客户端连接，确保应用程序的稳定性和一致性，避免多个实例之间的干扰。选择哪个设置取决于应用程序的需求和使用场景。如果需要支持多个客户端并且能够处理潜在的冲突，可以选择0；如果希望确保应用程序的稳定性和一致性，则应选择1。
python-can 的使用
weixin_33816300的博客
11-08 5066
最近在搞 websocket, 服务端是用 python 写的，所以，我需要用python 控制 can 去传输相关信息。 python-can 模块就是 python 控制 can 的模仿。 利用 buildroot 去生成 python-can 模块 cd $BUILDROOT_PATH make menuconfig Target packages ---&...
Python之python-can
PlutoZuo的博客
10-07 4795
Python-can介绍
Python CAN使用
黑客三遍猪
05-06 2465
作者 QQ群：852283276 微信：arm80x86 微信公众号：青儿创客基地 B站：主页 https://space.bilibili.com/208826118 报错CAN bit stuff error 来自， # python-can-3.3.4\can\interfaces\ixxat\canlib.py line227 CAN_ERROR_MESSAGES = { constants.CAN_ERROR_STUFF: "CAN bit stuff error", const
最新Python学习笔记1
07-07
通过这份学习笔记，初学者可以了解到Python的基础知识，包括但不限于Python的历史、版本、跨平台能力、基础语法、常用函数、数据类型、输入输出方法、以及一些常见的编程问题和解决方案。掌握这些知识点将有助于初学...
学习opencv-python笔记
qq_45856838的博客
11-10 3279
因为学校内一个项目设计的实验课，需要我们用opencv去做一些图像处理，以前一直没有做过类似的东西，对于编程也并不是很熟悉，从小白开始学起，写这篇文章的想法是去整合自己学习过程中找到的一些资料，以及自己在调试中遇到的一些小问题，希望可以帮到那些和我一样同样从头开始学习的uu们。废话很多，当然可能也会有一些不是很准确的说法，望各位指正交流！ 学习资料 我是在GitHub上找到的一个讲opencv-python的博主的文章，里面讲的很基础很详细，但是对于小白来说效果着实不错，大佬...
python--pymysql模块学习笔记
Lee hua
05-16 413
一：二:
PCANBasic.dll
11-05
windows64位系统，用于模拟车辆CAN总线数据的发送和接收
kvaser信息发送读取python库
11-05
kvaser信息发送读取python库，需要kvaser canlib驱动支持
Python学习--Python_can
W295723987的博客
10-20 2600
//是否为canfd。, //是否为接收帧。, //数据。, //通道。, //是否为扩展帧。, //是否为错误帧。, //是否为远程帧。
python-can介绍
qq_45303968的博客
08-02 9676
python-can 库为 Python 提供控制器局域网支持，为不同的硬件设备提供通用抽象，以及一套用于在 CAN 总线上发送和接收消息的实用程序。python-can 可以在任何 Python 运行的地方运行；从 CAN 的高功率计算机到 USB 设备，再到运行 linux 的低功率设备，例如 BeagleBone 或 RaspberryPi。............
Python can库
Python老吕的博客
07-15 1288
Python的can库是一个用于CAN（Controller Area Network）网络编程的库。CAN网络是车辆和工业应用中最常见的通信协议之一，它允许不同的设备在无需主机的情况下相互通信。Python的can库提供了一套统一的API，使得开发者可以使用Python来编写CAN网络相关的应用。Python的can库为开发者提供了一种方便、灵活的方式来编写与CAN总线进行通信的应用。通过统一的API，开发者可以轻松地连接到CAN总线、发送和接收消息、处理错误等。此外，can。
Python实现CAN通讯
sinat_35773915的博客
07-25 4913
CAN通讯是一种高可靠性、高效率的通信协议，具有抗干扰能力强、高可靠性、高效率和支持多节点等特点。它在汽车、工业控制、航空航天和医疗设备等领域得到广泛应用，成为实时应用通信的重要技术。Python-can 是一个功能强大的 Python 库，用于控制和通信汽车网络。它提供了一组简单易用的接口和工具，用于发送和接收 CAN 消息，以及解析和处理 CAN 数据。通过它，可以轻松地与 CAN 总线进行通信，并与汽车和工业领域的电子控制单元进行交互。
CAN通讯-使用Python收发CAN数据保姆级教程（包含完整代码）
热门推荐
ShakalakaPHD的博客
04-16 2万+
CAN通讯-使用Python收发CAN数据配置环境1.环境配置1.1安装CAN通讯需要的包1.2 安装kvaser_drivers以及Kvaser CanKing2.使用Python收发数据2.1接发数据代码如下：2.1.1接收数据代码2.1.2发送数据代码2.2验证发送数据2.2.1使用Kvaser Can King接收数据2.2.2使用Python发送数据2.3验证接收数据2.3.1使用Kvaser Can King发送数据2.3.2使用Python发接收数据2.3代码间发送与接收数据：3.参考文献4.
分享自制CAN工具【python源码】
MIC01234的博客
11-01 2886
背景：由于工作原因，最近想写一个CAN工具：1，界面简单容易操作；2，适合实车操作，有实车信号按钮；3.可自动化测试；4.CANoe Is Too Expensive! 环境：python3.7 +tkinter+多线程 一、调用dll库文件 调用的创芯科技DLL也可以用周立功DLL库； # -*- encoding=utf-8 -*- from ctypes import * import time dll = windll.LoadLibrary('./ControlCAN.dll') .
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值