一、遇到的问题

1、发送单包数据，我想都非常简答，例子一大堆包括，demo。但是发送多包数据怎么处理？
: b4 g; V0 ~5 W/ j% {/ |8 P2、发送多包数据，网上基本上就两种说发
*两个数据之间加延时
*查询邮箱是否满了
HAL_CAN_GetTxMailboxesFreeLevel（）
; K2 W4 t4 Y3 k6 s; j) @) E8 v对比上面两种方法，为了效率我们选择第二种

) v" p+ ]$ Y2 u9 f

3 Q  ?" P" C3 a9 @6 v" U

二、配置与代码

直接上cubemx配置

( ?+ N. ]$ T  F/ S3 g# p6 R

' {- q5 y6 i  {. `$ z
. ^" Q7 w2 c0 M5 b* k3 M9 h
直接生成后，cubemx没有设置过滤器，需要自己添加，结合网上各资料总结代码如下

1. int main(void)
   
2. {
   
3.   /* USER CODE BEGIN 1 */
   4 _3 ]  X, V% b$ U. B
4. 
   * z# a1 V) o+ G6 Y, o* f
5.   /* USER CODE END 1 */
   ; Q8 I7 @% e. H5 B; G) J. v
6. 
   
7.   /* MCU Configuration--------------------------------------------------------*/
   
8. 
   
9.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   
10.   HAL_Init();
    . T, h0 Z" N. e
11. 
    " Q( N8 Y& ^/ Y1 L/ X: D; Y
12.   /* USER CODE BEGIN Init */
    $ p. S3 I* i5 t6 H5 t: e$ h8 |
13. 
    
14.   /* USER CODE END Init */
    
15. 
    
16.   /* Configure the system clock */
    2 F) Z9 q7 {9 J, |- K/ Q
17.   SystemClock_Config();
    . L2 f8 I( l7 p6 E
18. 
    4 j! G) C6 i! g1 I' d
19.   /* USER CODE BEGIN SysInit */
    
20. 
    9 l: O: a0 P2 u/ E4 u6 C
21.   /* USER CODE END SysInit */
    ) ]0 S9 Q6 d. W1 O
