一、CAN基础
差分信号：显性电平对应逻辑0，CAN_H和CAN_L差为2.5V；隐形电平对应逻辑1，CAN_H和CAN_L差为0V。
+ B2 U- ^7 h% M$ X; M; ^
CAN总线的开始和结束都有一个120Ω的终端电阻。

' m* F  B5 a! J& ?- Y; I数据帧：标准帧11位，  扩展帧29位。
$ m8 V' x5 z3 \0 I8 B4 D
; n, p/ ]% z& h2 {1 {其他的一些理论知识就不再赘述了，可以参考维基百科对于CAN的描述。

STM32F7xx的bxCAN主要特点：支持CAN2.0A和CAN2.0B，波特率高达1Mbps，支持时间触发，具有3个发送邮箱，2个接收邮箱，可变的过滤器组等。

% Z! Y# v# X- o二、几个重要的CAN函数
; I* C1 A( \( [8 W! d0 ~

1. HAL_StatusTypeDef HAL_CAN_Init(CAN_HandleTypeDef* hcan); // CAN初始化
   
2. 
   
3. HAL_StatusTypeDef HAL_CAN_Transmit(CAN_HandleTypeDef *hcan, uint32_t Timeout); // CAN发送
   
4. 
   " v; n: u1 u$ S; e
5. HAL_StatusTypeDef HAL_CAN_Receive(CAN_HandleTypeDef *hcan, uint8_t FIFONumber, uint32_t Timeout); // CAN接收

复制代码

7 m+ [) Z; c6 I. t4 p5 t. _三、几个重要的结构

1. // CAN操作句柄 包含CAN基地址（CAN1/CAN2/CAN3） 初始化结构 发送接收结构体 其余三个是过程变量
   
2. typedef struct
   
3. {
   
4.   CAN_TypeDef                 *Instance;  /*!< Register base address          */
   
5. 
   ) _  ^# p# Y& c9 _, j* V
6.   CAN_InitTypeDef             Init;       /*!< CAN required parameters        */
   
7. 
   7 d. S  _8 t0 U/ l, _$ e
8.   CanTxMsgTypeDef*            pTxMsg;     /*!< Pointer to transmit structure  */
   7 Z0 h, ~9 [* i
9. 
   
10.   CanRxMsgTypeDef*            pRxMsg;     /*!< Pointer to reception structure */
    + u# [; I, W. U' d8 b" u
11. 
    
12.   __IO HAL_CAN_StateTypeDef   State;      /*!< CAN communication state        */
    3 q9 F' V! m$ w( O! j9 k
13. 
    
14.   HAL_LockTypeDef             Lock;       /*!< CAN locking object             */
    
15. 
    
16.   __IO uint32_t               ErrorCode;  /*!< CAN Error code                 */
      U, S1 X! v; x* _+ B7 P" Z2 m+ `
17. 
    2 R! e2 e/ G" V# C8 I
18. }CAN_HandleTypeDef;

复制代码

1. // CAN配置结构体
   
2. // 前5个参数来设置 CAN_BTR —— 波特率
   
3. // 后6个参数用来设置 CAN_MCR —— 通信相关的控制位
   
4. typedef struct
   
5. {
   & X# a* z! f, h1 t1 T
6.   uint32_t Prescaler;  /*!< Specifies the length of a time quantum.
   8 C' `; R: j4 [2 _5 @! H  P3 k% k
7.                             This parameter must be a number between Min_Data = 1 and Max_Data = 1024 */
   
8. 
   
9.   uint32_t Mode;       /*!< Specifies the CAN operating mode.
   ! ]5 l8 j  F; Y) x7 N
10.                             This parameter can be a value of @ref CAN_operating_mode */
    ; d# k2 z# U3 c' w
11. 
    ' Z0 q, z! o9 }* ?
12.   uint32_t SJW;        /*!< Specifies the maximum number of time quanta
    # ]  v; }, b% B. w, v" \
13.                             the CAN hardware is allowed to lengthen or
    / q" E% }& P& O2 J' ]0 g4 d1 ~# ^
14.                             shorten a bit to perform resynchronization.
    
15.                             This parameter can be a value of @ref CAN_synchronisation_jump_width */
    1 K2 I; ^( H5 o! ]7 t4 E
16. 
    
17.   uint32_t BS1;        /*!< Specifies the number of time quanta in Bit Segment 1.
    
18.                             This parameter can be a value of @ref CAN_time_quantum_in_bit_segment_1 */
    
19. 
    ; |. J% r3 s4 ^" w5 `) q, l
20.   uint32_t BS2;        /*!< Specifies the number of time quanta in Bit Segment 2.
    
21.                             This parameter can be a value of @ref CAN_time_quantum_in_bit_segment_2 */
    4 D  e  W* D7 ]" h3 e$ c+ k
22. 
    
23.   uint32_t TTCM;       /*!< Enable or disable the time triggered communication mode.
    
24.                             This parameter can be set to ENABLE or DISABLE. */
    
25. 
    
26.   uint32_t ABOM;       /*!< Enable or disable the automatic bus-off management.
    
27.                             This parameter can be set to ENABLE or DISABLE */
    ! D- N  `2 x) }- b
28. 
    
29.   uint32_t AWUM;       /*!< Enable or disable the automatic wake-up mode.
    
30.                             This parameter can be set to ENABLE or DISABLE */
    
31. 
    
32.   uint32_t NART;       /*!< Enable or disable the non-automatic retransmission mode.
    3 ?/ }+ a, E) z
33.                             This parameter can be set to ENABLE or DISABLE */
    6 i( g3 k% D0 R( A; g: a1 X, ?9 I6 y
34. 
    
35.   uint32_t RFLM;       /*!< Enable or disable the receive FIFO Locked mode.
    + d; `1 d; D% o, ^
36.                             This parameter can be set to ENABLE or DISABLE */
    
37. 
    
38.   uint32_t TXFP;       /*!< Enable or disable the transmit FIFO priority.
    ! ^4 H* E& ^4 A$ N  j
39.                             This parameter can be set to ENABLE or DISABLE */
    
40. }CAN_InitTypeDef;

复制代码

1. // 过滤器设置
   
2. typedef struct
   
3. {
   . g4 Z' w3 H. U
4.   uint32_t FilterIdHigh;          /*!< Specifies the filter identification number (MSBs for a 32-bit
   & q) y+ Q) M1 K9 i, m" o
5.                                        configuration, first one for a 16-bit configuration).
   
6.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
   % h1 B6 g1 x: F
7. 
   0 H' o( K: S, c7 l8 q  y' t
8.   uint32_t FilterIdLow;           /*!< Specifies the filter identification number (LSBs for a 32-bit
   ( M5 f; b& H8 r: L. x8 b1 ]
9.                                        configuration, second one for a 16-bit configuration).
   * b3 W3 N4 V" Z- T7 Z* p5 v3 l
10.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
    
11. 
    7 @& i/ z6 G0 l- m4 u# t6 s
12.   uint32_t FilterMaskIdHigh;      /*!< Specifies the filter mask number or identification number,
    ! @+ a; b/ x/ G# s% ?
13.                                        according to the mode (MSBs for a 32-bit configuration,
    
14.                                        first one for a 16-bit configuration).
    ) W0 \+ S* n+ Y) q% j
15.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
    ( g. {+ Z) c" D+ z6 K0 `% ?
16. 
    6 ]: I! n. t+ @( ?# h1 A
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).
    $ _1 ?) Q- y3 B3 c6 M1 \0 k& j
20.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
    & `$ d; z& x) `8 W
21. 
    
22.   uint32_t FilterFIFOAssignment;  /*!< Specifies the FIFO (0 or 1) which will be assigned to the filter.
    8 m6 ]5 K- F! P& J) K
23.                                        This parameter can be a value of @ref CAN_filter_FIFO */
    
24. 
    6 m8 S0 D" T, S7 ^  q" }
25.   uint32_t FilterNumber;          /*!< Specifies the filter which will be initialized.
    % k: e  c" d+ c- {, _
26.                                        This parameter must be a number between Min_Data = 0 and Max_Data = 27 */
    9 W# S' b: _9 J8 m) x
27. 
    
28.   uint32_t FilterMode;            /*!< Specifies the filter mode to be initialized.
    
29.                                        This parameter can be a value of @ref CAN_filter_mode */
    
30. 
    - k# P% A1 t: J1 y$ A) U/ B
31.   uint32_t FilterScale;           /*!< Specifies the filter scale.
    
32.                                        This parameter can be a value of @ref CAN_filter_scale */
    
33. 
    
34.   uint32_t FilterActivation;      /*!< Enable or disable the filter.
    $ u9 X6 ~! q8 c- B
35.                                        This parameter can be set to ENABLE or DISABLE. */
    
36. 
    
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 */
    " k6 T. ?- d) }4 g
39. 
    
40. }CAN_FilterConfTypeDef;

复制代码

1. // 模式  我们使用普通模式
   
2. #define CAN_MODE_NORMAL             ((uint32_t)0x00000000U)                     /*!< Normal mode   */
   ; n1 T* c. }/ i5 o& z0 [' i2 A
3. #define CAN_MODE_LOOPBACK           ((uint32_t)CAN_BTR_LBKM)                   /*!< Loopback mode */
   
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 */
   
3. #define CAN_ID_EXT             ((uint32_t)0x00000004U)  /*!< Extended Id */

复制代码

1. // 数据帧 远程帧
   
2. #define CAN_RTR_DATA                ((uint32_t)0x00000000U)  /*!< Data frame */
     z' a5 a" H% |1 [+ `
3. #define CAN_RTR_REMOTE              ((uint32_t)0x00000002U)  /*!< Remote frame */

复制代码

1. // CAN中断使能
   1 P0 J3 O% ~3 Q: G
2. __HAL_CAN_ENABLE_IT(__HANDLE__, __INTERRUPT__)

复制代码

1. // 接收中断
   
2. #define CAN_IT_FMP0                 ((uint32_t)CAN_IER_FMPIE0)  /*!< FIFO 0 message pending interrupt */
   
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         */
     [9 J2 M1 r6 ]8 b( d- V8 R
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            */
   ' z, S2 P3 i" K5 p1 P
7. #define CAN_IT_FOV1                 ((uint32_t)CAN_IER_FOVIE1)  /*!< FIFO 1 overrun interrupt         */

复制代码

四、接口设计
2 b1 c+ U  S/ F6 z' \" ~与串口类似，使用中断接收。先封装单路CAN需要的几个小接口，再顶一个列表，最后使用统一的接口扫描这个列表。
/ g, e8 ~1 U- m* b/ v4 J8 t0 D" s' D

1. typedef enum
   * \& P' V: J: j7 Q* L
2. {
   
3.   CAN_CHANNEL_NONE,
   
4.   CAN_CHANNEL_1,
   1 i: D1 I1 Y9 u" ]9 F3 y
5.   CAN_CHANNEL_2,
   
6.   CAN_CHANNEL_NUM
   3 }6 A+ e0 ]( f5 u5 E
7. } can_channel_t;
   - S) C3 B/ H3 }! i1 ?1 t
8. 
   
9. #define CAN1_CHANNEL              CAN1
   
10. #define CAN1_PREEMPT_PRIO         CAN1_RX_PRIORITY
      h$ f  A, q% p2 h
11. #define CAN1_RX_IRQ               CAN1_RX0_IRQn
    
12. #define CAN1_RX_IRQ_FUNC          CAN1_RX0_IRQHandler
    ! G0 c; d: n) U( u2 d) {" d7 M: }
13. #define CAN1_CLK_ENABLE()         __HAL_RCC_CAN1_CLK_ENABLE()
    
14. #define CAN1_TX_PORT              GPIOA
    . h" K+ |# s5 x; t, B& ]+ U
15. #define CAN1_TX_PIN               GPIO_PIN_12
    8 M( {/ Q6 Z8 J% f# Y4 B
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)
    
18. #define CAN1_RX_PORT              GPIOA
    
19. #define CAN1_RX_PIN               GPIO_PIN_11
    
20. #define CAN1_RX_AF                GPIO_AF9_CAN1
    
21. #define CAN1_RX_CONFIG()          GPIOConfigExt(CAN1_RX_PORT, CAN1_RX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, CAN1_RX_AF)
    : X8 B4 ]7 _2 T- V# Y0 h4 ^+ k! y
22. 
    4 U  X$ [+ W! P) U$ j4 H
23. #define CAN2_CHANNEL              CAN2
    : g/ O1 s" v' h8 J8 H
24. #define CAN2_PREEMPT_PRIO         CAN2_RX_PRIORITY
    
25. #define CAN2_RX_IRQ               CAN2_RX0_IRQn
      R! g! K: T$ ^5 a6 m2 y
26. #define CAN2_RX_IRQ_FUNC          CAN2_RX0_IRQHandler
    , j* l1 B6 o# r7 n" R
27. #define CAN2_CLK_ENABLE()         __HAL_RCC_CAN2_CLK_ENABLE()
    ' [- B& f  }' N3 _; P
28. #define CAN2_TX_PORT              GPIOB
    
29. #define CAN2_TX_PIN               GPIO_PIN_6
    + @" a- P& f% S0 C5 Y
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)
    $ N9 c. ]5 T1 |" c" ~3 t8 I
