发现一篇关于bxcan外设的解析，分析的很到位，希望对那些对can通信有困惑的人有帮助。

弹指一春秋

文章来自：https://blog.csdn.net/ludaoyi88/article/details/53350077?utm_source=itdadao&utm_medium=referral

另有一篇是关于can通信的文章，讲的很生动：https://wenku.baidu.com/view/70736cf9c9d376eeaeaad1f34693daef5ef7131b.html


STM32的bxCAN外设介绍

STM32提供很好bxCAN外设，专门用于CAN总线编程。提供的很多的封装函数，提供了极大的便利，编程上大大减少时间，并易于理解。一般的103系列都有带有一个bxCAN外设，互联型的有2个bxCAN外设。

特点

由CAN_TX和CAN_RX两条收发线组成，外电路可通过芯片JT1050的CAN收发芯片，转换成CAN_H和CAN_L。

bxCAN模式选择（加粗部分为最常见的）

工作模式：初始化模式，正常模式，睡眠模式
测试模式：静默模式，环回模式，环回静默模式。

静默模式：只接不发。
环回模式：不接收，但发的同时，不仅发给外设备还自发自接。
环回静默模式：不接收，只能自发自接。
调试模式。
bxCAN的ID筛选器（关键）

使用筛选器，可以筛选出想要接收的指定ID数据，屏蔽不想要的数据，通过设置还筛选器，接收到的信息ID符合筛选器要求，那么消息将会被接收。一般STM32有14个筛选器，互联型有28个筛选器。

筛选器的两种工作模式：

1. 屏蔽模式：即掩码模式，通过设置寄存器：CAN_FxR1和CAN_FxR2（x指使用x号筛选器）。CAN_FxR1配置为期望收到的ID，CAN_FxR2为可选择屏蔽不检查不关心的ID位，即设置掩码ID(0表不关心此位，1表关心此位)。

eg，举例(使用筛选器0)：若CAN_F0R1=0xFFFF0000，CAN_F0R2=0xFF00FF00,表示最好期望能收到ID为0xFFFF0000的数据，但是设置了CAN_F0R2=0xFF00FF00，因此只关心[31：24][15：8]位的ID ,其他位不关心，因此只要传进来的ID为0xFFxx00xx，都可以接收。
2. 列表模式：

列表模式没有设置掩码ID功能，因此CAN_F0R2充当CAN_F0R1使用，只要接受的ID符合CAN_F0R1或者CAN_F0R2都可以。

bxCAN的发送和接收

1. 发送：bxCAN有3个发送邮箱，进行消息的发送。
2. 接收：bxCAN有两个FIFO，每个FIFO有3个邮箱，通过设置哪个FIFO进行消息接收，当有消息时会分别依次存进每个邮箱，若邮箱的消息没有及时读出，会出现溢出。
bxCAN的位时序（波特率设置）

上面的CAN概念简单的介绍了波特率的设置，bxCAN将传播时间段和相位缓冲时间段合并成一个段，因此只有3个段的位时间：tsjw，tb1，tb2。

另外波特率还跟bxCAN外设的时钟总线频率(fAPB1)以及分频系数（brp）有关。波特率公式：Fpclk1/((tsjw+tbs1+tbs2)*brp)

eg，举例:一般地，bxCAN外设的时钟总线频率fAPB1=36Mhz（F4系列为42M）。设置tsjw=1，tb1=7，tb2=8，brp=5。
则：波特率=Fpclk1/((tsjw+tbs1+tbs2)*brp) = 36M/(1+7+8)*5 = 450Kbps
3. STM32的bxCAN外设实验（程序设计）

bxCAN初始化流程

引脚配置以及使能时钟（APB1），其中CAN_RX引脚为上拉输入，CAN_TX为复用输出。
设置bxCAN模式（见上有讲解）。
设置波特率（tsjw，tb1，tb2，brp）
设置滤波器。
bxCAN设置滤波器流程

选择筛选器组号。
使用哪个FIFO(FIFO0或FIFO1)关联到筛选器号（即用哪个FIFO进行接收消息
设置筛选器模式以及需要筛选的ID
bxCAN发送流程

选用哪种帧类型（一般可选：标准数据帧，扩展数据帧，遥控帧）
设置标准帧（StdId），扩展帧（ExtId）的ID，以及需要一次性发送的数据长度（字节数）
将要发送的数据赋值给结构体成员（最多只能赋值8个字节的数据，每个数据1字节），并发送。
bxCAN接收流程