22. 
    & U+ ^( l- m1 R+ D; Y
23.   /* Initialize all configured peripherals */
    
24.   MX_GPIO_Init();
    
25.   MX_CAN1_Init();
    $ ?% Z8 E: j$ w
26.   /* USER CODE BEGIN 2 */
    7 _9 O0 N. {7 a. Q4 L
27.         CAN_Init();
    : q/ ~0 j; Y' W% m+ b! D
28.   /* USER CODE END 2 */
    
29. 
    
30.   /* Infinite loop */
    ' m! B5 N$ Q* w8 e$ v
31.   /* USER CODE BEGIN WHILE */
    ! x5 L; C* q; C! _* {! C/ H
32.   while (1)
    ; y; T/ G1 o2 a* |/ R  @' {
33.   {
    
34.     /* USER CODE END WHILE */
    # s2 _2 `( Q/ d7 D1 a: z, S( K, ]
35. 
    
36.     /* USER CODE BEGIN 3 */
    
37.                 uint8_t TxData[100] ;
    + Y  y8 |+ F4 z' Z7 r0 c
38.                 for(uint8_t i=0;i<100;i++)
    3 T; z( ~) o8 w; K9 M1 |5 N
39.                         TxData[i]=i;
    5 i; \  b$ T7 D! u
40.                 CAN_SendStdMsg(&hcan1,TxData,sizeof(TxData));
    % x8 p, p9 \/ t
41.                 HAL_Delay(100);
    
42.   }
    $ }3 v* [7 a4 d4 z, l
43.   /* USER CODE END 3 */
    " `* H& j& \* ?1 @  D; B% v
44. }

复制代码

bsp_can.c

& {, P/ {! I3 v  X  i& c" o* S7 M

1. #include "bsp_can.h"
   $ Q# s2 ]6 s+ W- }
2. 
   
3. 
   
4. /// CAN过滤器寄存器位宽类型定义
   $ l' P, \5 B- D7 i2 ]
5. typedef union
   , u2 F# _9 T. u) c6 D5 x3 w
6. {
   . F) C! V# V, Z  D
7.     __IO uint32_t value;
   
8.     struct
   
9.     {
   
10.         uint8_t REV : 1;                        ///< [0]    ：未使用
    
11.         uint8_t RTR : 1;                        ///< [1]    : RTR（数据帧或远程帧标志位）
    8 J$ {* h5 C+ n" B% W) A) s8 G
12.         uint8_t IDE : 1;                        ///< [2]    : IDE（标准帧或扩展帧标志位）
    ! p8 f2 M1 K" ^* I" \, m. W
13.         uint32_t EXID : 18;                        ///< [21:3] : 存放扩展帧ID
    
14.         uint16_t STID : 11;                        ///< [31:22]: 存放标准帧ID
    
15.     } Sub;
    
16. } CAN_FilterRegTypeDef;
    0 M3 R5 K! q2 [* U/ w& R& Y' a, n
17. 
    
18. 
    
19. #define CAN_BASE_ID 0                                                ///< CAN标准ID，最大11位，也就是0x7FF
    
20. 
    * d+ c7 o0 M7 X5 ^' l
21. #define CAN_FILTER_MODE_MASK_ENABLE 1                ///< CAN过滤器模式选择：=0：列表模式  =1：屏蔽模式
    ) U1 i9 W6 q( o4 Q* \
22. 
    
23. #define CAN_ID_TYPE_STD_ENABLE      1       ///< CAN过滤ID类型选择：=1：标准ID，=0：扩展ID
    
24. 
    1 Y$ c! ?! t4 L5 S9 x! b
25. void CAN_Filter_Config(void)
    
26. {
    5 s' J4 T) E7 q1 E) D
27.     CAN_FilterTypeDef sFilterConfig;
    . a7 `8 G' {. I' s
28.     CAN_FilterRegTypeDef IDH = {0};
    
29.     CAN_FilterRegTypeDef IDL = {0};
    
30. 
    / u' Y5 g$ @7 [
31. #if CAN_ID_TYPE_STD_ENABLE
    
32.     IDH.Sub.STID = (CAN_BASE_ID >> 16) & 0xFFFF;                                                                                        // 标准ID高16位
    & f. R0 ~( S% Y
33.     IDL.Sub.STID = (CAN_BASE_ID & 0xFFFF);                                                                                                                // 标准ID低16位
    
34. #else
    
35.     IDH.Sub.EXID = (CAN_BASE_ID >> 16) & 0xFFFF;                                                                                        // 扩展ID高16位
    9 k, u# M. ?3 a3 [
36.     IDL.Sub.EXID = (CAN_BASE_ID & 0xFFFF);                                                                                                                // 扩展ID低16位
    
37.     IDL.Sub.IDE  = 1;                                                                                                                                                                                                        // 扩展帧标志位置位
    0 t5 d" z* V' [
38. #endif
    
39.     sFilterConfig.FilterBank           = 0;                                                                                                    // 设置过滤器组编号
    6 ^+ M: B/ B6 x+ e5 m
40. #if CAN_FILTER_MODE_MASK_ENABLE
    
41.     sFilterConfig.FilterMode           = CAN_FILTERMODE_IDMASK;                                // 屏蔽位模式
    
42. #else
    - j9 N& [% l" R
43.     sFilterConfig.FilterMode           = CAN_FILTERMODE_IDLIST;                                // 列表模式
    ) A: L3 H9 T6 o8 ~# l
44. #endif
    + |4 a  Y! f1 P9 H
45.     sFilterConfig.FilterScale          = CAN_FILTERSCALE_32BIT;                                // 32位宽
    + N: z( L8 |' b  b& O/ W, ?
46.     sFilterConfig.FilterIdHigh         = IDH.value;                                                                                // 标识符寄存器一ID高十六位，放入扩展帧位
      X* K1 g0 [6 J; v# k; \8 A
47.     sFilterConfig.FilterIdLow          = IDL.value;                                                                                // 标识符寄存器一ID低十六位，放入扩展帧位
    # f" p0 {7 z2 _! G( `
48.     sFilterConfig.FilterMaskIdHigh     = IDH.value;                                                                                // 标识符寄存器二ID高十六位，放入扩展帧位
    
49.     sFilterConfig.FilterMaskIdLow      = IDL.value;                                                                                // 标识符寄存器二ID低十六位，放入扩展帧位
    0 p2 \- s  o3 c9 `2 C, e2 g. g
50.     sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;                                                                // 过滤器组关联到FIFO0
    0 V! w* u, f+ W* [0 B8 w& Z# U& b% A
51.     sFilterConfig.FilterActivation     = ENABLE;                                                                                        // 激活过滤器
    
52.     sFilterConfig.SlaveStartFilterBank = 14;                                                                                                        // 设置从CAN的起始过滤器编号，本单片机只有一个CAN，顾此参数无效
    
53.     if (HAL_CAN_ConfigFilter(&hcan1, &sFilterConfig) != HAL_OK)
    
54.     {
    , a) e1 t0 b2 y9 x
55.         Error_Handler();
    
56.     }
    : }# T# Q5 K# S0 X" M% e
57. }
    
58. 
    & N% Z& P3 A7 I6 M2 Z& s
59. 
    & G. x3 }7 a  A% [  O" h
60. 
    ' K' \6 ?* c  R1 E  }* j
61. void CAN_Init(void)
    1 O4 \, n! P# l) ]! a/ _
62. {
    
63.     CAN_Filter_Config();
    
64.     HAL_CAN_Start(&hcan1);
    ) b% ^. x) r9 e/ H6 G, B+ z
65.     HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING);                                        // 使能CAN接收中断
    
66. }
    
67. 
    - U" x( _& k8 P6 G
68. void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *canHandle)
      N9 m1 {  |3 y& Z+ ?6 v
69. {
    
70.         static CAN_RxPacketTypeDef packet;
    
71.        
    
72.     // CAN数据接收
    
73.     if (canHandle->Instance == hcan1.Instance)
    
74.     {
    
75.         if (HAL_CAN_GetRxMessage(canHandle, CAN_RX_FIFO0, &packet.hdr, packet.payload) == HAL_OK)                // 获得接收到的数据头和数据
    9 E7 {- H# b* ?% }, h+ M% H
76.         {
    & L6 f2 I$ x* \  J9 f; ^9 D. q, R. R
77. //                        printf("\r\n\r\n\r\n################### CAN RECV ###################\r\n");
    5 ?- y- F* S0 g( M; d& [, E
78. //                        printf("STID:0x%X\r\n",packet.hdr.StdId);
    
79. //                        printf("EXID:0x%X\r\n",packet.hdr.ExtId);
    4 I2 u0 ]' k% W2 }6 g2 t8 ^+ C
80. //                        printf("DLC :%d\r\n", packet.hdr.DLC);
    
81. //                        printf("DATA:");
    . ~9 y7 O! x- y; k' g7 b% j# g  n
82. //                        for(int i = 0; i < packet.hdr.DLC; i++)
    
83. //                        {
    ) {0 `: ?2 s) _; V8 n
84. //                                printf("0x%02X ", packet.payload[i]);
    / a1 x0 M* o0 s$ A4 w- n
85. //                        }
    * }. o( f7 J2 k) W' N
86.            HAL_CAN_ActivateNotification(canHandle, CAN_IT_RX_FIFO0_MSG_PENDING);                                                // 再次使能FIFO0接收中断
    $ N! p$ X# }! U1 r2 V; G
87.         }
    
88.     }
    
89. }
    
90. 
    
91. 
    ! y* ]9 a3 T7 K) u, o3 d
