一、遇到的问题

1、发送单包数据，我想都非常简答，例子一大堆包括，demo。但是发送多包数据怎么处理？
% ]5 e8 {; D3 K$ {: Y/ }/ D2、发送多包数据，网上基本上就两种说发
! s: H# q/ a' ^* z. r; G5 }*两个数据之间加延时
*查询邮箱是否满了
" ~2 v  B) v1 X$ i& g; eHAL_CAN_GetTxMailboxesFreeLevel（）
对比上面两种方法，为了效率我们选择第二种

7 ]/ D7 e" C) k: C% d- l

二、配置与代码

直接上cubemx配置

* v( t5 |2 G# D$ c7 `/ p

# o+ T) c- G6 m# O/ i

6 n9 a/ m; T7 Z7 Y
& @3 t3 ?: \: P
直接生成后，cubemx没有设置过滤器，需要自己添加，结合网上各资料总结代码如下

+ R5 L7 j# H% r  L: m7 f

1. int main(void)
   
2. {
   
3.   /* USER CODE BEGIN 1 */
   $ F9 Z7 u% N/ R: G( X% @
4. 
   
5.   /* USER CODE END 1 */
   
6. 
   ! `$ L$ p! ^/ \
7.   /* MCU Configuration--------------------------------------------------------*/
   
8. 
   . _, a2 K+ [, A' D
9.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   
10.   HAL_Init();
    $ V$ R  t: d2 ~
11. 
    6 }9 i4 m1 L- J( [" ~
12.   /* USER CODE BEGIN Init */
    
13. 
    : X1 [# W* o) b( \% z! [* R3 ?
14.   /* USER CODE END Init */
    $ T1 x8 Q% p# O, U
15. 
    
16.   /* Configure the system clock */
    ; O8 C) N7 r6 k( P. ?( U
17.   SystemClock_Config();
    
18. 
    2 e0 `  h/ w! E/ r
19.   /* USER CODE BEGIN SysInit */
    
20. 
    / D! h3 j: E( ]; Q4 W9 l
21.   /* USER CODE END SysInit */
    
22. 
    8 {" L! H: M( z; a
23.   /* Initialize all configured peripherals */
    
24.   MX_GPIO_Init();
    1 \1 j+ l: h( H3 z8 j% j
25.   MX_CAN1_Init();
    & @5 N9 b3 e& E0 B; u  ^. S) x
26.   /* USER CODE BEGIN 2 */
    
27.         CAN_Init();
    
28.   /* USER CODE END 2 */
    / _- N3 M6 _5 r- U8 W3 n
29. 
    - q$ N6 {* y& J. u- N% y4 J3 h
30.   /* Infinite loop */
    % A0 V4 L  Q/ C7 r
31.   /* USER CODE BEGIN WHILE */
    - L' e& h* b$ ^& Z. g: k
32.   while (1)
    2 h* v# u. a) U/ q; m+ L$ Z3 O4 X$ P
33.   {
    " _* z. ^( E( U( H- r
34.     /* USER CODE END WHILE */
    
35. 
    / b% P+ C) e2 `% q: S* D& L
36.     /* USER CODE BEGIN 3 */
    - l* Y/ K4 W: q% T3 P
37.                 uint8_t TxData[100] ;
    
38.                 for(uint8_t i=0;i<100;i++)
    ; _1 Z6 T$ K8 A% F# J% b( E
39.                         TxData[i]=i;
    2 p" n* `- {$ V2 b" ~  v5 L
40.                 CAN_SendStdMsg(&hcan1,TxData,sizeof(TxData));
    
41.                 HAL_Delay(100);
    
42.   }
    
43.   /* USER CODE END 3 */
    
44. }

复制代码

bsp_can.c

/ V1 n) t+ I( J

1. #include "bsp_can.h"
   
2. 
   
3. 
   , ?- B6 R$ j3 N0 q: u4 \: p
4. /// CAN过滤器寄存器位宽类型定义
   3 P, Y3 p( H) a3 [: Q, K: X; \
5. typedef union
   
6. {
   ! B9 ?# S0 |6 s. v3 C
7.     __IO uint32_t value;
   
8.     struct
   + t2 N1 |4 g+ d6 O" G, q1 K
9.     {
   
10.         uint8_t REV : 1;                        ///< [0]    ：未使用
    ' t' t: E9 R# S- H- _. n* ~/ g: i
11.         uint8_t RTR : 1;                        ///< [1]    : RTR（数据帧或远程帧标志位）
    - b* L. L# c7 ?
12.         uint8_t IDE : 1;                        ///< [2]    : IDE（标准帧或扩展帧标志位）
    ' Z9 E$ u1 ^9 Z4 y4 W
13.         uint32_t EXID : 18;                        ///< [21:3] : 存放扩展帧ID
    " P* f! j% }4 n1 I% I% {9 W: R
14.         uint16_t STID : 11;                        ///< [31:22]: 存放标准帧ID
    2 ]( s4 Y( S9 r' w2 f/ ]& K" B# r9 X
15.     } Sub;
    - n% s' h8 z; D9 D
16. } CAN_FilterRegTypeDef;
    
17. 
    
18. 
    4 K! L/ p% _5 \. h
19. #define CAN_BASE_ID 0                                                ///< CAN标准ID，最大11位，也就是0x7FF
    : h( p9 k+ y/ Q" `4 X
20. 
    
21. #define CAN_FILTER_MODE_MASK_ENABLE 1                ///< CAN过滤器模式选择：=0：列表模式  =1：屏蔽模式
    
22. 
    
23. #define CAN_ID_TYPE_STD_ENABLE      1       ///< CAN过滤ID类型选择：=1：标准ID，=0：扩展ID
    
24. 
    
25. void CAN_Filter_Config(void)
    : @' l; D7 q2 ?9 ?, Z. L1 K5 U# F, `
26. {
    
27.     CAN_FilterTypeDef sFilterConfig;
    
28.     CAN_FilterRegTypeDef IDH = {0};
    4 W7 E  G# B" N5 v1 J" Y. W1 b" x) ?
29.     CAN_FilterRegTypeDef IDL = {0};
    * T( _  ^1 ~6 C6 R7 G0 r
30. 
    
31. #if CAN_ID_TYPE_STD_ENABLE
    4 b5 Z4 l" J! V% T) G2 h4 Y
32.     IDH.Sub.STID = (CAN_BASE_ID >> 16) & 0xFFFF;                                                                                        // 标准ID高16位
    # r7 g7 L' V4 h! M7 O
33.     IDL.Sub.STID = (CAN_BASE_ID & 0xFFFF);                                                                                                                // 标准ID低16位
    , \) D3 F/ D( U9 l% Z& b8 u, y& }
34. #else
    + |" r' E% |$ g& H3 A6 g/ b
35.     IDH.Sub.EXID = (CAN_BASE_ID >> 16) & 0xFFFF;                                                                                        // 扩展ID高16位
      {% g: _; y) M4 w9 {
36.     IDL.Sub.EXID = (CAN_BASE_ID & 0xFFFF);                                                                                                                // 扩展ID低16位
    
37.     IDL.Sub.IDE  = 1;                                                                                                                                                                                                        // 扩展帧标志位置位
    * p  {- B  ~( l$ _) ^+ M
38. #endif
      U% `& E4 \. B- d3 e! Y4 \
39.     sFilterConfig.FilterBank           = 0;                                                                                                    // 设置过滤器组编号
    
40. #if CAN_FILTER_MODE_MASK_ENABLE
    
41.     sFilterConfig.FilterMode           = CAN_FILTERMODE_IDMASK;                                // 屏蔽位模式
    - V5 N/ A1 D4 ~) N& T* F
42. #else
    : H% k( m6 s( b& G# F2 g$ [7 f/ S; @' ?
43.     sFilterConfig.FilterMode           = CAN_FILTERMODE_IDLIST;                                // 列表模式
    % E" _- k5 t1 U" x6 x
44. #endif
    ' X6 I4 B7 J% X: j) O
45.     sFilterConfig.FilterScale          = CAN_FILTERSCALE_32BIT;                                // 32位宽
    
46.     sFilterConfig.FilterIdHigh         = IDH.value;                                                                                // 标识符寄存器一ID高十六位，放入扩展帧位
    
47.     sFilterConfig.FilterIdLow          = IDL.value;                                                                                // 标识符寄存器一ID低十六位，放入扩展帧位
    
48.     sFilterConfig.FilterMaskIdHigh     = IDH.value;                                                                                // 标识符寄存器二ID高十六位，放入扩展帧位
    $ O( T/ L0 l- R- E; Z
49.     sFilterConfig.FilterMaskIdLow      = IDL.value;                                                                                // 标识符寄存器二ID低十六位，放入扩展帧位
    . D6 ^% [: u" @+ B* h
50.     sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;                                                                // 过滤器组关联到FIFO0
    / W# r$ w4 E5 e8 {
51.     sFilterConfig.FilterActivation     = ENABLE;                                                                                        // 激活过滤器
    / p3 W! G2 X( u: O; f
52.     sFilterConfig.SlaveStartFilterBank = 14;                                                                                                        // 设置从CAN的起始过滤器编号，本单片机只有一个CAN，顾此参数无效
    
53.     if (HAL_CAN_ConfigFilter(&hcan1, &sFilterConfig) != HAL_OK)
    
54.     {
    
55.         Error_Handler();
    1 k7 \" Z1 [' K, {
56.     }
    & C& x( S5 _% V/ c, ^" ?2 x7 L& q
57. }
    4 ]9 q" b$ _) S! n
58. 
    ( Y3 Q! S& \0 [  |  V0 z6 S
59. 
    
60. 
    
61. void CAN_Init(void)
    
62. {
    
63.     CAN_Filter_Config();
    , S- A* m) N& k1 o) m  u2 Z, |
64.     HAL_CAN_Start(&hcan1);
    ! ^  S7 ~, k  |$ F; Y
65.     HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING);                                        // 使能CAN接收中断
    9 j/ u2 X; k) A; S
66. }
    
67. 
    
68. void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *canHandle)
    
69. {
    # g& I7 I. s+ {  E
70.         static CAN_RxPacketTypeDef packet;
    6 ~) o' N' j# C1 G$ j: J, e
71.        
    
72.     // CAN数据接收
    
73.     if (canHandle->Instance == hcan1.Instance)
    / B( w4 Q2 ?: j. C% [0 v
74.     {
    0 I1 n7 b+ V$ H
75.         if (HAL_CAN_GetRxMessage(canHandle, CAN_RX_FIFO0, &packet.hdr, packet.payload) == HAL_OK)                // 获得接收到的数据头和数据
    , w! ?, N( c' L5 Q3 e+ {2 K
76.         {
    & X( @5 |9 r! F1 o1 y
77. //                        printf("\r\n\r\n\r\n################### CAN RECV ###################\r\n");
    3 U& R( n4 z( |# R. w, v6 D
78. //                        printf("STID:0x%X\r\n",packet.hdr.StdId);
    , l; b0 E. E$ B* u; J  `& A+ N2 l* L/ R
79. //                        printf("EXID:0x%X\r\n",packet.hdr.ExtId);
    + q' m: z/ ^3 _
80. //                        printf("DLC :%d\r\n", packet.hdr.DLC);
    
81. //                        printf("DATA:");
    7 h" e6 b! j/ C2 I
82. //                        for(int i = 0; i < packet.hdr.DLC; i++)
    
83. //                        {
    
84. //                                printf("0x%02X ", packet.payload[i]);
    7 X$ T6 Q( r  r& y+ h' i
85. //                        }
    2 E& M3 i# W6 ?; A' y1 U. J& U  p
86.            HAL_CAN_ActivateNotification(canHandle, CAN_IT_RX_FIFO0_MSG_PENDING);                                                // 再次使能FIFO0接收中断
      V; S9 t1 k; w
87.         }
    
88.     }
    
89. }
    
90. 
    ! f: P" R9 N- s# j! C
91. 
    ! U; [: _! n; N2 e- L) {2 j9 X; t
92. uint8_t CAN_Transmit(CAN_TxPacketTypeDef* packet)
    ! y3 ~2 b: \* R# e4 I+ K* H$ |
93. {
    " _5 Q5 B* J; V4 [& M6 g% g
94.         if(HAL_CAN_AddTxMessage(&hcan1, &packet->hdr, packet->payload, &packet->mailbox) != HAL_OK)
    
95.                 return 1;
    # |$ l3 k" r+ |3 H* O' }- B
96.         return 0;
    
97. }
    / z- I0 z; T/ ]# O  P
98. 
    6 o3 l( K8 @) m& J5 H5 N7 X
99. 
    
100. CAN_TxHeaderTypeDef TxMeg;
     : F3 N% a0 q# m5 u
101. uint16_t TimsRepeat;
     " b/ |* o( R* h6 ~' a
102. uint8_t CAN_SendStdMsg(CAN_HandleTypeDef* __hcan,uint8_t *pData,uint16_t Len)
     
103. {
     
104.         uint16_t SendCNT=0;
     - E$ B4 P& H) z; f2 l2 g# T7 [
105.         uint32_t TxMailbox;
     . m& ~" _/ L; S3 H8 b7 M
106.         HAL_StatusTypeDef        HAL_RetVal;
     
107.        
     
108.         TxMeg.StdId = 0x321; //标准ID
     
109. //        TxMeg.ExtId = 0x10F01234;
     , z( L+ p6 j- Z& D8 H% I
110.         TxMeg.IDE = CAN_ID_STD;// 标准ID类型
     
111. //TxMeg.IDE = CAN_ID_EXT;// 扩展ID类型
     
112.         TxMeg.RTR = CAN_RTR_DATA;                // 数据帧
     
113. //TxMeg.RTR =  CAN_RTR_REMOTE;                // 远程帧
     , e3 f% |2 c/ F, l1 E0 \
114.         TxMeg.TransmitGlobalTime = DISABLE;
       m+ T0 b5 m. y# h9 b
115.        
     
116.         if(!__hcan || ! pData ||!Len) return 1;
     
117. 
       g8 ^# `7 T) g
118.         TimsRepeat =Len/8+(Len%8?1:0);
     2 ]0 v% M4 p0 t3 H; B, k3 \" Q
119.         while(TimsRepeat--)
     7 A: Y5 n2 q1 G) C3 G& ]1 i, ^
120.         {
     3 L5 h# }5 B) k# O
121.                 while(HAL_CAN_GetTxMailboxesFreeLevel(__hcan)==0);
     
122.                 if(TimsRepeat>0)
     , D' K5 W, T+ K* S& i0 H$ S
123.                 {       
     1 T+ w- v# z: j
124.                         TxMeg.DLC=8;
     * \4 A: b4 A1 \4 @5 P/ i
125.                 }
     5 A* S7 I- d5 Z1 x' A3 x
126.                 else
     
127.                 {
     : _3 L5 ?5 M7 [6 E& W7 b+ N9 @+ @: c1 p
128.                         if(Len%8)
     
129.                         TxMeg.DLC=Len%8;
     
130.                 }
     + [* q( e7 Q1 V0 [& i
131.                 HAL_RetVal=HAL_CAN_AddTxMessage(__hcan,&TxMeg,(pData+SendCNT),&TxMailbox);  
     0 I8 N" _. Z: O; A+ c: P4 t1 `
132.                 if(HAL_RetVal!=HAL_OK)
     1 O0 l8 i& P- \) W( y
133.                 {
     3 Y" W. y2 M. h+ v' F5 D
134.                         return 0;
     
135.                 }
     9 e5 Q1 _: o$ Z  N3 ?8 l8 r* ?2 [9 k
136.                 SendCNT+=8;
     
137.         }
     
138.         return 1;

复制代码

. L+ x# }; _4 Y8 I( p  `1 ]6 D

bsp_can.h

4 Y9 B6 M0 p( O* b3 C% j0 b. I" q2 K

1. #ifndef _BSP_CAN_H
   
2. #define _BSP_CAN_H
   
3. #include "stm32f4xx_hal.h"
   
4. #include "can.h"
   
5. 
   ) G" t3 I' M/ C) `- ^
6. //typedef struct
   0 |% R: o9 N  Q. {  ?$ F* ~
7. //{
   & J& r1 G0 @/ I" H# y$ n
8. //        uint32_t mailbox;
   . b# D9 {9 N- w8 Z
9. //        CAN_TxHeaderTypeDef hdr;
   ( F( q! D& v. _' a4 v/ x, L1 U
10. //        uint8_t payload[8];
    1 \# k' e1 `9 @* Q, _6 N
11. //}CAN_TxPacketTypeDef;
    2 O# J6 w* k$ f' J8 w6 F5 G
12. 
    % ~& ^. Q# c5 I
13. typedef struct
    ) R9 p5 {$ ?8 S- U8 X. A
14. {
    8 T5 V! P: W( X5 F# F
15.         CAN_RxHeaderTypeDef hdr;
      m: v' `1 C0 C3 M! C) {1 H# }. V+ d
16.         uint8_t payload[8];
    % n, H+ P! x6 {7 r2 K9 H: |( u% U
17. }CAN_RxPacketTypeDef;
    
18. 
    
19. 
    2 Y4 Q5 f2 ~- `
20. void CAN_Init(void);
    
21. uint8_t CAN_SendStdMsg(CAN_HandleTypeDef* __hcan,uint8_t *pData,uint16_t Len);
    ' E# v; x1 h: f2 L
22. #endif

复制代码

就可以工作了？？？非也
- d' H& v! \/ A9 ^' n+ d2 `其实我发现还是有问题

3 E! Z( X% K3 L# k

1 P, q2 X4 V6 X! k7 s% ?& I为什么第2 3包数据到最后去了？

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

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

查看库函数
, n& f: ]8 J2 K$ {& _# n1 ~0 k& ~0 z

1. /**
   
2.   * @brief  Return Tx Mailboxes free level: number of free Tx Mailboxes.
   ( z  H0 ]8 T% N. h
3.   * @param  hcan pointer to a CAN_HandleTypeDef structure that contains
   
4.   *         the configuration information for the specified CAN.
   , `/ f. N% J; S2 e6 z* z: s
5.   * @retval Number of free Tx Mailboxes.
   
6.   */
     ^, U2 i9 I) R5 n) _; U
7. uint32_t HAL_CAN_GetTxMailboxesFreeLevel(CAN_HandleTypeDef *hcan)
   ) D# I+ n6 V9 S- {
8. {
   
9.   uint32_t freelevel = 0U;
   5 n1 A6 S7 I. m) o$ c3 C$ t% N
10.   HAL_CAN_StateTypeDef state = hcan->State;
    0 M& g: L+ H1 U1 {" l1 h4 }; q# b
11. 
    2 j% h4 U- P) h/ t6 P
12.   if ((state == HAL_CAN_STATE_READY) ||
    & W1 S2 O+ K" ]
13.       (state == HAL_CAN_STATE_LISTENING))
    
14.   {
    ' n) o# k) Q2 y  e9 X. r6 u
15.     /* Check Tx Mailbox 0 status */
    * a0 e% a5 |! X1 v
16.     if ((hcan->Instance->TSR & CAN_TSR_TME0) != 0U)
    ( a" ~- h$ ?/ g! _; @$ `8 m2 m
17.     {
    " x+ E" `2 c. h
18.       freelevel++;
    3 j. t, f6 F# i' c# Q# i
19.     }
    
20. 
    5 w5 v. J7 z9 [
21.     /* Check Tx Mailbox 1 status */
    ' |0 d6 Q6 x  r
22.     if ((hcan->Instance->TSR & CAN_TSR_TME1) != 0U)
    ! J! D3 Z& B& ~# `- E, s
23.     {
    # q' K1 `; n- N5 y
24.       freelevel++;
    6 p2 H  _1 x. [3 ]4 G/ b
25.     }
    0 b8 E: C7 C# k% R2 c
26. 
    2 h, v/ ], o1 a, z  a6 F/ C3 H
27.     /* Check Tx Mailbox 2 status */
    ' @% T9 p- G) o9 X1 \* {
28.     if ((hcan->Instance->TSR & CAN_TSR_TME2) != 0U)
    
29.     {
    3 m( Q4 k2 A* a+ j- i) H
30.       freelevel++;
    
31.     }
    
32.   }
    ( H/ M3 n& O% W- r
33. 
    % J" @' T# B" ]) Y; G9 d. R
34.   /* Return Tx Mailboxes free level */
    
35.   return freelevel;
    ! l! m) Q- c  r9 {8 K+ A
36. }

复制代码

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

' w( U( h0 W9 j5 x3 ^) Q

1. uint32_t HAL_CAN_GetTxMailboxesFreeLevel(CAN_HandleTypeDef *hcan)
   
2. {
   : M) s" H! I5 t5 d" w4 X" G
3.   uint32_t freelevel = 0U;
   
4.   HAL_CAN_StateTypeDef state = hcan->State;
   
5. 
   0 Q* _5 a# ^3 Y' i
6.   if ((state == HAL_CAN_STATE_READY) ||
   $ B# E' G( e+ d. J
7.       (state == HAL_CAN_STATE_LISTENING))
   : e) o! T. C8 ^- S
8.   {
   , y, `: O7 N- j( b
9.                
   3 p1 H* r0 R5 [1 E% m% K) K7 R, U
10.                 if (((hcan->Instance->TSR & CAN_TSR_TME0) != 0U)&& \
    8 G1 L: m; {( a" b$ J
11.                           ((hcan->Instance->TSR & CAN_TSR_TME1) != 0U)&& \
    
12.                      (hcan->Instance->TSR & CAN_TSR_TME2) != 0U)
    
13.     {
    
14.       freelevel++;
    $ Y/ G1 U* a/ V+ |
15.     }
    
16. 
    
17.     /* Check Tx Mailbox 0 status */
    
18. //    if ((hcan->Instance->TSR & CAN_TSR_TME0) != 0U)
    ( |% u7 K1 }/ `  Z
19. //    {
    7 F7 j  m5 e$ ^( R
20. //      freelevel++;
    2 T2 w9 B% e5 t. [* }/ ?9 C5 T
21. //    }
    
22. 
    ) V7 ?2 D: ]0 I, ?6 A$ `& U. O
23.     /* Check Tx Mailbox 1 status */
    
24. //    if ((hcan->Instance->TSR & CAN_TSR_TME1) != 0U)
    
25. //    {
    $ u3 u( d1 g6 d4 Y! M6 H% Q
26. //      freelevel++;
    
27. //    }
    
28. 
    
29. //    /* Check Tx Mailbox 2 status */
    
30. //    if ((hcan->Instance->TSR & CAN_TSR_TME2) != 0U)
    4 o. a5 \* A4 k. Q* L( p$ f, v& _
31. //    {
    8 B: v3 Z. R2 a
32. //      freelevel++;
    7 E; |- r! G( y, p5 d
33. //    }
    
34.   }
    ' {# `( s& L, N5 h( G' }1 B' ~! ]9 v$ N
35. 
    
36.   /* Return Tx Mailboxes free level */
    ) \% E7 t$ A% B. A0 l3 x8 l" m
37.   return freelevel;
    
38. }

复制代码

& Y, Y" r/ K) T0 t) g+ V三 总结

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

7 P# R; M( k- E0 H( z. D

四、CAN以及库函数分析

CAN总线
1、根据标示符（也就是 ID）来决定优先级的。
2、在同一网络中，所有单元必须设定成统一的通信速度，最高 1Mbps（距离小于40M），最远可达 10KM（速率低于 5Kbps）
! R1 D; N' V6 @: W2 _1 ]* S# @- A. i3、可通过发送“遥控帧” 请求其他单元发送数据。
4、CAN Model:

Normal 正常模式
Silent 静默模式
Loopback 环回模式 测试
  G" @3 J1 L0 KSilent_loopback 静默换回模式 测试

6 N; g3 b3 W. N2 E* z5、波特率

波特率(Kpbs) = fpclk / ((CAN_BS1 + CAN_BS2 + 1) * CAN_Prescaler)

6、发送数据结构体指针

  

1. /**
   " Y+ y/ R% ]: R5 F- a
2.   * @brief  CAN Tx message header structure definition
   
3.   */
   
4. typedef struct
   ' T+ j; ^+ ~+ x; d. G( ]$ F0 b7 O
5. {
   3 {9 C: ]: l9 r. `
6. //表示标准的ID
   
7.   uint32_t StdId;    /*!< Specifies the standard identifier.
   5 ]2 k7 P5 K# ~3 W3 x6 a
8.                                                   This parameter must be a number between Min_Data = 0 and Max_Data = 0x7FF. */
   
9. //表示扩展的ID
   + d  ]0 g7 c0 x8 S6 ?
10.   uint32_t ExtId;    /*!< Specifies the extended identifier.
    
11.                           This parameter must be a number between Min_Data = 0 and Max_Data = 0x1FFFFFFF. */
    : e# o# n& t9 r! J5 x) g
12. //要发送的是扩展帧还是标准帧
    
13.   uint32_t IDE;      /*!< Specifies the type of identifier for the message that will be transmitted.
    * W, \1 }- k+ G0 K* H; m
14.                           This parameter can be a value of @ref CAN_identifier_type */
    , q* l# ^3 U- z) ]9 C+ J; d* f
15. //表示发送的帧类型。如：数据帧、远程帧等
    
16.   uint32_t RTR;      /*!< Specifies the type of frame for the message that will be transmitted.
    
17.                           This parameter can be a value of @ref CAN_remote_transmission_request */
    ' r/ f' l+ N2 ]* ]" |
18. //表示发送的数据长度
    % f" ?( A& n5 @9 u, Y
19.   uint32_t DLC;      /*!< Specifies the length of the frame that will be transmitted.
    ( O2 H) C" R9 W; N- L+ ^) Z
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
    : i" J6 W% b5 ?5 j0 k0 p/ H5 N- Y
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.
    : w% E& X% S- a5 e: p( B
26.                           This parameter can be set to ENABLE or DISABLE. */
    
27. 
    ' R- M6 \8 _( m" X9 y. Q$ c' y
28. } CAN_TxHeaderTypeDef;

复制代码

3 `) O% l, I6 T8 U( O* O, N3 t

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

+ M; o: ]: Y- ?8 P+ m" D6 Y+ a6 n

% }5 h3 J, |; }! K

8、过滤器结构体

1. /**
   5 _  J+ e5 `6 N* L0 J1 {, o! f8 `
2.   * @brief  CAN filter configuration structure definition
   
3.   */
   ( S8 L) [; v5 t9 J
4. typedef struct
   # [& {' ^4 e& z
5. {
   ( g. c, |  t( S" x; _; Q
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).
   - B/ q5 n( p% v2 z& {7 Q3 m
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).
    7 j6 u) ^+ T+ }7 y' V7 ^
13.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF. */
    # K6 z4 G/ t, {) T, c
14.         //这个是屏蔽寄存器高字节的设置
    3 y$ z8 l7 T1 D, k
15.   uint32_t FilterMaskIdHigh;      /*!< Specifies the filter mask number or identification number,
    
16.                                        according to the mode (MSBs for a 32-bit configuration,
    # S5 V! w) i9 V5 J- y
17.                                        first one for a 16-bit configuration).
    
18.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF. */
    
19.         //这个是屏蔽寄存器低字节的设置
    
20.   uint32_t FilterMaskIdLow;       /*!< Specifies the filter mask number or identification number,
    " E, U. s8 [8 c; q+ z. v' B9 v. \
21.                                        according to the mode (LSBs for a 32-bit configuration,
    / w9 `3 f- S) K1 E! t/ Z' j& O
22.                                        second one for a 16-bit configuration).
    0 T$ b2 r% G8 u+ c( c( d  r8 ?
23.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF. */
    
24.         //选择你要使用的邮箱，它有 0 和 1
    , B# b; x6 D2 X6 s: j
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。
    ! F/ ]$ E* _0 b; H9 y
28.   uint32_t FilterBank;            /*!< Specifies the filter bank which will be initialized.
    
29.                                        For single CAN instance(14 dedicated filter banks),
    5 M* _" S" R2 J2 Z& q4 s  R
30.                                        this parameter must be a number between Min_Data = 0 and Max_Data = 13.
    . n+ \3 s, Y& y& l/ b0 m* O
31.                                        For dual CAN instances(28 filter banks shared),
    
32.                                        this parameter must be a number between Min_Data = 0 and Max_Data = 27. */
    % C- K6 F- L4 W
33. //表示过滤模式。我们上面讲到它有屏蔽位模式和
    
34. //标示符列表模式。我们使用屏蔽位模式，所以设置为 ：
    ! q& W# Q; G7 }4 K
35. //CAN_FilterMode_IdMask。
      _- p3 t. I0 U' n7 M" E
36.   uint32_t FilterMode;            /*!< Specifies the filter mode to be initialized.
    8 Q9 v8 O% S: G/ i# a
37.                                        This parameter can be a value of @ref CAN_filter_mode */
    8 @9 P7 n- Q" q0 Z- P8 A+ ~; A
38. //表示设置过滤器的长度。过滤器是可以设置为16位和32位两种模式的（即接收标准帧和拓展帧的区别）。
    # U& U8 k5 u! |4 J8 |. m$ G. m& P! X3 G
39.   uint32_t FilterScale;           /*!< Specifies the filter scale.
    
40.                                        This parameter can be a value of @ref CAN_filter_scale */
    
41. //表示过滤器的使能
    
42.   uint32_t FilterActivation;      /*!< Enable or disable the filter.
    . L' Y) X9 g. z/ N
43.                                        This parameter can be a value of @ref CAN_filter_activation */
    / m: r) G6 y3 W2 e8 \
44. 
    
45.   uint32_t SlaveStartFilterBank;  /*!< Select the start filter bank for the slave CAN instance.
    
46.                                        For single CAN instances, this parameter is meaningless.
    
47.                                        For dual CAN instances, all filter banks with lower index are assigned to master
    5 j. L% ^1 f( n
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. */
    " X/ k7 H1 r1 V1 G+ l
51. } CAN_FilterTypeDef;
    ; p; O9 h- |. @- A  o: p# m

复制代码

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