一、CAN基础
0 F; @" y: J/ T6 j" B+ s- a: B差分信号：显性电平对应逻辑0，CAN_H和CAN_L差为2.5V；隐形电平对应逻辑1，CAN_H和CAN_L差为0V。

CAN总线的开始和结束都有一个120Ω的终端电阻。

0 T) y+ I9 s5 R  R2 S2 G数据帧：标准帧11位，  扩展帧29位。
- n0 Q  h8 f5 _4 F7 V; q# r
其他的一些理论知识就不再赘述了，可以参考维基百科对于CAN的描述。
( f: q/ l$ u8 R1 O  K
STM32F7xx的bxCAN主要特点：支持CAN2.0A和CAN2.0B，波特率高达1Mbps，支持时间触发，具有3个发送邮箱，2个接收邮箱，可变的过滤器组等。
1 y( r* S; b1 ^9 q$ C- {
二、几个重要的CAN函数
, L" K9 y* j: k+ H  \

1. HAL_StatusTypeDef HAL_CAN_Init(CAN_HandleTypeDef* hcan); // CAN初始化
   9 {; t' ~/ r3 v( o0 }% m# x
2. 
   
3. HAL_StatusTypeDef HAL_CAN_Transmit(CAN_HandleTypeDef *hcan, uint32_t Timeout); // CAN发送
   
4. 
   6 M/ ?7 \" \# s
5. HAL_StatusTypeDef HAL_CAN_Receive(CAN_HandleTypeDef *hcan, uint8_t FIFONumber, uint32_t Timeout); // CAN接收

复制代码

三、几个重要的结构

1. // CAN操作句柄 包含CAN基地址（CAN1/CAN2/CAN3） 初始化结构 发送接收结构体 其余三个是过程变量
   
2. typedef struct
   + Q  b  f. E8 b; u& Q
3. {
   / q) h+ f5 b& `3 w; k
4.   CAN_TypeDef                 *Instance;  /*!< Register base address          */
   - y( T; m7 S# c* Y8 m+ u! ?
5. 
   $ S9 q& o8 l* x0 F& Z! Q
6.   CAN_InitTypeDef             Init;       /*!< CAN required parameters        */
   
7. 
   & F! _, y2 o! v" C: ^5 e1 \
8.   CanTxMsgTypeDef*            pTxMsg;     /*!< Pointer to transmit structure  */
   9 w$ ?  a/ e' p' K% ^, e# C& G
9. 
   # V5 p, M; n1 W9 T' z2 l$ a3 y
10.   CanRxMsgTypeDef*            pRxMsg;     /*!< Pointer to reception structure */
    ( R9 N  R+ o9 q
11. 
    
12.   __IO HAL_CAN_StateTypeDef   State;      /*!< CAN communication state        */
    : K$ r* {0 l3 E& A
13. 
    
14.   HAL_LockTypeDef             Lock;       /*!< CAN locking object             */
    
15. 
    
16.   __IO uint32_t               ErrorCode;  /*!< CAN Error code                 */
    6 y' S$ N! h% E5 x' p
17. 
    " A9 G  H( q- u7 u" p% ]( @
18. }CAN_HandleTypeDef;

复制代码

1. // CAN配置结构体
   
2. // 前5个参数来设置 CAN_BTR —— 波特率
   
3. // 后6个参数用来设置 CAN_MCR —— 通信相关的控制位
   / f. I- f# F8 p* R; u
4. typedef struct
   ! A, w2 a& |  C7 r  K* O
5. {
   
6.   uint32_t Prescaler;  /*!< Specifies the length of a time quantum.
   5 P8 k- i# z4 p. H& T2 b
7.                             This parameter must be a number between Min_Data = 1 and Max_Data = 1024 */
   ; [( R- H2 s" W
8. 
   5 m: g/ ~1 `& s* t
9.   uint32_t Mode;       /*!< Specifies the CAN operating mode.
   2 j: j6 {) ~4 d
10.                             This parameter can be a value of @ref CAN_operating_mode */
    
11. 
    4 i( J% w2 U! y  n
12.   uint32_t SJW;        /*!< Specifies the maximum number of time quanta
    " R0 o2 w$ ^: h
13.                             the CAN hardware is allowed to lengthen or
    1 x' o) R4 B+ r: }1 m& \- b
14.                             shorten a bit to perform resynchronization.
    
15.                             This parameter can be a value of @ref CAN_synchronisation_jump_width */
    
16. 
    9 w: S3 M) [- d8 \1 l; a
17.   uint32_t BS1;        /*!< Specifies the number of time quanta in Bit Segment 1.
    ) g/ Q; f# o, |0 I' S4 Q
18.                             This parameter can be a value of @ref CAN_time_quantum_in_bit_segment_1 */
    - t! @2 i! K/ ^! j% s
19. 
    
20.   uint32_t BS2;        /*!< Specifies the number of time quanta in Bit Segment 2.
    2 s- t* I& i& t3 u6 G# g6 W
21.                             This parameter can be a value of @ref CAN_time_quantum_in_bit_segment_2 */
    
22. 
    
23.   uint32_t TTCM;       /*!< Enable or disable the time triggered communication mode.
    
24.                             This parameter can be set to ENABLE or DISABLE. */
      e+ T2 q: H) r1 M/ Y
25. 
    9 E$ {1 ^2 j$ S2 E! \. @+ j
26.   uint32_t ABOM;       /*!< Enable or disable the automatic bus-off management.
    , s: s) H: X! ]) P# P
27.                             This parameter can be set to ENABLE or DISABLE */
    7 ~: ~' P3 g% V. ]. ?& h' l2 P
28. 
    
29.   uint32_t AWUM;       /*!< Enable or disable the automatic wake-up mode.
    - E# j+ o, o9 Z. s6 Y  w* T2 t. O8 k
30.                             This parameter can be set to ENABLE or DISABLE */
    % C' n( |' }6 d9 G, w% N
31. 
    
32.   uint32_t NART;       /*!< Enable or disable the non-automatic retransmission mode.
    
33.                             This parameter can be set to ENABLE or DISABLE */
    
34. 
    8 \2 J& F# B: A8 k; C: w
35.   uint32_t RFLM;       /*!< Enable or disable the receive FIFO Locked mode.
    7 m9 }8 r; F  A/ E& U' c
36.                             This parameter can be set to ENABLE or DISABLE */
    & O- W' |1 j$ K5 w& n. e; |
37. 
    7 Q9 `/ \4 b- W- Y; v
38.   uint32_t TXFP;       /*!< Enable or disable the transmit FIFO priority.
    
39.                             This parameter can be set to ENABLE or DISABLE */
    9 m/ b) @' T' N) O, L, m
40. }CAN_InitTypeDef;

复制代码

1. // 过滤器设置
   9 Z/ l" z5 Z- i# m1 e
2. typedef struct
   1 z2 C9 y2 V+ y) X0 c- G
3. {
   
4.   uint32_t FilterIdHigh;          /*!< Specifies the filter identification number (MSBs for a 32-bit
   
5.                                        configuration, first one for a 16-bit configuration).
   
6.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
   
7. 
   % K* U9 m" ~) E2 L& N
8.   uint32_t FilterIdLow;           /*!< Specifies the filter identification number (LSBs for a 32-bit
   + M* d, T3 p0 u/ U' [. x
9.                                        configuration, second one for a 16-bit configuration).
   
10.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
    
11. 
    
12.   uint32_t FilterMaskIdHigh;      /*!< Specifies the filter mask number or identification number,
    
13.                                        according to the mode (MSBs for a 32-bit configuration,
    ! F4 Y( @* u' G( n1 x+ E2 g& x% E
14.                                        first one for a 16-bit configuration).
    ) ^7 ^( {2 Q% X
15.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
    
16. 
    
17.   uint32_t FilterMaskIdLow;       /*!< Specifies the filter mask number or identification number,
    
18.                                        according to the mode (LSBs for a 32-bit configuration,
    
19.                                        second one for a 16-bit configuration).
    % y3 v* ^* b; a) D  [1 y3 a
20.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
    : n' }# Q+ [* I; m4 D
21. 
    
22.   uint32_t FilterFIFOAssignment;  /*!< Specifies the FIFO (0 or 1) which will be assigned to the filter.
    
23.                                        This parameter can be a value of @ref CAN_filter_FIFO */
    
24. 
    
25.   uint32_t FilterNumber;          /*!< Specifies the filter which will be initialized.
    
26.                                        This parameter must be a number between Min_Data = 0 and Max_Data = 27 */
    ! Q3 b, i% n& ?. {3 f6 c- [  _
27. 
    
28.   uint32_t FilterMode;            /*!< Specifies the filter mode to be initialized.
    " [+ s. i: s5 i
29.                                        This parameter can be a value of @ref CAN_filter_mode */
    
30. 
    
31.   uint32_t FilterScale;           /*!< Specifies the filter scale.
    : L4 O1 R2 r$ M# \$ E) R" B
32.                                        This parameter can be a value of @ref CAN_filter_scale */
    " u5 c5 A4 e: [% l
33. 
    
34.   uint32_t FilterActivation;      /*!< Enable or disable the filter.
    
35.                                        This parameter can be set to ENABLE or DISABLE. */
    
36. 
    ; k' q) C# K* S' z$ R5 z
37.   uint32_t BankNumber;            /*!< Select the start slave bank filter.
    
38.                                        This parameter must be a number between Min_Data = 0 and Max_Data = 28 */
    
39. 
    
40. }CAN_FilterConfTypeDef;

复制代码

1. // 模式  我们使用普通模式
   
2. #define CAN_MODE_NORMAL             ((uint32_t)0x00000000U)                     /*!< Normal mode   */
   ; |% a# s% M: i2 |
3. #define CAN_MODE_LOOPBACK           ((uint32_t)CAN_BTR_LBKM)                   /*!< Loopback mode */
   6 n& D- b% i9 p4 R# _
4. #define CAN_MODE_SILENT             ((uint32_t)CAN_BTR_SILM)                   /*!< Silent mode   */
   
5. #define CAN_MODE_SILENT_LOOPBACK    ((uint32_t)(CAN_BTR_LBKM | CAN_BTR_SILM))  /*!< Loopback combined with silent mode */

复制代码

1. // 标准帧 扩展帧
   
2. #define CAN_ID_STD             ((uint32_t)0x00000000U)  /*!< Standard Id */
   6 f! ]" e/ S: ?* d1 K" N: O9 r3 @
3. #define CAN_ID_EXT             ((uint32_t)0x00000004U)  /*!< Extended Id */

复制代码

1. // 数据帧 远程帧
   8 M$ E2 u, d1 G- v2 ~
2. #define CAN_RTR_DATA                ((uint32_t)0x00000000U)  /*!< Data frame */
   ) [+ g: U2 d3 R& |) P
3. #define CAN_RTR_REMOTE              ((uint32_t)0x00000002U)  /*!< Remote frame */

复制代码

1. // CAN中断使能
   0 B8 s9 p  I6 E* m! c% [8 f
2. __HAL_CAN_ENABLE_IT(__HANDLE__, __INTERRUPT__)

复制代码

1. // 接收中断
   
2. #define CAN_IT_FMP0                 ((uint32_t)CAN_IER_FMPIE0)  /*!< FIFO 0 message pending interrupt */
   & [) r$ O+ r6 c1 E5 [  F9 {
3. #define CAN_IT_FF0                  ((uint32_t)CAN_IER_FFIE0)   /*!< FIFO 0 full interrupt            */
   
4. #define CAN_IT_FOV0                 ((uint32_t)CAN_IER_FOVIE0)  /*!< FIFO 0 overrun interrupt         */
   
5. #define CAN_IT_FMP1                 ((uint32_t)CAN_IER_FMPIE1)  /*!< FIFO 1 message pending interrupt */
   
6. #define CAN_IT_FF1                  ((uint32_t)CAN_IER_FFIE1)   /*!< FIFO 1 full interrupt            */
   7 X6 z8 K8 h7 J6 N! T0 z
7. #define CAN_IT_FOV1                 ((uint32_t)CAN_IER_FOVIE1)  /*!< FIFO 1 overrun interrupt         */

复制代码

四、接口设计
与串口类似，使用中断接收。先封装单路CAN需要的几个小接口，再顶一个列表，最后使用统一的接口扫描这个列表。
% Q, k- z8 J6 w! B
$ i* q7 |) s" @7 j% I1 X+ e1 F

1. typedef enum
   / L/ O& Q" N7 Q" H! K8 Q6 A- J
2. {
   
3.   CAN_CHANNEL_NONE,
   1 q/ `! m' u+ ^' }% E
4.   CAN_CHANNEL_1,
   & y3 r) h/ j8 B' u" \; y3 N
5.   CAN_CHANNEL_2,
   
6.   CAN_CHANNEL_NUM
   
7. } can_channel_t;
   
8. 
   * q8 z; ?# u1 e
9. #define CAN1_CHANNEL              CAN1
   ) L6 V8 a. @' w4 k
