一、CAN总线简介
: o. k+ B9 Y! T6 W8 m        1.1 CAN概述
        CAN是Controller Area Network（控制区域网络） 的缩写，是ISO国际标准化的串行通信协议。由德国电气商博世公司在1986年率先提出。此后，CAN通过ISO11898及ISO11519进行了标准化。现在在欧洲已是汽车网络的标准协议。
8 M; y0 Q& E8 A7 ]$ `* o& S* i2 F
7 Z3 _, ?# q* p        CAN协议经过ISO标准化后有两个标准：ISO11898标准和ISO11519-2标准。其中ISO11898是针对通信速率为125Kbps~1Mbps的高速通信标准，总线最大长度达到40m/1Mbps，连接单元数最大支持到30；而ISO11519-2是针对通信速率为125Kbps以下的低速通信标准，总线最大长度达到1km/40kbps，连接单元数最大支持到20。
. q5 ?: D+ N  e- \' D
9 Z2 a% b! L) ]0 {' w        CAN 控制器根据两根线上的电位差来判断总线电平。总线电平分为显性电平和隐性电平，二者必居其一。发 送方通过使总线电平发生变化，将消息发送给接收方。只有2个设备简单通信时，当成USART串口使用，多个设备同时通信时，遵循CAN协议，使用邮箱、识别符、过滤器功能：总线空闲时，所有单元都可发送消息，而两个以上的单元同时开始发送消息时，根据标识符（ID，非地址）决定优先级。两个以上的单元同时开始发送消息时，对各消息ID 的每个位进行逐个仲裁比较。仲裁获胜（优先级最高）的单元可继续发送消息，仲裁失利的单元则立刻停止发送而进行接收工作。

! F6 d$ [+ R: D/ q- R' M9 {: T) Y        1.2 CAN总线较其他串行通信优势
# E6 a! n: a+ x, I' n; G        CAN总线相比起其他串行通信协议，具有以下优势：

        【1】由于连接总线的单元，没有类似“地址”的信息，因此，在总线上添加单元时，已连接的其他单元的软硬件和应用层都不需要做改变。      
: T& s8 s, @- |* I" `% v
        【2】具有错误检测、错误通知和错误恢复功能：所有单元都可以检测错误（错误检测功能），检测出错误的单元会立即同时通知其他所有单元（错误通知功能），正在发送消息的单元一旦检测出错误，会强制结束当前的发送。强制结束发送的单元会不断反复地重新发送此消息直到成功发送为止（错误恢复功能）。

$ e1 A6 w* m4 A  t        【3】故障封闭功能：CAN可以判断出错误的类型是总线上暂时的数据错误（如外部噪声等）还是持续的数据错误（如单元内部故障、驱动器故障、断线等）。由此功能，当总线上发生持续数据错误时，可将引起此故障的单元从总线上隔离出去。
' W0 a0 G* Z; C0 x6 G" @; W
2 J0 h7 s" l* @& z        【4】连接节点多。CAN 总线是可同时连接多个单元的总线。可连接的单元总数理论上是没有限制的。但实际上可连接的单元数受总线上的时间延迟及电气负载的限制。降低通信速度，可连接的单元数增加；提高通信速度，则可连接的单元数减少。
  b2 J. a$ D" F8 O. t2 Y
