一、CAN基础
# I* k/ \/ i- ~差分信号：显性电平对应逻辑0，CAN_H和CAN_L差为2.5V；隐形电平对应逻辑1，CAN_H和CAN_L差为0V。
% r2 ^+ Y: H2 D* N
CAN总线的开始和结束都有一个120Ω的终端电阻。
+ D' g  ^- M) S% p4 l4 n2 K+ [
数据帧：标准帧11位，  扩展帧29位。

. H6 g# w/ V! l' F8 A- J其他的一些理论知识就不再赘述了，可以参考维基百科对于CAN的描述。
) I: l3 ~- _" b; Q. g
STM32F7xx的bxCAN主要特点：支持CAN2.0A和CAN2.0B，波特率高达1Mbps，支持时间触发，具有3个发送邮箱，2个接收邮箱，可变的过滤器组等。
: D' |  v) o4 F/ ^' F+ }9 X
二、几个重要的CAN函数
1 e+ g. ^; ~! ~5 \0 f

1. HAL_StatusTypeDef HAL_CAN_Init(CAN_HandleTypeDef* hcan); // CAN初始化
   : \4 k/ ~) V- {) f
2. 
   " T0 M' u3 u% _0 p- a- G
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接收

复制代码

三、几个重要的结构

1. // CAN操作句柄 包含CAN基地址（CAN1/CAN2/CAN3） 初始化结构 发送接收结构体 其余三个是过程变量
   - v  E! C. l; @# M* M
2. typedef struct
   , h5 d! Y; c- B, Z+ {' S8 V
3. {
   
4.   CAN_TypeDef                 *Instance;  /*!< Register base address          */
   
5. 
   
6.   CAN_InitTypeDef             Init;       /*!< CAN required parameters        */
   
7. 
   
8.   CanTxMsgTypeDef*            pTxMsg;     /*!< Pointer to transmit structure  */
   
9. 
   
10.   CanRxMsgTypeDef*            pRxMsg;     /*!< Pointer to reception structure */
    6 Y3 ^$ j1 X, G6 _" _" A6 @3 T, @$ u/ Q
11. 
    / D; y. K2 }! J
12.   __IO HAL_CAN_StateTypeDef   State;      /*!< CAN communication state        */
    % G) _* w6 W6 F( n! U. j
13. 
    5 s& Y* E# D7 G4 S' Y
14.   HAL_LockTypeDef             Lock;       /*!< CAN locking object             */
    
15. 
    - R' a: G, Y; T. D( S6 Q  c
16.   __IO uint32_t               ErrorCode;  /*!< CAN Error code                 */
    - {$ g0 c* \/ p: T  s# t# ]
17. 
    4 h  m/ P: ]! E6 T  k2 J
18. }CAN_HandleTypeDef;

复制代码

1. // CAN配置结构体
   2 v, k" V7 [- `; q3 s
2. // 前5个参数来设置 CAN_BTR —— 波特率
   
3. // 后6个参数用来设置 CAN_MCR —— 通信相关的控制位
   
4. typedef struct
   
5. {
   
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 */
   * M0 O* g0 A3 ]
8. 
   5 O8 r, `6 L5 B+ n
9.   uint32_t Mode;       /*!< Specifies the CAN operating mode.
   
10.                             This parameter can be a value of @ref CAN_operating_mode */
    
11. 
    
12.   uint32_t SJW;        /*!< Specifies the maximum number of time quanta
    
13.                             the CAN hardware is allowed to lengthen or
    1 b- C6 `- \5 P  A$ q- A8 E
14.                             shorten a bit to perform resynchronization.
    
15.                             This parameter can be a value of @ref CAN_synchronisation_jump_width */
    
16. 
    
17.   uint32_t BS1;        /*!< Specifies the number of time quanta in Bit Segment 1.
    6 Q) c- J' }1 d/ V
18.                             This parameter can be a value of @ref CAN_time_quantum_in_bit_segment_1 */
    % k& @3 \) V7 B. V
