一、遇到的问题

1、发送单包数据，我想都非常简答，例子一大堆包括，demo。但是发送多包数据怎么处理？
2、发送多包数据，网上基本上就两种说发
*两个数据之间加延时
  t+ H$ O. W% }4 V. E*查询邮箱是否满了
HAL_CAN_GetTxMailboxesFreeLevel（）
对比上面两种方法，为了效率我们选择第二种

$ S& E$ S. E5 |% W  }

二、配置与代码
/ h, e  M" P% [0 O- P' V' ~
! e3 n# B& G/ `

直接上cubemx配置

; a7 Z/ S- h: n' ?: ^( T

0 g& d- S/ g) f4 ?! s8 W3 c& [, z

/ C6 l3 }) R1 I# h9 H. D- \

2 t2 ?6 O" }+ c5 c$ R" E- I
; e) ?5 w6 m- c' n9 l
直接生成后，cubemx没有设置过滤器，需要自己添加，结合网上各资料总结代码如下

1. int main(void)
   : x- \* {: U9 J6 j3 U# U
2. {
   % b. h8 D$ t" W
3.   /* USER CODE BEGIN 1 */
   ( H0 J2 |  p5 B8 Y6 \5 B
4. 
   , h% \; P. L7 b* n
5.   /* USER CODE END 1 */
   
6. 
   
7.   /* MCU Configuration--------------------------------------------------------*/
   9 j3 K, V2 U; z' i
8. 
   % j0 g. p2 z. `/ X- V
9.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   
10.   HAL_Init();
    
11. 
    
12.   /* USER CODE BEGIN Init */
    
13. 
    0 g0 n: F) `& n% ^! r% C
14.   /* USER CODE END Init */
    
15. 
    * Q! A& b/ `- u
16.   /* Configure the system clock */
    ! P( F) N8 c; `5 M
17.   SystemClock_Config();
    . H+ W' d; v% |# a: z
18. 
    
19.   /* USER CODE BEGIN SysInit */
    " p, o) Z; H6 f# T% u( E
20. 
    
21.   /* USER CODE END SysInit */
    
22. 
    ) j$ V! z& ~- h5 L) \; q
23.   /* Initialize all configured peripherals */
    
24.   MX_GPIO_Init();
    3 J  _3 \; r! j; O8 X; V
25.   MX_CAN1_Init();
    7 {/ o* n! i, L+ @6 s: L. N1 o% S
26.   /* USER CODE BEGIN 2 */
    
27.         CAN_Init();
    
28.   /* USER CODE END 2 */
    : O% I$ T8 J* Y% a, u& N
29. 
    
30.   /* Infinite loop */
    
31.   /* USER CODE BEGIN WHILE */
    
32.   while (1)
    4 k1 t, _4 o* [6 b& W
33.   {
    
34.     /* USER CODE END WHILE */
    / ~' Q. q9 j% Z. R# y  k0 m
35. 
    
36.     /* USER CODE BEGIN 3 */
    ; m. W7 k0 y  y0 M5 h1 Y6 l- w% @
37.                 uint8_t TxData[100] ;
    
38.                 for(uint8_t i=0;i<100;i++)
    
39.                         TxData[i]=i;
    
40.                 CAN_SendStdMsg(&hcan1,TxData,sizeof(TxData));
    0 P& \1 o2 }- _1 ^2 u
41.                 HAL_Delay(100);
    6 r3 x) q5 ^; F2 Q. S: W  d: J
42.   }
    
43.   /* USER CODE END 3 */
    
44. }

复制代码

# G9 s$ G( W( c3 u% P* A# q

bsp_can.c

1. #include "bsp_can.h"
   8 S1 t! ^. Q( }! M
2. 
   ! I7 V# D7 o9 P2 U" U
3. 
   5 ~2 q# y& S# ^# K2 P2 R/ |6 j6 m