92. uint8_t CAN_Transmit(CAN_TxPacketTypeDef* packet)
    
93. {
    5 f9 L: X3 u% L" r' }! N8 g8 ^. R
94.         if(HAL_CAN_AddTxMessage(&hcan1, &packet->hdr, packet->payload, &packet->mailbox) != HAL_OK)
    8 C, g- e& Y- U/ V# z4 H
95.                 return 1;
    
96.         return 0;
    
97. }
    
98. 
    
99. 
    
100. CAN_TxHeaderTypeDef TxMeg;
     & {- n3 ^. f5 f' |
101. uint16_t TimsRepeat;
     
102. uint8_t CAN_SendStdMsg(CAN_HandleTypeDef* __hcan,uint8_t *pData,uint16_t Len)
     
103. {
     
104.         uint16_t SendCNT=0;
     3 j5 a3 k+ T* C
105.         uint32_t TxMailbox;
     ' t1 N7 ^' Q' j6 ^
106.         HAL_StatusTypeDef        HAL_RetVal;
     0 C, K3 o+ x' t& \9 P* _
107.        
     
108.         TxMeg.StdId = 0x321; //标准ID
     
109. //        TxMeg.ExtId = 0x10F01234;
     
110.         TxMeg.IDE = CAN_ID_STD;// 标准ID类型
     " F0 E; d# m; k& \  |2 w
111. //TxMeg.IDE = CAN_ID_EXT;// 扩展ID类型
     
112.         TxMeg.RTR = CAN_RTR_DATA;                // 数据帧
     0 O2 o, Z6 T6 T
113. //TxMeg.RTR =  CAN_RTR_REMOTE;                // 远程帧
     
114.         TxMeg.TransmitGlobalTime = DISABLE;
     - d* _6 q* b. ]( m5 X' H) Y
115.        
     
116.         if(!__hcan || ! pData ||!Len) return 1;
     , _' {) p3 w' C" b4 u! p" R  N
117. 
     
118.         TimsRepeat =Len/8+(Len%8?1:0);
     
119.         while(TimsRepeat--)
     - V1 m+ F' ~2 k
120.         {
     
121.                 while(HAL_CAN_GetTxMailboxesFreeLevel(__hcan)==0);
     
122.                 if(TimsRepeat>0)
     
123.                 {       
     & n3 u8 I$ M' S1 k/ d$ j6 E. R
124.                         TxMeg.DLC=8;
     
125.                 }
     
126.                 else
     
127.                 {
     3 h0 L% x- p9 V
128.                         if(Len%8)
     
129.                         TxMeg.DLC=Len%8;
     % a4 n4 l: Y6 C6 D) M
130.                 }
     
131.                 HAL_RetVal=HAL_CAN_AddTxMessage(__hcan,&TxMeg,(pData+SendCNT),&TxMailbox);  
     
132.                 if(HAL_RetVal!=HAL_OK)
     
133.                 {
     : }- g6 s' P8 s9 r* R9 L
134.                         return 0;
     
135.                 }
     
136.                 SendCNT+=8;
     
137.         }
     