32. #define CAN2_RX_PORT              GPIOB
    
33. #define CAN2_RX_PIN               GPIO_PIN_5
    
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设备结构体
   : P+ h) X6 `: T- Y
2. typedef struct
   
3. {
   
4.   CAN_HandleTypeDef handle; // CAN操作句柄
     O' n1 W% ^, }. A$ U3 O
5. 
   
6.   CanTxMsgTypeDef tx;       // CAN发送
   ; o0 U8 e/ K1 i0 h5 X* ?1 [+ C1 P
7. 
   
8.   CanRxMsgTypeDef rx;       // CAN接收
   , t6 h- c! B& I. v% i; ?( `4 p
9. 
   
10.   can_queue_t recv;         // 接收队列
    + q" F  w2 z6 k
11. 
    
12. } can_dev_t;

复制代码

1. // 将每路CAN封装成几个小函数
   % x' n( K* ?  m4 R% c7 F
2. static can_dev_t can1_dev, can2_dev;
   ! V' m3 M# w9 _: O
3. 
   3 \0 u  H. v1 a9 O* E- M
4. static void can1_var_init(void)
   - z" R9 @: W: L4 `, `5 O( s
5. {
   % ~9 O, g4 r; @- ^+ s9 I
6.   can1_dev.recv = can1_queue_recv;
   
7. 
   
8.   CanQueueInit(&can1_dev.recv);
   
9. }
   
