引言

CAN 是 Controller Area Network 的缩写（以下称为 CAN），是 ISO 国际标准化的串行通信协议。CAN 总线是一种应用广泛的现场总线，是近20年发展起来的新技术。在当前的汽车产业中，出于对安全性、舒适性、方便性、低公害、低成本的要求，各种各样的电子控制系统被开发了出来。由于这些系统之间通信所用的数据类型及对可靠性的要求不尽相同，由多条总线构成的情况很多，线束的数量也随之增加。为适应“减少线束的数量”、“通过多个 LAN，进行大量数据的高速通信”的需要，1986 年德国电气商博世公司开发出面向汽车的 CAN 通信协议。此后，CAN 通过 ISO11898 及 ISO11519 进行了标准化，现在在欧洲已是汽车网络的标准协议。
现在，CAN 的高性能和可靠性已被认同，并被广泛地应用于工业自动化、船舶、医疗设备、工业设备等方面。现场总线是当今自动化领域技术发展的热点之一，被誉为自动化领域的计算机局域网。它的出现为分布式控制系统实现各节点之间实时、可靠的数据通信提供了强有力的技术支持。近年来，其所具有的高可靠性和良好的错误检测能力受到重视，被广泛应用于汽车计算机控制系统和环境温度恶劣、电磁辐射强和振动大的工业环境。

介绍CAN协议的特点

CAN属于总线式串行通信网络。由于采用了许多新技术和独特的设计思想 ,与同类产品相比 , CAN 总线在数据通信方面具有可靠、实时和灵活的优点。
CAN 总线上用“显性”（Dominant）和“隐性” (Recessive)两个互补的逻辑值表示“0”和“1”。CAN-H和CAN-L为CAN总线收发器 与总线之间的两接口引脚，信号是以两线之间的“差 分”电压形式出现。在隐性状态，CNA-H和CANL被固定在平均电压电平附近，Vdiff近似于0。显性位以大于最小阀值的差分电压表示。CAN 总线的通信距离最远可达10Km(位速率为5 kbps) ，通信速率最快可达 1Mbps（此时最长通信距离为40m）。