19. 
    2 [! p( G1 v" ~5 `! @
20.   uint32_t BS2;        /*!< Specifies the number of time quanta in Bit Segment 2.
    . w) u) Z2 L5 j! k* j0 {. Q6 o, ]
21.                             This parameter can be a value of @ref CAN_time_quantum_in_bit_segment_2 */
    
22. 
    + z8 E3 ^/ t3 T. {
23.   uint32_t TTCM;       /*!< Enable or disable the time triggered communication mode.
    2 x! H: e' _5 M& e" @) D$ u
24.                             This parameter can be set to ENABLE or DISABLE. */
    ' r8 v# d( F4 P6 s. f) }, i
25. 
    & O0 N% `! j; e5 M% H
26.   uint32_t ABOM;       /*!< Enable or disable the automatic bus-off management.
    
27.                             This parameter can be set to ENABLE or DISABLE */
    
28. 
    
29.   uint32_t AWUM;       /*!< Enable or disable the automatic wake-up mode.
    . `) L3 \5 L  A: S8 `
30.                             This parameter can be set to ENABLE or DISABLE */
    ' [3 t" l3 B- E; V: n8 K, B
31. 
    
32.   uint32_t NART;       /*!< Enable or disable the non-automatic retransmission mode.
    5 P- L. b$ R4 @; S: f  O7 g( z! H
33.                             This parameter can be set to ENABLE or DISABLE */
    ) Z5 Z! U% J# u" L* h
34. 
    
35.   uint32_t RFLM;       /*!< Enable or disable the receive FIFO Locked mode.
    
36.                             This parameter can be set to ENABLE or DISABLE */
    ! q* }4 Y3 K# H+ s/ b
37. 
    
38.   uint32_t TXFP;       /*!< Enable or disable the transmit FIFO priority.
    $ C3 U9 F, M6 Q* B: r
39.                             This parameter can be set to ENABLE or DISABLE */
    . K0 W. n) \7 H! @2 A" ^* p
40. }CAN_InitTypeDef;

复制代码

1. // 过滤器设置
   ! x1 i  S0 T. d3 g" v1 R
2. typedef struct
   
3. {
   6 q* u0 @& ^1 t0 R/ z7 e7 s4 P
4.   uint32_t FilterIdHigh;          /*!< Specifies the filter identification number (MSBs for a 32-bit
   - g5 M7 x& _( n. {1 [
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 B7 B2 c+ }
7. 
   
8.   uint32_t FilterIdLow;           /*!< Specifies the filter identification number (LSBs for a 32-bit
   
9.                                        configuration, second one for a 16-bit configuration).
   # ~3 J; g1 C6 V! e$ O* B; m0 G  d2 W
10.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
    ! A$ j& P2 T+ q2 `& u+ Y
11. 
    0 m  M7 ^% q2 c2 t5 f5 l0 Y+ H! O( q- l
12.   uint32_t FilterMaskIdHigh;      /*!< Specifies the filter mask number or identification number,
    1 @: `: Q3 e+ o2 N# S& P
13.                                        according to the mode (MSBs for a 32-bit configuration,
    1 ^3 P" N; y! V  x
14.                                        first one for a 16-bit configuration).
    
15.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
    
16. 
    ) s2 }4 k- D4 C
17.   uint32_t FilterMaskIdLow;       /*!< Specifies the filter mask number or identification number,
    
18.                                        according to the mode (LSBs for a 32-bit configuration,
    3 l2 q1 b4 ?" Z
19.                                        second one for a 16-bit configuration).
    # a7 Y8 X0 i  @5 ]+ P; \* w
20.                                        This parameter must be a number between Min_Data = 0x0000 and Max_Data = 0xFFFF */
    
21. 
    
22.   uint32_t FilterFIFOAssignment;  /*!< Specifies the FIFO (0 or 1) which will be assigned to the filter.
      d1 {4 h- G( w
23.                                        This parameter can be a value of @ref CAN_filter_FIFO */
    4 B6 _/ i5 J/ R+ h
24. 
    ! A* m7 V7 `% {' P  ?; x/ Z6 r
25.   uint32_t FilterNumber;          /*!< Specifies the filter which will be initialized.
    + D1 A4 W- X* g7 X3 L
26.                                        This parameter must be a number between Min_Data = 0 and Max_Data = 27 */
    
27. 
    ' m" E" ^. ^  G& M4 [) p0 h6 m1 P) f
28.   uint32_t FilterMode;            /*!< Specifies the filter mode to be initialized.
    
29.                                        This parameter can be a value of @ref CAN_filter_mode */
    
30. 
    
31.   uint32_t FilterScale;           /*!< Specifies the filter scale.
    
32.                                        This parameter can be a value of @ref CAN_filter_scale */
    4 @7 s$ ?3 x- J8 @0 {
33. 
    
34.   uint32_t FilterActivation;      /*!< Enable or disable the filter.
    
35.                                        This parameter can be set to ENABLE or DISABLE. */
    
36. 
    7 Z( F. F' r' i" v$ d8 Q. f
37.   uint32_t BankNumber;            /*!< Select the start slave bank filter.
    8 v* |5 g& H' i3 `3 _; v; g
38.                                        This parameter must be a number between Min_Data = 0 and Max_Data = 28 */
    # y0 k; p4 x/ E, {7 w+ ]8 v
39. 
    5 L* J* j0 k% Q' w6 p3 R; W
40. }CAN_FilterConfTypeDef;

复制代码

1. // 模式  我们使用普通模式
   ( B$ @: M: ~3 G; D; @
2. #define CAN_MODE_NORMAL             ((uint32_t)0x00000000U)                     /*!< Normal mode   */
   # r! s. k( }  o" H
3. #define CAN_MODE_LOOPBACK           ((uint32_t)CAN_BTR_LBKM)                   /*!< Loopback mode */
   7 p+ n5 `  j* B
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. // 标准帧 扩展帧
   " |3 n& H! L- x' K! {6 R
2. #define CAN_ID_STD             ((uint32_t)0x00000000U)  /*!< Standard Id */
   - [" K7 [+ ~( ~( J% x# t
3. #define CAN_ID_EXT             ((uint32_t)0x00000004U)  /*!< Extended Id */

复制代码

1. // 数据帧 远程帧
   , R% R" y* W. |
2. #define CAN_RTR_DATA                ((uint32_t)0x00000000U)  /*!< Data frame */
   5 y6 s9 W: O( Y  g: v& {( o
3. #define CAN_RTR_REMOTE              ((uint32_t)0x00000002U)  /*!< Remote frame */

复制代码

1. // CAN中断使能
   9 z8 s, Q; Q7 K4 X( z
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            */
   ( p# A3 H0 P- v' q- Y
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 */
   & K4 D+ L# U) `' E  T
6. #define CAN_IT_FF1                  ((uint32_t)CAN_IER_FFIE1)   /*!< FIFO 1 full interrupt            */
   
7. #define CAN_IT_FOV1                 ((uint32_t)CAN_IER_FOVIE1)  /*!< FIFO 1 overrun interrupt         */

复制代码

$ `0 V4 @3 r% \+ x# K: c四、接口设计
与串口类似，使用中断接收。先封装单路CAN需要的几个小接口，再顶一个列表，最后使用统一的接口扫描这个列表。
; C, E* P  f4 F* D( G
* V+ O! q$ a* m- _

1. typedef enum
   8 G/ W' `, A0 E; _
2. {
   
3.   CAN_CHANNEL_NONE,
   . j" `' u4 E: l- i' X+ K; U) T/ ^
4.   CAN_CHANNEL_1,
   5 `) }* C, U, a* O: {# Z
5.   CAN_CHANNEL_2,
   : T* T( l* I6 r! S# k5 M0 W
6.   CAN_CHANNEL_NUM
   
7. } can_channel_t;
   + M' P. p* w7 @* K* @) k$ w9 w6 ]
8. 
   
9. #define CAN1_CHANNEL              CAN1
   6 J* z& Q0 G+ W9 \/ [& s5 O7 W# t
10. #define CAN1_PREEMPT_PRIO         CAN1_RX_PRIORITY
    
11. #define CAN1_RX_IRQ               CAN1_RX0_IRQn
    * D$ Z$ m3 {, z
12. #define CAN1_RX_IRQ_FUNC          CAN1_RX0_IRQHandler
    ' I* g  Z. v8 C
13. #define CAN1_CLK_ENABLE()         __HAL_RCC_CAN1_CLK_ENABLE()
    + O" z: \$ G: ~( x6 N1 d
14. #define CAN1_TX_PORT              GPIOA
    / F& D" \1 o3 h* d1 s
15. #define CAN1_TX_PIN               GPIO_PIN_12
    
16. #define CAN1_TX_AF                GPIO_AF9_CAN1
    - N& e9 l3 [9 g, E
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
    ' Z* |, b) c: a
19. #define CAN1_RX_PIN               GPIO_PIN_11
    3 W# g' u) O9 w% ^
20. #define CAN1_RX_AF                GPIO_AF9_CAN1
    / n$ P6 F2 `  d* O+ }. I  e
21. #define CAN1_RX_CONFIG()          GPIOConfigExt(CAN1_RX_PORT, CAN1_RX_PIN, GPIO_MODE_AF_PP, GPIO_PULLUP, CAN1_RX_AF)
    
22. 
    
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()
    - S0 u( G, R5 |+ P% ~  \% b
28. #define CAN2_TX_PORT              GPIOB
    * l0 H' y8 y0 W8 z. i4 i
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)
    , h+ K  f% v- H+ [
32. #define CAN2_RX_PORT              GPIOB
    1 y- F, D% ^- v/ m4 \5 m3 p' }7 {+ k& s* [
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设备结构体
   
2. typedef struct
   * m. j& n5 M4 q
3. {
   
4.   CAN_HandleTypeDef handle; // CAN操作句柄
   
5. 
   , I- h3 O+ Y4 C8 d5 @4 d& s
6.   CanTxMsgTypeDef tx;       // CAN发送
   
7. 
   0 L/ j  ~5 d! g5 b6 A
8.   CanRxMsgTypeDef rx;       // CAN接收
   ' Y: |$ E' B+ d
9. 
   
10.   can_queue_t recv;         // 接收队列
      q  L$ R8 u- f- f6 n
11. 
    
12. } can_dev_t;

复制代码

1. // 将每路CAN封装成几个小函数
   
2. static can_dev_t can1_dev, can2_dev;
   
3. 
   & v2 c1 w) o2 g9 y& k; E) ]
4. static void can1_var_init(void)
   
5. {
   
6.   can1_dev.recv = can1_queue_recv;
   % U3 a/ K. h9 B8 g( F, E8 j
7. 
   ; b9 z7 ^5 Q8 m
8.   CanQueueInit(&can1_dev.recv);
   : G- q& _' k- S4 I) A/ P' K
9. }
   
10. 
    
11. static void can1_gpio_init(void)
    8 ?) U0 p: {  A" h& K1 j5 R8 T, i6 V
12. {
    9 Z2 ~8 m/ d8 I! v# |) ]7 k4 ~( _
13.   CAN1_TX_CONFIG();
    
14.   CAN1_RX_CONFIG();
    
15. }
    ( f& k8 ?- w. u1 M6 {* |+ I4 k
16. 
    
17. // 波特率 = Fpclk1 / ((ts1+ts2+3) * brp)  Fpclk1 = 54M
    
18. static void can1_mode_init(void)
    
19. {
    
20.   CAN1_CLK_ENABLE();
    
21. 
    8 f8 j7 B2 j3 H% p# N: W3 A/ Z
22.   can1_dev.handle.Instance = CAN1_CHANNEL;
    
23.   can1_dev.handle.pTxMsg = &can1_dev.tx;
    & Q8 R8 i# N/ h9 v
24.   can1_dev.handle.pRxMsg = &can1_dev.rx;
    8 g4 w' ~* }& K
25.   can1_dev.handle.Init.Prescaler = 6;
    ! p  A0 J( z1 X
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
    + Q% K3 B4 }% r8 b" {8 X- C
28.   can1_dev.handle.Init.BS1 = CAN_BS1_11TQ;// tbs1范围CAN_BS1_1TQ~CAN_BS1_16TQ
    / T2 y: g) S" P, m, R+ A4 J+ y" Z
29.   can1_dev.handle.Init.BS2 = CAN_BS2_6TQ; // tbs2范围CAN_BS2_1TQ~CAN_BS2_8TQ
    
30.   can1_dev.handle.Init.TTCM = DISABLE;    // 非时间触发通信模式
    ! C% |8 D2 g& @% f8 Y& M
31.   can1_dev.handle.Init.ABOM = ENABLE;     // 软件自动离线管理
    
32.   can1_dev.handle.Init.AWUM = DISABLE;    // 睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
      v& q2 \8 m/ K9 V
33.   can1_dev.handle.Init.NART = ENABLE;     // 禁止报文自动传送
    
34.   can1_dev.handle.Init.RFLM = DISABLE;    // 报文不锁定,新的覆盖旧的
    
35.   can1_dev.handle.Init.TXFP = DISABLE;    // 优先级由报文标识符决定
    7 N: K* i' f+ O& }
36.   HAL_CAN_Init(&can1_dev.handle);
    
37. }
    
38. 
    
39. static void can1_filter_init(void)
    / J2 [& _0 p3 B! c% [; r9 z4 w
40. {
    
41.   CAN_FilterConfTypeDef  filter;
    % j. i) Z( P4 V9 B/ n8 H9 R
42. 
    4 d; Y1 z6 `& i! U: G5 `5 b- g" h. F
43.   filter.FilterNumber     = 0; // 过滤器0
    ; G6 j) b# u) t- y- O
44.   filter.FilterMode       = CAN_FILTERMODE_IDMASK;
    
45.   filter.FilterScale      = CAN_FILTERSCALE_32BIT;
    
46. 
    
47.   filter.FilterIdHigh     = 0;
    
48.   filter.FilterIdLow      = 0;
    ( U4 g$ k, y3 Z: L# n. m
49.   filter.FilterMaskIdHigh = 0;
    
50.   filter.FilterMaskIdLow  = 0;
    : p- z- ?6 S3 _6 }, O
51. 
    0 s; Q# k: v  z$ T6 [0 {0 y
52.   filter.FilterFIFOAssignment = CAN_FILTER_FIFO0; // 过滤器0关联到FIFO0
    
53.   filter.FilterActivation = ENABLE; //激活滤波器0
    
54.   //filter.BankNumber=14;
    $ W% a, X8 h: F: a- ^$ P
55. 
    
56.   HAL_CAN_ConfigFilter(&can1_dev.handle, &filter);
    
57. }
    
58. 
    1 a% d' q( b  F) A6 W' x
59. static void can1_nvic_init(void)
    $ ~9 o: x6 W+ Q" z8 ?& {6 N  _* _
60. {
    , J& ^# Y6 h; a6 b2 s/ |) \9 E
61.   __HAL_CAN_ENABLE_IT(&can1_dev.handle, CAN_IT_FMP0); //FIFO0消息挂号中断允许.
    8 q5 y2 i& H: I2 M/ G7 f! P) w
62.   HAL_NVIC_SetPriority(CAN1_RX_IRQ, CAN1_RX_PRIORITY, 0);
    
63.   HAL_NVIC_EnableIRQ(CAN1_RX_IRQ);
    ; O! z$ Y* _  s$ c- Y+ R
64. }
    ( d+ D$ ]% N. ?! x- c
65. 
    
66. 
    
67. 
    9 b( }! X) X. k2 Y6 V! R# V
68. static void can2_var_init(void)
    4 o! A& L3 e: e6 P
69. {
    8 ^+ G, H; ], P* v" y$ Z, @
70.   can2_dev.recv = can2_queue_recv;
    : Z6 s; q: d' y0 L3 W* d
71. 
    + j. d( {# H. j; f2 Y7 Y
72.   CanQueueInit(&can2_dev.recv);
    5 v' h7 w0 |) s4 y# B
73. }
    8 u8 k9 L3 s* D* t  F
74. 
    # v) W8 M5 {& T" D2 v+ k* g5 T6 _
75. static void can2_gpio_init(void)
    7 `8 i& n3 E; Z- _' s, `
76. {
    
77.   CAN2_TX_CONFIG();
    $ y, |2 {" a: V- _6 O$ L
78.   CAN2_RX_CONFIG();
    ( z4 u" z; I# y3 w
79. }
    
80. 
    
81. // 波特率 = Fpclk1 / ((ts1+ts2+3) * brp)  Fpclk1 = 54M
    7 O/ j6 {. z: _/ [5 u0 N
82. static void can2_mode_init(void)
    * ?% Y$ a8 r! k
83. {
    
84.   CAN2_CLK_ENABLE();
    . c- a! S1 \0 u  G5 H# o
85. 
    / C" |7 y" D6 \7 F2 v5 W4 _  G
86.   can2_dev.handle.Instance = CAN2_CHANNEL;
    
87.   can2_dev.handle.Init.Prescaler = 6;
    % H) O& H3 D. M( ^7 P
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
    6 a7 n# L1 a  x: @* Z
90.   can2_dev.handle.Init.BS1 = CAN_BS1_11TQ;// tbs1范围CAN_BS1_1TQ~CAN_BS1_16TQ
    $ I7 C3 V7 J& H# u$ s3 D
91.   can2_dev.handle.Init.BS2 = CAN_BS2_6TQ; // tbs2范围CAN_BS2_1TQ~CAN_BS2_8TQ
    
92.   can2_dev.handle.Init.TTCM = DISABLE;    // 非时间触发通信模式
    + d( g4 z) R7 o" N
93.   can2_dev.handle.Init.ABOM = ENABLE;     // 软件自动离线管理
    4 h  J  J6 j% h8 M' n! A
94.   can2_dev.handle.Init.AWUM = DISABLE;    // 睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    
95.   can2_dev.handle.Init.NART = ENABLE;     // 禁止报文自动传送
    $ z1 q7 A" Q( A8 M! W
96.   can2_dev.handle.Init.RFLM = DISABLE;    // 报文不锁定,新的覆盖旧的
    9 m$ r# y/ c& J' k" y) y
97.   can2_dev.handle.Init.TXFP = DISABLE;    // 优先级由报文标识符决定
    
98.   HAL_CAN_Init(&can2_dev.handle);
    " A( j) D3 h# Z& S
99. }
    : L6 O/ g  `2 S  f) l
100. 
     
101. static void can2_filter_init(void)
     
102. {
     
103.   CAN_FilterConfTypeDef  CAN_FilterInitStructure;
     
104. 
     
105.   CAN_FilterInitStructure.FilterNumber     = 14;
     
106.   CAN_FilterInitStructure.FilterMode       = CAN_FILTERMODE_IDMASK;
     / o( [2 W2 g2 u5 G5 N% f* \: d1 G/ I  j# q
107.   CAN_FilterInitStructure.FilterScale      = CAN_FILTERSCALE_32BIT;
     
108. 
     7 f) u$ P0 H, U4 ]' L: c
109.   CAN_FilterInitStructure.FilterIdHigh     = 0;
     ! b. C4 b) F5 c, @) V& V
110.   CAN_FilterInitStructure.FilterIdLow      = 0;
     - T( Y. L% s5 y7 R4 @9 C
111.   CAN_FilterInitStructure.FilterMaskIdHigh = 0;
     $ \" L; a$ ^- `) c
112.   CAN_FilterInitStructure.FilterMaskIdLow  = 0;
     1 Y- g" A3 W2 W- |% ~/ ~3 F- s, g
113. 
     
114.   CAN_FilterInitStructure.FilterFIFOAssignment = CAN_FILTER_FIFO0; // 过滤器0关联到FIFO0
     
115.   CAN_FilterInitStructure.FilterActivation = ENABLE; //激活滤波器0
     1 V1 ?0 P' ]1 G) F. G0 _5 ?6 H
116.   //CAN_FilterInitStructure.BankNumber=14;
     
117. 
     
118.   HAL_CAN_ConfigFilter(&can2_dev.handle, &CAN_FilterInitStructure);
     
119. }
     
120. 
     
121. static void can2_nvic_init(void)
     
122. {
     : I" J: B7 d. X4 S) Z  K9 ~
123.   __HAL_CAN_ENABLE_IT(&can2_dev.handle, CAN_IT_FMP0); //FIFO0消息挂号中断允许1
     & i" V1 u7 @5 ~) C) m0 K
124.   HAL_NVIC_SetPriority(CAN2_RX_IRQ, CAN2_RX_PRIORITY, 0);
     % a8 b9 L9 C& d$ z4 d+ w) b$ O
125.   HAL_NVIC_EnableIRQ(CAN2_RX_IRQ);
     " Q1 r7 F) p! f8 a/ Q( m
126. }

复制代码

1. // 每路CAN都有的几个操作，使用列表包含，然后统一扫描处理
   
2. typedef struct
   
3. {
   ) o  G% Y8 v+ K& y. C: u9 z0 j
4.   uint8_t channel;
   # B+ C7 L* X% }8 I6 S6 g
5.   can_dev_t *dev;
   : K: q- n1 \8 d2 D9 W" M, L4 e6 H, [8 y1 `
6.   void (* var_init_cb)(void);
   2 g5 L; B5 H' W& l5 @/ K% Y: v& F
7.   void (* gpio_init_cb)(void);
   ( ^0 k* j/ @7 U  ^. d
8.   void (* mode_init_cb)(void);
   * Z4 n' H, \' A6 f* l# S  _# W
9.   void (* filter_init_cb)(void);
   . ^* u: P7 C2 ^7 @7 D% `* e
10.   void (* nvic_init_cb)(void);
    , {0 E1 T0 B9 l- c9 R( ^# o
11. } can_config_t;
    * J' t6 V, P4 r: T( A3 O
12. 
    * y% V& B2 I, v2 F
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},
    6 c, _, s0 g8 o0 o5 p; ?! W% G
16.   {CAN_CHANNEL_2, &can2_dev, can2_var_init, can2_gpio_init, can2_mode_init, can2_filter_init, can2_nvic_init},
    
17. };
    
18. 
    & `! S- }6 d. J# e% @$ P# k4 o
19. static can_dev_t *can_dev_get(uint8_t channel)
    
20. {
    , R5 G, s1 f. i
21.   uint8_t i;
    
22. 
    ' D+ w, g8 k' C& i0 W
23.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    1 k# C( f3 ?8 q- o3 S  C
24.   {
    ! ]- K% R# ~' W0 R
25.     if(channel == can_configs<i>.channel)
    : u' k& `. O$ D) U/ d( |% a3 C; ]
26.     {
    & `. X; y+ k# D8 R5 N
27.       return can_configs<i>.dev;
    , T$ v! b" B+ @$ N$ [* O
28.     }
    
29.   }
    
30. 
    
31.   return 0;
    
32. }
    ) [3 N6 D7 {) x7 \6 f: t* ]
33. 
    
34. static void can_var_init(uint8_t channel)
    % b' N+ _! v9 @) _0 u
35. {
    4 W$ g* c5 [5 S, O
36.   uint8_t i;
    
37. 
    + k; J! q9 a: [5 O
38.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    4 z4 E# `) T& X3 J
39.   {
    7 g/ r/ g6 d* a% @# C
40.     if(channel == can_configs<i>.channel)
    
41.     {
    
42.       can_configs<i>.var_init_cb();
    
43.       return;
    & }* ~- E5 x1 X
44.     }
    # V  d# N2 ~* i6 f  s! Q
45.   }
    
46. }
    
47. 
    3 E& U" n) y" [1 X+ W; ^7 g5 Z
48. static void can_gpio_init(uint8_t channel)
    
49. {
    
50.   uint8_t i;
    3 E. D9 l5 e# S& i; G
51. 
    # n7 N% @. J! G: s& ~" I: g
52.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    
53.   {
    
54.     if(channel == can_configs<i>.channel)
    
55.     {
    
56.       can_configs<i>.gpio_init_cb();
    
57.       return;
    : v6 f2 B; ?& r- T
58.     }
    
59.   }
    
60. }
    4 ?  w3 x+ C! r7 [( C# x; G& P4 }
61. 
    + m+ e9 N. H6 o" t( y8 {% }
62. static void can_mode_init(uint8_t channel)
    : c& q1 _- B9 F
63. {
    2 ?( o* o; S, }2 p
64.   uint8_t i;
    $ K- ?& h. F' _1 t
65. 
    
66.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    
67.   {
    3 o8 k3 ?* \2 n7 j8 O+ a
68.     if(channel == can_configs<i>.channel)
    
69.     {
    7 w4 S. d% H8 W
70.       can_configs<i>.mode_init_cb();
    
71.       return;
    
72.     }
    
73.   }
    5 j! `* t& q- Y  {7 x# O
74. }
    
75. 
    9 E5 P3 @% k0 o% ]2 @2 _* `7 \, k
76. static void can_filter_init(uint8_t channel)
    
77. {
    
78.   uint8_t i;
    
79. 
    
80.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    ( s8 R+ L( P& T/ I: w5 U+ D
81.   {
    
82.     if(channel == can_configs<i>.channel)
    % ^1 w+ w+ C1 g4 Y9 w
83.     {
    
84.       can_configs<i>.filter_init_cb();
    , f0 s, R  J& F( H. ]1 b, u
85.       return;
    3 C/ k% @" _9 G7 L& V* {
86.     }
    
87.   }
    
88. }
    
89. 
    7 Y) [# P5 n* P6 o. H
90. static void can_nvic_init(uint8_t channel)
    
91. {
    ; t3 _+ _7 R6 |0 w; R
92.   uint8_t i;
    - ?$ R. o- [5 t
93. 
    : o& L; |2 [& ]% l1 a
94.   for(i = 0; i < ARRAY_SIZE(can_configs); ++i)
    4 t1 S9 W+ ^0 Q
95.   {
    3 X2 l$ S4 ^! P+ W3 `. V- K% X7 D
96.     if(channel == can_configs<i>.channel)
    2 i7 q$ M5 M* Q) S
97.     {
    ; ?  b! s/ A' ^5 T* i
98.       can_configs<i>.nvic_init_cb();
    
99.       return;
    
100.     }
     3 T$ S9 w8 V% P3 g: w+ @1 E. e
101.   }
     + P( Z" `; L4 c( I; [; y9 d( n
102. }</i></i></i></i></i></i></i></i></i></i></i></i>

复制代码

1. // 对外的接口 初始化 发送和接收
   ) Q' q8 a/ A7 [% F9 ], |
2. void CanInit(uint8_t channel)
   
3. {
   
4.   can_var_init(channel);
   
5.   can_gpio_init(channel);
   
6.   can_mode_init(channel);
   3 ?0 a" g1 [: o9 P) l4 Q
7.   can_filter_init(channel);
   2 S7 [* L7 R# ~/ w! N6 _
8.   can_nvic_init(channel);
   ! H: f1 h  U9 P# a
9. }
   
10. 
    % I# I- N" s' D( E9 g  K
11. void CanSend(uint8_t channel, can_frame_t *frame)
    - G7 Z& N) Y" u( c. l4 R
12. {
    
13.   can_dev_t *dev = can_dev_get(channel);
    
14. 
    , s, v; @+ a: A" @
15.   if(dev == 0)
    
16.   {
    ( E# R& v: ~5 b( F
17.     return;
    
18.   }
    
19. 
    
20.   dev->handle.pTxMsg->StdId = frame->StdId;
    3 I3 y7 i/ a, l  G$ ?" F( e
21.   dev->handle.pTxMsg->IDE   = frame->IDE;
    
22.   dev->handle.pTxMsg->RTR   = frame->RTR;
    & w' {* ]+ z# u+ N2 Z
23.   dev->handle.pTxMsg->DLC   = frame->DLC;
    
24.   memcpy(dev->handle.pTxMsg->Data, frame->Data, frame->DLC);
    
25. 
    & c7 g7 o1 b$ k/ R4 O  Z
26.   HAL_CAN_Transmit(&dev->handle, 10);
    # K& I+ a0 T8 c* Z
27. }
    
28. 
    
29. uint8_t CanRecv(uint8_t channel, can_frame_t *frame)
    
30. {
    
31.   can_dev_t *dev = can_dev_get(channel);
    : D8 h) x0 W9 m$ l) g$ C$ u
32. 
    / P6 S9 |6 y" b& t9 y5 F8 B) J
33.   if(dev == 0)
    - s6 L% i3 v* D; u, T
34.   {
    * a$ W' Z4 O6 G( x) ]% m0 i
35.     return 0;
    
36.   }
    
37. 
    
38.   return CanQueueRead(&can1_dev.recv, frame);
    
39. }

复制代码

1. // CAN中断
   ! K9 [4 z$ L0 g  K& a# j4 h
2. void CAN1_RX_IRQ_FUNC(void)
   2 P1 d+ j0 h/ Y8 e, }# z
3. {
     l/ X1 Z) V, P$ ?2 w( }
4.   HAL_CAN_IRQHandler(&can1_dev.handle);
   # c4 a3 A/ ]9 X5 S4 ^; I
5. }
   0 M6 v4 |. ~  Z; {( \3 i6 J2 N
6. 
   
7. void CAN2_RX_IRQ_FUNC(void)
   8 a( `7 D; F( w9 t* W& Q$ Z$ N
8. {
   
9.   HAL_CAN_IRQHandler(&can2_dev.handle);
   
10. }
    
11. 
    
12. void HAL_CAN_RxCpltCallback(CAN_HandleTypeDef *hcan)
    $ K1 m3 d4 u0 W+ \( E+ L, }' e
13. {
    
14.   if(hcan == (&can1_dev.handle))
    
15.   {
    
16.     //CAN_Receive_IT()函数会关闭FIFO0消息挂号中断，因此我们需要重新打开
    $ y7 t6 g! j- V
17.     __HAL_CAN_ENABLE_IT(&can1_dev.handle, CAN_IT_FMP0);//重新开启FIF00消息挂号中断
    
18.     CanQueueWrite(&can1_dev.recv, can1_dev.handle.pRxMsg);
    
19.   }
    
20.   else if(hcan == (&can2_dev.handle))
    0 y  |; q  |6 e1 C& n+ T1 J! T
21.   {
    7 @3 d7 q) x9 S. [5 r
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);
    ( P7 {0 b& [  q7 `! B
25.   }
    / w; b9 z; e( n( {! P- ^1 L0 E: B/ O
26. }

复制代码

/ W. Q9 w3 o; l        之所以使用列表的形式，是为了方便增加和删除CAN通道和使对外的接口更统一，不会出现CAN1Init() CAN2Init()，个人习惯问题。

0 _; V* I: ]: ]2 B. X& Y: O! {! Y

$ d. i+ h; @- R. K0 O. Y