10. #define CAN1_PREEMPT_PRIO         CAN1_RX_PRIORITY
    / N. D- `( f, J3 |# e- [
11. #define CAN1_RX_IRQ               CAN1_RX0_IRQn
    
12. #define CAN1_RX_IRQ_FUNC          CAN1_RX0_IRQHandler
    ) f$ c9 T( I* D5 g( f% ^  ?0 A% b
13. #define CAN1_CLK_ENABLE()         __HAL_RCC_CAN1_CLK_ENABLE()
    
14. #define CAN1_TX_PORT              GPIOA
    - v6 M4 g$ W- x) V
15. #define CAN1_TX_PIN               GPIO_PIN_12
    
16. #define CAN1_TX_AF                GPIO_AF9_CAN1
    
17. #define CAN1_TX_CONFIG()          GPIOConfigExt(CAN1_TX_PORT, CAN1_TX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, CAN1_TX_AF)
    ) d2 s8 S  O& }5 Q+ z7 F3 E- n
18. #define CAN1_RX_PORT              GPIOA
    
19. #define CAN1_RX_PIN               GPIO_PIN_11
    
20. #define CAN1_RX_AF                GPIO_AF9_CAN1
    - ^: v+ O1 |4 Q4 {2 I* P
21. #define CAN1_RX_CONFIG()          GPIOConfigExt(CAN1_RX_PORT, CAN1_RX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, CAN1_RX_AF)
    ! `3 v* S4 l+ F$ n$ `4 z! o
22. 
    
23. #define CAN2_CHANNEL              CAN2
    " E( R/ ]" w3 q
24. #define CAN2_PREEMPT_PRIO         CAN2_RX_PRIORITY
    9 w1 g# H$ K) K$ F
25. #define CAN2_RX_IRQ               CAN2_RX0_IRQn
    
26. #define CAN2_RX_IRQ_FUNC          CAN2_RX0_IRQHandler
    
27. #define CAN2_CLK_ENABLE()         __HAL_RCC_CAN2_CLK_ENABLE()
    * C: g- M( k- p- i- c7 c2 z
28. #define CAN2_TX_PORT              GPIOB
    
29. #define CAN2_TX_PIN               GPIO_PIN_6
    
30. #define CAN2_TX_AF                GPIO_AF9_CAN2
    
31. #define CAN2_TX_CONFIG()          GPIOConfigExt(CAN2_TX_PORT, CAN2_TX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, CAN2_TX_AF)
    
32. #define CAN2_RX_PORT              GPIOB
    ( o' ?0 ?3 l+ t! V' _' y+ T
33. #define CAN2_RX_PIN               GPIO_PIN_5
    4 A  F, d' b# s8 h  D9 V6 ]9 D! c! g
34. #define CAN2_RX_AF                GPIO_AF9_CAN2
    
35. #define CAN2_RX_CONFIG()          GPIOConfigExt(CAN2_RX_PORT, CAN2_RX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, CAN2_RX_AF)

复制代码

1. <span style="background-color: rgb(255, 255, 255);">/</span>/ 抽象出一个CAN设备结构体
   + _8 @, A2 R$ S; |5 e, {0 U  D8 H
2. typedef struct
   
3. {
   
4.   CAN_HandleTypeDef handle; // CAN操作句柄
   ! E  B  I) y# _4 Q' j- E6 z' T
5. 
   3 U' d) Z- A4 L1 s
6.   CanTxMsgTypeDef tx;       // CAN发送
   
7. 
   
8.   CanRxMsgTypeDef rx;       // CAN接收
   ) t4 l/ ^/ o4 @7 u9 }, [# J6 @
9. 
   ! L/ }3 S" [1 A! C, `# }7 p