• 多主控制。在总线空闲时，所有单元都可以发送消息（多主控制），而两个以上的单元同时开始发送消息时，根据标识符（Identifier 以下称为 ID）决定优先级。ID 并不是表示发送的目的地址，而是表示访问总线的消息的优先级。两个以上的单元同时开始发送消息时，对各消息 ID 的每个位进行逐个仲裁比较。仲裁获胜（被判定为优先级最高）的单元可继续发送消息，仲裁失利的单元则立刻停止发送而进行接收工作。
• 系统的柔软性。与总线相连的单元没有类似于“地址”的信息。因此在总线上增加单元时，连接在总线上的其它单元的软硬件及应用层都不需要改变。
• 通信速度较快，通信距离远。最高 1Mbps（距离小于 40M），最远可达10KM（速率低于 5Kbps）。
• 具有错误检测、错误通知和错误恢复功能。所有单元都可以检测错误（错误检测功能），检测出错误的单元会立即同时通知其他所有单元（错误通知功能），正在发送消息的单元一旦检测出错误，会强制结束当前的发送。强制结束发送的单元会不断反复地重新发送此消息直到成功发送为止（错误恢复功能）。
• 故障封闭功能。CAN 可以判断出错误的类型是总线上暂时的数据错误（如外部噪声等）还是持续的数据错误（如单元内部故障、驱动器故障、断线等）。由此功能，当总线上发生持续数据错误时，可将引起此故障的单元从总线上隔离出去。
• 连接节点多。CAN 总线是可同时连接多个单元的总线。可连接的单元总数理论上是没有限制的。但实际上可连接的单元数受总线上的时间延迟及电气负载的限制。降低通信速度，可连接的单元数增加；提高通信速度，则可连接的单元数减少。
  
  , H0 v' D2 e  B- r7 l9 b2 M
  7 A. a5 E& V2 H( U

正是因为 CAN 协议的这些特点，使得 CAN 特别适合工业过程监控设备的互连，因此，越来越受到工业界的重视，并已公认为最有前途的现场总线之一。

4 ?& h6 W: M5 W5 L6 `  l  B

CAN的帧
6 T7 p! p% O' wCAN的帧的类型

CAN 协议是通过以下 5 种类型的帧进行的：

• 数据帧
• 遥控帧
• 错误帧
• 过载帧
• 间隔帧
  
  

( @  M1 u$ O; P, m

另外，数据帧和遥控帧有标准格式和扩展格式两种格式。标准格式有 11 个位的标识符（ID），扩展格式有 29 个位的 ID。

帧类型	帧用途
数据帧	用于发送单元向接收单元传送数据的帧
遥控帧	用于接收单元向具有相同 ID 的发送单元请求数据的帧
错误帧	用于当检测出错误时向其它单元通知错误的帧
过载帧	用于接收单元通知其尚未做好接收准备的帧
间隔帧	用于将数据帧及遥控帧与前面的帧分离开来的帧

! M8 U) n9 s$ f) l1 v
数据帧的构成

• 帧起始。表示数据帧开始的段。
• 仲裁段。表示该帧优先级的段。
• 控制段。表示数据的字节数及保留位的段。
• 数据段。数据的内容，一帧可发送 0~8 个字节的数据。
• CRC 段。检查帧的传输错误的段。
• ACK 段。表示确认正常接收的段。
• 帧结束。表示数据帧结束的段。
  
  
  

STM32的CAN

STM32F1 自带的是 bxCAN，即基本扩展 CAN。它支持 CAN 协议 2.0A 和 2.0B。它的设计目标是，以最小的 CPU 负荷来高效处理大量收到的报文。它也支持报文发送的优先级要求(优先级特性可软件配置)。
- M7 t( }: a2 Q5 V$ G, USTM32F1 的 bxCAN 的主要特点有：

• 支持 CAN 协议 2.0A 和 2.0B 主动模式
• 波特率最高达 1Mbps
• 支持时间触发通信
• 具有 3 个发送邮箱
• 具有 3 级深度的 2 个接收 FIFO
• 可变的过滤器组（最多 28 个）
  
  ) X8 w. y# {, C) a% z* m- d, J
  

低速CAN总线为开环，高速CAN总线为闭环，总线由CAN_H和CAN_L两根线组成，总线上可以挂多个节点设备。每个节点设备由CAN控制器和CAN收发器组成，CAN控制器通常作为外设集成在MPU/MCU上，而CAN收发器则需要外围添加芯片电路。

CAN的发送接收CAN的发送流程

CAN 发送流程为：程序选择 1 个空置的邮箱（TME=1）→设置标识符（ID），数据长度和发送数据→设置 CAN_TIxR 的 TXRQ 位为 1，请求发送→邮箱挂号（等待成为最高优先级）→预定发送（等待总线空闲）→发送→邮箱空置。

CAN的接收流程

CAN 接收到的有效报文，被存储在 3 级邮箱深度的 FIFO 中。FIFO 完全由硬件来管理，从而节省了 CPU 的处理负荷，简化了软件并保证了数据的一致性。应用程序只能通过读取FIFO输出邮箱，来读取 FIFO 中最先收到的报文。这里的有效报文是指那些正确被接收的（直到 EOF都没有错误）且通过了标识符过滤的报文。前面我们知道 CAN 的接收有 2 个 FIFO，我们每个滤波器组都可以设置其关联的 FIFO，通过 CAN_FFA1R 的设置，可以将滤波器组关联到FIFO0/FIFO1。
CAN 接收流程为：FIFO 空 → 收到有效报文 → 挂号_1（存入 FIFO 的一个邮箱，这个由硬件控制，我们不需要理会）→ 收到有效报文 → 挂号_2 → 收到有效报文→挂号_3→收到有效报文→溢出。
这个流程里面，我们没有考虑从 FIFO 读出报文的情况，实际情况是：我们必须在 FIFO 溢出之前，读出至少 1 个报文，否则下个报文到来，将导致 FIFO 溢出，从而出现报文丢失。每读出 1 个报文，相应的挂号就减 1，直到 FIFO 空。
. u& V# J  p. P; E: U. sFIFO 接收到的报文数，我们可以通过查询 CAN_RFxR 的 FMP 寄存器来得到，只要 FMP不为 0，我们就可以从 FIFO 读出收到的报文。

CAN控制和状态寄存器
CAN主控制寄存器 (CAN_MCR)
" [) Q9 |5 p; B

: W# q: C7 J: h" }; P

对于我们正常的开发来说，INRQ 位是最重要的一位，该位用来控制初始化请求。
$ M9 n  e  Y  A5 F# i2 N0 ^软件对该位清 0，可使 CAN 从初始化模式进入正常工作模式：当 CAN 在接收引脚检测到连续的 11 个隐性位后，CAN 就达到同步，并为接收和发送数据作好准备了。为此，硬件相应地对 CAN_MSR 寄存器的 INAK 位清’0’。
软件对该位置 1 可使 CAN 从正常工作模式进入初始化模式：一旦当前的 CAN 活动(发送或接收)结束，CAN 就进入初始化模式。相应地，硬件对 CAN_MSR 寄存器的 INAK 位置’1’。
所以我们在 CAN 初始化的时候，先要设置该位为 1，然后进行初始化（尤其是 CAN_BTR的设置，该寄存器，必须在 CAN 正常工作之前设置），之后再设置该位为 0，让 CAN 进入正常工作模式。

0 {: @  ^' v/ M6 N3 M! r

CAN 位时序寄存器（CAN_BTR）

当CAN处于初始化模式时，该寄存器只能由软件访问。

该寄存器用于设置分频、Tbs1、Tbs2以及 Tsjw 等非常重要的参数，直接决定了 CAN 的波特率。另外该寄存器还可以设置 CAN 的工作模式。

6 h4 T! d+ E) x; S3 f8 M# d# F

STM32 提供了两种测试模式，环回模式和静默模式，当然他们组合还可以组合成环回静默模式。
, j# _2 Z. _/ Z在环回模式下，bxCAN 把发送的报文当作接收的报文并保存(如果可以通过接收过滤)在接收邮箱里。也就是环回模式是一个自发自收的模式。
# N1 x' k) e4 G0 _环回模式可用于自测试。为了避免外部的影响，在环回模式下 CAN 内核忽略确认错误(在数据/远程帧的确认位时刻，不检测是否有显性位)。在环回模式下，bxCAN 在内部把 Tx 输出回馈到 Rx 输入上，而完全忽略 CANRX 引脚的实际状态。发送的报文可以在CANTX 引脚上检测到。

CAN 发送邮箱标识符寄存器（CAN_TIxR）

• 当其所属的邮箱处在等待发送的状态时，该寄存器是写保护的
• 该寄存器实现了发送请求控制功能(第0位)－复位值为0
  
  " k* E! `( I+ l( D

8 c4 a  V, A: o8 H' p

该寄存器主要用来设置标识符（包括扩展标识符），另外还可以设置帧类型，通过 TXRQ值 1，来请求邮箱发送。因为有 3 个发送邮箱，所以寄存器CAN_TIxR 有 3 个。

CAN 发送邮箱数据长度和时间戳寄存器 (CAN_TDTxR)

当邮箱不在空置状态时，该寄存器的所有位为写保护。

9 f% H- d" s3 m% F; I5 Z% |

该寄存器我们本章仅用来设置数据长度，即最低 4 个位。

! e0 @% F. t/ d% H- }8 s+ E

CAN 发送邮箱低字节数据寄存器 (CAN_TDLxR)
5 K5 R" J' ~. c( J

+ a# J9 o. e  w5 k4 j  \& L6 ^

该寄存器用来存储将要发送的数据，这里只能存储低 4 个字节，另外还有一个寄存器CAN_TDHxR，该寄存器用来存储高 4 个字节，这样总共就可以存储 8 个字节。CAN_TDHxR的各位描述同 CAN_TDLxR 类似。

CAN 接收 FIFO 邮箱标识符寄存器 (CAN_RIxR)

该寄存器各位描述同 CAN_TIxR 寄存器几乎一模一样，只是最低位为保留位，该寄存器用于保存接收到的报文标识符等信息，我们可以通过读该寄存器获取相关信息。

同样的，CAN 接收 FIFO 邮箱数据长度和时间戳寄存器 (CAN_RDTxR) 、CAN 接收 FIFO邮 箱 低 字 节 数 据 寄 存 器 (CAN_RDLxR) 和 CAN 接 收 FIFO 邮 箱 高 字 节 数 据 寄 存 器(CAN_RDHxR) 分别和发送邮箱的：CAN_TDTxR、CAN_TDLxR 以及 CAN_TDHxR 类似。

软件实现

HAL 库 中 CAN 相 关 的 函 数 在 文 件 stm32f1xx_hal_can.c 和 对 应 的 头 文 件stm32f1xx_hal_can.h 中。

! Y+ h  C6 J% ?4 aCAN 的初始化配置步骤

• 配置相关引脚的复用功能，使能 CAN 时钟。
  我们要用 CAN，第一步就要使能 CAN 的时钟，CAN 的时钟通过 APB1ENR 的第 25 位来设置。其次要设置 CAN 的相关引脚为复用输出，这里我们需要设置 PA11 为上拉输入（CAN_RX引脚）PA12 为复用输出（CAN_TX 引脚），并使能 PA 口的时钟。CAN 发送接受引脚是哪些口，可以在中文参考手册引脚表里面查找。
  
  ! M$ v  k+ \; L9 G- e9 A* |- _
  : Y% k" c- K" g

1. 
   # ^3 Q; a  f. ]$ p2 b2 {* b- |
2.     GPIO_InitTypeDef GPIO_Initure;
   
3.    
   0 a, d0 C6 d4 J/ X2 h
4.     __HAL_RCC_CAN1_CLK_ENABLE();                //使能CAN1时钟
   ; X& ^  j3 W) Y- R; k& d. P
5.     __HAL_RCC_GPIOA_CLK_ENABLE();          //开启GPIOA时钟
   
6.   
   5 d% j8 `- a/ P* C
7.     GPIO_Initure.Pin=GPIO_PIN_12;         //PA12
   
8.     GPIO_Initure.Mode=GPIO_MODE_AF_PP;          //推挽复用
   
9.     GPIO_Initure.Pull=GPIO_PULLUP;              //上拉
   3 [0 K+ D+ i2 z& l
10.     GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;    //高速
    0 P* X9 ], [) a3 ?0 W4 U# n- ^
11.     HAL_GPIO_Init(GPIOA,&GPIO_Initure);         //初始化  
    
12.   GPIO_Initure.Pin=GPIO_PIN_11;         //PA11
    % W& p7 t4 p  P8 O! v) K
13.   GPIO_Initure.Mode=GPIO_MODE_AF_INPUT;       //推挽复用
    
14.   HAL_GPIO_Init(GPIOA,&GPIO_Initure);         //初始化

复制代码

2.设置 CAN 工作模式及波特率等。

这一步通过先设置 CAN_MCR 寄存器的 INRQ 位，让 CAN 进入初始化模式，然后设置CAN_MCR 的其他相关控制位。再通过 CAN_BTR 设置波特率和工作模式（正常模式/环回模式）等信息。最后设置 INRQ 为 0，退出初始化模式。

在库函数中，提供了函数 HAL_CAN_Init 用来初始化 CAN 的工作模式以及波特率，HAL_CAN_Init 函数体中，在初始化之前，会设置 CAN_MCR 寄存器的 INRQ 为 1 让其进入初始化模式，然后初始化 CAN_MCR 寄存器和 CRN_BTR 寄存器之后，会设置 CAN_MCR 寄存器的 INRQ 为 0 让其退出初始化模式。所以我们在调用这个函数的前后不需要再进行初始化模式设置。

. n; |5 Y/ E  _0 ]

初始化实例为：

1.     CAN_HandleTypeDef   CAN1_Handler;  //CAN1句柄
   
2.     CAN_InitTypeDef    CAN1_InitConf;
   1 J) H% w, ]5 c; p, b
3.     CAN1_Handler.Instance=CAN1;
   ! B: e$ c- L8 H3 g' A. o6 K
4.     CAN1_Handler.Init = CAN1_InitConf;  
   & M8 n8 E$ V0 [4 |
5.     CAN1_Handler.Init.Prescaler=brp;        //分频系数(Fdiv)为brp+1
   
6.     CAN1_Handler.Init.Mode=mode;          //模式设置
   * d5 |8 f7 y2 m. Y
7.     CAN1_Handler.Init.SyncJumpWidth=tsjw;      //重新同步跳跃宽度(Tsjw)为tsjw+1个时间单位 CAN_SJW_1TQ~CAN_SJW_4TQ
   
8.     CAN1_Handler.Init.TimeSeg1=tbs1;        //tbs1范围CAN_BS1_1TQ~CAN_BS1_16TQ
   
9.     CAN1_Handler.Init.TimeSeg2=tbs2;        //tbs2范围CAN_BS2_1TQ~CAN_BS2_8TQ
   
10.     CAN1_Handler.Init.TimeTriggeredMode=DISABLE;  //非时间触发通信模式
    8 x% M: k7 l/ Z: D0 [
11.     CAN1_Handler.Init.AutoBusOff=DISABLE;      //软件自动离线管理
    + B4 @! Z: N% Z3 m: U% G
12.     CAN1_Handler.Init.AutoWakeUp=DISABLE;      //睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    
13.     CAN1_Handler.Init.AutoRetransmission=ENABLE;  //禁止报文自动传送
    ; [, k: d1 h0 ~6 F
14.     CAN1_Handler.Init.ReceiveFifoLocked=DISABLE;  //报文不锁定,新的覆盖旧的
    
15.     CAN1_Handler.Init.TransmitFifoPriority=DISABLE;  //优先级由报文标识符决定
    
16.     if(HAL_CAN_Init(&CAN1_Handler)!=HAL_OK)      //初始化
    
17.     return 1;
    
18.     return 0;

复制代码

HAL 库通用提供了 MSP 初始化回调函数，CAN 回调函数为：

1. void HAL_CAN_MspInit(CAN_HandleTypeDef* hcan);

复制代码

% b& L+ t- N' R

该回调函数一般用来编写时钟使能，IO 初始化以及 NVIC 等配置。

1.   CAN_FilterTypeDef  sFilterConfig;
   * Y  v* k, L" y3 D+ m4 s7 v3 ~
2.   /*配置CAN过滤器*/
   
3.   sFilterConfig.FilterBank = 0;                     //过滤器0
   ' B1 w5 x5 f7 f, I
4.   sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
   
5.   sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
   . ]3 [- j3 W% |. U
6.   sFilterConfig.FilterIdHigh = 0x0000;              //32位ID
   
7.   sFilterConfig.FilterIdLow = 0x0000;
   $ o" \$ A8 O# X% ]3 b
8.   sFilterConfig.FilterMaskIdHigh = 0x0000;          //32位MASK
   
9.   sFilterConfig.FilterMaskIdLow = 0x0000;
   ( W3 ]3 r; n) M# O; I: H
10.   sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;//过滤器0关联到FIFO0
    
11.   sFilterConfig.FilterActivation = ENABLE;          //激活滤波器0
    " `  V, |9 m5 }1 F* x2 B