10. 
    ! `4 Q7 X  E$ Y
11. static void can1_gpio_init(void)
    
12. {
    " V& \$ L$ h  C  f( A$ o3 L5 Z
13.   CAN1_TX_CONFIG();
    
14.   CAN1_RX_CONFIG();
    
15. }
    # ~5 |2 ^1 a4 p1 G4 r9 f
16. 
    
17. // 波特率 = Fpclk1 / ((ts1+ts2+3) * brp)  Fpclk1 = 54M
    $ C$ C1 U- g# f1 A" b
18. static void can1_mode_init(void)
      F& r+ y+ r' P3 ~; I4 r
19. {
    
20.   CAN1_CLK_ENABLE();
    3 \' `  Y( R" w" `. D2 `
21. 
    4 v- H( U8 r4 J7 j: S
22.   can1_dev.handle.Instance = CAN1_CHANNEL;
    
23.   can1_dev.handle.pTxMsg = &can1_dev.tx;
    9 ~8 m3 a8 L, _  q  k5 q8 T
24.   can1_dev.handle.pRxMsg = &can1_dev.rx;
    
25.   can1_dev.handle.Init.Prescaler = 6;
    " }& ^% P2 W* q, Z  [
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
    
28.   can1_dev.handle.Init.BS1 = CAN_BS1_11TQ;// tbs1范围CAN_BS1_1TQ~CAN_BS1_16TQ
    0 Y- ~  |2 T2 }2 A
29.   can1_dev.handle.Init.BS2 = CAN_BS2_6TQ; // tbs2范围CAN_BS2_1TQ~CAN_BS2_8TQ
    
30.   can1_dev.handle.Init.TTCM = DISABLE;    // 非时间触发通信模式
    
31.   can1_dev.handle.Init.ABOM = ENABLE;     // 软件自动离线管理
    9 p& f2 c$ x7 Y4 f. [" @% j% v
32.   can1_dev.handle.Init.AWUM = DISABLE;    // 睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    " r# b% N% l2 ]9 ^
33.   can1_dev.handle.Init.NART = ENABLE;     // 禁止报文自动传送
    
34.   can1_dev.handle.Init.RFLM = DISABLE;    // 报文不锁定,新的覆盖旧的
    ) |) X1 n3 `: [& x- W: ]! n/ a5 Q
35.   can1_dev.handle.Init.TXFP = DISABLE;    // 优先级由报文标识符决定
    8 f( S3 K# t  L* |
36.   HAL_CAN_Init(&can1_dev.handle);
    6 ~  w3 k$ y; y( @& o
37. }
    
38. 
    5 ~0 h# z! v$ S) c. l3 l
39. static void can1_filter_init(void)
    
40. {
    
41.   CAN_FilterConfTypeDef  filter;
    
42. 
    3 L) S7 x' B1 a
43.   filter.FilterNumber     = 0; // 过滤器0
    
44.   filter.FilterMode       = CAN_FILTERMODE_IDMASK;
    3 Y8 }) V! N6 p, _# I5 g3 P5 d& N+ H
45.   filter.FilterScale      = CAN_FILTERSCALE_32BIT;
    0 b' T0 R( f' [
46. 
    
47.   filter.FilterIdHigh     = 0;
    ! I  N1 y. m, L9 s+ e
48.   filter.FilterIdLow      = 0;
    
49.   filter.FilterMaskIdHigh = 0;
    
50.   filter.FilterMaskIdLow  = 0;
    
51. 
    
52.   filter.FilterFIFOAssignment = CAN_FILTER_FIFO0; // 过滤器0关联到FIFO0
    
53.   filter.FilterActivation = ENABLE; //激活滤波器0
    
54.   //filter.BankNumber=14;
    5 p8 F2 _  x  r
55. 
    
56.   HAL_CAN_ConfigFilter(&can1_dev.handle, &filter);
    
57. }
    , y& l; d# J$ G1 K# D1 N6 v
58. 
    ) R# z( l% a1 ]6 O* J; g  q
59. static void can1_nvic_init(void)
    
60. {
    
61.   __HAL_CAN_ENABLE_IT(&can1_dev.handle, CAN_IT_FMP0); //FIFO0消息挂号中断允许.
    : x5 n; E9 J$ e. ?; \% a
62.   HAL_NVIC_SetPriority(CAN1_RX_IRQ, CAN1_RX_PRIORITY, 0);
    9 s4 j) d+ h+ ^; B! r
63.   HAL_NVIC_EnableIRQ(CAN1_RX_IRQ);
    
64. }
    
65. 
    3 E# m; n1 z) v9 b1 R) p
66. 
    0 W' i+ N4 m1 ~. W
67. 
    
68. static void can2_var_init(void)
    
69. {
    3 z& {( ?4 ?9 |% l: {; L1 W
70.   can2_dev.recv = can2_queue_recv;
    , ]" r/ k* `, J% {# D% k
71. 
    2 g# p1 p) c( F, P7 {
72.   CanQueueInit(&can2_dev.recv);
    
73. }
    " a* S& y: E6 U; A6 Q. g
