嵌入式作业6.3 CAN 总线编程

合集 - 嵌入式(20)
1.嵌入式系统学习札记系列2.嵌入式作业1.1 嵌入式系统常用术语3.嵌入式作业1.2 运行示例程序4.嵌入式作业2.1 汇编练习5.嵌入式笔记2.1 ARM Cortex-M3M4汇编指令集6.嵌入式笔记2.2 ARM-GUN汇编简介7.嵌入式作业3.1 GPIO点亮小灯8.嵌入式笔记1.1 ARM Cortex-M3M4简介9.嵌入式笔记3.1 GPIO（mcu 手册）10.嵌入式笔记4.2 USART11.嵌入式笔记4.3 Cortex-M3与Cortex-M4异常和中断详解12.嵌入式作业4.1 USART 编程13.嵌入式笔记4.1 GPIO 功能复用14.嵌入式笔记5.1 定时器详解15.嵌入式作业5.1 定时器编程16.嵌入式作业6.1 Flash 在线编程17.嵌入式笔记6.1 Flash18.嵌入式作业6.2 ADC 编程
19.嵌入式作业6.3 CAN 总线编程
20.嵌入式 Linux 基础：环境配置（Debian 12 安装配置）
收起

目录

2个或以上同学相互连接，利用CAN通信，向对方发送带有本人姓名的信息。连线方式：按基本原理性电路（不带收发器芯片）连接，参考教材图10-1。#

程序代码#

can.c：

//======================================================================
// 文件名称：can.c
// 功能概要：uart底层驱动构件源文件
// 版权所有：苏州大学嵌入式系统与物联网研究所(sumcu.suda.edu.cn)
// 更新记录：2021-02-03 V1.0  JJL
//======================================================================
#include "can.h"

CAN_TypeDef *CAN_ARR[] = {(CAN_TypeDef *)CAN1_BASE};         // CAN寄存器数组，包含一个指向CAN1_BASE地址的指针
IRQn_Type table_irq_can[2] = {CAN1_RX0_IRQn, CAN1_RX1_IRQn}; // 中断请求号数组，包含 CAN1 的两个接收中断请求号

uint8_t can_send_once(uint8_t canNo, uint32_t DestID, uint16_t len, uint8_t *buff);
uint8_t CAN_HWInit(uint8_t CANChannel);
uint8_t CAN_SWInit_Entry(uint8_t canNo);
void CAN_SWInit_CTLMode(uint8_t canNo);
void CAN_SWInit_BT(uint8_t canNo, uint32_t CANMode, uint32_t Prescaler);
uint8_t CAN_SWInit_Quit(uint8_t canNo);
uint8_t CANFilterConfig(uint8_t canNo, uint32_t canID, uint32_t FilterBank, uint32_t Can_Rx_FifoNo, uint8_t IsActivate, uint32_t FilterMode, uint32_t FilterScale);

//=====================================================================
// 函数名称：can_init
// 函数返回：无
// 参数说明：canNo：模块号，本芯片只有CAN_1
//		    canID：自身CAN节点的唯一标识，例如按照CANopen协议给出
//          BitRate：位速率
// 功能概要：初始化CAN模块
//=====================================================================
void can_init(uint8_t canNo, uint32_t canID, uint32_t BitRate)
{
    // 声明Init函数使用的局部变量
    uint32_t CANMode;
    uint32_t CANFilterBank;
    uint32_t CANFiltermode;
    uint32_t CAN_Filterscale;

    // 给Init函数使用的局部变量赋初值
    CANMode = CAN_MODE_NORMAL;               // 设置CAN的工作模式为正常模式
    CANFilterBank = CANFilterBank0;          // 设置过滤器组编号为0
    CANFiltermode = CAN_FILTERMODE_IDMASK;   // 设置过滤器模式为掩码模式
    CAN_Filterscale = CAN_FILTERSCALE_32BIT; // 设置过滤器比例为单32位过滤器

    // （1）CAN总线硬件初始化
    CAN_HWInit(CAN_CHANNEL);
    // （2）CAN总线进入软件初始化模式
    CAN_SWInit_Entry(canNo);
    // （3）CAN总线模式设置
    CAN_SWInit_CTLMode(canNo);
    // （4）CAN总线位时序配置
    CAN_SWInit_BT(canNo, CANMode, BitRate);
    // （5）CAN总线过滤器初始化
    CANFilterConfig(canNo, canID, CANFilterBank, CAN_RX_FIFO0, 1, CANFiltermode, CAN_Filterscale);
    // （6）CAN总线退出软件初始化模式，进入正常模式
    CAN_SWInit_Quit(canNo);
}