12.   sFilterConfig.SlaveStartFilterBank = 14;
    
13.   //过滤器配置
    7 n) \: B# N3 Q6 B
14.   if (HAL_CAN_ConfigFilter(&CAN1_Handler, &sFilterConfig) != HAL_OK)
    , P1 I( ]5 l/ c( F, z# ]6 X
15.   {
    
16.     while(1){}
    
17.   }

复制代码

, f9 {/ Z1 k4 k9 }0 i( T

3. 设置滤波器。
+ @1 Y4 ]# D: M- M5 W" ~+ M" K, m4 r我们将使用滤波器组 0，并工作在 32 位标识符屏蔽位模式下。先设置 CAN_FMR的 FINIT 位，让过滤器组工作在初始化模式下，然后设置滤波器组 0 的工作模式以及标识符 ID和屏蔽位。最后激活滤波器，并退出滤波器初始化模式。
2 j# B& `5 b" v& ?5 f* K7 r/ o在 HAL 库中，提供了函数 HAL_CAN_ConfigFilter 用来初始化 CAN 的滤波器相关参数。
0 G# a" c4 a6 L4 C; c+ ]HAL_CAN_ConfigFilter 函数体中，在初始化滤波器之前，会设置 CAN_FMR 寄存器的 FINIT位为 1 让其进入初始化模式，然后初始化 CAN 滤波器相关的寄存器之后，会设置 CAN_FMR寄存器的 FINIT 位为 0 让其退出初始化模式。所以我们在调用这个函数的前后不需要再进行初始化模式设置。

1.   CAN_FilterTypeDef  sFilterConfig;
   / c8 a/ j' G# I& m5 d, L/ w
2.   /*配置CAN过滤器*/
   
3.   sFilterConfig.FilterBank = 0;                     //过滤器0
   
4.   sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
   ) @; {1 b- v3 l- q% K3 T2 R
5.   sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
   , F) c' z: A. P