74. 
    
75. static void can2_gpio_init(void)
    
76. {
    " P5 k! P2 A: ^9 p; U# H! ]
77.   CAN2_TX_CONFIG();
    - ]) O- y! K- l, M" X" u0 r9 ?0 I
78.   CAN2_RX_CONFIG();
    ' F( `  E2 w7 J  [
79. }
    / I' k' H6 T; s2 A' e/ W$ ~9 |7 Q
80. 
    
81. // 波特率 = Fpclk1 / ((ts1+ts2+3) * brp)  Fpclk1 = 54M
    
82. static void can2_mode_init(void)
    
83. {
    3 X6 M/ W0 b$ f; ~, i
84.   CAN2_CLK_ENABLE();
    
85. 
    
86.   can2_dev.handle.Instance = CAN2_CHANNEL;
    - X' O$ s& X' Y: T0 U, j
87.   can2_dev.handle.Init.Prescaler = 6;
    
88.   can2_dev.handle.Init.Mode = CAN_MODE_LOOPBACK;
    2 @" w; g, H( N$ j  K, L
89.   can2_dev.handle.Init.SJW = CAN_SJW_1TQ; // 重新同步跳跃宽度(Tsjw)为tsjw+1个时间单位 CAN_SJW_1TQ~CAN_SJW_4TQ
    
90.   can2_dev.handle.Init.BS1 = CAN_BS1_11TQ;// tbs1范围CAN_BS1_1TQ~CAN_BS1_16TQ
      C  p- c2 f* \: H
91.   can2_dev.handle.Init.BS2 = CAN_BS2_6TQ; // tbs2范围CAN_BS2_1TQ~CAN_BS2_8TQ
    / X) B8 K" \; a0 O% u
