如何在没有任何 CAN 硬件的 2 台 Linux 机器之间发送和接收 CAN 消息？

Question

我一直在尝试在没有任何 CAN 硬件的情况下在我的笔记本电脑 (Ubuntu 20 Virtualbox) 和 Raspberry Pi (Ubuntu 20) 之间建立 CAN 通信，因为在模拟环境中不会收到 CAN 消息。我想通过 wifi 或 USB 将 CAN 数据作为有效负载发送。然后我的python模拟环境应该能够将这些解释为CAN消息并适当地转发。

我从socketcan 尝试过vcan，但它只能在同一Linux 机器的2 个终端之间工作。有人建议我查看slcan。除了使用实际的 CAN 硬件之外，似乎没有其他选择。我在任何地方都找不到任何教程或任何其他帮助。

如果有人能建议如何在没有任何 CAN 硬件的情况下通过 wifi 或 USB 在 2 台 Linux 机器之间发送和接收 CAN 消息，我将不胜感激？

我试过的Python源代码：

import sys
import socket
import argparse
import struct
import errno


class CANSocket(object):
  FORMAT = "<IB3x8s"
  FD_FORMAT = "<IB3x64s"
  CAN_RAW_FD_FRAMES = 5

  def __init__(self, interface=None):
    self.sock = socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
    if interface is not None:
      self.bind(interface)

  def bind(self, interface):
    self.sock.bind((interface,))
    self.sock.setsockopt(socket.SOL_CAN_RAW, self.CAN_RAW_FD_FRAMES, 1)

  def send(self, cob_id, data, flags=0):
    cob_id = cob_id | flags
    can_pkt = struct.pack(self.FORMAT, cob_id, len(data), data)
    self.sock.send(can_pkt)

  def recv(self, flags=0):
    can_pkt = self.sock.recv(72)

    if len(can_pkt) == 16:
      cob_id, length, data = struct.unpack(self.FORMAT, can_pkt)
    else:
      cob_id, length, data = struct.unpack(self.FD_FORMAT, can_pkt)

    cob_id &= socket.CAN_EFF_MASK
    return (cob_id, data[:length])


def format_data(data):
    return ''.join([hex(byte)[2:] for byte in data])


def generate_bytes(hex_string):
    if len(hex_string) % 2 != 0:
      hex_string = "0" + hex_string

    int_array = []
    for i in range(0, len(hex_string), 2):
        int_array.append(int(hex_string[i:i+2], 16))

    return bytes(int_array)


def send_cmd(args):
    try:
      s = CANSocket(args.interface)
    except OSError as e:
      sys.stderr.write('Could not send on interface {0}\n'.format(args.interface))
      sys.exit(e.errno)

    try:
      cob_id = int(args.cob_id, 16)
    except ValueError:
      sys.stderr.write('Invalid cob-id {0}\n'.format(args.cob_id))
      sys.exit(errno.EINVAL)

    s.send(cob_id, generate_bytes(args.body), socket.CAN_EFF_FLAG if args.extended_id else 0)


def listen_cmd(args):
    try:
      s = CANSocket(args.interface)
    except OSError as e:
      sys.stderr.write('Could not listen on interface {0}\n'.format(args.interface))
      sys.exit(e.errno)

    print('Listening on {0}'.format(args.interface))

    while True:
        cob_id, data = s.recv()
        print('%s %03x#%s' % (args.interface, cob_id, format_data(data)))


def parse_args():
    parser = argparse.ArgumentParser()
    subparsers = parser.add_subparsers()

    send_parser = subparsers.add_parser('send', help='send a CAN packet')
    send_parser.add_argument('interface', type=str, help='interface name (e.g. vcan0)')
    send_parser.add_argument('cob_id', type=str, help='hexadecimal COB-ID (e.g. 10a)')
    send_parser.add_argument('body', type=str, nargs='?', default='',
      help='hexadecimal msg body up to 8 bytes long (e.g. 00af0142fe)')
    send_parser.add_argument('-e', '--extended-id', action='store_true', default=False,
      help='use extended (29 bit) COB-ID')
    send_parser.set_defaults(func=send_cmd)

    listen_parser = subparsers.add_parser('listen', help='listen for and print CAN packets')
    listen_parser.add_argument('interface', type=str, help='interface name (e.g. vcan0)')
    listen_parser.set_defaults(func=listen_cmd)

    return parser.parse_args()


def main():
    args = parse_args()
    args.func(args)


if __name__ == '__main__':
    main()

Answer 1

CAN 是一个广播 协议，而不是像 TCP 那样的连接协议或像 UDP 这样的数据报协议。但是，如果您想要抽象硬件但仍然模拟 CAN 的更高层行为，我建议最好的方法是使用 UDP（但@M. Spiller 建议的 TCP 也可以工作，只是意味着处理接受连接您不必为 UDP 烦恼），并以与 CAN 帧相同的字节结构发送和接收数据包。您还需要考虑过滤器和错误帧。

如果你打算在 linux 上使用 socketcan，你的 UDP 数据包应该是这样的：

struct {
    uint16_t id;       /* CAN ID of the frame */
    uint8_t dlc;       /* frame payload length in bytes */
    uint8_t data[8];   /* CAN frame payload */
} simulated_udp_can_frame;

您应该阅读socketCAN kernel documentation 了解更多详情。