10.   can_queue_t recv;         // 接收队列
    
11. 
    
12. } can_dev_t;

复制代码

1. // 将每路CAN封装成几个小函数
   
2. static can_dev_t can1_dev, can2_dev;
   
3. 
   : g$ }$ T2 s6 f& Y: s( @$ i% ^
4. static void can1_var_init(void)
   5 L# U7 P) `3 T& B; m: `
5. {
   
6.   can1_dev.recv = can1_queue_recv;
   9 D$ p) z- c- ~; `6 a
7. 
   7 |! T2 g9 v  t  R" S" X' a* e! R
8.   CanQueueInit(&can1_dev.recv);
   ' C) e' v! u& v8 ]) a* ~
9. }
   + {' J6 x* Y1 B6 W9 Y
10. 
    
11. static void can1_gpio_init(void)
    : Z$ d5 l  u+ U9 a) ^3 R
12. {
    
13.   CAN1_TX_CONFIG();
    . }% W, O! r2 I! V# [
14.   CAN1_RX_CONFIG();
    4 s# l1 i8 ^3 Z: P
15. }
    
16. 
      b7 K6 w7 N% F: |
17. // 波特率 = Fpclk1 / ((ts1+ts2+3) * brp)  Fpclk1 = 54M
    , Y& Q4 ~# Z+ g( E
18. static void can1_mode_init(void)
    - _# ?: L9 i: U) ?+ Q+ T
19. {
    - B4 |6 }' |# J1 f
20.   CAN1_CLK_ENABLE();
    + N3 B9 P1 F; a5 B) }
21. 
    ) L& B- ]0 f% z2 a% x6 _
22.   can1_dev.handle.Instance = CAN1_CHANNEL;
    : E% j, z* @, \- n, [% t$ @
23.   can1_dev.handle.pTxMsg = &can1_dev.tx;
    
24.   can1_dev.handle.pRxMsg = &can1_dev.rx;
    ) K5 Y/ B; v/ c" U& S' G
25.   can1_dev.handle.Init.Prescaler = 6;
    5 k- }) p! B' ?; C
26.   can1_dev.handle.Init.Mode = CAN_MODE_NORMAL;
    
27.   can1_dev.handle.Init.SJW = CAN_SJW_1TQ; // 重新同步跳跃宽度(Tsjw)为tsjw+1个时间单位 CAN_SJW_1TQ~CAN_SJW_4TQ
    $ e2 w! F. R, N9 `' S
28.   can1_dev.handle.Init.BS1 = CAN_BS1_11TQ;// tbs1范围CAN_BS1_1TQ~CAN_BS1_16TQ
    , s! N8 B3 K5 v" N' n& v
29.   can1_dev.handle.Init.BS2 = CAN_BS2_6TQ; // tbs2范围CAN_BS2_1TQ~CAN_BS2_8TQ
    
30.   can1_dev.handle.Init.TTCM = DISABLE;    // 非时间触发通信模式
    & J" l1 T2 e6 S
31.   can1_dev.handle.Init.ABOM = ENABLE;     // 软件自动离线管理
    * v0 ^, s+ O# @+ Z
32.   can1_dev.handle.Init.AWUM = DISABLE;    // 睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    
33.   can1_dev.handle.Init.NART = ENABLE;     // 禁止报文自动传送
    
34.   can1_dev.handle.Init.RFLM = DISABLE;    // 报文不锁定,新的覆盖旧的
    
35.   can1_dev.handle.Init.TXFP = DISABLE;    // 优先级由报文标识符决定
    
36.   HAL_CAN_Init(&can1_dev.handle);
    5 Z# M, `: ?1 C, R9 c# {
37. }
    3 x" N8 W  a* C5 j! c/ X