92.   can2_dev.handle.Init.TTCM = DISABLE;    // 非时间触发通信模式
    
93.   can2_dev.handle.Init.ABOM = ENABLE;     // 软件自动离线管理
    - S' J( z$ p8 V. ^, O
94.   can2_dev.handle.Init.AWUM = DISABLE;    // 睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    / v5 U  C3 k  j# G$ c
95.   can2_dev.handle.Init.NART = ENABLE;     // 禁止报文自动传送
      `8 w; x5 ?  x5 \* c
96.   can2_dev.handle.Init.RFLM = DISABLE;    // 报文不锁定,新的覆盖旧的
      U1 I* |" Y- X& T! T) R
97.   can2_dev.handle.Init.TXFP = DISABLE;    // 优先级由报文标识符决定
    $ L6 l8 r* b5 l9 _, R9 \
98.   HAL_CAN_Init(&can2_dev.handle);
    
99. }
    
100. 
     
101. static void can2_filter_init(void)
     . Q4 H/ j, `* q5 ~3 L8 q) {
102. {
     
103.   CAN_FilterConfTypeDef  CAN_FilterInitStructure;
     . X' U# t' U6 D% p! E% M1 N
104. 
     
105.   CAN_FilterInitStructure.FilterNumber     = 14;
     5 i: F, p. T4 T& s3 Q% x
106.   CAN_FilterInitStructure.FilterMode       = CAN_FILTERMODE_IDMASK;
     
107.   CAN_FilterInitStructure.FilterScale      = CAN_FILTERSCALE_32BIT;
     " c9 o8 \% B2 z, u* s7 N& e
108. 
     
109.   CAN_FilterInitStructure.FilterIdHigh     = 0;
     
110.   CAN_FilterInitStructure.FilterIdLow      = 0;
     , R% t9 \3 \7 E
111.   CAN_FilterInitStructure.FilterMaskIdHigh = 0;
     $ `" l( r5 F/ ]# a) F8 p
112.   CAN_FilterInitStructure.FilterMaskIdLow  = 0;
     $ M( F# F6 t0 P( J
113. 
     
114.   CAN_FilterInitStructure.FilterFIFOAssignment = CAN_FILTER_FIFO0; // 过滤器0关联到FIFO0
     
115.   CAN_FilterInitStructure.FilterActivation = ENABLE; //激活滤波器0
     2 z1 H# n8 w* T
116.   //CAN_FilterInitStructure.BankNumber=14;
     8 s- n3 Z# Z9 A' X7 _
117. 
     , I$ `1 @" _% P
118.   HAL_CAN_ConfigFilter(&can2_dev.handle, &CAN_FilterInitStructure);
     
119. }
     - e, h! f( w) z4 `4 @2 J
120. 
     
121. static void can2_nvic_init(void)
     " E7 t$ I. e1 e5 J
122. {
     ) n1 W$ m+ z( T3 K) P/ s2 N" K
123.   __HAL_CAN_ENABLE_IT(&can2_dev.handle, CAN_IT_FMP0); //FIFO0消息挂号中断允许1
     
124.   HAL_NVIC_SetPriority(CAN2_RX_IRQ, CAN2_RX_PRIORITY, 0);
     3 u- c; ^' N$ P8 ]( P' `2 Q5 m
125.   HAL_NVIC_EnableIRQ(CAN2_RX_IRQ);
     
126. }

