前面我们用了很大篇幅介绍 CAN 总线和 STM32F1 的 CAN 控制器， 其实还是比较复杂的， 如果不明白没有关系， 我们可以先从软件层面上来学习怎么使用CAN，然后再回过头看这些理论知识，这样学习 CAN 应该会比较轻松。接下来我们就介绍下如何使用库函数对 CAN进行配置。这个也是在编写程序中必须要了解的。具体步骤如下：（CAN 相关库函数在 stm32f10x_can.c 和 stm32f10x_can.h文件中）

（1）使能 CAN 时钟，将对应引脚复用映射为 CAN 功能

    要使用 CAN，首先就是使能它的时钟，我们知道 CAN1 和 CAN2 是挂接在APB1总线上的，其发送和接收引脚对应不同的 STM32F1 IO（具体 IO 可以通过数据手册查找，也可以在我们原理图上查找），因此使能 CAN 时钟后，还需要使能对应端口的时钟，并且将其引脚配置为复用功能。因为我们使用的 STM32F103ZET6芯片只有一个 CAN， 即 CAN1， 其对应的 IO 是 PA11 （CAN1_RX） 和 PA12 （CAN1_TX） 。

    所以配置代码如下：

1. //使能相关时钟
   % T& i8 [/ q2 ]( y( A
2. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);//使能 PORTA时钟
   
3. RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);//使能 CAN1 时钟
   
4. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11; //PA11
   7 `& z7 R) a2 R) q" y
5. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //上拉输入模式
   8 F5 a9 T! s9 f" {  L! h' d0 a
6. GPIO_Init(GPIOA, &GPIO_InitStructure);
   / @" E* g8 z9 p( m! I# z4 m
7. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12; //PA12
   
8. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
   5 y# ~9 C) a& e; Y: y1 U6 r
9. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //IO 口速度为 50MHz
   1 ]: S+ ]/ ]) }3 b, r- `7 O
10. GPIO_Init(GPIOA, &GPIO_InitStructure);

复制代码

（2）设置 CAN 工作模式、波特率等

    使能了 CAN 时钟后，接下来就可以通过 CAN_MCR 寄存器配置其工作模式、波特率大小等参数。库函数中提供了 CAN_Init()函数用来完成这一步骤，函数原型是：

1. uint8_t CAN_Init(CAN_TypeDef* CANx, CAN_InitTypeDef*CAN_InitStruct);

复制代码

$ P# W4 w9 P' A

    函数中第一个参数是用来设置哪个 CAN，例如 CAN1；第二个参数是一个结构体指针变量，结构体类型是 CAN_InitTypeDef，其内包含了 CAN 工作模式及波特率初始化的成员变量。下面我们简单介绍下它的成员：

1. typedef struct
   % ?$ [$ o4 |6 k; A$ h: L
2. {
   
3. uint16_t CAN_Prescaler; //
   0 D9 e9 ~  W- P' {3 T. a
4. uint8_t CAN_Mode; //
   
5. uint8_t CAN_SJW; //
   
6. uint8_t CAN_BS1; //
   ( E, H8 ]* c0 t: ^
7. uint8_t CAN_BS2; //
   
8. FunctionalState CAN_TTCM; //
   
9. FunctionalState CAN_ABOM; //
   
10. FunctionalState CAN_AWUM; //
    
11. FunctionalState CAN_NART; //
    
12. FunctionalState CAN_RFLM; //
    " ^) Z" y! }" I
13. FunctionalState CAN_TXFP; //
    
14. } CAN_InitTypeDef;
    ) I6 E! ^$ @9 Q8 n6 _) V; Q3 X

复制代码

) E, ^3 Y  L; r! w) u$ U+ u2 N( ]; U

    CAN_Prescaler：用于设置 CAN 外设的时钟分频，它可控制时间片 tq 的时间长度，这里设置的值最终会加 1 后再写入 BRP 寄存器位。

    CAN_Mode ：用 于 设 置 CAN 的 工 作 模 式 ， 可 设 置 为 正 常 模 式