38. 
    
39. static void can1_filter_init(void)
    
40. {
    
41.   CAN_FilterConfTypeDef  filter;
    $ T. F6 A7 w- o1 Q
42. 
    2 i! x" p, o) t
43.   filter.FilterNumber     = 0; // 过滤器0
    ! e9 Y7 D& Q* S& I6 t
44.   filter.FilterMode       = CAN_FILTERMODE_IDMASK;
    
45.   filter.FilterScale      = CAN_FILTERSCALE_32BIT;
    
46. 
    2 R( }6 ^* Q1 Q7 G6 E6 C
47.   filter.FilterIdHigh     = 0;
    & E) b, O/ I2 e
48.   filter.FilterIdLow      = 0;
    
49.   filter.FilterMaskIdHigh = 0;
    / h- U( N& a' L, A" t* P+ }) `
50.   filter.FilterMaskIdLow  = 0;
    
51. 
    
52.   filter.FilterFIFOAssignment = CAN_FILTER_FIFO0; // 过滤器0关联到FIFO0
    
53.   filter.FilterActivation = ENABLE; //激活滤波器0
    * b( Z0 _( J: O  V9 P) ]$ }# o9 G5 M
54.   //filter.BankNumber=14;
    
55. 
    ! i' x- V  @+ h- ]