复制代码

1. // 每路CAN都有的几个操作，使用列表包含，然后统一扫描处理
   
2. typedef struct
   ) a9 O5 r4 |' O% n% n' u( o
3. {
   
4.   uint8_t channel;
   & v4 k' M; y. f( V- j( g
5.   can_dev_t *dev;
   
6.   void (* var_init_cb)(void);
   
7.   void (* gpio_init_cb)(void);
   
8.   void (* mode_init_cb)(void);
   
9.   void (* filter_init_cb)(void);
   
10.   void (* nvic_init_cb)(void);
    ; m1 x* ?( N. g) K/ g! y
11. } can_config_t;
    
12. 
    7 z& h- i4 l& N, Q3 e
13. static const can_config_t can_configs[] =
    0 R( T9 x# \: n2 `5 Q2 ^
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. };
    9 X4 c# x' o" t5 U1 T0 d" P
18. 
    / H% O6 C! [/ B' }1 F
19. static can_dev_t *can_dev_get(uint8_t channel)
    5 N6 v% f" k* _! I$ _2 l$ l
20. {
    
21.   uint8_t i;
    ' S  o5 P1 ?, E* m$ ?
22. 
    
23.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    3 q+ P+ ?+ N" I+ H
24.   {
    8 e, O9 W) T5 q0 t- l
25.     if(channel == can_configs<i>.channel)
    . G  Y( Q0 i& q
26.     {
    
27.       return can_configs<i>.dev;
    
28.     }
    2 d) u5 d4 f- |' L- P3 |
29.   }
    
30. 
    
31.   return 0;
    0 e  a7 a# e, y. n6 C
32. }
    
33. 
      K5 G/ s, G6 ]  q2 y" v