等待有消息到达。
将接收的消息（消息为结构体类型）存于指定FIFO（有2个FIFO，每个FIFO下有3个邮箱）。
把消息的数据提出。
将FIFO里的消息释放，避免堆积。
程序例程

实验内容：采用环回模式，过滤器采用掩码模式，进行扩展数据帧的bxCAN自发自接，并将接收的数据发送的电脑上位机显示。（程序只粘贴主要的内容）
    int main(void)
    {

        uint8_t  Data[8]="AJU8iK9a";//要发送的数据，一次不能超过8字节

        CanRxMsg RecieveMess; //注意！不能定义为指针形否则会卡死在CAN接收函数！
        char  Recievedata1[8]={0};
        char* Recievedata = Recievedata1;

        ALL_init();//时钟，GPIO，串口，延时初始化（不粘贴）

        //can1 环回模式（即发送数据同时还能给自己发，用于测试） 450Kbps波特率
        CANInit(CAN1 , CAN_Mode_LoopBack ,CAN_SJW_1tq , CAN_BS1_7tq , CAN_BS2_8tq ,5);

        printf("下面是CAN自测试（环回模式）\r\n");

        while(1)
        {

            if(CAN_TX_data(Data , sizeof(Data)/sizeof(uint8_t)))//注意长度获取不能在形参内去获取，否则出错
            {
                printf("发送成功\r\n");

                if(CAN_RX_data(RecieveMess , (u8*)Recievedata))
                {
                    printf("接收到数据:%s\r\n",Recievedata);
                }
                else
                {
                    printf("接收不到\r\n");
                }

            }
            else
            {
                printf("发送失败\r\n");
            }
            delay_ms(100);

        }
    }
    /*
    函数描述：can初始化配置（包括对时钟和IO配置）
    参数： CANx  CAN模式（环回模式和正常模式） 波特率有关的参数(tsjw,tbs1,tbs2,brp)
    返回：初始化成功返回1，否则0
    流程：
    1：CAN初始化（环回模式和正常模式）
    2：过滤器初始化（掩码模式和列表模式）

    CAN波特率计算方法：
        CAN1位于APB1线上，时钟36M
        波特率=Fpclk1/((tsjw+tbs1+tbs2)*brp) = 36M/(1+7+8)*5 = 450Kbps;

    */

    char CANInit(CAN_TypeDef* CANx  ,u8 CAN_Mode_xyz ,u8 tsjw,u8 tbs1,u8 tbs2 ,u8 brp)
    {

        char StateFlag = 0;
        CAN_InitTypeDef CAN_InitStruct;
        CAN_FilterInitTypeDef CAN_FilterInitStruct;

        //时钟和复用IO口配置
        if(CANx == CAN1)
        {
            RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);
            RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1  , ENABLE);

            GPIOInit(GPIOA , GPIO_Pin_11 , GPIO_Mode_IPU , 1 ); //can_RX   GPIO_Mode_IN_FLOATING
            GPIOInit(GPIOA , GPIO_Pin_12 , GPIO_Mode_AF_PP ,2); //can_TX
        }

        if(CANx == CAN2)
        {
            RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE);
            RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2  , ENABLE);

                GPIOInit(GPIOB , GPIO_Pin_12 ,GPIO_Mode_IN_FLOATING ,1); //can_RX
            GPIOInit(GPIOB , GPIO_Pin_13 , GPIO_Mode_AF_PP , 1 ); //can_TX

        }

        CAN_DeInit(CANx);

        ///////////////CAN参数初始化///////////////
        CAN_InitStruct.CAN_ABOM = DISABLE;
        CAN_InitStruct.CAN_AWUM = DISABLE;
        CAN_InitStruct.CAN_Mode = CAN_Mode_xyz;//can模式   CAN_Mode_LoopBack;// CAN_Mode_Normal  
        CAN_InitStruct.CAN_NART = DISABLE;
        CAN_InitStruct.CAN_RFLM = DISABLE;
        CAN_InitStruct.CAN_TTCM = DISABLE;
        CAN_InitStruct.CAN_TXFP = DISABLE;  

        CAN_InitStruct.CAN_Prescaler = brp; //分频
        CAN_InitStruct.CAN_SJW = tsjw;//CAN_SJW_1tq;//同步时间  Tq
        CAN_InitStruct.CAN_BS1 = tbs1;//CAN_BS1_1tq;
        CAN_InitStruct.CAN_BS2 = tbs2;//CAN_BS2_4tq;



        StateFlag = CAN_Init(CANx, &CAN_InitStruct);//初始化成功返回1

        ///////////过滤器初始化（掩码模式）////////////
        CAN_FilterInitStruct.CAN_FilterActivation = ENABLE;//使能过滤器
        CAN_FilterInitStruct.CAN_FilterNumber = 0;  //过滤器号，可选0--13（F103）
        CAN_FilterInitStruct.CAN_FilterFIFOAssignment = CAN_FilterFIFO0; //使用FIFO0，过滤器0关联到FIFO0（可选FIFO0和FIFO1）

        //能通过的标准ID号
        CAN_FilterInitStruct.CAN_FilterIdHigh =0xABCDEF98>>16;//0xABC<<4;//;  //标准ID不能为：1111111xxxx类型
        CAN_FilterInitStruct.CAN_FilterIdLow =0xABCDEF98&0x0000FFF8;// 0x00 ;

    //接收的ID号需要严格检测的位，该位不符合标准ID号相应的位，则不让通过
        CAN_FilterInitStruct.CAN_FilterMaskIdHigh = 0xFFFF ;//0x0000; //0表此位不关心
        CAN_FilterInitStruct.CAN_FilterMaskIdLow = 0xFFF8 & 0xFFF8;//扩展帧下，掩码模式只能关心前29位，后3位不能关心
        CAN_FilterInitStruct.CAN_FilterMode = CAN_FilterMode_IdMask;  //过滤器为掩码模式   //CAN_FilterMode_IdList为列表模式
        ;
        CAN_FilterInitStruct.CAN_FilterScale = CAN_FilterScale_32bit;//过滤器为32位

        CAN_FilterInit(&CAN_FilterInitStruct);

        return StateFlag;

    }
    /*
    函数描述：can数据发送
    参数： 发送的数据
    返回：发送成功返回1
    说明： 发送数据得配置发送数据的参数，将数据和相关参数写入结构体再发送

    发送参数配置流程：
    1：选择帧类型（标准数据帧 ，扩展数据帧，遥控帧）
    （标准帧ID11位 扩展帧ID29位  遥控帧：只有ID无数据，请求指定ID发数据）
    2：写入ID
    3：写入数据（帧数据总长度64位，可最多一次性写入8个数据，每个数据只占1字节）
    4：通过结构体把数据及ID参数发出去，并自动返回发出的邮箱号（发送邮箱一共有3个）
    5：等待发送成功
    */
    char CAN_TX_data(u8 *TXdata ,u8 DataLen)
    {
        int i=0;
        u8 mailbox;
        CanTxMsg TxMessage;
        uint8_t TXdata1[8]={0};

        //设置为标准数据帧   （还有扩展数据帧  遥控帧）
        TxMessage.RTR = CAN_RTR_Data;//数据帧
        TxMessage.IDE =CAN_Id_Extended;//CAN_Id_Standard// CAN_Id_Standard;//使用标准帧id

        TxMessage.StdId = 0xABC>>1;//0x12;//标准帧ID
        TxMessage.ExtId = 0xABCDEF98>>3;//0x12;//扩展帧ID
        TxMessage.DLC = DataLen;//sizeof(TXdata)/sizeof(uint8_t); //需要一次性发送的数据个数（不超过8个）


        for(i =0 ;i < DataLen ; i++)//
        {
            TxMessage.Data[i] = TXdata[i];//Data个数小于8个，并且每个数据大小为1字节
    //      printf("%d ",sizeof(TXdata));
        }

        mailbox = CAN_Transmit(CAN1, &TxMessage);//将消息发送出去。返回值为发送出去的邮箱号


        //等待发送成功
        i = 0xfff;
        while(CAN_TransmitStatus(CAN1, mailbox) != CAN_TxStatus_Ok &&i) //获取该邮箱号的发送成功与否标志，一定的延迟防止死循环
        {
        i--;
        }

        if(i==0)  return  0;  //发送失败 ，返回0
        else  return 1;  //发送成功，返回1
     //
    }
    /*
    函数描述：can数据接收
    参数： 接收的数据和参数的结构体   接收的数据部分
    返回：接收成功返回1
    说明：接收数据存于结构体中，应对结构体进行解析读取。

    接收流程：
    1：等待有消息到达
    2:将接收的消息（消息为结构体类型）存于指定FIFO（有2个FIFO，每个FIFO下有3个邮箱）
    3:把消息的数据提出
    4：将FIFO里的消息释放，避免堆积。

    注意：函数定义形参：CanRxMsg  RecieveData; 应该为非指针形。否则会出现多一个字符的乱码现象。
    */
    char CAN_RX_data(CanRxMsg  RecieveData , uint8_t *RXdata)
    {
    //  CanRxMsg  RecieveData1;
        int i = 0xfff;

        if(!CAN_MessagePending(CAN1, CAN_FIFO0)) //注意：CAN_FIFO0，不是CAN_FilterFIFO0
        {
            return  0;//没有数据接收 ，返回0
        }

        CAN_Receive(CAN1, CAN_FIFO0 , &RecieveData);//接收FIOFO_0下的邮箱（CAN1有两个FIFO，每个FIFO有3级邮箱）

        //把这次接收所有数据都提取并存起来
        for(i=0; i<RecieveData.DLC ;i++)
        {
            RXdata[i] =RecieveData.Data[i];
        }

    //  printf("长度%d ",RecieveData.DLC);

        CAN_FIFORelease(CAN1, CAN_FilterFIFO0);  //释放FIFO_0邮箱的消息,以便接收新消息

        return 1;  //接收成功，返回1
    }