56.   HAL_CAN_ConfigFilter(&can1_dev.handle, &filter);
    
57. }
    
58. 
    
59. static void can1_nvic_init(void)
    
60. {
    7 p8 Z: c% }8 f) \4 X9 Z
61.   __HAL_CAN_ENABLE_IT(&can1_dev.handle, CAN_IT_FMP0); //FIFO0消息挂号中断允许.
    8 d' z! ~$ [8 |7 D) _
62.   HAL_NVIC_SetPriority(CAN1_RX_IRQ, CAN1_RX_PRIORITY, 0);
    5 M. t' ^' v5 I# T2 ~5 f) ?
63.   HAL_NVIC_EnableIRQ(CAN1_RX_IRQ);
    
64. }
    4 Y( ]9 |2 G" h* o( }
65. 
    
66. 
    " j% N7 m# M7 ?7 m- W: q5 O
67. 
    2 \) R+ U9 V" Q) I
68. static void can2_var_init(void)
    
69. {
    
70.   can2_dev.recv = can2_queue_recv;
    
71. 
    
72.   CanQueueInit(&can2_dev.recv);
    $ R( x' b; P, Q; y7 ~
73. }
    
74. 
      L- S( H/ p6 [. _/ {) A
75. static void can2_gpio_init(void)
    * e& ^8 f9 {9 L0 `: ~/ d
76. {
    # f1 I0 ]  r$ B; n, S
77.   CAN2_TX_CONFIG();
    ( P$ I2 u# e+ p
78.   CAN2_RX_CONFIG();
    5 G* F+ D* [' d  P) r0 P- A0 c
79. }
    ) S$ V. K( e$ `; q! D) n0 E
80. 
    
81. // 波特率 = Fpclk1 / ((ts1+ts2+3) * brp)  Fpclk1 = 54M
    1 R  y+ O/ R6 a3 D* S
82. static void can2_mode_init(void)
    
83. {
    5 ~. S/ R, L2 n: i) n& |7 c
84.   CAN2_CLK_ENABLE();
    
85. 
    * D9 p& ~6 j0 e+ _( p* [1 h* @# `$ {6 b
86.   can2_dev.handle.Instance = CAN2_CHANNEL;
    ! J- M' q1 {; s+ g; c
87.   can2_dev.handle.Init.Prescaler = 6;
    
88.   can2_dev.handle.Init.Mode = CAN_MODE_LOOPBACK;
    
89.   can2_dev.handle.Init.SJW = CAN_SJW_1TQ; // 重新同步跳跃宽度(Tsjw)为tsjw+1个时间单位 CAN_SJW_1TQ~CAN_SJW_4TQ
    , M& w2 E" Q* }: u- f( S0 w
90.   can2_dev.handle.Init.BS1 = CAN_BS1_11TQ;// tbs1范围CAN_BS1_1TQ~CAN_BS1_16TQ
    . r" @/ |  B4 C4 P; D. x4 q
91.   can2_dev.handle.Init.BS2 = CAN_BS2_6TQ; // tbs2范围CAN_BS2_1TQ~CAN_BS2_8TQ
    
92.   can2_dev.handle.Init.TTCM = DISABLE;    // 非时间触发通信模式
    : A3 N! J9 @1 W3 d6 M
93.   can2_dev.handle.Init.ABOM = ENABLE;     // 软件自动离线管理
    , g  ?; ?4 h" c5 u4 _
94.   can2_dev.handle.Init.AWUM = DISABLE;    // 睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    6 g+ }4 a4 P' M( v
95.   can2_dev.handle.Init.NART = ENABLE;     // 禁止报文自动传送
    / z0 P* C  Q# `
96.   can2_dev.handle.Init.RFLM = DISABLE;    // 报文不锁定,新的覆盖旧的
    
97.   can2_dev.handle.Init.TXFP = DISABLE;    // 优先级由报文标识符决定
    
98.   HAL_CAN_Init(&can2_dev.handle);
    
99. }
    
100. 
     
101. static void can2_filter_init(void)
     % f+ \0 [5 [5 S9 S& y6 F% N
102. {
     
103.   CAN_FilterConfTypeDef  CAN_FilterInitStructure;
     ) L7 x, `0 `+ `$ I' a
104. 
     
105.   CAN_FilterInitStructure.FilterNumber     = 14;
     % J3 R8 _& u  z; y! [
106.   CAN_FilterInitStructure.FilterMode       = CAN_FILTERMODE_IDMASK;
     
107.   CAN_FilterInitStructure.FilterScale      = CAN_FILTERSCALE_32BIT;
     ' v# R* [+ S, k+ R4 T
108. 
     9 k& m' Y  V  Z( r: i6 d; f- x
109.   CAN_FilterInitStructure.FilterIdHigh     = 0;
     
110.   CAN_FilterInitStructure.FilterIdLow      = 0;
     $ X( m4 E6 h* o) k" |: v
111.   CAN_FilterInitStructure.FilterMaskIdHigh = 0;
     
112.   CAN_FilterInitStructure.FilterMaskIdLow  = 0;
     
113. 
     
114.   CAN_FilterInitStructure.FilterFIFOAssignment = CAN_FILTER_FIFO0; // 过滤器0关联到FIFO0
     
115.   CAN_FilterInitStructure.FilterActivation = ENABLE; //激活滤波器0
     / d) d& s5 r3 ?3 V. z0 @
116.   //CAN_FilterInitStructure.BankNumber=14;
     
117. 
     / }8 q1 j% _9 A2 b1 I" E
118.   HAL_CAN_ConfigFilter(&can2_dev.handle, &CAN_FilterInitStructure);
     
119. }
     
120. 
     5 z# W% R9 x8 g( X
121. static void can2_nvic_init(void)
     + f# B0 t5 I, u6 }* ]9 {
122. {
     
123.   __HAL_CAN_ENABLE_IT(&can2_dev.handle, CAN_IT_FMP0); //FIFO0消息挂号中断允许1
     % X% K% v: s6 K3 y* B6 E! ~
124.   HAL_NVIC_SetPriority(CAN2_RX_IRQ, CAN2_RX_PRIORITY, 0);
     ; H! @: T% ]0 a
125.   HAL_NVIC_EnableIRQ(CAN2_RX_IRQ);
     
126. }

复制代码

1. // 每路CAN都有的几个操作，使用列表包含，然后统一扫描处理
   # f$ e  c5 ?% O. j
2. typedef struct
   ) h7 O; `. B8 i7 W/ H$ K* l
3. {
     G) {# v6 k  G' S7 i4 v3 `( W
4.   uint8_t channel;
   
5.   can_dev_t *dev;
   - \+ Z) t: R& Q7 ~# V3 X8 W# J
6.   void (* var_init_cb)(void);
   $ `5 z% l! \) R5 Z4 [2 k) k
7.   void (* gpio_init_cb)(void);
   # @0 @. c. Z) Z1 r5 `' |! e
8.   void (* mode_init_cb)(void);
   , C. q) L: Y- g& H/ J; p
9.   void (* filter_init_cb)(void);
   
10.   void (* nvic_init_cb)(void);
    
11. } can_config_t;
    
12. 
    
13. static const can_config_t can_configs[] =
    4 T0 F5 h. C$ K# |. S
14. {
    
15.   {CAN_CHANNEL_1, &can1_dev, can1_var_init, can1_gpio_init, can1_mode_init, can1_filter_init, can1_nvic_init},
    
16.   {CAN_CHANNEL_2, &can2_dev, can2_var_init, can2_gpio_init, can2_mode_init, can2_filter_init, can2_nvic_init},
    
17. };
    
18. 
    ; _( j( ]) \6 r; L0 C
19. static can_dev_t *can_dev_get(uint8_t channel)
    3 u: [* E6 q  d( X* O6 P0 e9 J8 V4 y
20. {
    
21.   uint8_t i;
    ; O& _0 o2 Y9 g8 S+ v
22. 
    $ t( T# T1 s: z6 ~- h
23.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    
24.   {
    
25.     if(channel == can_configs<i>.channel)
    2 A$ A4 g  l: ?  V3 R! X
26.     {
    
27.       return can_configs<i>.dev;
    
28.     }
    
29.   }
    # ], ?# H  @$ H) [8 q
30. 
    . Q. N* N& L( @2 _  |/ D
31.   return 0;
    ) l/ Z* f; g* A  _! q  e7 [) q8 G
32. }
    
33. 
    
34. static void can_var_init(uint8_t channel)
    2 m1 K8 X3 X3 j# G* m3 w
35. {
    ) v( d- S; G+ @5 Q+ W
36.   uint8_t i;
    ' I/ L  L  U2 x% V4 F3 M: b0 t% @
37. 
    + ~5 _4 ^8 |) k0 X& A; s: w9 `
38.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    ( L; E. B! V5 y" K7 t$ z7 i
39.   {
    
40.     if(channel == can_configs<i>.channel)
      G- {* K9 V' |; `# ^. X
41.     {
    ; z9 J- e/ E+ {/ Y; Z
42.       can_configs<i>.var_init_cb();
    ' X' v, B, _! N& X
43.       return;
    
44.     }
    
45.   }
    7 u/ E/ M. P! z5 U) q
46. }
    
47. 
    1 ?  d& |' k0 x! p, I
48. static void can_gpio_init(uint8_t channel)
    
49. {
    
50.   uint8_t i;
    ! v! Z6 l, h% U! |5 r
51. 
    1 N; x7 C# G# J# t  V! R
52.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    
53.   {
    
54.     if(channel == can_configs<i>.channel)
    # R. s: C; K- R0 D, N; y5 O
55.     {
    8 V% o+ R  k3 z5 o1 s
56.       can_configs<i>.gpio_init_cb();
    0 V7 m2 L  ]4 u
57.       return;
    
58.     }
    . v" g, c8 E, h1 F, ^
59.   }
    
60. }
    * ?4 L- y* T' C, I  L% E
61. 
    2 M& S# R0 o& M" |
62. static void can_mode_init(uint8_t channel)
    
63. {
    
64.   uint8_t i;
    9 M) I" T- k, g3 B
65. 
    . H/ q/ H2 o& w. \
66.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    
67.   {
    
68.     if(channel == can_configs<i>.channel)
    
69.     {
    # c* a0 O! K+ ]
70.       can_configs<i>.mode_init_cb();
    
71.       return;
    
72.     }
    
73.   }
    5 G# x( n9 J. q
74. }
    - M+ w, v0 W! ^9 \6 k% _
75. 
    . s6 Z. c% \( R7 l) N7 O
76. static void can_filter_init(uint8_t channel)
    ) e0 f% D' G2 M2 {& w% n# F  w: @! Q
77. {
    
78.   uint8_t i;
    
79. 
    
80.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    
81.   {
    
82.     if(channel == can_configs<i>.channel)
    
83.     {
    
84.       can_configs<i>.filter_init_cb();
    ) \; `. V5 I& x; l  r
85.       return;
    
86.     }
    & q: a3 {9 g% [8 O  `2 Y( T
87.   }
    
88. }
    8 y4 |- u5 Y3 @
89. 
    4 H8 M' }. g. X8 L2 h
90. static void can_nvic_init(uint8_t channel)
    
91. {
    + j+ M, K, N" @" d1 R' r2 N
92.   uint8_t i;
    
93. 
    
94.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    
95.   {
    % m/ d3 n/ w: Q! N
96.     if(channel == can_configs<i>.channel)
    
97.     {
    . L4 {- F1 E$ n) D, v7 V
98.       can_configs<i>.nvic_init_cb();
    # F; @0 ]0 o7 {" Z3 k" Y) p! r
99.       return;
    
100.     }
     
101.   }
     3 E6 c6 @2 g0 e$ u
102. }</i></i></i></i></i></i></i></i></i></i></i></i>

复制代码

1. // 对外的接口 初始化 发送和接收
   ! }" y7 M  X9 Z* x) {7 R
2. void CanInit(uint8_t channel)
   
3. {
   - V. |6 o9 [5 H6 Q
4.   can_var_init(channel);
   1 \3 T& p# u3 W# R* o0 j1 s7 A
5.   can_gpio_init(channel);
   
6.   can_mode_init(channel);
   
7.   can_filter_init(channel);
   0 |, ^# I: `9 k, T1 @, V& |) p
8.   can_nvic_init(channel);
   
9. }
   
10. 
    + c& w, h8 p0 `* C8 u* N' j
11. void CanSend(uint8_t channel, can_frame_t *frame)
    1 ?1 a# m8 z  z/ P2 k9 e
12. {
    1 E/ x* x1 H* r4 U2 s( N
13.   can_dev_t *dev = can_dev_get(channel);
    
14. 
    - X. m/ R0 W3 E+ _( x/ H1 i- _% K
15.   if(dev == 0)
    + f  i0 O) M0 z4 I  L; Y' h8 u
16.   {
    4 i/ Z* q+ F) G1 Y
17.     return;
    
18.   }
    
19. 
    1 |+ T9 s. j2 D# I- n( @" T, _# A
20.   dev->handle.pTxMsg->StdId = frame->StdId;
    
21.   dev->handle.pTxMsg->IDE   = frame->IDE;
    
22.   dev->handle.pTxMsg->RTR   = frame->RTR;
    * T2 i+ p5 M1 C. c; h
23.   dev->handle.pTxMsg->DLC   = frame->DLC;
    
24.   memcpy(dev->handle.pTxMsg->Data, frame->Data, frame->DLC);
    9 u9 y, E: B' d
25. 
    5 s! u/ f+ u" U, t. g' Y( g& M
26.   HAL_CAN_Transmit(&dev->handle, 10);
    
27. }
    6 Z* ?% D1 I1 G. G
28. 
    
29. uint8_t CanRecv(uint8_t channel, can_frame_t *frame)
    3 f3 A+ W8 \1 V, R
30. {
    
31.   can_dev_t *dev = can_dev_get(channel);
    ) b3 N0 m7 ]! }' M5 R0 x
32. 
    4 h- @$ w7 H9 X% t
33.   if(dev == 0)
    
34.   {
    
35.     return 0;
    
36.   }
    ( U; a9 |. q# I: T" H8 E
37. 
    ( Y  N( U: @; S: y* S+ L! V$ a
38.   return CanQueueRead(&can1_dev.recv, frame);
    . r$ ~3 f) _$ w/ r% U! I
39. }

复制代码

1. // CAN中断
   * h7 i$ O2 M2 t/ i& ^4 _5 O, C
2. void CAN1_RX_IRQ_FUNC(void)
   8 j* [/ r" h8 U3 w* j+ ^! b
3. {
   
4.   HAL_CAN_IRQHandler(&can1_dev.handle);
   1 D* W- e) `# e# }; F, P
5. }
   
6. 
   
7. void CAN2_RX_IRQ_FUNC(void)
   
8. {
   
9.   HAL_CAN_IRQHandler(&can2_dev.handle);
   ( J' Z: |0 R* h% Y7 C# t
10. }
    ! Y! g) ~; ^7 e: g: O4 a
11. 
    : u" v( m/ K. `- ?& o) @5 I- q
12. void HAL_CAN_RxCpltCallback(CAN_HandleTypeDef *hcan)
    
13. {
    
14.   if(hcan == (&can1_dev.handle))
    " r2 [# a3 c5 D& z/ Z; }) c+ V8 ]
15.   {
    0 Y8 k* \$ S$ [5 Q' O! L0 J
16.     //CAN_Receive_IT()函数会关闭FIFO0消息挂号中断，因此我们需要重新打开
    # b6 Q$ @; u$ N* U& P9 n7 f: p
17.     __HAL_CAN_ENABLE_IT(&can1_dev.handle, CAN_IT_FMP0);//重新开启FIF00消息挂号中断
    ( Y, u& k- z; m
18.     CanQueueWrite(&can1_dev.recv, can1_dev.handle.pRxMsg);
    , _, H/ b. M2 n1 w
19.   }
    5 K3 l0 `; B  u8 X" Z8 U
20.   else if(hcan == (&can2_dev.handle))
    
21.   {
      @7 h2 g8 h( R* D& q
22.     //CAN_Receive_IT()函数会关闭FIFO0消息挂号中断，因此我们需要重新打开
    2 Z: \/ K) v' x- M0 b1 z3 X. m
23.     __HAL_CAN_ENABLE_IT(&can2_dev.handle, CAN_IT_FMP0);//重新开启FIF00消息挂号中断
    
24.     CanQueueWrite(&can2_dev.recv, can2_dev.handle.pRxMsg);
    2 F) K2 p1 f. i. e9 ^  v. u7 P, \' ~$ b
25.   }
    
26. }

复制代码

" a: o1 |6 ?+ a3 A2 @        之所以使用列表的形式，是为了方便增加和删除CAN通道和使对外的接口更统一，不会出现CAN1Init() CAN2Init()，个人习惯问题。
* R2 m( O, z- J% U) a% [7 O


# e+ J: E# e9 R) s  H