34. static void can_var_init(uint8_t channel)
    ' k/ _' ~6 z. z: \) i5 w" P2 q
35. {
    
36.   uint8_t i;
    3 g# [" G7 i  m0 [
37. 
    5 h% D5 Z, l  B3 l( w2 V) O, S2 m
38.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    
39.   {
    
40.     if(channel == can_configs<i>.channel)
    
41.     {
      F; a3 m0 R2 D/ x
42.       can_configs<i>.var_init_cb();
    ' m; y- C* t8 B- Q" F5 L+ \& S! v
43.       return;
    
44.     }
    
45.   }
    
46. }
    % f, L' l" F2 X8 y1 [5 W
47. 
    
48. static void can_gpio_init(uint8_t channel)
    . \+ R. V# y6 m( P
49. {
    
50.   uint8_t i;
    
51. 
    
52.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    ( t; k+ m0 B, O$ _$ L. o, Y3 y! i+ v
53.   {
    
54.     if(channel == can_configs<i>.channel)
    
55.     {
    5 N4 l/ K" {. _& |) Z! P( E7 U
56.       can_configs<i>.gpio_init_cb();
      L& I3 l6 E/ t4 O0 W
57.       return;
    
58.     }
    * N: i% K3 |( }
59.   }
    , N7 z* {1 v) I; W* W! J
60. }
    
61. 
    
62. static void can_mode_init(uint8_t channel)
    . n# g4 ^/ o! q" R5 e
63. {
    
64.   uint8_t i;
    ( h1 q" Q; y1 n" I+ j, t
65. 
    
66.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    8 |2 i& h1 p) P) F! t, Y
67.   {
    
68.     if(channel == can_configs<i>.channel)
    
69.     {
    " m3 @! Q' k/ Z7 Q! @; O% `" l
70.       can_configs<i>.mode_init_cb();
    
71.       return;
    
72.     }
    
73.   }
    ) a0 M) E4 t0 n8 R7 V% h' }0 _
74. }
    
75. 
    8 i8 h# L5 a7 C* X
76. static void can_filter_init(uint8_t channel)
    $ |+ v; p, z, b