138.         return 1;

复制代码

" d& Q# h9 [5 Q1 C% i$ l

bsp_can.h

1. #ifndef _BSP_CAN_H
   ! v) {6 ]" a& k+ w4 o3 v3 N
2. #define _BSP_CAN_H
   4 a/ R+ X+ S0 w5 X' e' l
3. #include "stm32f4xx_hal.h"
   
4. #include "can.h"
   
5. 
   
6. //typedef struct
   
7. //{
   ) P5 n% T) E9 r2 ?, C- a4 u
8. //        uint32_t mailbox;
   " E6 H! g: Z5 y9 r: d# T
9. //        CAN_TxHeaderTypeDef hdr;
   # a3 o# _! s( Y6 P+ F
10. //        uint8_t payload[8];
    
11. //}CAN_TxPacketTypeDef;
    
12. 
    
13. typedef struct
    " `) F* u( @/ F+ D9 x. X
14. {
    " a7 k1 z: g2 p! L
15.         CAN_RxHeaderTypeDef hdr;
    & [. `! R% k. Q. {! v" n
16.         uint8_t payload[8];
    2 F5 J3 l' H; _7 f' G5 s
17. }CAN_RxPacketTypeDef;
    
18. 
    9 v; e+ C' C) T
19. 
    + [$ M' ~1 L) j$ ^# ^  U5 [
20. void CAN_Init(void);
    9 v% U# N& u# y) n$ E# z
21. uint8_t CAN_SendStdMsg(CAN_HandleTypeDef* __hcan,uint8_t *pData,uint16_t Len);
    8 V8 e2 z+ F' K( |5 |
22. #endif

复制代码

2 r' C& R9 g3 _+ m2 T% c' _5 n

就可以工作了？？？非也
3 `- u6 [5 c) w( l( B其实我发现还是有问题

8 g* N  j2 D, f+ o

9 V8 B) t' H1 y2 q% t6 d为什么第2 3包数据到最后去了？

查了一些资料发现了问题：
”发送邮箱“是用于CAN总线数据发送的，总共有3个，并且存在优先级关系。优先级越高表示其里面的数据会被优先发送。数据在发送前都会被送到优先级最高且空闲的发送邮箱，然后依次发送。最后说明一点：“发送邮箱有3个，且每个邮箱只能装一个报文”

原因是，三个邮箱有优先级，我发送前会检查三个邮箱是否都满，没满就发送。导致 第 2 3包数据在两个优先级低的邮箱，导致才最后发送

查看库函数

1. /**
   
2.   * @brief  Return Tx Mailboxes free level: number of free Tx Mailboxes.
   : r$ v& z2 C3 o
3.   * @param  hcan pointer to a CAN_HandleTypeDef structure that contains
   / B& R0 h+ Q& J5 `+ V. [
4.   *         the configuration information for the specified CAN.
   
5.   * @retval Number of free Tx Mailboxes.
   
6.   */
   + L- ^% |" W, M; @7 z4 c  o
7. uint32_t HAL_CAN_GetTxMailboxesFreeLevel(CAN_HandleTypeDef *hcan)
   
8. {
   $ s7 Z' d. E  a, y0 f7 i
9.   uint32_t freelevel = 0U;
   
10.   HAL_CAN_StateTypeDef state = hcan->State;
    
11. 
    
12.   if ((state == HAL_CAN_STATE_READY) ||
    
13.       (state == HAL_CAN_STATE_LISTENING))
    
14.   {
    . V! J& w& A  [: ]- v0 |
15.     /* Check Tx Mailbox 0 status */
    
16.     if ((hcan->Instance->TSR & CAN_TSR_TME0) != 0U)
    
17.     {
    4 P: X, Q2 V3 C
18.       freelevel++;
    
19.     }
    4 u. p- r6 ~6 p/ L8 v
20. 
    
21.     /* Check Tx Mailbox 1 status */
    # S" T& B+ |. [
22.     if ((hcan->Instance->TSR & CAN_TSR_TME1) != 0U)
    
23.     {
    
24.       freelevel++;
    
25.     }
    / _+ h  D: I; a& Y1 v! n
26. 
    
27.     /* Check Tx Mailbox 2 status */
    8 C, I, c" j4 n
28.     if ((hcan->Instance->TSR & CAN_TSR_TME2) != 0U)
    8 B% A; P, S0 p# N: b
29.     {
    ! ]& E6 J' O; @6 b
30.       freelevel++;
    
31.     }
    
32.   }
    . J6 ], c( j7 `
33. 
    + V' `( n3 `" @3 T
34.   /* Return Tx Mailboxes free level */
    
35.   return freelevel;
    & l' j) Z0 i8 D2 k1 l* _3 [
36. }

复制代码

解决办法如下：当然你也可以自己封装一下

4 t. b3 p8 U$ u. g1 E" o7 W

1. uint32_t HAL_CAN_GetTxMailboxesFreeLevel(CAN_HandleTypeDef *hcan)
   9 n: X6 X$ V4 b. l
2. {
   
3.   uint32_t freelevel = 0U;
   
4.   HAL_CAN_StateTypeDef state = hcan->State;
   
5. 
   " ]5 j: _4 L3 d" l
6.   if ((state == HAL_CAN_STATE_READY) ||
   
7.       (state == HAL_CAN_STATE_LISTENING))
   
8.   {
   
9.                
   0 }3 D6 v: N- L
10.                 if (((hcan->Instance->TSR & CAN_TSR_TME0) != 0U)&& \
    " s+ K2 x, {' T8 o' ~$ q
11.                           ((hcan->Instance->TSR & CAN_TSR_TME1) != 0U)&& \
    * P8 I* G5 I) Q; L) J$ j
12.                      (hcan->Instance->TSR & CAN_TSR_TME2) != 0U)
    
13.     {
    4 \0 |2 y3 q* V, `, O1 ?; {. X
14.       freelevel++;
    
15.     }
    6 c; r. Y+ |; \6 h
16. 
    ' [. D# ?* S" A* R! j$ C( L
17.     /* Check Tx Mailbox 0 status */
    
18. //    if ((hcan->Instance->TSR & CAN_TSR_TME0) != 0U)
    ; x- F- m$ h' t8 G1 R8 Q9 ~
19. //    {
    & k- {: ?! P) r4 \+ l% l
20. //      freelevel++;
    
21. //    }
    
22. 
    
23.     /* Check Tx Mailbox 1 status */
    
24. //    if ((hcan->Instance->TSR & CAN_TSR_TME1) != 0U)
    $ l0 [; o+ L, j1 H& h+ `
25. //    {
    
26. //      freelevel++;
    
27. //    }
    
28. 
    
29. //    /* Check Tx Mailbox 2 status */
    
30. //    if ((hcan->Instance->TSR & CAN_TSR_TME2) != 0U)
      ?. n. u9 m" b  M, K! j
31. //    {
    
32. //      freelevel++;
    " C3 |' c; I1 g
33. //    }
    
34.   }
    $ b# n3 s) Z3 A9 X
35. 
    
36.   /* Return Tx Mailboxes free level */
    , _. T, N) j5 l4 M" G4 @6 P- F
37.   return freelevel;
    % R: D% E2 ], S' x$ Z1 D- s* O
38. }

复制代码

- f* p, E/ a7 F7 t0 a, p/ L

三 总结

CAN数据在发送前都会被送到优先级最高且空闲的发送邮箱，所有发送完后 我们不能检测三个邮箱是否有空邮箱，而是应该检测三个邮箱是否都是空的才对。

四、CAN以及库函数分析
" ?, v* p# u2 k, t- ]

CAN总线
9 G3 H. I" q" p1 Z- F& _1、根据标示符（也就是 ID）来决定优先级的。
2、在同一网络中，所有单元必须设定成统一的通信速度，最高 1Mbps（距离小于40M），最远可达 10KM（速率低于 5Kbps）
& O( a) Y) [# q5 c9 P: `3、可通过发送“遥控帧” 请求其他单元发送数据。
# K( l( y. `* T' Q4、CAN Model:

; M$ g& Q$ ?  r9 f: n. ]( y' eNormal 正常模式
Silent 静默模式
8 L/ c' E: Z- T  J, F" lLoopback 环回模式 测试
Silent_loopback 静默换回模式 测试

5、波特率

! y' g1 z+ z8 L1 i7 Y波特率(Kpbs) = fpclk / ((CAN_BS1 + CAN_BS2 + 1) * CAN_Prescaler)

6、发送数据结构体指针

  

1. /**
   
2.   * @brief  CAN Tx message header structure definition
   
3.   */
   
4. typedef struct
   
5. {
   ! N7 ?* W& ]" S5 k! V
6. //表示标准的ID
   
7.   uint32_t StdId;    /*!< Specifies the standard identifier.
   
8.                                                   This parameter must be a number between Min_Data = 0 and Max_Data = 0x7FF. */
   " f' N8 U& C+ h1 w, Z2 h) m0 ^
9. //表示扩展的ID
   6 \- U* q* Y& v
10.   uint32_t ExtId;    /*!< Specifies the extended identifier.
    7 o7 K' {% g; T
11.                           This parameter must be a number between Min_Data = 0 and Max_Data = 0x1FFFFFFF. */
    
12. //要发送的是扩展帧还是标准帧
    5 L$ G5 U% R/ B+ Y
13.   uint32_t IDE;      /*!< Specifies the type of identifier for the message that will be transmitted.
    
14.                           This parameter can be a value of @ref CAN_identifier_type */
    3 @: l* V& m# X# F
15. //表示发送的帧类型。如：数据帧、远程帧等
    
16.   uint32_t RTR;      /*!< Specifies the type of frame for the message that will be transmitted.
    2 |3 j# J+ S( i4 G8 {- e! d  r
17.                           This parameter can be a value of @ref CAN_remote_transmission_request */
    
18. //表示发送的数据长度
    / h# O7 y5 S4 J8 l! h' R4 [
19.   uint32_t DLC;      /*!< Specifies the length of the frame that will be transmitted.
    
20.                           This parameter must be a number between Min_Data = 0 and Max_Data = 8. */
    
21. 
    
22.   FunctionalState TransmitGlobalTime; /*!< Specifies whether the timestamp counter value captured on start
    
23.                           of frame transmission, is sent in DATA6 and DATA7 replacing pData[6] and pData[7].
    
24.                           @note: Time Triggered Communication Mode must be enabled.
    
25.                           @note: DLC must be programmed as 8 bytes, in order these 2 bytes are sent.
    
26.                           This parameter can be set to ENABLE or DISABLE. */
    
27. 
    
28. } CAN_TxHeaderTypeDef;

复制代码

- C: |* j3 {  }6 t0 c

7、过滤器：为了方便接收想要的ID，过滤掉不想要的ID。28组或14组过滤器，每组2个32为寄存器
屏蔽模式
8 E4 J8 x% s) T) B. y  `: O7 Z5 v8 R屏蔽位模式: 标识符寄存器（设置想接收的ID）和屏蔽寄存器（设置关心的位）。又比如说，当你值接收一个固定的 ID 的时候，你 把屏蔽寄存器全部设置为 1（即必须比较），然后在标示符寄存器里面存放你
想要的接收的 ID，那么当 CAN 总线上面出现你想要的 ID 的时候，它就将它接收，其他的不接收。
屏蔽列表模式:每组过滤器 中的两个寄存器全部用来做标示符寄存器，也就是说当接收的 ID 必须跟表 示符寄存器中的 ID 相同的时候才接收。

5 |0 B/ |- A  D3 _

9 _/ ~/ a: H/ u7 J5 K

8、过滤器结构体

1. /**
   . i$ H9 w1 Q. T) ^, C' z: g4 k
2.   * @brief  CAN filter configuration structure definition
   
3.   */
   
4. typedef struct
   6 }4 w/ i9 ?; _) w8 B6 D. N
5. {
   ' m( V* r+ {" Z" n; J
6.         //这个是标示符寄存器的高 16 位
   
7.   uint32_t FilterIdHigh;          /*!< Specifies the filter identification number (MSBs for a 32-bit
   
8.                                        configuration, first one for a 16-bit configuration).
   
9.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF. */
   
10.         //这个是标示符寄存器的低 16 位
    
11.   uint32_t FilterIdLow;           /*!< Specifies the filter identification number (LSBs for a 32-bit
    
12.                                        configuration, second one for a 16-bit configuration).
    
13.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF. */
    , b/ s- X. B( H9 s
14.         //这个是屏蔽寄存器高字节的设置
    
15.   uint32_t FilterMaskIdHigh;      /*!< Specifies the filter mask number or identification number,
    
16.                                        according to the mode (MSBs for a 32-bit configuration,
    : A+ v* R  o# M
17.                                        first one for a 16-bit configuration).
    
18.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF. */
    
19.         //这个是屏蔽寄存器低字节的设置
    $ x& e7 b2 d3 z0 `  ]9 q
20.   uint32_t FilterMaskIdLow;       /*!< Specifies the filter mask number or identification number,
    % s, q+ Q  Q0 p; s
21.                                        according to the mode (LSBs for a 32-bit configuration,
    
22.                                        second one for a 16-bit configuration).
    % c# Q: h; H* w& Z) [& r0 J5 e) X
23.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF. */
    & s1 e! @; |4 |2 j+ h) \# X