(CAN_Mode_Normal) 、 回 环 模 式 (CAN_Mode_LoopBack) 、 静 默 模 式(CAN_Mode_Silent)以及回环静默模式(CAN_Mode_Silent_LoopBack)。   

    本实验使用到的只有正常模式和回环模式。

    CAN_SJW：用于置 SJW 的极限长度，即 CAN 重新同步时单次可增加或缩短的最大长度，它可以被配置为 1-4tq(CAN_SJW_1/2/3/4tq)。

    CAN_BS1：用于设置 CAN 位时序中的 BS1 段的长度，它可以被配置为 1-16个 tq 长度(CAN_BS1_1/2/3…16tq)。

    CAN_BS2：用于设置 CAN 位时序中的 BS2 段的长度，它可以被配置为 1-8个 tq 长度(CAN_BS2_1/2/3…8tq)。

    CAN_TTCM：用于设置是否使用时间触发功能，ENABLE 为使能，DISABLE为失能。时间触发功能在某些CAN 标准中会使用到。

    CAN_ABOM：用于设置是否使用自动离线管理(ENABLE/DISABLE)，使用自动离线管理可以在节点出错离线后适时自动恢复，不需要软件干预。

    CAN_AWUM：用于设置是否使用自动唤醒功能(ENABLE/DISABLE)，使能自动唤醒功能后它会在监测到总线活动后自动唤醒。

    CAN_NART：用于设置是否使用自动重传功能(ENABLE/DISABLE)，使用自动重传功能时，会一直发送报文直到成功为止。

    CAN_RFLM：用于设置是否使用锁定接收 FIFO(ENABLE/DISABLE)，锁定接收FIFO 后，若 FIFO 溢出时会丢弃新数据，否则在 FIFO 溢出时以新数据覆盖旧数据。

    CAN_TXFP：用于设置发送报文的优先级判定方法(ENABLE/DISABLE)， 使能时，以报文存入发送邮箱的先后顺序来发送，否则按照报文 ID 的优先级来发送。

    了解结构体成员功能后，就可以进行配置，设置好 CAN_Prescaler、CAN_BS1和 CAN_BS2 的值，带入到CAN波特率计算公式：

    CAN 波特率=Fpclk1/((CAN_BS1+CAN_BS2+1)*CAN_Prescaler)就可以算出波特率。本章实验我们初始化配置 CAN 为正常工作模式，波特率为 500Kbps，配置代码如下：

1. CAN_InitTypeDef CAN_InitStructure;
   
