rt-thread can过滤实现

/**
 * struct can_filter - CAN ID based filter in can_register().
 * @can_id:   relevant bits of CAN ID which are not masked out.
 * @can_mask: CAN mask (see description)
 *
 * Description:
 * A filter matches, when
 *
 *          <received_can_id> & mask == can_id & mask
 *
 * The filter can be inverted (CAN_INV_FILTER bit set in can_id) or it can
 * filter for error frames (CAN_ERR_FLAG bit set in mask).
 */

/*
 * @brief   设置can过滤策略 (只支持标准帧或扩展帧)
 * @param port      CAN端口，1：stm32 CAN1，2：stm32 CAN2，3：CAN3(MCP2515扩展CAN)
 * @param filter    要设置的过滤器数组
 * @param num       要设置的过滤器个数，最大个数不超过IF_CAN_FILTER_NUM_MAX
 * @return          success：RT_EOK，fail：(-RT_ERROR)
 */
int can_filter_setting(uint8_t port, struct can_filter *filter, uint8_t num)
{
    // rt-thread stm32 can过滤配置：
    // 参考1：can过滤器怎么设置才有效：https://club.rt-thread.org/ask/question/79ed148f8350326e.html
    // 参考2：STM32CAN发送和接收过滤详解：https://oss-club.rt-thread.org/uploads/20201023/44e3f3d9a6e80dba8e27e720f32e781f.pdf
    CHECK_CAN_NO(port);
    const uint8_t tmp_port = (port - 1);
    struct rt_can_filter_item items[IF_CAN_FILTER_NUM_MAX];
    struct rt_can_filter_config cfg = {.count = num, .actived = 1, .items = items};
    if (NULL == filter || 0 == num)
    {
        return  RT_EOK;
    }
    for (uint8_t i = 0; i < num; ++i)
    {
        const uint8_t eff_flag = (filter[i].can_id & CAN_EFF_FLAG) ? 1 : 0;// 扩展CAN标识
        uint32_t can_id   = filter[i].can_id   & CAN_EFF_MASK;  // 获取标准29bit can id
        uint32_t can_mask = filter[i].can_mask & CAN_EFF_MASK;  // 获取标准29bit can id
        if (1 == port || 2 == port)     // stm32自带can
        {
            // 根据drv_can.c对过滤的设置(即id的移位)，can_id要当作29bit id来看，
            can_id = can_id;
            // 根据drv_can.c对过滤的设置(即mask的移位)，can_mask要当作32bit id来看
            const uint32_t stid = can_mask >> 18;
            const uint32_t exid = can_mask &  0x3FFFF;
            can_mask = 0;
            can_mask |= (stid << 18);
            can_mask |= (exid << 3);
            if (eff_flag)
            {
                can_mask |= (1 << 2);
            }
        }
        else
        {
            // do nonthing
        }
        struct rt_can_filter_item item = RT_CAN_FILTER_EXT_INIT(can_id);
        item.mask = can_mask;
        item.hdr  = 0;
        item.ide  = eff_flag;
        items[i]  = item;
        LOG_W("CAN%u filter#%u: %08X - %08X", port, num, filter[0].can_id, filter[0].can_mask);
    }
    return (rt_device_control(can_dev[tmp_port], RT_CAN_CMD_SET_FILTER, &cfg) == RT_EOK ? RT_EOK : (-RT_ERROR);
}

/* special address description flags for the CAN_ID */
#define CAN_EFF_FLAG    0x80000000U        /* EFF/SFF is set in the MSB */
#define CAN_RTR_FLAG    0x40000000U        /* remote transmission request */
#define CAN_ERR_FLAG    0x20000000U        /* error frame */
/* valid bits in CAN ID for frame formats */
#define CAN_SFF_MASK    0x000007FFU        /* standard frame format (SFF) */
#define CAN_EFF_MASK    0x1FFFFFFFU        /* extended frame format (EFF) */
#define CAN_ERR_MASK    0x1FFFFFFFU        /* omit EFF, RTR, ERR flags */
/*
 * Controller Area Network Identifier structure
 *
 * bit 0-28    : CAN identifier (11/29 bit)
 * bit 29    : error frame flag (0 = data frame, 1 = error frame)
 * bit 30    : remote transmission request flag (1 = rtr frame)
 * bit 31    : frame format flag (0 = standard 11 bit, 1 = extended 29 bit)
 */
typedef unsigned int canid_t;
/*
 * Controller Area Network Error Frame Mask structure
 *
 * bit 0-28    : error class mask (see include/socketcan/can/error.h)
 * bit 29-31    : set to zero
 */
typedef unsigned int can_err_mask_t;
/**
 * struct can_frame - basic CAN frame structure
 * @can_id:  the CAN ID of the frame and CAN_*_FLAG flags, see above.
 * @can_dlc: the data length field of the CAN frame
 * @data:    the CAN frame payload.
 */
typedef struct can_frame {
    canid_t         can_id;  /* 32 bit CAN_ID + EFF/RTR/ERR flags */
    unsigned char   can_dlc; /* data length code: 0 .. 8 */
    unsigned char   can_na[3];//字节对齐问题
    unsigned char   data[8] __attribute__((aligned(8)));
} can_frame_t;
/**
 * struct can_filter - CAN ID based filter in can_register().
 * @can_id:   relevant bits of CAN ID which are not masked out.
 * @can_mask: CAN mask (see description)
 *
 * Description:
 * A filter matches, when
 *
 *          <received_can_id> & mask == can_id & mask
 *
 * The filter can be inverted (CAN_INV_FILTER bit set in can_id) or it can
 * filter for error frames (CAN_ERR_FLAG bit set in mask).
 */
struct can_filter {
    canid_t can_id;
    canid_t can_mask;
};
#define CAN_INV_FILTER 0x20000000U /* to be set in can_filter.can_id */