24.         //选择你要使用的邮箱，它有 0 和 1
    
25.   uint32_t FilterFIFOAssignment;  /*!< Specifies the FIFO (0 or 1U) which will be assigned to the filter.
    . R1 V6 j* j5 Y+ f
26.                                        This parameter can be a value of @ref CAN_filter_FIFO */
    0 V2 B( @, m3 M, E, N
27.   //表示标示符寄存器的ID，）我们这里使用第一组寄存器设置为：1。
    
28.   uint32_t FilterBank;            /*!< Specifies the filter bank which will be initialized.
    
29.                                        For single CAN instance(14 dedicated filter banks),
    
30.                                        this parameter must be a number between Min_Data = 0 and Max_Data = 13.
    3 S, b1 C4 O* R/ H' y/ n
31.                                        For dual CAN instances(28 filter banks shared),
    
32.                                        this parameter must be a number between Min_Data = 0 and Max_Data = 27. */
    
33. //表示过滤模式。我们上面讲到它有屏蔽位模式和
    
34. //标示符列表模式。我们使用屏蔽位模式，所以设置为 ：
    
35. //CAN_FilterMode_IdMask。
    2 H' O! q; y' m7 Y& D7 a
36.   uint32_t FilterMode;            /*!< Specifies the filter mode to be initialized.
    
37.                                        This parameter can be a value of @ref CAN_filter_mode */
      C$ m' Z- N. u
38. //表示设置过滤器的长度。过滤器是可以设置为16位和32位两种模式的（即接收标准帧和拓展帧的区别）。
    1 B4 }5 U& D3 F; O  h
