一、CAN基础
( [0 N0 e% {" P: }: V差分信号：显性电平对应逻辑0，CAN_H和CAN_L差为2.5V；隐形电平对应逻辑1，CAN_H和CAN_L差为0V。
* D; @, Q; @, B/ @1 U$ G
CAN总线的开始和结束都有一个120Ω的终端电阻。
  }/ `& G+ C9 ?+ H& H
数据帧：标准帧11位，  扩展帧29位。
- I# p0 @" s' G# L; W: i: n
其他的一些理论知识就不再赘述了，可以参考维基百科对于CAN的描述。
% K; x0 M0 a, c
STM32F7xx的bxCAN主要特点：支持CAN2.0A和CAN2.0B，波特率高达1Mbps，支持时间触发，具有3个发送邮箱，2个接收邮箱，可变的过滤器组等。
# [( B) F' q( I. A6 D1 e9 g
二、几个重要的CAN函数

1. HAL_StatusTypeDef HAL_CAN_Init(CAN_HandleTypeDef* hcan); // CAN初始化
   8 f8 R( K6 c/ Q
2. 
   2 q1 d1 V3 |7 `/ p6 r
3. HAL_StatusTypeDef HAL_CAN_Transmit(CAN_HandleTypeDef *hcan, uint32_t Timeout); // CAN发送
   
4. 
   
5. HAL_StatusTypeDef HAL_CAN_Receive(CAN_HandleTypeDef *hcan, uint8_t FIFONumber, uint32_t Timeout); // CAN接收

复制代码

! J9 q" p, @" `! C三、几个重要的结构

1. // CAN操作句柄 包含CAN基地址（CAN1/CAN2/CAN3） 初始化结构 发送接收结构体 其余三个是过程变量
   
2. typedef struct
   
3. {
   * ?7 P8 f; A- ?* R: A
4.   CAN_TypeDef                 *Instance;  /*!< Register base address          */
   
5. 
   1 Q2 r7 ?6 U0 j2 j7 x
6.   CAN_InitTypeDef             Init;       /*!< CAN required parameters        */
   
7. 
   
8.   CanTxMsgTypeDef*            pTxMsg;     /*!< Pointer to transmit structure  */
   
9. 
   1 V# a/ _* i% p& L9 ]1 X
10.   CanRxMsgTypeDef*            pRxMsg;     /*!< Pointer to reception structure */
    
11. 
    8 P' x. x7 m+ T; a- f* Y/ m! v6 w
12.   __IO HAL_CAN_StateTypeDef   State;      /*!< CAN communication state        */
    
13. 
      g) V, p' ]$ U: S8 {- G2 D
14.   HAL_LockTypeDef             Lock;       /*!< CAN locking object             */
    
15. 
    
16.   __IO uint32_t               ErrorCode;  /*!< CAN Error code                 */
    
17. 
    
18. }CAN_HandleTypeDef;

复制代码

1. // CAN配置结构体
   5 H" }, ]: Q+ c; \5 o
2. // 前5个参数来设置 CAN_BTR —— 波特率
   # v6 L1 Y4 `# V5 ]  W$ V% u/ ]
3. // 后6个参数用来设置 CAN_MCR —— 通信相关的控制位
   , I  c( n; w! [- l' ?8 R
4. typedef struct
   
5. {
   # _( y  i; q8 ]( U* U8 Q
6.   uint32_t Prescaler;  /*!< Specifies the length of a time quantum.
   
7.                             This parameter must be a number between Min_Data = 1 and Max_Data = 1024 */
   6 L# {) K/ O4 w7 l& A
8. 
   
9.   uint32_t Mode;       /*!< Specifies the CAN operating mode.
   
10.                             This parameter can be a value of @ref CAN_operating_mode */
    ! B6 R: Y3 S, q) l; ]4 z$ ?
11. 
    
12.   uint32_t SJW;        /*!< Specifies the maximum number of time quanta
    
13.                             the CAN hardware is allowed to lengthen or
    
14.                             shorten a bit to perform resynchronization.
    
15.                             This parameter can be a value of @ref CAN_synchronisation_jump_width */
    " M) O8 P1 F# O3 B: 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 */
    5 U0 l2 V7 H: w" |% x( X
19. 
    . m% ^" |$ I3 k" k
20.   uint32_t BS2;        /*!< Specifies the number of time quanta in Bit Segment 2.
    5 }2 C6 R! S9 c: t" Q4 a
21.                             This parameter can be a value of @ref CAN_time_quantum_in_bit_segment_2 */
    # ^- _+ ?* _( U0 `0 G, d  V6 e
22. 
    
23.   uint32_t TTCM;       /*!< Enable or disable the time triggered communication mode.
    
24.                             This parameter can be set to ENABLE or DISABLE. */
    
25. 
    & f: ^0 {* k% M4 c) h: @
26.   uint32_t ABOM;       /*!< Enable or disable the automatic bus-off management.
    & _3 p3 p2 W# F3 T
27.                             This parameter can be set to ENABLE or DISABLE */
    
28. 
    
29.   uint32_t AWUM;       /*!< Enable or disable the automatic wake-up mode.
    5 @1 `5 J) P7 l; V1 ^  B; R
30.                             This parameter can be set to ENABLE or DISABLE */
    9 L: E3 f' ]1 P- `
31. 
    
32.   uint32_t NART;       /*!< Enable or disable the non-automatic retransmission mode.
    
33.                             This parameter can be set to ENABLE or DISABLE */
    
34. 
    ! F5 F+ J. W; f* D* l
35.   uint32_t RFLM;       /*!< Enable or disable the receive FIFO Locked mode.
    $ l; m+ C, a, i* B2 F! ^) H
36.                             This parameter can be set to ENABLE or DISABLE */
    
37. 
    ' f: n! A8 r! F' |6 m$ D
38.   uint32_t TXFP;       /*!< Enable or disable the transmit FIFO priority.
    
39.                             This parameter can be set to ENABLE or DISABLE */
    
40. }CAN_InitTypeDef;

复制代码

1. // 过滤器设置
   
2. typedef struct
   # Q. s# K5 v- H0 O/ b
3. {
   
4.   uint32_t FilterIdHigh;          /*!< Specifies the filter identification number (MSBs for a 32-bit
   1 P0 W! _6 }) j) K
5.                                        configuration, first one for a 16-bit configuration).
   
6.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
   6 m$ T4 m0 W9 B& {7 I, V$ |
7. 
   
8.   uint32_t FilterIdLow;           /*!< Specifies the filter identification number (LSBs for a 32-bit
   
9.                                        configuration, second one for a 16-bit configuration).
   / Y$ \) Y* w; n, j) d8 r' `. E1 O
10.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
    ' U( `7 Y2 n4 s' ?5 _
11. 
    
12.   uint32_t FilterMaskIdHigh;      /*!< Specifies the filter mask number or identification number,
    
13.                                        according to the mode (MSBs for a 32-bit configuration,
    * U+ x6 g: P7 T) ]' Z' r
14.                                        first one for a 16-bit configuration).
    
15.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
    3 I* ~" I; r- p/ R9 j/ m9 G
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).
    ) E- x) y5 n# x
20.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
    
21. 
    3 {+ I6 {( f3 A9 L' J6 }; z
22.   uint32_t FilterFIFOAssignment;  /*!< Specifies the FIFO (0 or 1) which will be assigned to the filter.
    % I' J" Q1 D9 I4 x! [5 Z" i0 k7 K
23.                                        This parameter can be a value of @ref CAN_filter_FIFO */
    + _8 N; f- Z" E% y. }7 _& j$ K6 k: n$ o. S
24. 
    
25.   uint32_t FilterNumber;          /*!< Specifies the filter which will be initialized.
    / m% n$ V/ x- B+ i7 [
26.                                        This parameter must be a number between Min_Data = 0 and Max_Data = 27 */
    
27. 
    
28.   uint32_t FilterMode;            /*!< Specifies the filter mode to be initialized.
    ( \" e+ L! k. U
29.                                        This parameter can be a value of @ref CAN_filter_mode */
    7 q% g% R. f( S) R" G8 q
30. 
    
31.   uint32_t FilterScale;           /*!< Specifies the filter scale.
    
32.                                        This parameter can be a value of @ref CAN_filter_scale */
    
33. 
    6 O& _+ O2 G( v; P4 P
34.   uint32_t FilterActivation;      /*!< Enable or disable the filter.
    
35.                                        This parameter can be set to ENABLE or DISABLE. */
    - t& k3 Y5 w- T; I! v  k
36. 
    * C+ ~4 V% L- _4 f; |
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 */
    9 ~3 C' T& k2 l8 ?0 O
39. 
    
40. }CAN_FilterConfTypeDef;

复制代码

1. // 模式  我们使用普通模式
   
2. #define CAN_MODE_NORMAL             ((uint32_t)0x00000000U)                     /*!< Normal mode   */
   
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. // 标准帧 扩展帧
   & h9 r0 N& q2 v% _7 h
2. #define CAN_ID_STD             ((uint32_t)0x00000000U)  /*!< Standard Id */
   
3. #define CAN_ID_EXT             ((uint32_t)0x00000004U)  /*!< Extended Id */

复制代码

1. // 数据帧 远程帧
   & x; A7 ^5 [, F( r! z4 K
2. #define CAN_RTR_DATA                ((uint32_t)0x00000000U)  /*!< Data frame */
   
3. #define CAN_RTR_REMOTE              ((uint32_t)0x00000002U)  /*!< Remote frame */

复制代码

1. // CAN中断使能
   + K. M$ F! g0 q7 o0 d' u0 A
2. __HAL_CAN_ENABLE_IT(__HANDLE__, __INTERRUPT__)

复制代码

1. // 接收中断
   - `' W4 b/ g; [! B2 W
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         */
   3 G* s/ P2 [1 f; B: ~' F
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            */
   $ ^$ l* V+ ~( z" |
7. #define CAN_IT_FOV1                 ((uint32_t)CAN_IER_FOVIE1)  /*!< FIFO 1 overrun interrupt         */

复制代码

1 F- a+ r- I; B四、接口设计
8 Z# g; J! `) o  N3 ^- f( C) ]与串口类似，使用中断接收。先封装单路CAN需要的几个小接口，再顶一个列表，最后使用统一的接口扫描这个列表。
# u% h% b9 x9 E- X
4 l* ~# T, @! l5 W

1. typedef enum
   ( e' O2 s- Q8 f" P( I8 j2 @
2. {
   : P6 P) m( [. X1 @( [% J' d  x  W
3.   CAN_CHANNEL_NONE,
     [5 ?" j2 h) @
4.   CAN_CHANNEL_1,
   
5.   CAN_CHANNEL_2,
   
6.   CAN_CHANNEL_NUM
   
7. } can_channel_t;
   
8. 
   # m# P; f9 L# c" ^
9. #define CAN1_CHANNEL              CAN1
   
10. #define CAN1_PREEMPT_PRIO         CAN1_RX_PRIORITY
    ' w" ]7 u/ b7 Q* a6 w. i9 Y7 Y
11. #define CAN1_RX_IRQ               CAN1_RX0_IRQn
    ; ~/ }# ^! e0 |3 {5 d; V% L) O
12. #define CAN1_RX_IRQ_FUNC          CAN1_RX0_IRQHandler
      h# q) x2 V! S4 J
13. #define CAN1_CLK_ENABLE()         __HAL_RCC_CAN1_CLK_ENABLE()
    : c" s$ D6 o% a* b, g
14. #define CAN1_TX_PORT              GPIOA
    . L. R( D0 }+ ?( s
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)
    3 `; C2 o1 D1 ~  o7 b7 j; s9 q
18. #define CAN1_RX_PORT              GPIOA
    4 t$ y6 u' n% i* ~
19. #define CAN1_RX_PIN               GPIO_PIN_11
    . n/ h( {' V: D5 z! A
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)
    
22. 
    6 @/ k7 Z, u3 y
23. #define CAN2_CHANNEL              CAN2
    
24. #define CAN2_PREEMPT_PRIO         CAN2_RX_PRIORITY
    
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()
    6 V2 G, Z4 }( t+ ?
28. #define CAN2_TX_PORT              GPIOB
    0 g4 d. g6 V: H- c9 x7 a
29. #define CAN2_TX_PIN               GPIO_PIN_6
    
30. #define CAN2_TX_AF                GPIO_AF9_CAN2
    ) T, E% R/ c! \
31. #define CAN2_TX_CONFIG()          GPIOConfigExt(CAN2_TX_PORT, CAN2_TX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, CAN2_TX_AF)
    1 E. x2 o3 j8 L( c) J+ I8 e
32. #define CAN2_RX_PORT              GPIOB
    
33. #define CAN2_RX_PIN               GPIO_PIN_5
    4 Q! o  A8 _* V& X6 m
34. #define CAN2_RX_AF                GPIO_AF9_CAN2
    2 U" B5 S; r* M/ o
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设备结构体
   
2. typedef struct
   " T4 o) \' a6 t- F$ o" T% [0 b6 A
3. {
   : d8 P! G. ?9 l7 q1 M/ T4 q
4.   CAN_HandleTypeDef handle; // CAN操作句柄
   
5. 
   
6.   CanTxMsgTypeDef tx;       // CAN发送
   
7. 
   
8.   CanRxMsgTypeDef rx;       // CAN接收
   " E' Z' j0 o/ v! L3 ?
9. 
   : z. l5 }' Q0 V6 B# v& }' w
10.   can_queue_t recv;         // 接收队列
    
11. 
    ( o4 C# [/ C$ `7 U- c7 s, f3 y; j
12. } can_dev_t;

复制代码

1. // 将每路CAN封装成几个小函数
   
2. static can_dev_t can1_dev, can2_dev;
   
3. 
   0 G: X4 b7 w! P1 w- X: `, A9 P
4. static void can1_var_init(void)
   
5. {
   
6.   can1_dev.recv = can1_queue_recv;
   
7. 
   ) m* Y" C  P  ^# m) ]
8.   CanQueueInit(&can1_dev.recv);
   
9. }
   ) B' w' E6 A+ T/ c  Z8 |3 Y7 Z
10. 
    * V- T' g/ o% A/ X" q2 E% z% W
11. static void can1_gpio_init(void)
    
12. {
    
13.   CAN1_TX_CONFIG();
    
14.   CAN1_RX_CONFIG();
    9 G: x6 l/ w* Z! K. h
15. }
    
16. 
    8 H, `" x0 O1 v( f' I
17. // 波特率 = Fpclk1 / ((ts1+ts2+3) * brp)  Fpclk1 = 54M
    
18. static void can1_mode_init(void)
    6 ]9 F7 g2 w& F, s5 z9 H
19. {
    
20.   CAN1_CLK_ENABLE();
    4 [3 G. T: p3 U6 t0 x/ s1 |& ?
21. 
    
22.   can1_dev.handle.Instance = CAN1_CHANNEL;
    1 ?. K2 F9 K! ?8 L. ^9 {( c% ?+ {$ M
23.   can1_dev.handle.pTxMsg = &can1_dev.tx;
    8 j# \  B9 ^. U) A* ^' Q* M" \
24.   can1_dev.handle.pRxMsg = &can1_dev.rx;
    ' h; J' X% W3 e0 ]3 i' @
25.   can1_dev.handle.Init.Prescaler = 6;
    
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
    , z& [. |" c4 F( J4 z0 \: S$ e
29.   can1_dev.handle.Init.BS2 = CAN_BS2_6TQ; // tbs2范围CAN_BS2_1TQ~CAN_BS2_8TQ
    
30.   can1_dev.handle.Init.TTCM = DISABLE;    // 非时间触发通信模式
    2 r; A% M. _6 I3 x* o
31.   can1_dev.handle.Init.ABOM = ENABLE;     // 软件自动离线管理
    8 F. v0 d# S. K; u
32.   can1_dev.handle.Init.AWUM = DISABLE;    // 睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    
33.   can1_dev.handle.Init.NART = ENABLE;     // 禁止报文自动传送
    * i7 _- r6 {3 ?1 Y: }" ?5 e1 _6 E
34.   can1_dev.handle.Init.RFLM = DISABLE;    // 报文不锁定,新的覆盖旧的
    ! M  _7 c3 a. Y8 n/ F/ Z
35.   can1_dev.handle.Init.TXFP = DISABLE;    // 优先级由报文标识符决定
    ( F) M. A/ B6 k8 L5 C& T% e6 q
36.   HAL_CAN_Init(&can1_dev.handle);
    
37. }
      `" t. C# n7 Z7 d  |4 E: d
38. 
    , e6 J+ c8 q% K% b
39. static void can1_filter_init(void)
    0 v" A; W* J- b, Y) Y( ]8 v0 k* W
40. {
    
41.   CAN_FilterConfTypeDef  filter;
    
42. 
    
43.   filter.FilterNumber     = 0; // 过滤器0
    
44.   filter.FilterMode       = CAN_FILTERMODE_IDMASK;
    / D2 {) K2 [5 M5 F5 q) ]2 r+ h% O
45.   filter.FilterScale      = CAN_FILTERSCALE_32BIT;
    / S+ \7 H. Q1 Y4 c& I
46. 
    / W( p4 d9 W* x% S: m; T  W
47.   filter.FilterIdHigh     = 0;
    
48.   filter.FilterIdLow      = 0;
    
49.   filter.FilterMaskIdHigh = 0;
    8 i$ ~: O% d. y1 n
50.   filter.FilterMaskIdLow  = 0;
    $ h# E& {7 Q6 z2 v! C: Y9 Y
51. 
    : E* E% W0 L" _( w/ U8 B
52.   filter.FilterFIFOAssignment = CAN_FILTER_FIFO0; // 过滤器0关联到FIFO0
    ! g; O7 q' V: b- T
53.   filter.FilterActivation = ENABLE; //激活滤波器0
    
54.   //filter.BankNumber=14;
    
55. 
    
56.   HAL_CAN_ConfigFilter(&can1_dev.handle, &filter);
    0 `5 q0 p+ i- G. v
57. }
    : R7 ]. {2 ?% m1 E% q' y
58. 
    
59. static void can1_nvic_init(void)
    & o& \) W- w2 T: f9 C- _
60. {
    ; V8 L% w' y$ ], ^! W
61.   __HAL_CAN_ENABLE_IT(&can1_dev.handle, CAN_IT_FMP0); //FIFO0消息挂号中断允许.
    ( M8 m* t0 |9 H; |1 f
62.   HAL_NVIC_SetPriority(CAN1_RX_IRQ, CAN1_RX_PRIORITY, 0);
    4 Z1 [9 ?* r* B0 L' x7 g
63.   HAL_NVIC_EnableIRQ(CAN1_RX_IRQ);
    
64. }
    ; t4 f9 }& s+ G# n; _
65. 
    / i! Q& L: {! u( C6 Q
66. 
    
67. 
    
68. static void can2_var_init(void)
    0 v7 U' O  d) n8 \; Z
69. {
    
70.   can2_dev.recv = can2_queue_recv;
    
71. 
    
72.   CanQueueInit(&can2_dev.recv);
    
73. }
    
74. 
    . J6 s; S) h- N' a: H
75. static void can2_gpio_init(void)
    
76. {
    
77.   CAN2_TX_CONFIG();
    
78.   CAN2_RX_CONFIG();
    
79. }
    
80. 
    
81. // 波特率 = Fpclk1 / ((ts1+ts2+3) * brp)  Fpclk1 = 54M
    
82. static void can2_mode_init(void)
    
83. {
    # z* D& ~( \+ x7 S( ^: r8 q
84.   CAN2_CLK_ENABLE();
    8 ~/ o8 _/ z# C3 L, P8 |; ?6 K
85. 
    
86.   can2_dev.handle.Instance = CAN2_CHANNEL;
    8 B: C$ Z* U5 K" b# D
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
    9 q/ P* y) e+ y. y5 B  M! _
90.   can2_dev.handle.Init.BS1 = CAN_BS1_11TQ;// tbs1范围CAN_BS1_1TQ~CAN_BS1_16TQ
      R( }+ ]8 q5 P3 I
91.   can2_dev.handle.Init.BS2 = CAN_BS2_6TQ; // tbs2范围CAN_BS2_1TQ~CAN_BS2_8TQ
    
92.   can2_dev.handle.Init.TTCM = DISABLE;    // 非时间触发通信模式
    
93.   can2_dev.handle.Init.ABOM = ENABLE;     // 软件自动离线管理
    
94.   can2_dev.handle.Init.AWUM = DISABLE;    // 睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    
95.   can2_dev.handle.Init.NART = ENABLE;     // 禁止报文自动传送
    4 K/ l$ m# O: }9 V" i. a
96.   can2_dev.handle.Init.RFLM = DISABLE;    // 报文不锁定,新的覆盖旧的
    7 \7 q4 K! Y: Z: `( X  H0 g
97.   can2_dev.handle.Init.TXFP = DISABLE;    // 优先级由报文标识符决定
    
98.   HAL_CAN_Init(&can2_dev.handle);
    % |. O% D; [- p' V. U/ |# h7 ], e
99. }
    , _% U  z$ P+ A0 ?( F/ ~
100. 
     + [/ ?; q& K( X0 v! o0 T9 p4 H
101. static void can2_filter_init(void)
     
102. {
     
103.   CAN_FilterConfTypeDef  CAN_FilterInitStructure;
     & F1 T7 \8 _$ a0 v1 k( y; W1 u/ \4 K; v
104. 
     % E2 o5 ~5 g6 g
105.   CAN_FilterInitStructure.FilterNumber     = 14;
     
106.   CAN_FilterInitStructure.FilterMode       = CAN_FILTERMODE_IDMASK;
     
107.   CAN_FilterInitStructure.FilterScale      = CAN_FILTERSCALE_32BIT;
     ; e* P3 k2 K# [% E! I
108. 
     7 y' g3 `4 ^) l9 h
109.   CAN_FilterInitStructure.FilterIdHigh     = 0;
     3 V! n' t6 z: E+ b7 e, `
110.   CAN_FilterInitStructure.FilterIdLow      = 0;
     4 i+ A& E& m2 M7 S
111.   CAN_FilterInitStructure.FilterMaskIdHigh = 0;
     3 N4 p9 v9 F4 b5 c2 T5 h) V, |
112.   CAN_FilterInitStructure.FilterMaskIdLow  = 0;
     8 v1 Y4 ?, X, P( l( d6 Y
113. 
     
114.   CAN_FilterInitStructure.FilterFIFOAssignment = CAN_FILTER_FIFO0; // 过滤器0关联到FIFO0
     
115.   CAN_FilterInitStructure.FilterActivation = ENABLE; //激活滤波器0
     ) A( {0 `6 j$ `" m/ ^  }
116.   //CAN_FilterInitStructure.BankNumber=14;
     $ t+ W( w6 Y& r. p( l/ m
117. 
     # |; ~% e- W8 l
118.   HAL_CAN_ConfigFilter(&can2_dev.handle, &CAN_FilterInitStructure);
     
119. }
     
120. 
     ) H$ Z( J6 G2 N
121. static void can2_nvic_init(void)
     
122. {
     " \9 x) P: ^1 y, O
123.   __HAL_CAN_ENABLE_IT(&can2_dev.handle, CAN_IT_FMP0); //FIFO0消息挂号中断允许1
     5 o3 X7 f) Q2 _2 c) h+ N* N
124.   HAL_NVIC_SetPriority(CAN2_RX_IRQ, CAN2_RX_PRIORITY, 0);
     
125.   HAL_NVIC_EnableIRQ(CAN2_RX_IRQ);
     2 E( ~5 O( K7 D2 ?0 t, k, T
126. }

复制代码

1. // 每路CAN都有的几个操作，使用列表包含，然后统一扫描处理
   
2. typedef struct
   
3. {
   ' _- n4 k* L+ p- @
4.   uint8_t channel;
   
5.   can_dev_t *dev;
   
6.   void (* var_init_cb)(void);
   
7.   void (* gpio_init_cb)(void);
   # E, h. o" }. t) l, L& y5 z% u9 K& F
8.   void (* mode_init_cb)(void);
   
9.   void (* filter_init_cb)(void);
   
10.   void (* nvic_init_cb)(void);
    . _, L! l( y) D; c9 A( o
11. } can_config_t;
    0 t; I4 O3 G2 d
12. 
    
13. static const can_config_t can_configs[] =
    
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},
    # C) J. [7 {6 Z# L% v
17. };
    
18. 
    
19. static can_dev_t *can_dev_get(uint8_t channel)
    5 G8 L# a* D# i
20. {
    9 G  r' N6 s& R: P* \' `# ]: v
21.   uint8_t i;
    
22. 
    
23.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    
24.   {
    
25.     if(channel == can_configs<i>.channel)
    2 R: |% |! e& F
26.     {
    
27.       return can_configs<i>.dev;
    
28.     }
    0 p4 m* G- t1 Y( t3 G* B
29.   }
    0 V- m2 _) C5 i6 Z- c* |, J2 e8 M
30. 
    
31.   return 0;
    % v6 H: s) |, {. a( i0 d1 o' s
32. }
    
33. 
    
34. static void can_var_init(uint8_t channel)
    
35. {
    ' n9 }. s' z* s' U7 s
36.   uint8_t i;
    5 s' b, K; P5 N9 N& k
37. 
    
38.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    
39.   {
    
40.     if(channel == can_configs<i>.channel)
    
41.     {
    
42.       can_configs<i>.var_init_cb();
    - @6 j1 N0 \; A
43.       return;
    ( G1 ?! y) l- \1 z& v
44.     }
    7 p6 ^# E: ^7 z& S
45.   }
    / u9 j- N: |7 i4 Z4 o4 U$ ?) h4 S
46. }
    
47. 
    
48. static void can_gpio_init(uint8_t channel)
    
49. {
    
50.   uint8_t i;
    
51. 
    ; i4 |$ y. L. Y
52.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    
53.   {
    . `% r, O$ V; B1 u0 S$ d* B
54.     if(channel == can_configs<i>.channel)
    2 X7 z# H' P5 a* w3 _: n8 E) s
55.     {
    7 e  w" w/ m* E- C5 O
56.       can_configs<i>.gpio_init_cb();
    
57.       return;
    : N* {: z: k( i  V. t2 A+ }3 u
58.     }
    
59.   }
    4 Y- Y# K% G: s
60. }
    
61. 
    . s/ C$ D0 t( e: R
62. static void can_mode_init(uint8_t channel)
    
63. {
    
64.   uint8_t i;
    % T# c0 I6 [; Z1 W. o( i
65. 
    ' j  i9 {+ k6 A* o
66.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    8 Z5 D  ^* e+ P8 |% q
67.   {
    
68.     if(channel == can_configs<i>.channel)
    
69.     {
    / H2 U+ I4 G: @9 k7 K
70.       can_configs<i>.mode_init_cb();
    $ H9 C3 W& @; v5 v8 g  N
71.       return;
    
72.     }
    
73.   }
    
74. }
    , d0 P8 f# n( Y1 K9 @& b7 k
75. 
    4 q6 P) W( ?# h' p( R
76. static void can_filter_init(uint8_t channel)
    
77. {
    
78.   uint8_t i;
    # m2 o1 c4 }  r5 _6 z9 w
79. 
    4 T" j) P3 o1 k/ ^2 {! k( `: I3 g4 C
80.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    ( q' c, p8 @" \. R, d& z
81.   {
    
82.     if(channel == can_configs<i>.channel)
    
83.     {
    
84.       can_configs<i>.filter_init_cb();
    7 h6 {* |# ^0 s' q/ m# R" `* G
85.       return;
    
86.     }
    3 e: w# a3 H, f, f( D
87.   }
    
88. }
    
89. 
    # L3 o) F0 ?% _
90. static void can_nvic_init(uint8_t channel)
    9 e9 H& Y- t4 s
91. {
    
92.   uint8_t i;
    3 I" y/ d5 s1 H' y) M4 f; u
93. 
    # r  m9 H+ g0 E$ j+ m: W  z
94.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    . _: V: z. }# I& e
95.   {
    
96.     if(channel == can_configs<i>.channel)
    
97.     {
    
98.       can_configs<i>.nvic_init_cb();
    
99.       return;
    
100.     }
     
101.   }
     
102. }</i></i></i></i></i></i></i></i></i></i></i></i>

复制代码

1. // 对外的接口 初始化 发送和接收
   
2. void CanInit(uint8_t channel)
   2 m5 V. Z: t. Q6 b# z2 I- k% `
3. {
   
4.   can_var_init(channel);
   
5.   can_gpio_init(channel);
   1 D7 [5 m) |: ]; s# t' N
6.   can_mode_init(channel);
   
7.   can_filter_init(channel);
   / H* ?) z  u4 K7 e
8.   can_nvic_init(channel);
   
9. }
   
10. 
    1 h7 w1 h) m$ v0 H" A" H
11. void CanSend(uint8_t channel, can_frame_t *frame)
    
12. {
    
13.   can_dev_t *dev = can_dev_get(channel);
    
14. 
    
15.   if(dev == 0)
    
16.   {
    : e" X2 Z8 Q! ?) g: p
17.     return;
    
18.   }
    / y7 a1 O* G  O8 U& s1 j* _
19. 
    * l% [/ a7 y! u& H5 g
20.   dev->handle.pTxMsg->StdId = frame->StdId;
    7 g  G" p. i3 B
21.   dev->handle.pTxMsg->IDE   = frame->IDE;
    
22.   dev->handle.pTxMsg->RTR   = frame->RTR;
    
23.   dev->handle.pTxMsg->DLC   = frame->DLC;
    
24.   memcpy(dev->handle.pTxMsg->Data, frame->Data, frame->DLC);
    
25. 
    
26.   HAL_CAN_Transmit(&dev->handle, 10);
    
27. }
    7 M( L5 w9 Z1 G4 ]; [: ~
28. 
    ! d6 e6 _' }6 t# r3 \) y1 s. Z
29. uint8_t CanRecv(uint8_t channel, can_frame_t *frame)
    ' j/ u. }+ e- y. a4 {% }, @
30. {
    
31.   can_dev_t *dev = can_dev_get(channel);
    ; F/ s" ^. r( N/ m/ j% u
32. 
    
33.   if(dev == 0)
    + z4 n- }) F8 A+ O2 V
34.   {
    
35.     return 0;
    9 F- w5 p2 r7 p7 Z3 N' c/ i/ e
36.   }
    * |/ }, H" Q" |0 Y& X. |% a. y. b
37. 
    
38.   return CanQueueRead(&can1_dev.recv, frame);
    9 W7 c( U1 ]3 M( o0 x1 y
39. }

复制代码

1. // CAN中断
     s2 ~0 H# P. s
2. void CAN1_RX_IRQ_FUNC(void)
   
3. {
   % U% |* D0 f# o# L2 h4 P
4.   HAL_CAN_IRQHandler(&can1_dev.handle);
   
5. }
   
6. 
   ; g' m8 f! g+ R- B7 h/ n. e
7. void CAN2_RX_IRQ_FUNC(void)
   ' V* L, {3 i% M& u6 ]9 {
8. {
   
9.   HAL_CAN_IRQHandler(&can2_dev.handle);
   - y/ e+ _  L  I" {5 j( d
10. }
    
11. 
    
12. void HAL_CAN_RxCpltCallback(CAN_HandleTypeDef *hcan)
    4 {' T$ e; C* S5 _+ G
13. {
    
14.   if(hcan == (&can1_dev.handle))
    $ V3 A& e/ h) k
15.   {
    7 s2 q8 o* M" s* y+ l+ r7 ~
16.     //CAN_Receive_IT()函数会关闭FIFO0消息挂号中断，因此我们需要重新打开
    
17.     __HAL_CAN_ENABLE_IT(&can1_dev.handle, CAN_IT_FMP0);//重新开启FIF00消息挂号中断
    - u, |5 ^* S1 ]
18.     CanQueueWrite(&can1_dev.recv, can1_dev.handle.pRxMsg);
    ) s/ h* x( p, N' Q' C" K
19.   }
    
20.   else if(hcan == (&can2_dev.handle))
    
21.   {
    + o6 r7 X2 w* }$ G- G# v% {1 J
22.     //CAN_Receive_IT()函数会关闭FIFO0消息挂号中断，因此我们需要重新打开
    
23.     __HAL_CAN_ENABLE_IT(&can2_dev.handle, CAN_IT_FMP0);//重新开启FIF00消息挂号中断
    / ?# \! O0 j0 J$ e6 y! `8 X9 E4 @: z
24.     CanQueueWrite(&can2_dev.recv, can2_dev.handle.pRxMsg);
    
25.   }
    3 _, ~3 D* m  w
26. }

复制代码

7 K+ |8 B1 Q* G# \        之所以使用列表的形式，是为了方便增加和删除CAN通道和使对外的接口更统一，不会出现CAN1Init() CAN2Init()，个人习惯问题。
  a7 B( p6 I1 J, B, M$ [; B4 G4 P  U9 O


: c& z% I1 _1 j' ?) g