2. //CAN 单元设置
   4 [/ g' x5 |3 M9 D! M5 {
3. CAN_InitStructure.CAN_TTCM=DISABLE; //非时间触发通信模式
   
4. CAN_InitStructure.CAN_ABOM=DISABLE; //软件自动离线管理
   # O( ^% A" o) O* `3 N! r0 F
5. CAN_InitStructure.CAN_AWUM=DISABLE;//睡眠模式通过软件唤醒(清除CAN->MCR 的 SLEEP 位)
   - `. _  A" h" E+ P  T
6. CAN_InitStructure.CAN_NART=ENABLE; //使用报文自动传送
   # s  N; k! d. S
7. CAN_InitStructure.CAN_RFLM=DISABLE; //报文不锁定,新的覆盖旧的
   
8. CAN_InitStructure.CAN_TXFP=DISABLE; //优先级由报文标识符决定
   
9. CAN_InitStructure.CAN_Mode= CAN_Mode_Normal; //模式设置
   2 h* @: V) H% T+ q# d- A9 y8 N& T! d
10. CAN_InitStructure.CAN_SJW=CAN_SJW_1tq; //重新同步跳跃宽度(Tsjw)为 tsjw+1 个时间单位 CAN_SJW_1tq~CAN_SJW_4tq
    / A* @) ?- Q7 ]( j) ?" O
11. CAN_InitStructure.CAN_BS1=CAN_BS1_7tq; //Tbs1 范 围 CAN_BS1_1tq~CAN_BS1_16tq
    
12. CAN_InitStructure.CAN_BS2=CAN_BS2_6tq;//Tbs2 范 围 CAN_BS2_1tq ~CAN_BS2_8tq
    ) w% ~; t( u  R. ^' z
13. CAN_InitStructure.CAN_Prescaler=6; //分频系数(Fdiv)为brp+1
    % Y! f) e% D6 y
14. CAN_Init(CAN1, &CAN_InitStructure); // 初始化 CAN1

复制代码

  ]3 R! Y" x9 [1 W0 T- Q. ?8 Q

（3）设置 CAN 筛选器

    设置好 CAN 的工作模式及波特率后，我们还需要通过 CAN_FMR 寄存器设置CAN 筛选器，库函数中提供了 CAN_FilterInit()函数来完成这一步骤，函数原型是：

1. void CAN_FilterInit(CAN_FilterInitTypeDef* CAN_FilterInitStruct);

复制代码

# f! E8 c2 k3 X& q: Z

    与前面一样采用结构体方式对 CAN 筛选器进行控制管理，结构体类型是
& E7 H3 s9 u, [! Y4 r

CAN_FilterInitTypeDef。下面我们简单介绍下它的成员：

1. typedef struct
   
2. {
   
3. uint16_t CAN_FilterIdHigh; //
   ' @$ e) [% I/ x4 ?3 F0 |6 m
4. uint16_t CAN_FilterIdLow; //
   , D! d( T2 l& w, F; l
5. uint16_t CAN_FilterMaskIdHigh; //
   
6. uint16_t CAN_FilterMaskIdLow; //
   ! Y; b+ e3 g; `" A* a- ^. G0 }6 w
7. uint16_t CAN_FilterFIFOAssignment; //
   
8. uint8_t CAN_FilterNumber; //
   & U6 y% {% d5 n: _  p+ o: t; U. U' w
9. uint8_t CAN_FilterMode; //
   
10. uint8_t CAN_FilterScale; //
    
11. FunctionalState CAN_FilterActivation; //
    ' r0 D6 B  V# Y) j
12. } CAN_FilterInitTypeDef;

复制代码

$ V- O1 V5 H0 @3 }/ J% f

    CAN_FilterIdHigh：用于存储要筛选的 ID，若筛选器工作在 32 位模式，
6 F& n: l# X" B* P) k  \) q. l; O- @% ]

它存储的是所筛选 ID 的高 16 位；若筛选器工作在 16 位模式，它存储的就是一个完整的要筛选的 ID。

    CAN_FilterIdLow：同上一个成员一样，它也是用于存储要筛选的 ID，若筛选器工作在 32 位模式， 它存储的是所筛选 ID 的低 16 位；若筛选器工作在 16位模式，它存储的就是一个完整的要筛选的 ID。

    CAN_FilterMaskIdHigh ：用 于 存 储 要 筛 选 的 ID 或 掩 码 。

CAN_FilterMaskIdHigh 存储的内容分两种情况，当筛选器工作在标识符列表模式时，它的功能与 CAN_FilterIdHigh 相同，都是存储要筛选的 ID；而当筛选器工作在掩码模式时，它存储的是 CAN_FilterIdHigh 成员对应的掩码，与CAN_FilterIdLow 组成一组筛选器。

    CAN_FilterMaskIdLow：同上一个成员一样，它也是用于存储要筛选的 ID

或掩码，只不过这里对应存储 CAN_FilterIdLow 的成员。

    CAN_FilterFIFOAssignment：用于设置当报文通过筛选器的匹配后，该报文会 被 存 储 到 哪 一 个 接 收 FIFO ， 它 的 可 选 值 为 FIFO0 或

FIFO1(CAN_Filter_FIFO0/1)。

    CAN_FilterNumber：用于设置筛选器的编号， 即使用的是哪个筛选器。CAN 一共有 28 个筛选器，所以它的可输入参数范围为 0-27。

    CAN_FilterMode：用于设置筛选器的工作模式，可以设置为列表模式