39.   uint32_t FilterScale;           /*!< Specifies the filter scale.
    
40.                                        This parameter can be a value of @ref CAN_filter_scale */
    
41. //表示过滤器的使能
    # q$ |$ l# N5 g8 c
42.   uint32_t FilterActivation;      /*!< Enable or disable the filter.
    
43.                                        This parameter can be a value of @ref CAN_filter_activation */
    
44. 
    * v$ ], @+ r' N1 \, u
45.   uint32_t SlaveStartFilterBank;  /*!< Select the start filter bank for the slave CAN instance.
    
46.                                        For single CAN instances, this parameter is meaningless.
    4 I7 n6 d, j3 ^6 B. B, T
47.                                        For dual CAN instances, all filter banks with lower index are assigned to master
    + t: ]. i& z  }& l, v/ q' O& @7 i1 I7 S
48.                                        CAN instance, whereas all filter banks with greater index are assigned to slave
    4 ~4 E" |" M( c0 x* }+ j8 a
49.                                        CAN instance.
    
50.                                        This parameter must be a number between Min_Data = 0 and Max_Data = 27. */
    
51. } CAN_FilterTypeDef;
    * l$ M+ F3 j" M8 S

复制代码

4 e8 Y% v. J( h

不应该中断方式发送多包嘛