编程调试心得（总结一些知识要点）

1 对CAN_RX_data的函数定义

如果函数定义成形式：char CAN_RX_data(CanRxMsg* RecieveData , uint8_t *RXdata);会出现如下反应：
i:如果 CanRxMsg RecieveMess; 放在CAN_RX_data函数外，即主函数里，将会多打印出一字符：”接收到数据:AED9i8ua”(会多接收到一个的乱码)
ii:如果 CanRxMsg RecieveMess; 放在函数内，显示正常：”接收到数据:AED9i8ua”
如果函数定义成形式：char CAN_RX_data(CanRxMsg RecieveData , uint8_t *RXdata);,即：RecieveData为非指针。
无论CanRxMsg RecieveMess; 在函数内还是函数外不影响。
分析原因：和形参的指针有关（形参应该为非指针形式）。具体详细原因未解。
2 知识难点（针对过滤器（筛选器）的理解与配置）：

如果是接收的数据是标准帧格式：
标准帧ID占用位数为11位， 在发送函数中设置的标准帧ID（StdId）只需为低11位赋值即可，另外高5位可任意。
过滤器的ID号与接收的标准帧ID是左对齐形式（即32位与11位的左对齐），因此过滤器的ID号的高11位有过滤的效果，其他位可设任意值。
举例，如：发送函数配置的标志帧ID：StdId=0xFA8B;则标准帧ID= 010 1000 1011（取最低的11位）
如果在掩码模式的所有位都在检测的情况下，那么过滤器ID号高11位和标准帧ID应该一样，
可以取:CAN_FilterIdHigh=0x516F=010 1000 1011 01111 ( CAN_FilterIdLow 任意）
同理，如果是接收的数据是扩展帧格式：
标准帧ID占用位数为29位，只需对ExtId的低29位赋值即可。
过滤时和过滤ID好也是左对齐，因此过滤器的ID号的高29位有过滤的效果，其他位可设任意值。
3 对过滤器（筛选器）配置方法的改进：

改进：由于以上给帧ID和过滤器ID赋值格式不统一，也不容易计算。为了统一并方便观察，
对取标准/扩展帧ID和过滤器ID的赋值进行如下改进。（最严格情况：掩码模式对所有位都要关心）
举例（标准帧），如程序可设置标准帧ID宏定义为：0xABC（取前11位，最后一位必须取0，不作为标准ID位）。但是，将其写入StdId时，需右移动一位，取出高11位作为有效位：
StdId = 0xABC>>1; //（取出11位)
CAN_FilterIdHigh= 0xABC<<4; //11个有效位移动到最左端（使32位过滤ID与11位标准帧的左对齐）
举例（扩展帧）：如程序可设置扩展帧ID宏定义为：0xABCDEF98（取前29位，最后3位必须取0，不作为标准ID位），但是，将其写入ExtId为时，需右移动3位，取出高29位作为有效位：
ExtId = 0xABCDEF98>>3;（取出29位）
CAN_FilterIdHigh = 0xABCDEF98>>16;
CAN_FilterIdLow = 0xABCDEF98&0x0000FFF8 ;//29个有效位移到最高位（使32位过滤ID与29位标准帧的左对齐）
需要注意：
在标准帧下，对于32位的过滤器，设置掩码ID只能关心高11位，后25位不能关心。（掩码ID：0表不关心此位，1表关心此位）
在扩展帧下，设置掩码ID只能关心高29位，后3位不能关心。

正点原子

谢谢分享，最好发分享帖。