4. /// CAN过滤器寄存器位宽类型定义
   ) G4 Y2 J2 S% V, f( P, a! ^
5. typedef union
     Y0 w6 U3 u; u: A# w
6. {
   - }: E- E, X/ g
7.     __IO uint32_t value;
   % Q, p& G. S) \. W; }1 c0 C
8.     struct
   
9.     {
   
10.         uint8_t REV : 1;                        ///< [0]    ：未使用
    
11.         uint8_t RTR : 1;                        ///< [1]    : RTR（数据帧或远程帧标志位）
    $ _8 B! j# [8 |9 T+ C  E" O
12.         uint8_t IDE : 1;                        ///< [2]    : IDE（标准帧或扩展帧标志位）
    
13.         uint32_t EXID : 18;                        ///< [21:3] : 存放扩展帧ID
    
14.         uint16_t STID : 11;                        ///< [31:22]: 存放标准帧ID
    
15.     } Sub;
    
16. } CAN_FilterRegTypeDef;
    
17. 
    ) `, h4 F9 V9 b
18. 
    
19. #define CAN_BASE_ID 0                                                ///< CAN标准ID，最大11位，也就是0x7FF
    
20. 
    + r" Q% e( f+ E7 a' }7 E; b
21. #define CAN_FILTER_MODE_MASK_ENABLE 1                ///< CAN过滤器模式选择：=0：列表模式  =1：屏蔽模式
    4 O+ ]% y6 w; b5 B4 U' Q/ y7 D) l
22. 
    # |& c, t9 E* j
23. #define CAN_ID_TYPE_STD_ENABLE      1       ///< CAN过滤ID类型选择：=1：标准ID，=0：扩展ID
    # X% ], N' l$ V, P
24. 
    
25. void CAN_Filter_Config(void)
    2 S$ |: w2 }/ z& Y, ?  H
26. {
    
27.     CAN_FilterTypeDef sFilterConfig;
    
28.     CAN_FilterRegTypeDef IDH = {0};
    
29.     CAN_FilterRegTypeDef IDL = {0};
    
30. 
    
31. #if CAN_ID_TYPE_STD_ENABLE
    
32.     IDH.Sub.STID = (CAN_BASE_ID >> 16) & 0xFFFF;                                                                                        // 标准ID高16位
    
33.     IDL.Sub.STID = (CAN_BASE_ID & 0xFFFF);                                                                                                                // 标准ID低16位
    8 m' P, C' a& [- Y2 s
34. #else
    
35.     IDH.Sub.EXID = (CAN_BASE_ID >> 16) & 0xFFFF;                                                                                        // 扩展ID高16位
      \1 o8 Q7 _5 J6 a% a: G6 C0 g
36.     IDL.Sub.EXID = (CAN_BASE_ID & 0xFFFF);                                                                                                                // 扩展ID低16位
    
37.     IDL.Sub.IDE  = 1;                                                                                                                                                                                                        // 扩展帧标志位置位
    # ~; ^8 l% \6 N  `- [, f+ T$ D6 g1 C
38. #endif
    
39.     sFilterConfig.FilterBank           = 0;                                                                                                    // 设置过滤器组编号
    9 Z. W4 ^5 t/ X3 w* V! ~' ], H( }
40. #if CAN_FILTER_MODE_MASK_ENABLE
    
41.     sFilterConfig.FilterMode           = CAN_FILTERMODE_IDMASK;                                // 屏蔽位模式
    
42. #else
    
43.     sFilterConfig.FilterMode           = CAN_FILTERMODE_IDLIST;                                // 列表模式
    3 j' H. H6 O/ W7 X( S! a1 z/ v; t; Y
44. #endif
    
45.     sFilterConfig.FilterScale          = CAN_FILTERSCALE_32BIT;                                // 32位宽
    
46.     sFilterConfig.FilterIdHigh         = IDH.value;                                                                                // 标识符寄存器一ID高十六位，放入扩展帧位
    5 A- m' ], F" `1 O: i
47.     sFilterConfig.FilterIdLow          = IDL.value;                                                                                // 标识符寄存器一ID低十六位，放入扩展帧位
    
48.     sFilterConfig.FilterMaskIdHigh     = IDH.value;                                                                                // 标识符寄存器二ID高十六位，放入扩展帧位
    
49.     sFilterConfig.FilterMaskIdLow      = IDL.value;                                                                                // 标识符寄存器二ID低十六位，放入扩展帧位
    
50.     sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;                                                                // 过滤器组关联到FIFO0
    
51.     sFilterConfig.FilterActivation     = ENABLE;                                                                                        // 激活过滤器
    + ^7 W" @# x* F! F
52.     sFilterConfig.SlaveStartFilterBank = 14;                                                                                                        // 设置从CAN的起始过滤器编号，本单片机只有一个CAN，顾此参数无效
    
53.     if (HAL_CAN_ConfigFilter(&hcan1, &sFilterConfig) != HAL_OK)
    - t6 U- l7 z1 G
54.     {
    ; ?- i" b2 N5 V6 u8 N
55.         Error_Handler();
    
56.     }
    ' `; s- X( Y: t, c  {
57. }
    