//=====================================================================
// 函数名称：can_send
// 函数返回：0=正常，1=错误
// 参数说明：canNo：模块号，本芯片只有CAN_1
//          DestID：目标CAN节点的唯一标识，例如按照CANopen协议给出
//          len：待发送数据的字节数
//          buff：待发送数据发送缓冲区首地址
// 功能概要：CAN模块发送数据
//=====================================================================
uint8_t can_send(uint8_t canNo, uint32_t DestID, uint16_t len, uint8_t *buff)
{
    // 检查目标ID是否超过29位扩展标识符的最大值
    if (DestID > 0x1FFFFFFFU)
        return 1;

    uint8_t send_length; // 发送长度

    // 循环处理待发送的数据，每次发送最多8个字节
    for (int i = len; i > 0; i = i - 8)
    {
        // 计算当前发送的数据长度，如果剩余长度大于8，则发送8个字节，否则发送剩余长度
        send_length = (i > 8) ? 8 : i;
        // 调用 can_send_once 函数发送数据
        if (can_send_once(canNo, DestID, send_length, buff + len - i) == 1)
        {
            return 1;
        }
    }
    return 0;
}

//=====================================================================
// 函数名称：can_recv
// 函数返回：接收到的字节数
// 参数说明：canNo：模块号，本芯片只有CAN_1
//          buff：接收到的数据存放的内存区首地址
// 功能概要：在CAN模块接收中断中调用本函数接收已经到达的数据
//=====================================================================
uint8_t can_recv(uint8_t canNo, uint8_t *buff)
{
    uint8_t len;                    // 收到的数据长度
    uint32_t RxFifo = CAN_RX_FIFO0; // 设置接收FIFO为FIFO0（先进先出队列）

    // （1）判断哪个邮箱收到了报文信息
    //  检查FIFO0是否有待处理消息
    if (RxFifo == CAN_RX_FIFO0)
    {
        // 检查FIFO0消息挂起位，如果没有消息，返回1表示错误
        if ((CAN_ARR[canNo - 1]->RF0R & CAN_RF0R_FMP0) == 0U)
        {
            return 1;
        }
    }
    else
    {
        // 检查FIFO1消息挂起位，如果没有消息，返回1表示错误
        if ((CAN_ARR[canNo - 1]->RF1R & CAN_RF1R_FMP1) == 0U)
        {
            return 1;
        }
    }

    // （2）获取数据长度
    //  从接收FIFO的邮箱中获取数据长度
    len = (CAN_RDT0R_DLC & CAN_ARR[canNo - 1]->sFIFOMailBox[RxFifo].RDTR) >> CAN_RDT0R_DLC_Pos;

    // （3）获取数据帧中的数据
    //  从接收FIFO的邮箱中读取数据帧的每个字节，并存储到缓冲区buff中
    buff[0] = (uint8_t)((CAN_RDL0R_DATA0 & CAN_ARR[canNo - 1]->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA0_Pos);
    buff[1] = (uint8_t)((CAN_RDL0R_DATA1 & CAN_ARR[canNo - 1]->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA1_Pos);
    buff[2] = (uint8_t)((CAN_RDL0R_DATA2 & CAN_ARR[canNo - 1]->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA2_Pos);
    buff[3] = (uint8_t)((CAN_RDL0R_DATA3 & CAN_ARR[canNo - 1]->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA3_Pos);
    buff[4] = (uint8_t)((CAN_RDH0R_DATA4 & CAN_ARR[canNo - 1]->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA4_Pos);
    buff[5] = (uint8_t)((CAN_RDH0R_DATA5 & CAN_ARR[canNo - 1]->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA5_Pos);
    buff[6] = (uint8_t)((CAN_RDH0R_DATA6 & CAN_ARR[canNo - 1]->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA6_Pos);
    buff[7] = (uint8_t)((CAN_RDH0R_DATA7 & CAN_ARR[canNo - 1]->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA7_Pos);

    // （4）清除标志位，等待接收下一帧数据
    //  清除对应FIFO的消息挂起标志位，以便接收下一帧数据
    if (RxFifo == CAN_RX_FIFO0)
    {
        SET_BIT(CAN_ARR[canNo - 1]->RF0R, CAN_RF0R_RFOM0);
    }
    else
    {
        SET_BIT(CAN_ARR[canNo - 1]->RF1R, CAN_RF1R_RFOM1);
    }

    return len; // 返回接收到的数据长度
}

//=====================================================================
// 函数名称：CAN_enable_re_int
// 函数返回：无
// 参数说明：canNo:模块基地址号，Can_Rx_FifoNo:中断使用的邮箱号
// 功能概要：CAN接收中断开启
//=====================================================================
void can_enable_recv_int(uint8_t canNo)
{
    uint8_t Can_Rx_FifoNo;
    Can_Rx_FifoNo = CAN_RX_FIFO0; // 设置接收FIFO编号为FIFO0

    // 判断接收FIFO编号，如果为FIFO0，设置相应的中断使能位
    if (Can_Rx_FifoNo == CAN_RX_FIFO0)
        SET_BIT(CAN_ARR[canNo - 1]->IER, CAN_IER_FMPIE0); // 设置FIFO0消息挂起中断使能位
    else
        SET_BIT(CAN_ARR[canNo - 1]->IER, CAN_IER_FMPIE1); // 设置FIFO1消息挂起中断使能位

    // 启用相应的中断请求
    NVIC_EnableIRQ(table_irq_can[Can_Rx_FifoNo]);
}

//=====================================================================
// 函数名称：can_disable_recv_int
// 函数返回：无
// 参数说明：canNo：模块号，本芯片只有CAN_1
// 功能概要：关闭CAN接收中断
//=====================================================================
void can_disable_recv_int(uint8_t canNo)
{
    uint8_t Can_Rx_FifoNo;
    Can_Rx_FifoNo = CAN_RX_FIFO0;
    if (Can_Rx_FifoNo == CAN_RX_FIFO0)
        CLEAR_BIT(CAN_ARR[canNo - 1]->IER, CAN_IER_FMPIE0); // 清除FIFO0消息挂起中断使能位
    else
        CLEAR_BIT(CAN_ARR[canNo - 1]->IER, CAN_IER_FMPIE1); // 清除FIFO1消息挂起中断使能位

    // 禁用相应的中断请求
    NVIC_DisableIRQ(table_irq_can[Can_Rx_FifoNo]);
}

//=====================================================================
// 函数名称：can_send_once
// 函数返回：0=正常，1=错误
// 参数说明：canNo：模块号，本芯片只有CAN_1
//          DestID：目标CAN节点的唯一标识，例如按照CANopen协议给出
//          len：待发送数据的字节数
//          buff：待发送数据发送缓冲区首地址
// 功能概要：CAN模块发送一次数据
//=====================================================================
uint8_t can_send_once(uint8_t canNo, uint32_t DestID, uint16_t len, uint8_t *buff)
{
    // （1）定义Can发送函数所需要用到的变量
    uint32_t transmit_mailbox;                        // 用于存储可用的发送邮箱
    uint32_t register_tsr;                            // 用于存储发送状态寄存器的值
    uint32_t rtr;                                     // 帧类型（数据帧）
    rtr = CAN_RTR_DATA;                               // 设置为数据帧
    register_tsr = READ_REG(CAN_ARR[canNo - 1]->TSR); // 读取发送状态寄存器的值

    // （2）判断3个邮箱中是否有空闲邮箱，若有，选取其中一个进行发送，选取顺序为1，2，3
    if (((register_tsr & CAN_TSR_TME0) != 0U) ||
        ((register_tsr & CAN_TSR_TME1) != 0U) ||
        ((register_tsr & CAN_TSR_TME2) != 0U))
    {
        transmit_mailbox = (register_tsr & CAN_TSR_CODE) >> CAN_TSR_CODE_Pos; // 获取空闲邮箱编号
        if (transmit_mailbox > 2U)                                            // 如果编号大于2，返回错误
        {
            return 1;
        }

        // （2.1）判断并设置发送帧为标准帧还是扩展帧
        if (DestID <= 0x7FFU) // 如果目标ID在标准ID范围内
        {
            CAN_ARR[canNo - 1]->sTxMailBox[transmit_mailbox].TIR = ((DestID << CAN_TI0R_STID_Pos) | CAN_ID_STD | rtr); // 设置标准帧ID和帧类型
        }
        else // 如果目标ID在扩展ID范围内
        {
            CAN_ARR[canNo - 1]->sTxMailBox[transmit_mailbox].TIR = ((DestID << CAN_TI0R_EXID_Pos) | CAN_ID_EXT | rtr); // 设置扩展帧ID和帧类型
        }

        // （2.2）设置发送帧的数据长度
        CAN_ARR[canNo - 1]->sTxMailBox[transmit_mailbox].TDTR = len; // 设置数据长度
        // SET_BIT(CAN_ARR[canNo-1]->sTxMailBox[transmit_mailbox].TDTR, CAN_TDT0R_TGT);

        // （2.3）设置发送帧的数据
        //  设置高位数据
        WRITE_REG(CAN_ARR[canNo - 1]->sTxMailBox[transmit_mailbox].TDHR,
                  ((uint32_t)buff[7] << CAN_TDH0R_DATA7_Pos) |
                      ((uint32_t)buff[6] << CAN_TDH0R_DATA6_Pos) |
                      ((uint32_t)buff[5] << CAN_TDH0R_DATA5_Pos) |
                      ((uint32_t)buff[4] << CAN_TDH0R_DATA4_Pos));
        // 设置低位数据
        WRITE_REG(CAN_ARR[canNo - 1]->sTxMailBox[transmit_mailbox].TDLR,
                  ((uint32_t)buff[3] << CAN_TDL0R_DATA3_Pos) |
                      ((uint32_t)buff[2] << CAN_TDL0R_DATA2_Pos) |
                      ((uint32_t)buff[1] << CAN_TDL0R_DATA1_Pos) |
                      ((uint32_t)buff[0] << CAN_TDL0R_DATA0_Pos));

        // （2.4）发送Can数据报
        SET_BIT(CAN_ARR[canNo - 1]->sTxMailBox[transmit_mailbox].TIR, CAN_TI0R_TXRQ); // 请求发送数据
        return 0;
    }
    else // 如果没有空闲邮箱
    {
        return 1;
    }
}

//=====================================================================
// 函数名称：CAN_HWInit
// 函数返回：0=正常，1=错误
// 参数说明：CANChannel:硬件引脚组号，共有3组，分别为PTA11&PTA12(CAN_CHANNEL0),PTB8&PTB9(CAN_CHANNEL1),PTD0&PTD1(2)
// 功能概要：CAN模块引脚初始化
//=====================================================================
uint8_t CAN_HWInit(uint8_t CANChannel)
{
    // 检查CANChannel的合法性，必须在0到2之间
    if (CANChannel < 0 || CANChannel > 2)
    {
        return 1;
    }

    // 根据CANChannel的值进行不同的引脚初始化
    if (CANChannel == 0)
    {
        RCC->APB1ENR1 |= RCC_APB1ENR1_CAN1EN; // 启用CAN1时钟
        RCC->AHB2ENR |= RCC_AHB2ENR_GPIOAEN;  // 启用GPIOA时钟
                                              // 配置PA11和PA12为复用功能模式
        GPIOA->MODER &= ~(GPIO_MODER_MODE11 | GPIO_MODER_MODE12);
        GPIOA->MODER |= (GPIO_MODER_MODE11_1 | GPIO_MODER_MODE12_1);
        // 配置PA11和PA12为CAN复用功能（AF9）
        GPIOA->AFR[1] &= ~(GPIO_AFRH_AFSEL11 | GPIO_AFRH_AFSEL12);
        GPIOA->AFR[1] |= (GPIO_AFRH_AFSEL11_0 | GPIO_AFRH_AFSEL11_3) | (GPIO_AFRH_AFSEL12_0 | GPIO_AFRH_AFSEL12_3);
    }
    else if (CANChannel == 1)
    {
        RCC->APB1ENR1 |= RCC_APB1ENR1_CAN1EN;
        RCC->AHB2ENR |= RCC_AHB2ENR_GPIOBEN;
        GPIOB->MODER &= ~(GPIO_MODER_MODE8 | GPIO_MODER_MODE9);
        GPIOB->MODER |= (GPIO_MODER_MODE8_1 | GPIO_MODER_MODE9_1);
        GPIOB->AFR[1] &= ~(GPIO_AFRH_AFSEL8 | GPIO_AFRH_AFSEL9);
        GPIOB->AFR[1] |= ((GPIO_AFRH_AFSEL8_0 | GPIO_AFRH_AFSEL8_3) |
                          (GPIO_AFRH_AFSEL9_0 | GPIO_AFRH_AFSEL9_3));
    }
    else
    {
        RCC->APB1ENR1 |= RCC_APB1ENR1_CAN1EN;
        RCC->AHB2ENR |= RCC_AHB2ENR_GPIODEN;
        GPIOD->MODER &= ~(GPIO_MODER_MODE0 | GPIO_MODER_MODE1);
        GPIOD->MODER |= (GPIO_MODER_MODE0_1 | GPIO_MODER_MODE1_1);
        GPIOD->AFR[0] &= ~(GPIO_AFRL_AFSEL0 | GPIO_AFRL_AFSEL1);
        GPIOD->AFR[0] |= ((GPIO_AFRL_AFSEL0_0 | GPIO_AFRL_AFSEL0_3) |
                          (GPIO_AFRL_AFSEL1_0 | GPIO_AFRL_AFSEL1_3));
    }
    return 0;
}

//=====================================================================
// 函数名称：CAN_SWInit_Entry
// 函数返回：0=正常，1=错误
// 参数说明：canNo:模块基地址号，本芯片只有CAN_1,
// 功能概要：进入初始化模式
//=====================================================================
uint8_t CAN_SWInit_Entry(uint8_t canNo)
{
    int i;

    // 取消睡眠模式，确保CAN模块不在睡眠状态
    CLEAR_BIT(CAN_ARR[canNo - 1]->MCR, CAN_MCR_SLEEP);

    // 取消睡眠模式，确保CAN模块不在睡眠状态
    i = 0;
    while ((CAN_ARR[canNo - 1]->MSR & CAN_MSR_SLAK) != 0U)
    {
        // 如果等待时间过长
        if (i++ > 0x30000)
        {
            return 1;
        }
    }

    // 进入初始化模式
    SET_BIT(CAN_ARR[canNo - 1]->MCR, CAN_MCR_INRQ);

    // 等待确认进入初始化模式
    i = 0;
    while ((CAN_ARR[canNo - 1]->MSR & CAN_MSR_INAK) == 0U)
    {
        if (i++ > 0x30000)
        {
            return 1;
        }
    }
    return 0;
}

//=====================================================================
// 函数名称：CAN_SWInit_CTLMode
// 函数返回：无
// 参数说明：canNo:模块基地址号，本芯片只有CAN_1,
// 功能概要：CAN总线模式设置
//=====================================================================
void CAN_SWInit_CTLMode(uint8_t canNo)
{
    CLEAR_BIT(CAN_ARR[canNo - 1]->MCR, CAN_MCR_TTCM); // 清除时间触发通信模式
    CLEAR_BIT(CAN_ARR[canNo - 1]->MCR, CAN_MCR_ABOM); // 清除自动离线管理模式
    CLEAR_BIT(CAN_ARR[canNo - 1]->MCR, CAN_MCR_AWUM); // 清除自动唤醒模式
    SET_BIT(CAN_ARR[canNo - 1]->MCR, CAN_MCR_NART);   // 设置无自动重传模式
    CLEAR_BIT(CAN_ARR[canNo - 1]->MCR, CAN_MCR_RFLM); // 清除接收FIFO锁定模式
    CLEAR_BIT(CAN_ARR[canNo - 1]->MCR, CAN_MCR_TXFP); // 清除发送FIFO优先级模式
}

//=====================================================================
// 函数名称：CAN_SWInit_CTLMode
// 函数返回：无
// 参数说明：canNo:模块基地址号，本芯片只有CAN_1,
//			CANMode:CAN总线工作模式，分别为正常模式(CAN_MODE_NORMAL)、回环模式(CAN_MODE_LOOPBACK)、
//										    静默模式(CAN_MODE_SILENT)以及回环与静默组合模式(CAN_MODE_SILENT_LOOPBACK)
// 功能概要：CAN总线位时序配置
//=====================================================================
void CAN_SWInit_BT(uint8_t canNo, uint32_t CANMode, uint32_t Prescaler)
{
    // 配置位时序和工作模式，预分频器值、同步跳转宽度为1个时间量、时间段1、时间段2、CAN总线工作模式
    CAN_ARR[canNo - 1]->BTR |= ((uint32_t)(Prescaler - 1) | CAN_SJW_1TQ | CAN_BTR_TS1_1 | CAN_BTR_TS1_0 | CAN_BTR_TS2_2 | CANMode);
}

//=====================================================================
// 函数名称：CAN_SWInit_Quit
// 函数返回：0=正常，1=错误
// 参数说明：canNo:模块基地址号
// 功能概要：退出初始化模式，进入正常模式
//=====================================================================
uint8_t CAN_SWInit_Quit(uint8_t canNo)
{
    int i;
    // 清除初始化请求位，退出初始化模式
    CLEAR_BIT(CAN_ARR[canNo - 1]->MCR, CAN_MCR_INRQ);

    // 等待确认退出初始化模式
    i = 0;
    while ((CAN_ARR[canNo - 1]->MSR & CAN_MSR_INAK) != 0U)
    {
        if (i++ > 0x30000)
        {
            return 1;
        }
    }
    return 0;
}

//=====================================================================
// 函数名称： CANFilterConfig
// 函数返回：0=正常，1=错误
// 参数说明： canNo:模块基地址号，
//		    canID：自身CAN节点的唯一标识，例如按照CANopen协议给出
//		    Can_Rx_FifoNo:中断使用的邮箱号，
//			IsActivate:是否激活过滤器
//			CANFilterBank:CAN总线过滤器组选择,共有28个,(CANFilterBank0~CANFilterBank27)
//			CANFiltermode:CAN总线过滤器模式，分别为掩码模式(CAN_FILTERMODE_IDMASK)和列表模式(CAN_FILTERMODE_IDLIST)
//			CAN_Filterscale:CAN总线过滤器位数，分别为32位(CAN_FILTERSCALE_32BIT)和16位(CAN_FILTERSCALE_16BIT)
// 功能概要：CAN接收中断开启
//=====================================================================
uint8_t CANFilterConfig(uint8_t canNo, uint32_t CanID, uint32_t FilterBank, uint32_t Can_Rx_FifoNo, uint8_t IsActivate, uint32_t FilterMode, uint32_t FilterScale)
{
    // 定义过滤器ID和掩码的高低位变量，以及过滤器编号位掩码
    uint32_t FilterIdHigh, FilterIdLow, FilterMaskIdHigh, FilterMaskIdLow, filternbrbitpos;

    // 如果CanID是标准ID（11位），将其左移至标准ID位置
    if (CanID <= 0x7FFU)
        CanID = CanID << CAN_TI0R_STID_Pos;

    // 将CanID的高低位分割出来
    FilterIdHigh = (CanID >> 16) & 0xFFFF;
    FilterIdLow = (CanID & 0xFFFF);
    // 设置过滤器掩码，高位和低位
    FilterMaskIdHigh = 0xFFE0;
    FilterMaskIdLow = 0x0000;
    // 计算过滤器编号位掩码
    filternbrbitpos = (uint32_t)1 << (FilterBank & 0x1FU);

    // 设置过滤器初始化模式 (FINIT=1),在此模式下可以进行过滤器初始化
    SET_BIT(CAN_ARR[canNo - 1]->FMR, CAN_FMR_FINIT);
    CLEAR_BIT(CAN_ARR[canNo - 1]->FA1R, filternbrbitpos); // 关闭过滤器

    // 配置过滤器的缩放模式
    if (FilterScale == CAN_FILTERSCALE_16BIT)
    {
        // 配置为16位模式
        CLEAR_BIT(CAN_ARR[canNo - 1]->FS1R, filternbrbitpos);
        CAN_ARR[canNo - 1]->sFilterRegister[FilterBank].FR1 =
            ((0x0000FFFFU & (uint32_t)FilterMaskIdLow) << 16U) |
            (0x0000FFFFU & (uint32_t)FilterIdLow);
        CAN_ARR[canNo - 1]->sFilterRegister[FilterBank].FR2 =
            ((0x0000FFFFU & (uint32_t)FilterMaskIdHigh) << 16U) |
            (0x0000FFFFU & (uint32_t)FilterIdHigh);
    }
    if (FilterScale == CAN_FILTERSCALE_32BIT)
    {
        // 配置为32位模式
        SET_BIT(CAN_ARR[canNo - 1]->FS1R, filternbrbitpos);
        CAN_ARR[canNo - 1]->sFilterRegister[FilterBank].FR1 =
            ((0x0000FFFFU & (uint32_t)FilterIdHigh) << 16U) |
            (0x0000FFFFU & (uint32_t)FilterIdLow);
        CAN_ARR[canNo - 1]->sFilterRegister[FilterBank].FR2 =
            ((0x0000FFFFU & (uint32_t)FilterMaskIdHigh) << 16U) |
            (0x0000FFFFU & (uint32_t)FilterMaskIdLow);
    }

    // 设置过滤器模式
    if (FilterMode == CAN_FILTERMODE_IDMASK)
    {
        CLEAR_BIT(CAN_ARR[canNo - 1]->FM1R, filternbrbitpos);
    }
    else
    {
        SET_BIT(CAN_ARR[canNo - 1]->FM1R, filternbrbitpos);
    }

    // 配置过滤器关联的FIFO
    if (Can_Rx_FifoNo == CAN_FILTER_FIFO0)
    {
        CLEAR_BIT(CAN_ARR[canNo - 1]->FFA1R, filternbrbitpos);
    }
    else
    {
        SET_BIT(CAN_ARR[canNo - 1]->FFA1R, filternbrbitpos);
    }

    // 激活或停用过滤器
    if (IsActivate == 1)
    {
        SET_BIT(CAN_ARR[canNo - 1]->FA1R, filternbrbitpos);
    }
    
    // 退出过滤器初始化模式 (FINIT=0)
    CLEAR_BIT(CAN_ARR[canNo - 1]->FMR, CAN_FMR_FINIT);

    return 0;
}

main.c

//主函数
int main(void)
{
	vuint32_t mMainLoopCount;  //主循环次数变量
	uint32_t localMsgID;
	uint32_t txMsgID;
	uint32_t BitRate;

	DISABLE_INTERRUPTS;

    mMainLoopCount=0;    //主循环次数变量
	localMsgID = 0x0BU;
	txMsgID = 0x0AU;
	BitRate = 36;

    //【***CAN模块初始化***】
    can_init(CAN_1,localMsgID,BitRate);

    //【***使能CAN模块中断***】
    can_enable_recv_int(CAN_1);

	ENABLE_INTERRUPTS;

	for(;;)
	{
        mMainLoopCount++;
		if (mMainLoopCount<=12889000)  continue;
		mMainLoopCount=0;
		
		//【***CAN模块发送一帧数据***】
		can_send(CAN_1, txMsgID, 15, (uint8_t*)"我是周源聪");
		printf("\r\n");
	}
}

isr.c

void CAN1_RX0_IRQHandler(void)
{
	uint8_t buff[8];
	uint8_t len = 0;
	DISABLE_INTERRUPTS;
	//【***CAN模块接收一帧数据***】
	len = can_recv(CAN_1, buff);
	if(len >= 0)
	{
		uart_sendN(UART_Debug, len, buff);
	}
	ENABLE_INTERRUPTS;
}

运行效果#

c42acb44c0b05f6af24e9d01167a60e

作者：YZXE

出处：https://www.cnblogs.com/YZXE/p/18244992

版权：本作品采用「署名-非商业性使用-相同方式共享 4.0 国际」许可协议进行许可。

posted @   一只心耳  阅读(98)  评论(0)  编辑  收藏  举报
相关博文：
· 嵌入式作业5.1 定时器编程
· 嵌入式作业3.1 GPIO点亮小灯
· 9、can总线相关内容
· 第29章 CAN介绍
· 49. CAN通信协议
阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
more_horiz
keyboard_arrow_up dark_mode palette
选择主题
menu
点击右上角即可分享
微信分享提示