6.   sFilterConfig.FilterIdHigh = 0x0000;              //32位ID
   . r$ b' h9 f7 Z8 r5 b& \1 n0 m9 S( _
7.   sFilterConfig.FilterIdLow = 0x0000;
   
8.   sFilterConfig.FilterMaskIdHigh = 0x0000;          //32位MASK
   
9.   sFilterConfig.FilterMaskIdLow = 0x0000;
   & n! U/ D9 j. V
10.   sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;//过滤器0关联到FIFO0
    
11.   sFilterConfig.FilterActivation = ENABLE;          //激活滤波器0
    & v' r0 p3 ~& P3 K$ p& {
12.   sFilterConfig.SlaveStartFilterBank = 14;
    
13.   //过滤器配置
    ' y( C6 h; j1 Q6 O
14.   if (HAL_CAN_ConfigFilter(&CAN1_Handler, &sFilterConfig) != HAL_OK)
    % G0 n# r  \; `1 Q0 M- I
15.   {
    % C: m8 {$ M5 ]' p0 [3 w
16.     while(1){}
    $ d- t4 A, b9 R, Y0 v. V! o9 P7 n! f
17.   }

复制代码

, ~+ C7 ]0 L6 [+ k. _' d. ], r4 R
4.发送接收消息
在初始化 CAN 相关参数以及过滤器之后，接下来就是发送和接收消息了。HAL 库中提供了发送和接受消息的函数。
发送消息的函数是：

1. HAL_StatusTypeDef HAL_CAN_AddTxMessage(CAN_HandleTypeDef *hcan, CAN_TxHeaderTypeDef *pHeader, uint8_t aData[], uint32_t *pTxMailbox)

复制代码

• 入口参数 hcan为 CAN_HandleTypeDef 结构体指针类型
• pHeader 为发送的指针
• aData 是待发送数据
• pTxMailbox 为发送邮箱指针
  $ c! F$ ]0 o: F* }1 E接收消息的函数是：
  
  9 i1 ]5 k# }. V1 M