58. 
    6 O" _" j5 q1 F' f* Z9 I; l
59. 
    
60. 
    * [7 w) k) e4 r5 A) i0 ?
61. void CAN_Init(void)
    $ i, n; s( I" M- {$ Y
62. {
    . O3 n4 K0 j! Z) W: o1 \
63.     CAN_Filter_Config();
    
64.     HAL_CAN_Start(&hcan1);
    
65.     HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING);                                        // 使能CAN接收中断
    
66. }
    
67. 
    5 f0 Z' B1 w' o# R6 p$ c
68. void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *canHandle)
    / ]. D& }- H8 O" N1 X! \
69. {
    
70.         static CAN_RxPacketTypeDef packet;
    8 Q: _- m* d3 c4 J
71.        
    
72.     // CAN数据接收
    
73.     if (canHandle->Instance == hcan1.Instance)
    
74.     {
    ( E6 F9 g7 V4 ~/ b5 k$ T8 A% c
75.         if (HAL_CAN_GetRxMessage(canHandle, CAN_RX_FIFO0, &packet.hdr, packet.payload) == HAL_OK)                // 获得接收到的数据头和数据
    ) H" d9 k, Z+ T1 \2 Y
76.         {
    
77. //                        printf("\r\n\r\n\r\n################### CAN RECV ###################\r\n");
    
78. //                        printf("STID:0x%X\r\n",packet.hdr.StdId);
    2 @5 w& t( {2 N- W' m$ |9 E1 Q
79. //                        printf("EXID:0x%X\r\n",packet.hdr.ExtId);
    " b/ x9 q$ Q5 K: n& d# w
80. //                        printf("DLC :%d\r\n", packet.hdr.DLC);
    6 s" K% f/ Z2 R8 V. Y
81. //                        printf("DATA:");
    9 _, f" e% H0 G
82. //                        for(int i = 0; i < packet.hdr.DLC; i++)
    ' v, W/ Q) E& l; |1 p( @
83. //                        {
    * }8 M0 X8 c$ g* u. x
84. //                                printf("0x%02X ", packet.payload[i]);
    
85. //                        }
    
86.            HAL_CAN_ActivateNotification(canHandle, CAN_IT_RX_FIFO0_MSG_PENDING);                                                // 再次使能FIFO0接收中断
    
87.         }
    # @3 D% n9 {* P6 v- M3 r# g+ o
88.     }
    
89. }
    ( @7 F/ r4 @/ X1 Y! B2 I
90. 
    * O& Z' b7 S5 e: _* H, B
91. 
    
92. uint8_t CAN_Transmit(CAN_TxPacketTypeDef* packet)
    + X6 Y9 J5 q+ Y8 i% e% K( ^- K
93. {
    
94.         if(HAL_CAN_AddTxMessage(&hcan1, &packet->hdr, packet->payload, &packet->mailbox) != HAL_OK)
    6 |0 l1 x; q- M0 Z. R$ c8 V0 k
95.                 return 1;
    
96.         return 0;
    7 a( {) _1 |; ~, c/ a) a
97. }
    
98. 
    ( m* O$ X0 E7 L5 `& R
99. 
    0 |+ `8 H4 m1 O% _/ M. p( `. J
100. CAN_TxHeaderTypeDef TxMeg;
     ( J; y1 m) ~, R- a. T# f$ G
101. uint16_t TimsRepeat;
     
102. uint8_t CAN_SendStdMsg(CAN_HandleTypeDef* __hcan,uint8_t *pData,uint16_t Len)
     
103. {
     
104.         uint16_t SendCNT=0;
     
105.         uint32_t TxMailbox;
     
106.         HAL_StatusTypeDef        HAL_RetVal;
     
107.        
     9 x+ j8 y6 O1 g# u! e# h/ k; K
108.         TxMeg.StdId = 0x321; //标准ID
     4 j4 Z9 f% ^0 W4 l* Q/ |
109. //        TxMeg.ExtId = 0x10F01234;
     
110.         TxMeg.IDE = CAN_ID_STD;// 标准ID类型
     ; V1 }* N+ R: x2 a8 J  N$ Y4 a0 |
111. //TxMeg.IDE = CAN_ID_EXT;// 扩展ID类型
     2 }) P+ h3 p# i6 K8 r7 }7 }, ^4 E
112.         TxMeg.RTR = CAN_RTR_DATA;                // 数据帧
     & B4 e" Y7 h: H+ v
113. //TxMeg.RTR =  CAN_RTR_REMOTE;                // 远程帧
     4 p& T0 ?, b: M% `4 P( R% K
114.         TxMeg.TransmitGlobalTime = DISABLE;
     
115.        
     - ~. o4 T) M, q# Q2 B% u
116.         if(!__hcan || ! pData ||!Len) return 1;
     
117. 
     ! D' J5 Q/ d) K( I! }! g
118.         TimsRepeat =Len/8+(Len%8?1:0);
     
119.         while(TimsRepeat--)
     ' `% U0 X( y! `; d, t
120.         {
     0 N, @% q6 h0 G+ S, g' o% c
121.                 while(HAL_CAN_GetTxMailboxesFreeLevel(__hcan)==0);
     3 Q4 q( R7 K, u- i; @9 X
122.                 if(TimsRepeat>0)
     0 E+ J# s- K( Y/ s9 h
123.                 {       
     ( d  B- F: ?. Y% _% U/ s. m6 q3 G% y
124.                         TxMeg.DLC=8;
     # A+ s3 |6 z4 K" V
125.                 }
     
126.                 else
     
127.                 {
     
128.                         if(Len%8)
     
129.                         TxMeg.DLC=Len%8;
     
130.                 }
     # b- K# G/ D0 `& q$ s
131.                 HAL_RetVal=HAL_CAN_AddTxMessage(__hcan,&TxMeg,(pData+SendCNT),&TxMailbox);  
     / ]/ G9 S, f! z3 R& ?& n& R
132.                 if(HAL_RetVal!=HAL_OK)
     & D; P$ X' x. s4 `
133.                 {
     - x9 u' j( |8 p* N+ k, z- V; @
134.                         return 0;
     
135.                 }
     ; }- ?6 `& b7 `; d
136.                 SendCNT+=8;
     
137.         }
     / h* c0 m; u/ u# |* S+ B& f
138.         return 1;

复制代码

bsp_can.h

1. #ifndef _BSP_CAN_H
   
2. #define _BSP_CAN_H
   & S$ e! C/ e* Y
3. #include "stm32f4xx_hal.h"
   
4. #include "can.h"
   3 Q# H. u# v+ G
5. 
   % o1 M* j- l/ I3 z( U
6. //typedef struct
   
7. //{
   - Z4 r* r8 h: B5 i/ I% a: d7 Z# u
8. //        uint32_t mailbox;
   # C' P7 v7 H: s! o8 `
9. //        CAN_TxHeaderTypeDef hdr;
   - n& v2 c4 |! _" ^( w% H, c
10. //        uint8_t payload[8];
    ! r) E* A7 C6 E% m* Q
11. //}CAN_TxPacketTypeDef;
    
12. 
    * a- O6 \" G9 g0 M8 N
13. typedef struct
    , {5 V2 d* t4 g' K, K+ c
14. {
    % `8 |: ]' f( t4 n7 }, t0 w0 O" X$ \
15.         CAN_RxHeaderTypeDef hdr;
    7 O2 U% }* P, |1 m4 y/ y3 w
16.         uint8_t payload[8];
    5 X7 ^/ w* s) N* W6 R7 x; a
17. }CAN_RxPacketTypeDef;
    
18. 
    + k6 j( b$ N3 K
19. 
    
20. void CAN_Init(void);
    
21. uint8_t CAN_SendStdMsg(CAN_HandleTypeDef* __hcan,uint8_t *pData,uint16_t Len);
    4 Q$ O! |/ p" S7 Y' l5 K
22. #endif

复制代码

就可以工作了？？？非也
  N7 e; L2 w% D) o! s/ ?其实我发现还是有问题

6 h* t' q1 R% K0 e! @. V, N5 y; Z

0 p! O  R/ g2 o" j
5 F1 I! A6 u& G: X" L4 j6 N. L
为什么第2 3包数据到最后去了？

6 K' E/ {4 T  J6 t" r

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

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

查看库函数
+ e. n7 x0 W) V& N  u3 w

) }0 |- g# X# \9 \2 k. l: ~$ s/ a

1. /**
   
2.   * @brief  Return Tx Mailboxes free level: number of free Tx Mailboxes.
   4 k4 ~2 x6 y- \! e& \
3.   * @param  hcan pointer to a CAN_HandleTypeDef structure that contains
   
4.   *         the configuration information for the specified CAN.
   
5.   * @retval Number of free Tx Mailboxes.
   
6.   */
   , q* t. I2 j- v0 e2 P
7. uint32_t HAL_CAN_GetTxMailboxesFreeLevel(CAN_HandleTypeDef *hcan)
   ' q/ z5 i( E! @6 [) d
8. {
   
9.   uint32_t freelevel = 0U;
   # Y2 U! D* L. b2 L( Q
10.   HAL_CAN_StateTypeDef state = hcan->State;
    4 _5 f1 H  G8 b9 O, ?+ k! Q: }
11. 
    
12.   if ((state == HAL_CAN_STATE_READY) ||
    - |& t2 D# t9 B0 c9 `0 I% d( V( w) h
13.       (state == HAL_CAN_STATE_LISTENING))
    / s. b9 ^2 p# j5 C
14.   {
    , g6 _' `5 B- `6 W
15.     /* Check Tx Mailbox 0 status */
    : j- K, \: j4 L+ _
16.     if ((hcan->Instance->TSR & CAN_TSR_TME0) != 0U)
    
17.     {
    
18.       freelevel++;
    
19.     }
    
20. 
    
21.     /* Check Tx Mailbox 1 status */
    ; |: ?( v$ e) G+ u5 o" F3 k
22.     if ((hcan->Instance->TSR & CAN_TSR_TME1) != 0U)
    
23.     {
    
24.       freelevel++;
    ( `' p$ t( _  N% |# d$ ?, X
25.     }
    
26. 
    8 u" T7 p: n. A: d( F1 b
27.     /* Check Tx Mailbox 2 status */
    9 L' J$ P* z" p
28.     if ((hcan->Instance->TSR & CAN_TSR_TME2) != 0U)
    # H+ U5 G! V) v0 o1 H
29.     {
    ' T( ]$ H& ]2 F- \- V1 d  F
30.       freelevel++;
    9 m: i( H! T. {6 p" K+ @
31.     }
    ' L" ]- y9 T  u( a( A/ J
32.   }
    3 R/ Z  o+ W, Y+ j9 L2 [
33. 
    " u9 Y( ^# F; o2 {! X
34.   /* Return Tx Mailboxes free level */
    
35.   return freelevel;
    2 F1 u5 M& s9 e. g% j
36. }

复制代码

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

1. uint32_t HAL_CAN_GetTxMailboxesFreeLevel(CAN_HandleTypeDef *hcan)
   9 {  r" |* R- a; h0 @) [$ Z$ B
2. {
   5 h1 t7 L0 W; m7 [  r% z' {
3.   uint32_t freelevel = 0U;
   * z" ]3 |  ^7 }
4.   HAL_CAN_StateTypeDef state = hcan->State;
   ) s  [8 C: o2 I
5. 
   + t% Y5 B0 L; {, L' d- [- B
6.   if ((state == HAL_CAN_STATE_READY) ||
   
7.       (state == HAL_CAN_STATE_LISTENING))
   
8.   {
   
9.                
   ; `, u* u! ^8 g# _
10.                 if (((hcan->Instance->TSR & CAN_TSR_TME0) != 0U)&& \
    
11.                           ((hcan->Instance->TSR & CAN_TSR_TME1) != 0U)&& \
    " d2 a1 M4 O. x
12.                      (hcan->Instance->TSR & CAN_TSR_TME2) != 0U)
    ; A, M) |6 J2 \* Y& s
13.     {
    5 ~) `# j0 c. t( U8 W' v6 T! r; p
14.       freelevel++;
    % x; R$ R7 f) Q, @+ m
15.     }
    
16. 
    
17.     /* Check Tx Mailbox 0 status */
    
18. //    if ((hcan->Instance->TSR & CAN_TSR_TME0) != 0U)
    # f- ]) S4 [3 y+ a
19. //    {
    " ?" c4 Q5 P" _7 t: Y( l# U
20. //      freelevel++;
    
21. //    }
    3 [' m- u. p* V( u# U2 i) |) ?# u
22. 
    4 V% o4 o; L  K; m/ B2 I) Q- M
23.     /* Check Tx Mailbox 1 status */
    
24. //    if ((hcan->Instance->TSR & CAN_TSR_TME1) != 0U)
    ; V7 e9 u: R% a
25. //    {
    " E5 `2 {( D  K, D( r! S- T
26. //      freelevel++;
    
27. //    }
    
28. 
    
29. //    /* Check Tx Mailbox 2 status */
    
30. //    if ((hcan->Instance->TSR & CAN_TSR_TME2) != 0U)
    ; C: a* w" O% Z$ N8 i
31. //    {
    
32. //      freelevel++;
    4 h) Y* c+ q" K6 {: K. L' _* U& Z
33. //    }
    / ~5 J7 r% i9 x# C8 Q
34.   }
    " O8 I- C7 ~' U
35. 
    6 B: r* c, b5 c1 G* ]
36.   /* Return Tx Mailboxes free level */
    
37.   return freelevel;
    7 J* ~: m5 m7 @" |# I" _7 T4 G8 r
38. }

复制代码

! O3 V, J# k) G% v三 总结

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

9 A' j! b& Z! p, d7 d6 B

四、CAN以及库函数分析

CAN总线
! R+ o* f7 X$ [2 S7 A# x1、根据标示符（也就是 ID）来决定优先级的。
3 b+ s* z# v1 L) E0 k, e2、在同一网络中，所有单元必须设定成统一的通信速度，最高 1Mbps（距离小于40M），最远可达 10KM（速率低于 5Kbps）
* q8 P2 V3 E/ p) t7 g3、可通过发送“遥控帧” 请求其他单元发送数据。
4、CAN Model:

3 z' N' B* ~9 z6 `1 ~# WNormal 正常模式
" x  Q( C9 \, P6 qSilent 静默模式
9 }: X3 I' j( }. L/ dLoopback 环回模式 测试
Silent_loopback 静默换回模式 测试

5、波特率

% H  d* o% L- U9 p% _, f& x4 g波特率(Kpbs) = fpclk / ((CAN_BS1 + CAN_BS2 + 1) * CAN_Prescaler)

6、发送数据结构体指针

  

1. /**
   
2.   * @brief  CAN Tx message header structure definition
   % I6 Z) w/ F5 h2 H0 L  Q$ ~
3.   */
   
4. typedef struct
   
5. {
   1 A! _4 h9 |- d, B) H9 Q
6. //表示标准的ID
   " o6 _! ]7 p6 W0 M* S
7.   uint32_t StdId;    /*!< Specifies the standard identifier.
   
8.                                                   This parameter must be a number between Min_Data = 0 and Max_Data = 0x7FF. */
   ; u2 `$ @& V. e
9. //表示扩展的ID
   
10.   uint32_t ExtId;    /*!< Specifies the extended identifier.
    
11.                           This parameter must be a number between Min_Data = 0 and Max_Data = 0x1FFFFFFF. */
    
12. //要发送的是扩展帧还是标准帧
    
13.   uint32_t IDE;      /*!< Specifies the type of identifier for the message that will be transmitted.
    " q- B2 w& g5 s$ p6 O7 W% ]' _* d
14.                           This parameter can be a value of @ref CAN_identifier_type */
    
15. //表示发送的帧类型。如：数据帧、远程帧等
    1 I" C2 t8 T' n
16.   uint32_t RTR;      /*!< Specifies the type of frame for the message that will be transmitted.
    * z3 W% p, k" L4 n: L
17.                           This parameter can be a value of @ref CAN_remote_transmission_request */
    
18. //表示发送的数据长度
    / M% x5 Q+ ^3 d5 H7 S% Q
19.   uint32_t DLC;      /*!< Specifies the length of the frame that will be transmitted.
    % x8 n1 T7 y; j. o5 e7 }
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.
    ' f; U- [% x0 e' J
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. */
    2 Z$ a0 r2 w, c3 o3 @9 ]- L
27. 
    
28. } CAN_TxHeaderTypeDef;

复制代码

7、过滤器：为了方便接收想要的ID，过滤掉不想要的ID。28组或14组过滤器，每组2个32为寄存器
屏蔽模式
5 a+ {7 ^; L0 v; n) [2 k1 S( f屏蔽位模式: 标识符寄存器（设置想接收的ID）和屏蔽寄存器（设置关心的位）。又比如说，当你值接收一个固定的 ID 的时候，你 把屏蔽寄存器全部设置为 1（即必须比较），然后在标示符寄存器里面存放你
& l' a, i; \3 {! q想要的接收的 ID，那么当 CAN 总线上面出现你想要的 ID 的时候，它就将它接收，其他的不接收。
3 T  S. s4 Y: b- X, w屏蔽列表模式:每组过滤器 中的两个寄存器全部用来做标示符寄存器，也就是说当接收的 ID 必须跟表 示符寄存器中的 ID 相同的时候才接收。

# J8 N5 v3 j; o  v

& n+ L; I* p3 K. y' l. L

8、过滤器结构体

1. /**
   
2.   * @brief  CAN filter configuration structure definition
   
3.   */
   ; h% N( l- f* ?: o6 p
4. typedef struct
   ' U. L( }& P0 z1 b
5. {
   / L6 q# Z5 T/ J% n- n2 k: R+ W8 ~
6.         //这个是标示符寄存器的高 16 位
   
7.   uint32_t FilterIdHigh;          /*!< Specifies the filter identification number (MSBs for a 32-bit
   , E! I; W5 F: O' `4 Y: v+ E
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. */
    
14.         //这个是屏蔽寄存器高字节的设置
    ! _! _8 o; r( W4 F
15.   uint32_t FilterMaskIdHigh;      /*!< Specifies the filter mask number or identification number,
    
16.                                        according to the mode (MSBs for a 32-bit configuration,
    
17.                                        first one for a 16-bit configuration).
    - l$ N) l4 L0 X1 O+ H% P
18.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF. */
    # V2 j( F' u( G. h2 J6 @1 Q9 m
19.         //这个是屏蔽寄存器低字节的设置
    " O, O6 _) ?- ^+ H; G2 r  t
20.   uint32_t FilterMaskIdLow;       /*!< Specifies the filter mask number or identification number,
    : q3 n. j; I$ n# z3 R6 Q
21.                                        according to the mode (LSBs for a 32-bit configuration,
    
22.                                        second one for a 16-bit configuration).
    
23.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF. */
      @* N: M3 m+ [7 E( f4 ?
24.         //选择你要使用的邮箱，它有 0 和 1
    ( d0 `7 W$ n' D
25.   uint32_t FilterFIFOAssignment;  /*!< Specifies the FIFO (0 or 1U) which will be assigned to the filter.
    
26.                                        This parameter can be a value of @ref CAN_filter_FIFO */
    
27.   //表示标示符寄存器的ID，）我们这里使用第一组寄存器设置为：1。
    ' E7 L3 e6 d, H6 D( d' c
28.   uint32_t FilterBank;            /*!< Specifies the filter bank which will be initialized.
    
29.                                        For single CAN instance(14 dedicated filter banks),
      _1 r# t7 ^7 W- ?+ t! S% \3 `  v
30.                                        this parameter must be a number between Min_Data = 0 and Max_Data = 13.
    
31.                                        For dual CAN instances(28 filter banks shared),
    # O0 E. {- @! o) K9 u' U7 l" G7 e
32.                                        this parameter must be a number between Min_Data = 0 and Max_Data = 27. */
    & g$ n" Y* e6 y; C/ N
33. //表示过滤模式。我们上面讲到它有屏蔽位模式和
    4 p2 E" {0 k8 a. t+ \
34. //标示符列表模式。我们使用屏蔽位模式，所以设置为 ：
    
35. //CAN_FilterMode_IdMask。
    % J1 w% f7 Z9 t/ y+ `4 c1 ~
36.   uint32_t FilterMode;            /*!< Specifies the filter mode to be initialized.
    + {  R+ a# A5 C: j
37.                                        This parameter can be a value of @ref CAN_filter_mode */
    
38. //表示设置过滤器的长度。过滤器是可以设置为16位和32位两种模式的（即接收标准帧和拓展帧的区别）。
    
39.   uint32_t FilterScale;           /*!< Specifies the filter scale.
    1 M* u1 i3 k3 w, D; R: N9 A1 U
40.                                        This parameter can be a value of @ref CAN_filter_scale */
    
41. //表示过滤器的使能
    
42.   uint32_t FilterActivation;      /*!< Enable or disable the filter.
    ! w# @+ x9 _4 Q( u( g0 l
43.                                        This parameter can be a value of @ref CAN_filter_activation */
    - @+ |4 y4 D+ O2 n  m6 C
44. 
    
45.   uint32_t SlaveStartFilterBank;  /*!< Select the start filter bank for the slave CAN instance.
    
46.                                        For single CAN instances, this parameter is meaningless.
    / P/ f! V/ h2 Z% o& t( A" [6 g' N7 U% e
47.                                        For dual CAN instances, all filter banks with lower index are assigned to master
    % }2 q" Q: q- E; B# o
48.                                        CAN instance, whereas all filter banks with greater index are assigned to slave
    
49.                                        CAN instance.
    
50.                                        This parameter must be a number between Min_Data = 0 and Max_Data = 27. */
    
51. } CAN_FilterTypeDef;
    

复制代码

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