(CAN_FilterMode_IdList)及掩码模式(CAN_FilterMode_IdMask)。

CAN_FilterScale：用于设置筛选器的位宽，可以设置为 32 位长

(CAN_FilterScale_32bit)及 16 位长(CAN_FilterScale_16bit)。

CAN_FilterActivation：用于设置是否激活这个筛选器(ENABLE/DISABLE)。

了解结构体成员功能后，就可以进行配置，本章实验使用滤波器组 0，并工

作在 32 位标识符屏蔽位模式，配置代码如下：

1. CAN_FilterInitTypeDef CAN_FilterInitStructure;
   : R# z& E. {; K9 ^
2. //配置过滤器
   , _/ z' w' V9 T8 m( ~6 V$ A$ J0 C
3. CAN_FilterInitStructure.CAN_FilterNumber=0; //过滤器0
   
4. CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
   
5. CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
   % u$ {5 T: H2 V
6. //32位
   
7. CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;////32 位ID
   ' _' h0 m9 S; u. c; Z0 t9 Z
8. CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
   & d$ Q  G. S9 v, I
9. CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;//32 位MASK
   
10. CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
      t+ {& P! D2 N& a, A
11. CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0;
    4 Y8 B1 I5 V* ^' L
12. //过滤器 0 关联到 FIFO0
    
13. CAN_FilterInitStructure.CAN_FilterActivation=ENABLE; //激活过滤器0
    # c2 c# e: @" ?1 {8 @* i8 ~
14. CAN_FilterInit(&CAN_FilterInitStructure);//滤波器初始化

复制代码

（4）选择 CAN 中断类型，开启中断
, i4 B3 {$ r" x& s

    配置好上述 3 个步骤后，CAN 就可以开始工作了，如果要开启 CAN 的接收中断， 我们还需要选择它的中断类型并使能。配置 CAN 中断类型及使能的库函数是：

1. void CAN_ITConfig(CAN_TypeDef* CANx, uint32_t CAN_IT,FunctionalState NewState);

复制代码

0 y& L/ X, n( w* a

    第一个参数用来选择CAN，第二个参数用来选择 CAN 中断类型，最后一个参数用来使能或者失能 CAN中断。

    CAN 的中断类型很多，可以在 stm32f10x_can.h 文件查找，如下：

    比如我们使用 FIFO0 消息挂号允许中断，那么此参数可以设置为CAN_IT_FMP0。使能中断后还需要设置它的中断优先级，即初始化 NVIC。当产生中断后就会进去CAN接收中断内进行处理， 所以需要编写一个CAN接收中断函数，如 CAN1_RX0_IRQHandler。本实验默认不开启 CAN 的接收中断，所以此步骤可以不用配置。

（5）CAN 发送和接收消息

    初始化 CAN 相关参数以及筛选器之后，接下来就是发送和接收消息了。库

函数中提供了发送和接受消息的函数。

    发送消息的函数是：

1. uint8_t CAN_Transmit(CAN_TypeDef* CANx, CanTxMsg* TxMessage);

复制代码

    这个函数非常好理解，第一个参数用来选择 CAN，比如 CAN1，第二个参数是一个结构体指针变量，结构体类型是 CanTxMsg，其内包含了往邮箱发送的报文信息。下面我们简单介绍下它的成员：

1. typedef struct
   8 _3 E  X& x) f2 x7 ~  Y
2. {
   , x5 D' v% [: j8 n1 Y) B
3. uint32_t StdId;
   
4. uint32_t ExtId;
   3 S: T5 ~) i) d% o2 A! Y
5. uint8_t IDE;
   4 w0 F% A- j* x2 ~
6. uint8_t RTR;
   
7. uint8_t DLC;
   
8. uint8_t Data[8];
   ) T1 ^( p/ x4 ^! v
9. } CanTxMsg;

复制代码

    StdId：用于存储报文的 11 位标准标识符，范围是 0-0x7FF。
2 e9 N' d3 Q+ z: y

    ExtId：用于存储报文的 29 位扩展标识符， 范围是 0-0x1FFFFFFF。ExtId 与StdId 这两个成员哪一个有效要根据下面的 IDE 位配置。

    IDE：用于存储扩展标志 IDE 位的值，其值可配置为 CAN_ID_STD 和

CAN_ID_EXT。如果为 CAN_ID_STD 时表示本报文是标准帧，使用 StdId 成员存储报文 ID。如果为 CAN_ID_EXT 时表示本报文是扩展帧，使用 ExtId 成员存储报文 ID。

    RTR：用于存储报文类型标志 RTR 位的值，当它的值为宏 CAN_RTR_Data 时表示本报文是数据帧；当它的值为宏 CAN_RTR_Remote 时表示本报文是遥控帧，由于遥控帧没有数据段，所以当报文是遥控帧时，下面的 Data[8]成员的内容是无效的。

    DLC：用于存储数据帧数据段的长度，其值范围是 0-8，当报文是遥控帧时DLC 值为 0。

    Data[8]：用于存储数据帧中数据段的数据。

    当我们需要发送报文时，就需要对此结构体进行初始化，然后调用该函数发送出去，例如：

1. CanTxMsg TxMessage;
   ) f$ ^% S" F- Y% W7 T. ?9 w
2. TxMessage.StdId=0x12; // 标准标识符为 0
   
3. TxMessage.ExtId=0x12; // 设置扩展标示符（29 位）
   
4. TxMessage.IDE=0; // 使用扩展标识符
   
5. TxMessage.RTR=0; // 消息类型为数据帧，一帧 8 位
   5 K5 _* M. m4 x, i# H
6. TxMessage.DLC=8; // 发送两帧信息
   4 K1 S3 x, C9 @3 h
7. for(i=0;i<8;i++)
   8 n0 w1 d, G2 |3 b) r4 y1 A