1. HAL_StatusTypeDef HAL_CAN_GetRxMessage(CAN_HandleTypeDef *hcan, uint32_t RxFifo, CAN_RxHeaderTypeDef *pHeader, uint8_t aData[])

复制代码

第一个入口参数为 CAN 句柄，第二个为 FIFO 号，然后是接收指针及数据存放的地址。我们接受之后，只需要读取 pHeader 便可获取接收数据和相关信息。
至此，CAN 就可以开始正常工作了。如果用到中断，就还需要进行中断相关的配置。

功能设计

• CAN 的初始化
  1. ////CAN初始化
     - W0 ~6 V  w' p* Q- L; O# t6 G
  2. //tsjw:重新同步跳跃时间单元.范围:CAN_SJW_1TQ~CAN_SJW_4TQ
     % ]& ?/ s. p- |) R. T7 t3 z
  3. //tbs2:时间段2的时间单元.   范围:CAN_BS2_1TQ~CAN_BS2_8TQ;
     : @8 a1 G4 ?  t, l. x
  4. //tbs1:时间段1的时间单元.   范围:CAN_BS1_1TQ~CAN_BS1_16TQ
     
  5. //brp :波特率分频器.范围:1~1024; tq=(brp)*tpclk1
     
  6. //波特率=Fpclk1/((tbs1+tbs2+1)*brp); 其中tbs1和tbs2我们只用关注标识符上标志的序号，例如CAN_BS2_1TQ，我们就认为tbs2=1来计算即可。
     4 n) u2 g( K! X. {8 {# A4 ^
  7. //mode:CAN_MODE_NORMAL,普通模式;CAN_MODE_LOOPBACK,回环模式;
     
  8. //Fpclk1的时钟在初始化的时候设置为36M,如果设置CAN1_Mode_Init(CAN_SJW_1tq,CAN_BS2_8tq,CAN_BS1_9tq,4,CAN_MODE_LOOPBACK);
     % e: V( `# N+ C7 I
  9. //则波特率为:36M/((8+9+1)*4)=500Kbps
     9 C3 c* O  c& V1 I9 ?6 L4 i* ]; ?
  10. //返回值:0,初始化OK;
      + N2 A/ w" Y, v  y0 \
  11. //    其他,初始化失败;
      " K- k* g8 B% b! ?2 P+ x
  12. u8 CAN1_Mode_Init(u32 tsjw,u32 tbs2,u32 tbs1,u16 brp,u32 mode)
      
  13. {
      
  14.   CAN_InitTypeDef    CAN1_InitConf;
      
  15.   CAN1_Handler.Instance=CAN1;
      
  16.   CAN1_Handler.Init = CAN1_InitConf;
      
  17.   
      & E- j- G# d$ w  E$ }& E$ X: T/ H
  18.     CAN1_Handler.Init.Prescaler=brp;        //分频系数(Fdiv)为brp+1
      
  19.     CAN1_Handler.Init.Mode=mode;          //模式设置
      + W& U' C# t; m9 J/ i2 V
  20.     CAN1_Handler.Init.SyncJumpWidth=tsjw;      //重新同步跳跃宽度(Tsjw)为tsjw+1个时间单位 CAN_SJW_1TQ~CAN_SJW_4TQ
      ) k3 M7 i/ b( ~! x8 X8 W
  21.     CAN1_Handler.Init.TimeSeg1=tbs1;        //tbs1范围CAN_BS1_1TQ~CAN_BS1_16TQ
      
  22.     CAN1_Handler.Init.TimeSeg2=tbs2;        //tbs2范围CAN_BS2_1TQ~CAN_BS2_8TQ
      $ D2 C8 t. U! g
  23.     CAN1_Handler.Init.TimeTriggeredMode=DISABLE;  //非时间触发通信模式
      ; ?  |3 e/ h( o- T6 t, x3 H5 {
  24.     CAN1_Handler.Init.AutoBusOff=DISABLE;      //软件自动离线管理
      3 N8 Y+ `8 b- a) n
  25.     CAN1_Handler.Init.AutoWakeUp=DISABLE;      //睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
      * u; `) n9 r7 R" I
  26.     CAN1_Handler.Init.AutoRetransmission=ENABLE;  //禁止报文自动传送
      
  27.     CAN1_Handler.Init.ReceiveFifoLocked=DISABLE;  //报文不锁定,新的覆盖旧的
      / g% ]9 |6 y9 u* B0 R
  28.     CAN1_Handler.Init.TransmitFifoPriority=DISABLE;  //优先级由报文标识符决定
      ) C# ]* s: K" F  T$ m* `6 ?: |
  29.     if(HAL_CAN_Init(&CAN1_Handler)!=HAL_OK)      //初始化
      % R; a6 B* n! Z3 C( S; M
  30.     return 1;
      0 r9 }/ Z" y4 \' x
  31.     return 0;
      
  32. }

  复制代码
  
  

该函数带有 5 个参数，可以设置 CAN 通信的波特率和工作模式等.

2. CAN 报文的发送
主要是设置标识符 ID等信息，写入数据长度和数据，并请求发送，实现一次报文的发送。

1. //can发送一组数据(固定格式:ID为0X12,标准帧,数据帧)  
   
2. //len:数据长度(最大为8)            
   6 A" P, N# \8 }
3. //msg:数据指针,最大为8个字节.
   + M0 I  Z- G/ a3 c% O
4. //返回值:0,成功;
   ; l9 i8 Y& k7 g; C  ?( m
5. //     其他,失败;
   ( X& o$ t! \( Q2 Y/ Y6 c0 y2 p
6. u8 CAN1_Send_Msg(u8* msg,u8 len)
   
7. {  
   4 {# T7 ~% x6 d& O0 |. V) E
8.     u8 i=0;
   : ~+ L# l$ z" a% Q8 J% N& w' [* t
9.   u32 TxMailbox;
   
10.   u8 message[8];
    : b* ~' d. G+ V( k( N: d( P; G
11.     TxHeader.StdId=0X12;        //标准标识符
    ' c  o5 _- C, r. H( a
12.     TxHeader.ExtId=0x12;        //扩展标识符(29位)
    
13.     TxHeader.IDE=CAN_ID_STD;    //使用标准帧
    
14.     TxHeader.RTR=CAN_RTR_DATA;  //数据帧
    
15.     TxHeader.DLC=len;               
    5 Y( W+ g  T, _$ V0 a8 k
16.     for(i=0;i<len;i++)
    
17.     {
    
18.     message[i]=msg[i];
    2 n6 G5 ~  C" a+ Z! E! P6 ?& t
19.   }
    3 S2 E1 |; O+ r+ n! `8 y4 h  H
20.     if(HAL_CAN_AddTxMessage(&CAN1_Handler, &TxHeader, message, &TxMailbox) != HAL_OK)//发送
    ( ^0 @; N% |* v  x# m5 E
21.   {
    % @# o) F, r  Z
22.     return 1;
    4 e# b9 w4 T& Q6 Z2 O* t8 @) b
23.   }
    6 `2 z0 Q% b' s2 m' `9 B
24.   while(HAL_CAN_GetTxMailboxesFreeLevel(&CAN1_Handler) != 3) {}
    
25.     return 0;
    
26. }

复制代码

2 }: b; A4 R' R! d( ^, c

• CAN接收函数
  用来接受数据并且将接受到的数据存放到 buf 中。
  1. //can口接收数据查询
     
  2. //buf:数据缓存区;   
     
  3. //返回值:0,无数据被收到;
     # ?2 B5 ^! ~( ?$ d2 \: d" Z
  4. //     其他,接收的数据长度;
     2 V" I; \8 J5 r* A  s6 w9 \% R
  5. u8 CAN1_Receive_Msg(u8 *buf)
     5 T' d8 b$ @6 O
  6. {
     & Q' r6 F6 `: o6 l; B' C7 E* L
  7.    u32 i;
     7 N% a8 V2 _' v
  8.   u8  RxData[8];
     9 R9 E. \1 C7 s; S
  9. 
     # B; K. {- ~" M% w
  10.   if(HAL_CAN_GetRxFifoFillLevel(&CAN1_Handler, CAN_RX_FIFO0) != 1)
      , c4 P3 t$ s7 {9 Z/ n/ c* V
  11.   {
      
  12.     return 0xF1;
      6 ?. s. Z* y# k. Z7 ~: r
  13.   }
      
  14. 
      
  15.   if(HAL_CAN_GetRxMessage(&CAN1_Handler, CAN_RX_FIFO0, &RxHeader, RxData) != HAL_OK)
      8 M0 n( c/ p& P. a3 D
  16.   {
      
  17.     return 0xF2;
      
  18.   }
      9 a7 Z. a. Z/ L- D# p) r* [
  19.     for(i=0;i<RxHeader.DLC;i++)
      $ V! {7 X+ I$ O& n4 f. m
  20.     buf[i]=RxData[i];
      ; S2 M" \& D/ J0 R, Q  p
  21.   return RxHeader.DLC;
      
  22. }

  复制代码
  
  9 L1 s) [/ D- u2 Q

( y( H2 W( }& p" k. @) b; D

• 主函数
  
  - x: V/ Y% g* g1 P. |4 o$ f$ k$ u

我们通过按键选择 CAN 的工作模式（正常模式/环回模式），然后通过 KEY0 控制数据发送，并通过查询的办法，将接收到的数据显示在串口上（选择非CAN占用的口）。如果是环回模式，我们不需要 2 个开发板。如果是正常模式，我们就需要 2 个开发板，并且将他们的 CAN 接口对接起来，然后一个开发板发送数据，另外一个开发板将接收到的数据显示在串口上。

1. int main(void)
   9 ~* a: r4 }9 F$ y9 |# \" x1 W% A
2. {  
   ) X3 Q+ f0 H6 ?/ R
3.      u8 key;
   $ \+ j: l: {1 v1 k
4.   u8 i=0,t=0;
   
5.   u8 cnt=0;
   
6.   u8 canbuf[8];
   & i+ E3 s: X; _
7.   u8 res;
   7 L9 `. N$ B9 w' t% B
8.   u8 mode=1;   
   
9.   HAL_Init();                         //初始化HAL库   
   
10.   Stm32_Clock_Init(RCC_PLL_MUL9);     //设置时钟,72M
    ' J  D# P, e9 t
11.   delay_init(72);                   //初始化延时函数
    
12.   uart_init(115200);          //初始化串口
    
13.   usmart_dev.init(84);            //初始化USMART  
    * W1 z3 ^2 n" v: E
14.   LED_Init();              //初始化LED  
    
15.   KEY_Init();              //初始化按键
    
16.    CAN1_Mode_Init(CAN_SJW_1TQ,CAN_BS2_8TQ,CAN_BS1_9TQ,4,CAN_MODE_LOOPBACK); //CAN初始化,波特率500Kbps      
    
17.   CAN_Config();   
    
18.   printf("LoopBack Mode");   
    6 q( e  D4 |* }2 {) U
19.   printf("KEY0:Send WK_UP:Mode");//显示提示信息      
    ! O3 v/ b0 i6 _8 x3 Z5 e  ]
20.   printf("Count:");      //显示当前计数值  
      @+ k. e( L. s( T
21.   printf("Send Data:");    //提示发送的数据  
    
22.   printf("Receive Data:");  //提示接收到的数据   
    
23.     while(1)
    - S0 r" k( h: j1 N& k
24.     {
    5 Z: }5 {. R/ ]& `, A2 b5 R
25.         key=KEY_Scan(0);
    % w3 f8 Q4 {, U6 k* ]% n
26.     if(key==KEY0_PRES)//KEY0按下,发送一次数据
    % Z: }# b/ i1 P! k% O% L/ x
27.     {
    : E, h/ W; w! y* A* a/ f
28.       for(i=0;i<8;i++)
    1 ~8 W% g% A' N, q. S
29.       {
    
30.         canbuf[i]=cnt+i;//填充发送缓冲区
    
31.         if(i<4)printf("%d\r\n",canbuf[i]);  //显示数据
    
32.         else printf("%d\r\n",canbuf[i]);  //显示数据
    * ]  Q4 W. _0 a+ |
33.        }
    
34.       res=CAN1_Send_Msg(canbuf,8);//发送8个字节
    
35.       if(res)printf("Failed");    //提示发送失败
    
36.       else printf("OK    ");       //提示发送成功                  
    
37.     }else if(key==WKUP_PRES)//WK_UP按下，改变CAN的工作模式
    
38.     {     
    
39.       mode=!mode;
    0 N1 W0 H% L7 e" z: J
40.             if(mode==0)  CAN1_Mode_Init(CAN_SJW_1TQ,CAN_BS2_8TQ,CAN_BS1_9TQ,4,CAN_MODE_NORMAL);        //回环模式,波特率500Kbps
      J  M) c) l; u/ e( H
41.             else if(mode==1) CAN1_Mode_Init(CAN_SJW_1TQ,CAN_BS2_8TQ,CAN_BS1_9TQ,4,CAN_MODE_LOOPBACK);  //回环模式,波特率500Kbps
    
42.       CAN_Config();
    3 k& M9 T# w" `- a
43.       if(mode==0)//普通模式，需要2个开发板
    
44.       {
    : C" [9 G9 A4 C2 p
45.         printf("Nnormal Mode ");      
    
46.       }else //回环模式,一个开发板就可以测试了.
    
47.       {
    
48.          printf("LoopBack Mode");
    
49.       }
    
50.     }     
    , I8 F0 D6 ]# V5 c
51.     key=CAN1_Receive_Msg(canbuf);
    
52.     if(key < 9)//接收到有数据
    
53.     {      
    
54. 
    
55.        for(i=0;i<key;i++)
    
56.       {                     
    
57.         if(i<4)printf("%d\r\n",canbuf[i]);  //显示数据
    ) P. N" }2 T2 v: U: ~/ r& X! ~
58.         else printf("%d\r\n",canbuf[i]);  //显示数据
    
59.        }
    ' ?5 j6 C2 w. C0 B( ~
60.     }
    ; y/ i9 l: q7 _" i! X
61.     t++;
    
62.     delay_ms(10);
    
63.     if(t==20)
    ' `2 S( {7 W9 J2 v; L
64.     {
    
65.       LED0=!LED0;//提示系统正在运行  
    
66.       t=0;
    
67.       cnt++;
    . L0 F" n  d( y
68.       printf("%d\r\n",cnt);  //显示数据
    2 O4 c& U% x( g5 [1 d
69.     }      
    " i( p! A- r) m- |: S% l" r4 y7 J
70.   }
    3 s7 r: R, a( O+ ]" q
71. }
    ( Y5 O- O0 [2 j$ d, f! ^1 F6 J
72.     }     
    
73.     key=CAN1_Receive_Msg(canbuf);
    
74.     if(key < 9)//接收到有数据
    1 q# _9 ~$ S1 i% ~9 T; C
75.     {      
    
76. 
    # H  |- h7 i( T0 G* _
77.        for(i=0;i<key;i++)
    
78.       {                     
    # F- g9 f) ?# B; S& {4 d
79.         if(i<4)printf("%d\r\n",canbuf[i]);  //显示数据
    - K; h' V2 K5 B5 ]
80.         else printf("%d\r\n",canbuf[i]);  //显示数据
    1 r& E5 @' \* S4 }
81.        }
    
82.     }
    8 W1 Q2 H# |, a: x1 O. Z6 ~
83.     t++;
    
84.     delay_ms(10);
    ' _/ x5 L/ X& U0 \' p2 _9 x
85.     if(t==20)
    $ e: x9 c3 P5 X0 H
86.     {
    / m& v" \7 S5 d! }0 G
87.       LED0=!LED0;//提示系统正在运行  
    
88.       t=0;
    / U( V  W; ?2 l4 q, T8 [8 W
89.       cnt++;
    
90.       printf("%d\r\n",cnt);  //显示数据
    
91.     }      
    4 w9 ^4 F: K7 g( R0 I
92.   }
    3 C& D7 w. X; H8 A4 w4 I( Q  Y
93. }

复制代码

0 ^( t! K9 U. }" I2 m

转载自： 跋扈洋