77. {
    
78.   uint8_t i;
    
79. 
    - ?% K- X8 O( [4 Z* Q4 A6 h% R7 O, n
80.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    
81.   {
    0 e$ k  g( F0 Z( R
82.     if(channel == can_configs<i>.channel)
    
83.     {
    . v5 E+ V* h. F& t
84.       can_configs<i>.filter_init_cb();
    
85.       return;
    
86.     }
    * a# D9 D1 M' p. b
87.   }
    
88. }
    * x7 x3 f& y& e
89. 
    - Y3 u' r6 U3 [9 L# O
90. static void can_nvic_init(uint8_t channel)
    
91. {
    . j0 C6 b$ f- e* V4 Z
92.   uint8_t i;
    
93. 
    ; C/ K( ~6 J7 [. t: ?' B
94.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    5 H- A0 I$ b* M
95.   {
    $ B) y( I& `) j; r. f( M
96.     if(channel == can_configs<i>.channel)
    
97.     {
    
98.       can_configs<i>.nvic_init_cb();
    
99.       return;
    
100.     }
     
101.   }
     * I" d  t# }7 Z8 W3 w2 f) y
102. }</i></i></i></i></i></i></i></i></i></i></i></i>

复制代码

1. // 对外的接口 初始化 发送和接收
   ; n+ b/ g- o9 x9 b7 F/ E
2. void CanInit(uint8_t channel)
   ! u2 j" v; J* v, [
3. {
   
4.   can_var_init(channel);
   " P/ r' C8 Z5 w& l% z& L8 T
5.   can_gpio_init(channel);
   
6.   can_mode_init(channel);
   
7.   can_filter_init(channel);
   
8.   can_nvic_init(channel);
   
9. }
   
10. 
    
11. void CanSend(uint8_t channel, can_frame_t *frame)
    9 P; x- K) C4 c3 i& C0 @; ~9 a
12. {
    / U1 z. I( Y# ~
13.   can_dev_t *dev = can_dev_get(channel);
    
14. 
    
15.   if(dev == 0)
    
16.   {
    
17.     return;
    
18.   }
    
19. 
    " `* `3 i4 H$ D, W
20.   dev->handle.pTxMsg->StdId = frame->StdId;
    " l0 Q" l* o5 y. ?9 U
21.   dev->handle.pTxMsg->IDE   = frame->IDE;
    : [; B, C( T2 _( D2 a4 y
22.   dev->handle.pTxMsg->RTR   = frame->RTR;
    , M( T8 F6 a+ G% o
23.   dev->handle.pTxMsg->DLC   = frame->DLC;
    
24.   memcpy(dev->handle.pTxMsg->Data, frame->Data, frame->DLC);
    , w  n+ k# s7 R" m/ w
25. 
    " V# ~' u/ f% `! S( s. n8 y$ o
26.   HAL_CAN_Transmit(&dev->handle, 10);
    % x4 |$ j7 o4 w6 G" F4 P
27. }
    
28. 
    
29. uint8_t CanRecv(uint8_t channel, can_frame_t *frame)
    
30. {
    & ?3 M! u& ]+ v+ }
31.   can_dev_t *dev = can_dev_get(channel);
    ! K6 Y" |: D( c4 n
32. 
    
33.   if(dev == 0)
    9 _) N/ ?4 U3 Y
34.   {
    ' y0 B/ }- g& z0 i5 H
35.     return 0;
    
36.   }
    
37. 
    3 ^/ s$ m5 _$ h. h
38.   return CanQueueRead(&can1_dev.recv, frame);
    
39. }

复制代码

1. // CAN中断
   
2. void CAN1_RX_IRQ_FUNC(void)
   " M' r. g# @% m9 |5 ?' `* Q
3. {
   
4.   HAL_CAN_IRQHandler(&can1_dev.handle);
   
5. }
   
6. 
     }: X& ~. s* [, B
7. void CAN2_RX_IRQ_FUNC(void)
   
8. {
   8 C$ m; K4 F# X* f1 I& a
9.   HAL_CAN_IRQHandler(&can2_dev.handle);
   
10. }
    
11. 
    
12. void HAL_CAN_RxCpltCallback(CAN_HandleTypeDef *hcan)
    
13. {
    
14.   if(hcan == (&can1_dev.handle))
    
15.   {
    
16.     //CAN_Receive_IT()函数会关闭FIFO0消息挂号中断，因此我们需要重新打开
    
17.     __HAL_CAN_ENABLE_IT(&can1_dev.handle, CAN_IT_FMP0);//重新开启FIF00消息挂号中断
    6 \# H$ C4 @5 k; j7 ~# c
18.     CanQueueWrite(&can1_dev.recv, can1_dev.handle.pRxMsg);
    
19.   }
    
20.   else if(hcan == (&can2_dev.handle))
    
21.   {
    
22.     //CAN_Receive_IT()函数会关闭FIFO0消息挂号中断，因此我们需要重新打开
    
23.     __HAL_CAN_ENABLE_IT(&can2_dev.handle, CAN_IT_FMP0);//重新开启FIF00消息挂号中断
    
24.     CanQueueWrite(&can2_dev.recv, can2_dev.handle.pRxMsg);
    
25.   }
    - W$ s5 v# M/ {. I7 }
26. }

复制代码

) R& r- l( H- l; F) D        之所以使用列表的形式，是为了方便增加和删除CAN通道和使对外的接口更统一，不会出现CAN1Init() CAN2Init()，个人习惯问题。
. @+ ~/ v  h8 w# m" Z

; v  x0 l; x! Z7 @  u- Z) f+ n2 f
5 p  Z: M" v  O/ w! v8 S& B; s, B
! N' I4 b+ j. G+ v, t% b