8. TxMessage.Data[8]=msg[i]; // 第一帧信息
   * b& A+ x: z# [/ l; A( l
9. CAN_Transmit(CAN1, &TxMessage);

复制代码

/ c* O) c6 o  g& f- I3 V" n* i7 ~

    接收消息的函数是：

1. void CAN_Receive(CAN_TypeDef* CANx, uint8_t FIFONumber, CanRxMsg*RxMessage);

复制代码

5 y+ c3 O- @& A

    前两个参数很好理解，选择 CAN 和 FIFO。第三个参数是一个结构体指针变量，结构体类型是 CanRxMsg，与 CanTxMsg 比较类似，其内包含了从邮箱接收的报文信息。下面我们简单介绍下它的成员：

1. typedef struct
   
2. {
   2 R6 P2 Q/ b6 {! G3 l3 I1 q
3. uint32_t StdId;
   8 P# {1 K( t3 m7 r
4. uint32_t ExtId;
   : P' N% w& N; Z! Y9 C8 C
5. uint8_t IDE;
   
6. uint8_t RTR;
   " j* L- H: H! e7 x* ^
7. uint8_t DLC;
   
8. uint8_t Data[8];
   
9. uint8_t FMI;
   
10. } CanRxMsg;

复制代码

    前面几个成员和 CanTxMsg结构体内是一样的， 在 CanRxMsg 中多了一个成员FMI，它用于存储筛选器的编号，表示本报文是经过哪个筛选器存储进接收 FIFO的，可以用它简化软件处理。

（6）CAN 状态获取

    当使用 CAN 进行数据传输时， 我们会通过获取 CAN 状态标志来确认是否传输完成，比如说在接收报文时，通过检测标志位获知接收 FIFO 的状态，若收到报文，可调用库函数 CAN_Receive 把接收 FIFO 中的内容读取到预先定义的接收类型结构体中，然后再访问该结构体即可利用报文了。

    库函数中提供了很多获取 CAN 状态标志的函数，如 CAN_TransmitStatus()函数， CAN_MessagePending()函数， CAN_GetFlagStatus()函数等等，大家可以根据需要来调用。

    将以上几步全部配置好后，我们就可以使用 STM32F1 的 CAN收发数据了。