go-can

package main

import (
    "fmt"
    "log"
    "github.com/wmem/go-can/pkg/raw"
)

func main() {
    // 创建CAN socket
    socket, err := raw.New("can0")
    if err != nil {
        log.Fatal(err)
    }
    defer raw.Free(socket)

    // 发送CAN帧
    frame := raw.RawFrameSend{
        ID:         0x123,
        Data:       []byte{0x01, 0x02, 0x03, 0x04},
        IsExtended: false,
        IsRemote:   false,
    }

    err = socket.SendFrame(frame)
    if err != nil {
        log.Fatal(err)
    }

    // 接收CAN帧
    recvFrame, err := socket.RecvFrame()
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("接收到CAN帧: ID=0x%X, 数据=%v\n", recvFrame.ID, recvFrame.Data)
}

// 发送CAN FD帧
fdFrame := raw.RawFrameSend{
    ID:     0x123,
    Data:   []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A},
    IsFD:   true,
    IsBRS:  true,  // 位率切换
    HasESI: false, // 错误状态指示
}

err = socket.SendFrame(fdFrame)

// 精确匹配过滤器
filters := raw.NewExactFilter(0x123)
socket.SetFilter([]raw.CanFilter{filters})

// 范围过滤器 - 自动拆分为多个2^n对齐的子块
rangeFilters := raw.NewRangeFilter(0x100, 0x130)
socket.SetFilter(rangeFilters)

// 多个过滤器组合
filters := []raw.CanFilter{
    raw.NewExactFilter(0x123),
    raw.NewMaskFilter(0x200, 0xFF00), // 匹配0x200-0x2FF
}
socket.SetFilter(filters)

frame, err := socket.RecvFrame()
if err == nil {
    // 软件时间戳
    if frame.SoftTime > 0 {
        fmt.Printf("软件时间戳: %.9f秒\n", float64(frame.SoftTime)/1e9)
    }

    // 硬件时间戳
    if frame.HardTime > 0 {
        fmt.Printf("硬件时间戳: %.9f秒\n", float64(frame.HardTime)/1e9)
    }
}

package main

import (
    "github.com/wmem/go-can/pkg/candevice"
)

func main() {
    // 创建设备实例
    device, err := candevice.DeviceFromName("can0")
    if err != nil {
        log.Fatal(err)
    }

    // 配置CAN参数
    params := candevice.DeviceParam{
        "bitrate":      500000,
        "sample-point": 0.875,
        "loopback":     false,
        "listen-only":  false,
    }

    err = device.SetParam(params)
    if err != nil {
        log.Fatal(err)
    }

    // 启动接口
    err = device.SetUp()
    if err != nil {
        log.Fatal(err)
    }
}

// CAN帧发送结构
type RawFrameSend struct {
    ID         uint32 // CAN ID
    Data       []byte // 数据
    IsRemote   bool   // 远程帧
    IsExtended bool   // 扩展帧
    IsFD       bool   // CAN FD帧
    HasESI     bool   // 错误状态指示
    IsBRS      bool   // 位率切换
}

// CAN帧接收结构
type RawFrameRecv struct {
    ID         uint32 // CAN ID
    Data       []byte // 数据
    IsRemote   bool   // 远程帧
    IsExtended bool   // 扩展帧
    IsFD       bool   // CAN FD帧
    HasESI     bool   // 错误状态指示
    IsBRS      bool   // 位率切换
    IsError    bool   // 错误帧
    IsTx       bool   // 发送帧(回环)
    SoftTime   uint64 // 软件时间戳(纳秒)
    HardTime   uint64 // 硬件时间戳(纳秒)
}

// CAN过滤器
type CanFilter struct {
    ID   uint32 // 过滤ID
    Mask uint32 // 过滤掩码
}

// 创建CAN socket
func New(ifName string) (*SocketRaw, error)

// 释放CAN socket
func Free(s *SocketRaw)

// 发送CAN帧
func (s *SocketRaw) SendFrame(msg RawFrameSend) error

// 接收CAN帧
func (s *SocketRaw) RecvFrame() (RawFrameRecv, error)

// 设置过滤器
func (s *SocketRaw) SetFilter(filters []CanFilter) error

// 设置超时
func (s *SocketRaw) SetTimeout(ms uint)

// 过滤器创建函数
func NewExactFilter(id uint32) CanFilter
func NewRangeFilter(startID, endID uint32) []CanFilter
func NewMaskFilter(id, mask uint32) CanFilter
func NewAcceptAllFilter() CanFilter