; Q3 }( l( p8 Z2 k
  Z2 B2 n1 H1 r        1.3 CAN总线通信
        CAN总线是基于相同波特率通信的，所以设备接入前要知道总线上的波特率是多少。在STM32CubeMX上，其波特率计算如下图所示：波特率=(pclk1/((1+8+7)*9)) = 36Mhz/16/9 = 250Kbits。
# ?2 t- k* p1 q+ `

4 X: z3 c* j  q$ ~2 t


4 ]0 r2 W0 X" g+ D- F         在数据传输方面，一次最多只能发送8个字节的数据，这是由CAN协议规定的。多于8个的需要第二次再发送，需要开发者自己实现连续多数据发送的函数来实现大于8字节数据量的应用。
9 K( l( d/ U; k8 P; ?0 o1 ~
- g; Y7 R5 l4 T        同一条 CAN 总线的不同主机，不能同时发送相同 ID 的报文：如果使用 2 个及以上驱动器，连接在同一条 CAN 线上，必须设置为不同的编号，比如 0 组 1 号和 0 组 2 号，如果不设置为不同的编号，一旦让驱动器回传报文，报文 ID 则会相同，就会造成总线致命冲突，此时驱动器会进入硬件错误状态。
* l2 ^6 O) d6 |( m$ x: i
$ B4 H  c" H' e" q7 F( q        CAN接口兼容规范2.0A和2.0B（主动式），可以接收和发送11位标识符的标准帧，也可以接收和发送29位标识符的扩展帧。具有3个发送邮箱和2个接收FIFO（邮箱及FIFO可以看做是缓存区域），3级14个可调节滤波器。

        “发送邮箱”是用于CAN总线数据发送的，总共有3个，每个邮箱只装一个报文，并且存在优先级关系。优先级越高表示其里面的数据会被优先发送。数据在发送前都会被送到优先级最高且空闲的发送邮箱，然后依次发送。如果所有邮箱都满了，会溢出标记为1，需要等待空邮箱。满邮箱按先后次序排队发送报文，发送完成后变成空邮箱。

  d+ L* ^& P( v        FIFO：表面的意思是“先入先出”，是指有层级深度的接收邮箱。一般CAN有2个FIFO邮箱(FIFO0和FIFO1)，每个FIFO有3层深度,3层深度是指每个邮箱可以接收3个报文，但读取时只能读到最先收到的报文报文处理完成后，再读取时则是下一个报文。

- J1 j- ~" ?& r" w$ x( |7 r* m) e        过滤器：可由硬件判断报文中的标识符，过滤掉标识符不匹配的报文（过滤掉不想要的ID，接收想要的ID）。CAN总线控制器通常提供了14个或28个过滤器组，每组2个32为寄存器。过滤器是由硬件实现的，只有与过滤器匹配的报文才需要软件处理。在接收报文时，数据先进入过滤器，与过滤器匹配的报文会被放入FIFO邮箱。过滤器根据下列优先级规则来确定：
+ n) J2 ~9 _; c' R, j8 |$ i        1，位宽为32位的过滤器，优先级高于位宽为16位的过滤器
        2，对于位宽相同的过滤器，标识符列表模式的优先级高于屏蔽位模式
        3，位宽和模式都相同的过滤器，优先级由过滤器号决定，过滤器号小的优先级高
$ y, k. V% w- W! H: ]8 D
        最终CAN总线通信如下图示意：

& E/ H$ g# e( n5 a6 z2 o
: m8 p8 [" \; ~' [' }9 k
         1.4 报文种类及格式
        CAN报文包含以下几种，其中数据帧及遥控帧是重点常用格式：
, C- z2 z0 W9 i9 M; o
        【1】数据帧，用于发送单元向接收单元传送数据的帧。
" ^  y4 @% p7 u' z! F" o! `) k$ X$ f
: Z' }, K: `4 o/ e3 Y/ u0 d        【2】遥控帧或远程帧，用于接收单元向具有相同ID的发送单元请求数据的帧。   
; h- o, H* p% h; N
        【3】错误帧，用于当检测出错误时向其它单元通知错误的帧。

3 ~7 Z! {. B" {& _% B        【4】过载帧，用于接收单元通知其尚未做好接收准备的帧。
  p' K9 d9 i# O- j
        【5】帧间隔，用于将数据帧及遥控帧与前面的帧分离开来的帧。
9 u5 M- `) V0 [7 O* A- Z1 G# a! B
        每种类型的报文格式都不相同，数据帧和遥控帧格式如下：
+ s  X3 _5 q! |/ T' U" U  F0 B8 k
3 ^0 P' d5 f; r8 ?, i4 n7 b( p

3 _% J1 p  |; v1 Z% Z        数据帧和遥控帧有标准格式和扩展格式两种格式，类似于I2C协议里的7位和10位地址。CAN的数据帧和遥控帧的标识符（ID）的标准格式有11个位标识符，扩展格式有29个位标识符。设备可以用标识符（ID）判断数据是不是发给自己的。
- L. \( T: `% }" Z
& M4 W: U* b4 x+ U0 `. Q6 ]        CAN总线收发数据报文，根据标示符（也就是 ID）来决定优先级的。必须注意的是，在同一CAN网络中，所有单元必须设定成统一的通信速度，CAN设备可通过发送“遥控帧” 请求其他单元发送数据。CAN支持Normal 正常模式、Silent 静默模式、Loopback 环回模式测试、Silent_loopback 静默换回模式测试共四种模式，在CubeMX对应如下：
5 }' p) j3 B: i, m2 E7 q8 H


, ]8 M3 m9 `, L; [; ~
         1.5 CAN应用
7 K9 S: D  t. |2 a. D, V        CAN具有很高的可靠性，广泛应用于：汽车电子、工业自动化、船舶、医疗设备、工业设备等方面。


2 l% j. W: }& J8 o' ]二、CAN工程创建及配置
3 @" d* q6 c# ?, r        2.1 工程设计及原理框图
        本文采用STM32L496VGTX+独立CAN 收发器（TJA1050）和STM32F103C8Tx开发板（已经集成了CAN 收发器-TJA1050）进行CAN通信。

4 n1 G9 G8 o: {/ K
3 \) V, D! ?$ g4 B9 I" a
& A3 a: l  ]) j! s        STM32L496VGTX预留了扩展引脚PD0、PD1支持CAN1，然后通过扩展引脚接入TJA1050：
/ G+ x8 q: J) a0 M# g6 Y3 ]
) K6 [) M; @3 o2 [5 d9 [  A

- d1 f: X. Q1 A: z. h, d3 Y. K
! k4 [, O0 _* e
2 m! j; g6 M1 e2 [/ Y9 T8 W
/ Z6 @: X& X; ?8 {" O         TJA1050原理框图，STM32L496VGTX扩展口PD0、PD1接下图的PA11、PA12。

7 G4 P. i5 |" ~! n: I# B
/ T( b) y( U8 z6 G1 }. T
& s! A4 ^: C. B; a, ]' g         STM32F103C8Tx开发板的CAN组件原理框图如下，PB8、PB9接MCU：



        2.2 工程创建接配置
3 e8 |: W' g2 K! R/ J- W        现以STM32L496VGTX为例创建CAN工程stm32L496VGT6_can，创建完成后，移植以前已经实现过的lpuart1通信功能、按键功能及LED灯功能

        假设已经移植了串口调试功能并能在电脑上通过串口通信实现调试信息输出。

& Y3 P6 O, E$ @  ~" a        进入CAN配置阶段，双击.ioc打开CubeMX配置界面，设置CAN1功能开启，先在图形配置界面选择PD0、PD1为CAN_RX/TX模式，将自动开启CAN1功能，然后进入CAN页面配置参数，波特率设置为250Kbits，及本次CAN网络的统一波特率。
0 R4 _- n1 e' L4 T- ]. d  B* R. O


         开启接收中断功能

8 r/ t- p+ F! z& Z- w3 ^

6 I8 ~$ g( P1 j* O1 C, g6 H& y         完成后点击保存输出生成代码

( Q; Y! Z; m6 A三、代码设计
  N/ p; T2 P! Z  S: o+ Q; M8 \8 T9 \        3.1 修改输出源文件can.c
, R  w# J  L2 t# W. [2 G        在Core/src目录下，双击打开can.c文件，修改MX_CAN1_Init函数，增加过滤设置、CAN开启、中断支持设置等功能。
5 [$ v& G% a: g1 [- s' x

1. /* USER CODE BEGIN 0 */
   8 C) v% Z2 u  J+ D  T0 E
2. //新增
   * n* i4 D+ Q9 w7 T1 l( A# t6 N) u: g
3. #define CAN1_ID_H      0x0000 //32位基础ID设置（高16位）
   + ]) B& M) |& E  ~, I
4. #define CAN1_ID_L      0x0000 //32位基础ID设置（低16位）
   " }# `- R+ U/ d  w3 m
5. #define CAN1_MASK_H    0x0000 //32位屏蔽MASK设置（高16位）
   
6. #define CAN1_MASK_L    0x0000 //32位屏蔽MASK设置（低16位）
   
7. /* USER CODE END 0 */
   # S' `0 Q* h) \8 C7 R8 n5 }% Y- B
8. 
   3 f9 S7 g) b- Q' i5 d2 `/ \# n
9. CAN_HandleTypeDef hcan1;
   
10. 
    5 R4 n2 W- o& y. r+ G8 p. m6 e% a
11. /* CAN1 init function */
    
12. void MX_CAN1_Init(void)
    
13. {
    
14. 
    7 L1 w7 v0 n: t9 {1 H
15.   /* USER CODE BEGIN CAN1_Init 0 */
    : U* Y$ h8 @- o/ _! |3 G% M4 z2 Y& R
16.     //新增
    , T/ r, E7 U+ F- Y( R% P
17.         CAN_FilterTypeDef  CAN1_sFilterConfig;
      F8 w4 C! x7 C7 E$ ?
18.         HAL_StatusTypeDef  HAL_Status;
    ' k" J# g4 b/ X" b
19.   /* USER CODE END CAN1_Init 0 */
    9 ~) P3 q8 M* w5 m
20. 
    . S( h/ |: o, m! q& F) R* Y; [
21.   /* USER CODE BEGIN CAN1_Init 1 */
    5 \7 R0 @6 f8 M/ W) A. B' `% q0 C" o
22. 
    
23.   /* USER CODE END CAN1_Init 1 */
    ' x. W3 v# ^% c/ ?9 @: h
24.   hcan1.Instance = CAN1;
    9 Z2 {1 {* e5 u
25.   hcan1.Init.Prescaler = 20;
    
26.   hcan1.Init.Mode = CAN_MODE_NORMAL;
    
27.   hcan1.Init.SyncJumpWidth = CAN_SJW_1TQ;
      M3 m- A7 A6 g7 ^
28.   hcan1.Init.TimeSeg1 = CAN_BS1_8TQ;
    / a' L: Y. M! f3 S
29.   hcan1.Init.TimeSeg2 = CAN_BS2_7TQ;
    ' w3 P; K5 j$ }& |9 d: {! C  m
30.   hcan1.Init.TimeTriggeredMode = DISABLE;
    & d+ Y1 G9 _) |, K$ ]% X  X
31.   hcan1.Init.AutoBusOff = DISABLE;
    
32.   hcan1.Init.AutoWakeUp = DISABLE;
    
33.   hcan1.Init.AutoRetransmission = DISABLE;
    0 S1 t* S, ^8 C& [5 |
34.   hcan1.Init.ReceiveFifoLocked = DISABLE;
    . V2 w# j' c- _+ I5 B- Y$ S
35.   hcan1.Init.TransmitFifoPriority = DISABLE;
    ( v( U8 l. G" m3 a- j, Y
36.   if (HAL_CAN_Init(&hcan1) != HAL_OK)
    
37.   {
    
38.     Error_Handler();
    
39.   }
    & G8 b$ o8 ^7 @, f
40.   /* USER CODE BEGIN CAN1_Init 2 */
    
41.     //新增
    
42.   CAN1_sFilterConfig.FilterIdHigh = CAN1_ID_H;//32位基础ID设置（高16位）
    + M8 C! F. r% R% E5 |6 [. C$ i
43.   CAN1_sFilterConfig.FilterIdLow = CAN1_ID_L;//32位基础ID设置（低16位）
    
44.   CAN1_sFilterConfig.FilterMaskIdHigh = CAN1_MASK_H;//32位屏蔽MASK设置（高16位）
    
45.   CAN1_sFilterConfig.FilterMaskIdLow = CAN1_MASK_L;//32位屏蔽MASK设置（低16位）
    
46.   CAN1_sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO1;//接收到的报文放入FIFO1位置
    7 `- a- ~3 ]/ N( I1 w' P
47.   CAN1_sFilterConfig.FilterBank = 0;//过滤器0
    7 @- b0 `% n4 i/ X
48.   CAN1_sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;//设为IDLIST列表模式/IDMASK屏蔽模式
    * K. h/ Q, c1 \: X- B$ T# X
49.   CAN1_sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;//过滤器位宽度
    
50.   CAN1_sFilterConfig.FilterActivation = ENABLE;//ENABLE激活过滤器，DISABLE禁止过滤器
    3 |* H6 c! c( C2 d/ J* s
51.   CAN1_sFilterConfig.SlaveStartFilterBank = 0;//过滤器组设置（单个CAN总线时无用）
    ! ^' O3 d( n' _+ {& u2 E
52.   HAL_Status = HAL_CAN_ConfigFilter(&hcan1, &CAN1_sFilterConfig);
    7 ?' l4 \4 t" e  e
53.   if ( HAL_Status!= HAL_OK)//判断开启是否成功
    
54.    {
    * E0 z$ i8 g, v" y) q( T
55.      /* Filter configuration Error */
    
56.      Error_Handler();//开启CAN总线失败的处理程序
    
57.    }
    
58. 
    , P/ x% N, c0 ^8 n
59.    /* Start the CAN peripheral */
    
60.   HAL_Status = HAL_CAN_Start(&hcan1);
    ' a) E4 V/ n" l6 x
61.    if ( HAL_Status!= HAL_OK)//这个函数和下面的函数是cubemx没有给出的，需要手动添加
    
62.    {
    
63.      /* Start Error */
    + T9 k' S% @$ d) q
64.      Error_Handler();//开启CAN总线失败的处理程序
    
65.    }
    
66. 
    
67.    /* Activate CAN RX notification */
    
68.    //若不使用CAN中断，以下不需要
    
69.    HAL_Status = HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO1_MSG_PENDING);
    3 n: x: B9 I+ ~9 e4 i$ R3 n
70.    if ( HAL_Status!= HAL_OK)//选择fifo1中断
    
71.    {
    $ [  _( i" o# C& I1 y) N& O
72.      /* Notification Error */
    $ m5 g! n* E7 \$ P
73.      Error_Handler();//开启CAN总线挂起中断失败的处理程序
    
74.    }
    
75. 
    
76.   /* USER CODE END CAN1_Init 2 */
    
77. 
    
78. }

复制代码

        3.2 自定义can应用驱动
         在ICore目录创建文件夹can，并在该文件夹下创建can1.h和can1.c源文件。
        can1.h
2 C" e8 N3 [. D- R$ T

1. #ifndef CAN_CAN1_H_
   
2. #define CAN_CAN1_H_
   3 c" V& I/ B7 I7 N! O
3. 
   
4. #include "stm32l4xx_hal.h" //HAL库文件声明
   
5. 
   . M3 B; y+ W2 E0 ]) \  p# L& z, }" M
6. extern CAN_HandleTypeDef hcan;//声明的HAL库结构体
   $ V+ F0 ]! M* F6 H
7. 
   
8. #define CAN1_REC_LEN  256//定义CAN1最大接收字节数
   
9. 
   : l3 M6 h  `3 X
10. extern uint8_t  CAN1_RX_BUF[CAN1_REC_LEN];//接收缓冲,末字节为换行符
    
11. extern uint16_t CAN1_RX_STA;//接收状态标记
    , Q2 s" c8 r5 F; s2 E1 E7 @
12. 
    
13. uint8_t  CAN1_SendNormalData(CAN_HandleTypeDef*  hcan,uint16_t ID,uint8_t *pData,uint16_t  Len);//CAN发送函数
    
14. void CAN1_printf (char *fmt, ...);//CAN总线通信，使用CAN1，这是CAN专用的printf函数
    / F  w3 ]- e  v& e' S' ?6 u
15. 
    , n3 g7 X5 i! x3 {% I
16. #endif /* CAN_CAN1_H_ */

复制代码

4 u8 v! u. b$ A4 \0 C        can1.c，该驱动通过CAN1_printf函数实现向CAN发送数据，通过重写stm32l4xx_hal_can.h/c文件中的HAL_CAN_RxFifo1MsgPendingCallback函数实现CAN数据接收。

1. #include "can1.h" //库文件声明
   
2. #include "main.h"
   
3. #include <string.h>//用于字符串处理的库
   ! \' L, f+ t7 F
4. #include <stdarg.h>
   7 p4 G9 n! w6 H2 v6 h; w6 M
5. #include <stdlib.h>
   
6. #include <stdio.h>
   4 ]- ^  f; O4 x* q& S! @2 q  ~
7. 
   
8. CAN_HandleTypeDef hcan;//声明的HAL库结构体
   ( R; @( H9 N+ Y- G* p
9. 
   
10. CAN_TxHeaderTypeDef     TxMeg;//CAN发送设置相关结构体
    . B1 i; k0 @5 X
11. CAN_RxHeaderTypeDef     RxMeg;//CAN接收设置相关结构体
    
12. 
    
13. uint8_t CAN1_RX_BUF[CAN1_REC_LEN];//接收缓冲,最大CAN1_REC_LEN个字节.末字节为换行符
    # B; ~5 W) k8 [% r0 g* u
14. uint16_t CAN1_RX_STA;//接收状态标记
    
15. 
    + y- X" ?3 z+ V! ]7 c
16. void  HAL_CAN_RxFifo1MsgPendingCallback(CAN_HandleTypeDef *hcan)  //接收回调函数（函数名不可改）
    
17. {
    - Y8 Z( {! ~; x1 Q+ o
18.     uint8_t  Data[8];//接收缓存数组
    1 e" r$ ^2 v: |+ v
19.     HAL_StatusTypeDef HAL_RetVal;//判断状态的枚举
    * u& e6 F. n4 P- Z' v" p, g
20.         HAL_RetVal=HAL_CAN_GetRxMessage(hcan,CAN_RX_FIFO1,&RxMeg,Data);//接收邮箱中的数据
    
21.         if (HAL_OK==HAL_RetVal){//判断接收是否成功
    
22.                 //接收成功后的数据处理程序，写在此处。（数据在Data数组中）
    9 ^$ p' D4 F& V: S7 C1 Q. x3 P
23.                 //以下2行是采用简单的寄存器查寻方式处理接收数据，每次只接收1位。在实际项目中的复杂接收程序可自行编写。
    , a5 F' @0 y2 Y3 ^1 w' W+ z
24.                 CAN1_RX_BUF[0]=Data[0];//将接收到的数据放入缓存数组（因只用到1个数据，所以只存放在数据[0]位置）
    ! F" D/ b/ v1 v( w0 ~. c0 G1 f
25.                 CAN1_RX_STA++;//数据接收标志位加1
    
26.         }
    7 P/ S( D4 ]/ T9 A; a( p
27. }
    0 n" g- m+ T" `
28. //CAN发送数据函数（参数：总线名，ID，数据数组，数量。返回值：0成功HAL_OK，1参数错误HAL_ERROR，2发送失败HAL_BUSY）
    
29. //示例：CAN1_SendNormalData(&hcan1,0,CAN_buffer,8);//CAN发送数据函数
    ; W0 x4 a' W+ M! y/ |
30. uint8_t  CAN1_SendNormalData(CAN_HandleTypeDef* hcan,uint16_t ID,uint8_t *pData,uint16_t  Len)
    
31. {
    
32.     HAL_StatusTypeDef HAL_RetVal;//判断状态的枚举
    + P8 ^% c! N4 ~2 C/ P8 _; s
33.     uint16_t SendTimes,SendCNT=0;
    , G- w# d: G9 u* @2 N4 F/ X; I
34.     uint8_t  FreeTxNum=0;
    + D; O, {$ p" h2 `* X( q) g) S
35.     uint8_t  FreeLevelCount=0;
    
36.     uint32_t CAN_TX_BOX0;
    
37.     TxMeg.StdId=ID;
    
38.     TxMeg.IDE = CAN_ID_STD;//扩展帧标识（STD标准帧/EXT扩展帧）
    2 B- Q: w9 ^/ |7 `' }6 q6 S
39.     TxMeg.RTR = CAN_RTR_DATA;//远程帧标识（DATA数据帧/REMOTE远程帧）
    
40.     if(!hcan||!pData||!Len){
    
41.             printf("\n\rCAN发送失败！\n\r"); //串口发送
    ! x* Z2 |- w! _/ j% J; n
42.             return  HAL_ERROR;//如果总线名、数据、数量任何一个为0则返回值为1
    ; r# X# l5 W- m' S
43.     }
    - [# _* h4 l) `
44.     SendTimes=Len/8+(Len%8?1:0);
    
45.     FreeTxNum=HAL_CAN_GetTxMailboxesFreeLevel(hcan);//得出空闲邮箱的数量
    % P2 y4 g  \+ @7 V0 T3 `6 M
46.     TxMeg.DLC=8;
    6 E9 `/ N9 q* |+ L, ]7 K6 Y
47.     while(SendTimes--){//循环判断分批发送是否结束
    3 P( a6 r! g( U% k# ~* ~
48.        if(0==SendTimes){//如果分批发送结束
    / K* z' I( W4 c9 p0 H
49.            if(Len%8)TxMeg.DLC=Len%8;//则加入最后不足8个的数据内容
    3 _# `; ~4 |3 R$ D
50.        }
    : B+ N, S' D, v& ]. D
51.        FreeLevelCount = 0;//防止死循环
      w8 c# ^: V/ V$ V
52.        while(0 == FreeTxNum&&FreeLevelCount<10){
    ' w2 `2 ?  F; {- q
53.                        FreeLevelCount++;
    
54.                        HAL_Delay(1);
    
55.             FreeTxNum = HAL_CAN_GetTxMailboxesFreeLevel(hcan);
    5 w  e. P! N& r( ]/ M" R
56.         }
    7 d% J( t$ b: O+ ]
57.        HAL_Delay(1);//延时防止速度过快导致的发送失败
    
58.        //开始发送数据（参数：总线名，设置参数，数据，邮箱号）
    1 i3 V. V3 I6 x7 [7 u) {
59.        HAL_RetVal=HAL_CAN_AddTxMessage(hcan,&TxMeg,pData+SendCNT,&CAN_TX_BOX0);
    
60.        if(HAL_RetVal!=HAL_OK){
    ' b3 A6 `1 N% r7 b% ~, a
61.                        printf("\n\rCAN总线忙碌！\n\r"); //串口发送
    . B" d/ \) x$ }7 P. B
62.                        return  HAL_BUSY;//如果发送失败，则返回值为2
    
63.        }
    
64.        SendCNT+=8;
    # j0 Y0 B2 I" a$ c& f
65.     }
    $ y  r4 \+ N! s+ I9 Q. N
66.     return HAL_OK;//如果发送成功结束，返回值为0
    1 |* C2 Y/ x$ ?7 B$ n4 Q
67. }
    
68. //CAN总线通信，使用CAN1，这是CAN专用的printf函数
    ) p; R4 {5 \  H, x# Q
69. //调用方法：CAN1_printf("123"); //向UART8发送字符123
    1 S' D' y6 a$ @" l, F8 p9 Y- c* F
70. void CAN1_printf (char *fmt, ...)
    " q' X2 k7 t/ @) x! I( X9 I
71. {
    4 k8 m3 s& H& \' J# X' h8 X- Q
72.     char buff[CAN1_REC_LEN+1];  //用于存放转换后的数据 [长度]
    7 O& }$ R2 a  ]
73.     uint16_t i=0;
    + l- D1 \1 ]* W
74.     va_list arg_ptr;
    6 O# {# l+ h2 h% H8 p
75.     va_start(arg_ptr, fmt);
    
76.     vsnprintf(buff, CAN1_REC_LEN+1, fmt,  arg_ptr);//数据转换
    
77.     i=strlen(buff);//得出数据长度
    ; W" k- [" U/ P4 B2 V
78.     if(strlen(buff)>CAN1_REC_LEN)i=CAN1_REC_LEN;//如果长度大于最大值，则长度等于最大值（多出部分忽略）
    $ [* f+ ]# l4 m/ ]8 s( ?
79.     CAN1_SendNormalData(&hcan,0x11,(uint8_t *)buff,i);//CAN发送数据函数（ID为0x11）
    3 q% B( ^0 M1 @7 y9 Q
80.     va_end(arg_ptr);
    6 o0 M- |5 }/ @, R! T
81. }

复制代码

3.3 CAN调用实现
        在main.c文件中，加入各驱动文件的头文件引用
8 Y! v# H7 S8 v& Q

1. /* USER CODE BEGIN Includes */
   
2. #include "../../ICore/key/key.h"
   
3. #include "../../ICore/led/led.h"
   
4. #include "../../ICore/print/print.h"
   
5. #include "../../ICore/usart/usart.h"
   
6. #include "../../ICore/can/can1.h"
   
7. /* USER CODE END Includes */

复制代码

         在main函数中，加入各驱动的初始化化实现，CAN的初始化以及生产代码自动调用
3 o: v$ P; g$ J" j# f

1.   /* USER CODE BEGIN 2 */
   
2.   ResetPrintInit(&hlpuart1);
   # A& z' O6 ?: |( ~0 W4 v% i
3.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
   
4.   HLPUSART_RX_STA = 0;
   $ }+ E. o  u8 K' {# C& b
5.   /* USER CODE END 2 */

复制代码

        在main函数循环体中，实现CAN调用

1.   /* USER CODE BEGIN WHILE */
   5 a8 K; v- _1 L, r( I' E2 y
2.   while (1)
   
3.   {
   
4.           if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
   8 A: A- u9 c! S# C- s
5.                   printf("%.*s\r\n",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
   1 q4 o  Z. j- X7 h
6.                   HLPUSART_RX_STA=0;//接收错误,重新开始
   % ]& H/ n- B" J/ U( m) ^- K1 @+ O+ {' D
7.                   HAL_Delay(100);//等待
   
8.           }
   
9.           if(CAN1_RX_STA!=0)//CAN判断中断接收标志位【处理从CAN外部设备接收的字符】
   
10.       {
    8 V) K5 D' [/ o" n  n2 c. P9 P
11.               //CAN1_printf("%c",CAN1_RX_BUF[0]); //CAN总线发送
    7 t0 Z0 ^7 d/ M( M- ^) L
12.               printf("CAN1 Receive:%c",CAN1_RX_BUF[0]); //lpuart1总线发送
    
13.               CAN1_RX_STA=0;//清除标志位
    
14.       }
    
15.           if(KEY_1())//按下KEY1判断
    , _" z7 t$ s  M/ ?* y  V; X( R+ U
16.           {
    ( l4 t1 d! p& _  r
17.                   CAN1_printf("A");//向CAN1发送字符A
    
18.           }
      \" A! n! h6 S  D9 ]
19.           if(KEY_2())//按下KEY2判断
    $ q" c4 r+ s9 W, y& j
20.           {
    
21.                   CAN1_printf("B");//向CAN1发送字符B
    
22.           }
    ! ?; K" U) k1 g# V
23.     /* USER CODE END WHILE */

复制代码

7 z6 z3 m& p  b! L& b% l5 ]四、编译及测试
        4.1 编译及测试
1 s9 p! X9 n: U# [4 `5 e$ d         编译工程，STM32L496VGx支持ST-Link，直接在CubeIDE配置运行及下载程序。


' W# }: M2 n) y' [& {
         同样方法基于STM32F103C8Tx芯片创建工程、配置CAN及代码编译，其CAN配置如下
) w9 a- D. I: @7 c& E  `; v3 r1 `

" N6 G3 e0 T% v' h9 j
' k/ M, l& P' U$ `, L6 I         完成工程编译后，加载测试
& P( i, e3 w) D9 F+ W

2 y% y: [1 A3 I$ r3 }( X4 |
         4.2 测试
* ]7 n# e- ~  a7 T  |. M3 }        打开串口工具，连接STM32L496芯片的工程lpuart1串口，在STM32F103C8Tx开发板上按键KEY1、KEY2，查看串口输出情况。


' _: O( O/ j. h8 |- k% j
————————————————
版权声明：py_free-物联智能
( ]* g  v' ]4 W! x9 E# J如有侵权请联系删除
2 ~5 R" _) g, N: o