1，开发环境

1，固件库：STM32F10x_StdPeriph_Lib_V3.5.0

8 e9 ]3 A5 Z0 E2，编译器：ARMCC V5.06
- m" b* R" F/ u. u
/ C! v0 f+ C5 X( y3，IDE：Keil uVision5

4，操作系统：Windows 10 专业版

6 ]6 a7 L6 a4 \& G  \( G1 X
" P1 g6 k5 {' r4 }  h6 F2，程序源码
7 N/ `" l( P) f+ F9 r* n3 t7 Q9 V
8 R$ x0 m0 Q/ o8 q* wRingBuffer.h 文件

1. /**
   4 ~: B* E' I9 I5 ~
2.   ******************************************************************************
   
3.   * @file    RingBuffer.h
   
4.   * @author  XinLi
   7 `% R, \3 n3 l
5.   * @version v1.1
   0 ?8 N6 `( w3 x% j, J6 A
6.   * @date    15-January-2018
   
7.   * @brief   Header file for RingBuffer.c module.
     A2 e- {6 p- q' p
8.   ******************************************************************************
   
9.   * @attention
   3 _1 O' g5 ]- G( v( |
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
      [1 F7 J- ]5 ]( f
12.   *
    8 H6 U7 a) c1 r( H1 L4 y$ H5 `, Q3 b
13.   * This program is free software: you can redistribute it and/or modify
    
14.   * it under the terms of the GNU General Public License as published by
    
15.   * the Free Software Foundation, either version 3 of the License, or
    5 O& E, {. |8 @4 |
16.   * (at your option) any later version.
    
17.   *
    2 T  B3 z+ A1 [2 e3 T8 b" f
18.   * This program is distributed in the hope that it will be useful,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    : C( u  t" B) L
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    3 l: W$ n  s# Y. q  e2 u
21.   * GNU General Public License for more details.
    
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    ! m' l: M: r8 q8 c# c6 z
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    6 w1 Z8 j% [: M$ f6 Y" ~) y
25.   *
    
26.   ******************************************************************************
    
27.   */
    5 ]9 h  z+ V& R7 G" [; C/ V
28. 
    
29. #ifndef __RINGBUFFER_H
    
30. #define __RINGBUFFER_H
    / t, C4 \/ h/ c4 Q3 e, D
31. 
    
32. #ifdef __cplusplus
    
33. extern "C" {
    3 ?& H( C. H% M7 V/ I
34. #endif
    / S7 Y1 `& ^* h
35. 
    ( O* l0 V% f7 b6 r$ k
36. /* Header includes -----------------------------------------------------------*/
    5 F. r& c+ @0 s6 L- H% f6 H
37. #include <stdint.h>
    1 ]3 w3 R9 g3 f. o1 E
38. #include <stdbool.h>
    
39. #include <stdlib.h>
    6 W9 ?% M9 R3 t6 m
40. 
    ) S! K* q  U/ X7 R  S
41. /* Macro definitions ---------------------------------------------------------*/
    8 X6 k; r% ]7 d3 k
42. #define RING_BUFFER_MALLOC(size)  malloc(size)
    
43. #define RING_BUFFER_FREE(block)   free(block)
    ; K# R. Q  E4 Z
44. 
    6 r# Q: C0 f- y' Z$ n. f
45. /* Type definitions ----------------------------------------------------------*/
    
46. typedef struct
    
47. {
    
48.   uint8_t *buffer;
    0 M  j8 X) x- _
49.   uint32_t size;
      V3 S, e' `# I, R/ N4 u& \2 r: o
50.   uint32_t in;
    9 V9 J- g9 c! w8 B" n
51.   uint32_t out;
    5 [' D- \2 b' G' {! F1 S
52. }RingBuffer;
    
53. 
    1 \( M6 R1 z: V( q2 Q
54. /* Variable declarations -----------------------------------------------------*/
    
55. /* Variable definitions ------------------------------------------------------*/
    6 x  X/ |" W$ u0 E! q6 C9 w
56. /* Function declarations -----------------------------------------------------*/
    9 c. ]9 B  t+ A1 \5 @0 \! y
57. RingBuffer *RingBuffer_Malloc(uint32_t size);
    
58. void RingBuffer_Free(RingBuffer *fifo);
    
59. 
    2 ^  P% [1 v8 Y, R+ o' M. u7 _
60. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len);
    
61. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len);
    ' Q1 {, _  j' q# L' i" h
62. 
    ( A# w  g& I+ l
63. /* Function definitions ------------------------------------------------------*/
    1 q& E+ K! c" u" {& N! I4 C' \
64. 
    3 T; \; {9 {8 g( \7 d* y, T
65. /**
    
66.   * @brief  Removes the entire FIFO contents.
    * @8 B3 g+ B! H( h; k
67.   * @param  [in] fifo: The fifo to be emptied.
    & M. [3 B' V! F$ D- m
68.   * @return None.
    5 R$ g, K2 [* m) P" C% a
69.   */
    1 t# M! ~1 R" u1 M" i4 s
70. static inline void RingBuffer_Reset(RingBuffer *fifo)
    
71. {
    + a# s& Y3 Z8 e) _  P* }4 I
72.   fifo->in = fifo->out = 0;
    2 O$ Y& n+ g$ y$ l9 o% l) k) e
73. }
    
74. 
    9 V. _) b5 g: v/ g
75. /**
    ' J% h+ P; m1 Q! k* ?
76.   * @brief  Returns the size of the FIFO in bytes.
    , w* w9 R4 }6 G- q% H
77.   * @param  [in] fifo: The fifo to be used.
    # {7 H: q/ U* ?  a$ h8 L5 t
78.   * @return The size of the FIFO.
    $ c, }( J# |0 _- }- p8 M
79.   */
    9 x# \) u, Z1 E( ^& o
80. static inline uint32_t RingBuffer_Size(RingBuffer *fifo)
    " r' u- J4 ?6 A% G8 |& m
81. {
    
82.   return fifo->size;
    
83. }
    8 X3 B8 G( ?: [4 @6 w( E
84. 
    ! v- g0 x, Z0 @8 G6 S* B
85. /**
    
86.   * @brief  Returns the number of used bytes in the FIFO.
    
87.   * @param  [in] fifo: The fifo to be used.
    
88.   * @return The number of used bytes.
    # T( {5 B+ j9 t# e. b' U. a1 `, A
89.   */
    3 e6 m) ]( w2 c7 ^' K) A$ H2 c
90. static inline uint32_t RingBuffer_Len(RingBuffer *fifo)
    - T1 J. K3 x0 e$ Q' l
91. {
    
92.   return fifo->in - fifo->out;
    
93. }
    
94. 
    % U. p7 A' s# I4 y) `5 l2 J
95. /**
    
96.   * @brief  Returns the number of bytes available in the FIFO.
    
97.   * @param  [in] fifo: The fifo to be used.
    8 n, s; R. S- _1 m3 f; g
98.   * @return The number of bytes available.
    , Y; P0 w/ s2 }; T1 B
99.   */
    
100. static inline uint32_t RingBuffer_Avail(RingBuffer *fifo)
     
101. {
     5 J8 M% i  S) J
102.   return RingBuffer_Size(fifo) - RingBuffer_Len(fifo);
     6 E0 G1 J4 ?. R
103. }
     6 U! r5 m- ]0 D
104. 
     
105. /**
     . @0 B- v9 r8 a, Y  P' C* i( E6 A3 P
106.   * @brief  Is the FIFO empty?
     ) c9 X5 W2 F7 J
107.   * @param  [in] fifo: The fifo to be used.
     
108.   * @retval true:      Yes.
     4 n) O  L, j( ~9 t/ g
109.   * @retval false:     No.
     ) @/ o& G7 p6 ]9 u
110.   */
     
111. static inline bool RingBuffer_IsEmpty(RingBuffer *fifo)
     
112. {
     
113.   return RingBuffer_Len(fifo) == 0;
     
114. }
     % b: m5 J. v2 t
115. 
     
116. /**
       O# E+ ^3 J9 e/ f  G% o
117.   * @brief  Is the FIFO full?
     % f! |7 j! Z3 Q3 X* k
118.   * @param  [in] fifo: The fifo to be used.
     : c% H( n) z# M* Z/ Z4 A
119.   * @retval true:      Yes.
     
120.   * @retval false:     No.
     
121.   */
     ' q  ?5 P% S% t% \- y
122. static inline bool RingBuffer_IsFull(RingBuffer *fifo)
     
123. {
     % e5 e# n6 {& T( T# F1 M7 Y
124.   return RingBuffer_Avail(fifo) == 0;
     
125. }
     
126. 
     7 w$ `  M2 b/ P9 H. ^
127. #ifdef __cplusplus
     * W: Q5 ~* T/ V& x$ ~
128. }
     ( `% r2 F5 {4 K% g) q6 I
129. #endif
     
130. 
     
131. #endif /* __RINGBUFFER_H */
     

复制代码

( m5 C1 O9 a# w& ?RingBuffer.c 文件
5 w" b/ I) b/ G0 z

1. <div>/**
   ) `2 w+ B$ j( T  {' ?' ~, ?" c
2.   ******************************************************************************
   
3.   * @file    RingBuffer.c
   
4.   * @author  XinLi
   3 V" w3 P) e9 m" [
5.   * @version v1.1
   
6.   * @date    15-January-2018
   
7.   * @brief   Ring buffer module source file.
   , H6 |! W$ |( d* {5 p& T
8.   ******************************************************************************
   
9.   * @attention
   5 k4 u3 H. K5 m, N3 A
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    2 l7 K8 C% }2 L2 x- k) H9 q2 c: W- r
13.   * This program is free software: you can redistribute it and/or modify
    3 R1 h; K/ ^  W( d
14.   * it under the terms of the GNU General Public License as published by
    
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    ! w/ S. V( d& C; J% f! y) B6 n
17.   *
    6 o. H4 A6 @! F7 O% \1 u
18.   * This program is distributed in the hope that it will be useful,
    % U& j/ R; G$ Z4 e
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    : }: G$ r% H& d4 x2 U# a* W
21.   * GNU General Public License for more details.
    
22.   *
    + u( d% P- S" B! b' I  O
23.   * You should have received a copy of the GNU General Public License
    
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    
25.   *
    0 t* f( N: ^, P0 E7 [( W
26.   ******************************************************************************
    
27.   */
      o: S5 J: D2 I9 @( Z5 p& n
28. 
    
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "RingBuffer.h"
    
31. #include <string.h>
    . z" i. x0 l% p0 D
32. 
    : x( v$ M9 G0 T- v+ C- |0 ?- G
33. /* Macro definitions ---------------------------------------------------------*/
    % n2 d# [  e2 c  r$ w: u
34. #define min(a, b)  (((a) < (b)) ? (a) : (b))
    
35. 
      ]7 U( f( J/ Y6 o$ R
36. /* Type definitions ----------------------------------------------------------*/
    . H  o9 M2 T. ]* x
37. /* Variable declarations -----------------------------------------------------*/
    
38. /* Variable definitions ------------------------------------------------------*/
    2 c/ R; c0 e# x; A. p8 x/ g
39. /* Function declarations -----------------------------------------------------*/
    ) Z6 u5 H+ D& o! W3 S
40. static bool is_power_of_2(uint32_t x);
    ' d# B3 V" T# Y! D& i% V) Z
41. static uint32_t roundup_pow_of_two(uint32_t x);
    1 {, ]# P1 _! y, U7 @1 c
42. 
    ) W6 H& c) [+ L% T& P9 H' X
43. /* Function definitions ------------------------------------------------------*/
    
44. 
    * M, F0 i0 @4 N( Z* L  ~/ D$ @! @
45. /**
    
46.   * @brief  Allocates a new FIFO and its internal buffer.
    5 T3 @/ k& j9 N1 v
47.   * @param  [in] size: The size of the internal buffer to be allocated.
    & P1 D; F* S/ ]- l6 d  {" b
48.   * @note   The size will be rounded-up to a power of 2.
      G9 B. S# p( g, t4 v3 e
49.   * @return RingBuffer pointer.
    ( U! g- C- l. f& \  q6 c" e! ~0 }
50.   */
    
51. RingBuffer *RingBuffer_Malloc(uint32_t size)
    
52. {
    2 a3 H0 U% s0 A5 R3 A0 g
53.   RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer));
    
54. 
    
55.   if(fifo != NULL)
    8 y7 ~: _1 F4 |$ M$ o; O
56.   {
    , i- q, U& |9 p5 r: p
57.     if(is_power_of_2(size) != true)
    
58.     {
    7 [+ h8 c3 ?# h; q
59.       if(size > 0x80000000UL)
    
60.       {
    
61.         RING_BUFFER_FREE(fifo);
    
62.         return NULL;
    & \5 [+ V2 S& j$ d! V% _0 s
63.       }
    
64. 
    ( Q. @$ @- n4 E  ^5 t* R
65.       size = roundup_pow_of_two(size);
    
66.     }
    
67. 
    
68.     fifo->buffer = RING_BUFFER_MALLOC(size);
    * m' @* T5 k- D
69. 
      r) C# F9 V' q) _& ]7 r; N6 y
70.     if(fifo->buffer == NULL)
    5 F; E! f- k4 X1 X* I
71.     {
    ; B! Y9 z: J2 Y; [; n+ [+ n! k
72.       RING_BUFFER_FREE(fifo);
    0 F& C0 k: P- D' c
73.       return NULL;
    
74.     }
    
75. 
    
76.     fifo->size = size;
    ( S3 _3 v) X. i' ~* w8 S
77.     fifo->in = fifo->out = 0;
    1 Z5 I0 F5 H5 `' w' F! U0 d3 P
78.   }
    
79. 
    1 V( i0 M* D* z# b
80.   return fifo;
    
81. }
    
82. 
    
83. /**
    8 y* k8 U  {5 {
84.   * @brief  Frees the FIFO.
    
85.   * @param  [in] fifo: The fifo to be freed.
    
86.   * @return None.
    
87.   */
    
88. void RingBuffer_Free(RingBuffer *fifo)
    
89. {
    
90.   RING_BUFFER_FREE(fifo->buffer);
    + _  p1 S0 Q, |* T3 t+ R; s
91.   RING_BUFFER_FREE(fifo);
    
92. }
    
93. 
    
94. /**
    
95.   * @brief  Puts some data into the FIFO.
    ' o! H- Y0 G$ L; o  K0 l1 z; W  Z
96.   * @param  [in] fifo: The fifo to be used.
    " X  t: C0 O+ k( [5 e
97.   * @param  [in] in:   The data to be added.
    5 K! `$ h7 L( p  Y% s0 |. B, t
98.   * @param  [in] len:  The length of the data to be added.
    0 u( W5 W6 X" _  L3 _1 I& k8 D
99.   * @return The number of bytes copied.
    
100.   * @note   This function copies at most @len bytes from the @in into
     
101.   *         the FIFO depending on the free space, and returns the number
     
102.   *         of bytes copied.
     
103.   */
     
104. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len)
     
105. {
     
106.   len = min(len, RingBuffer_Avail(fifo));
     
107. 
     
108.   /* First put the data starting from fifo->in to buffer end. */
     ( _: H" O# H7 \6 J8 P( j
109.   uint32_t l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
     ! L) E  ]. G: V4 H
110.   memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), in, l);
     
111. 
     
112.   /* Then put the rest (if any) at the beginning of the buffer. */
     3 p+ U$ ?7 a8 l# u0 t, |
113.   memcpy(fifo->buffer, (uint8_t *)in + l, len - l);
     " ?, K5 G9 m+ z1 L( M( c- ]' T
114. 
     
115.   fifo->in += len;
     5 x; y* Q. o0 N, i
116. 
     : i0 u- v+ p5 Z6 t
117.   return len;
     % d) ^. J5 ?" _% m  D" n- j5 g$ \# |
118. }
     
119. 
     
120. /**
     
121.   * @brief  Gets some data from the FIFO.
     - M) Z" `- b' c
122.   * @param  [in] fifo: The fifo to be used.
     
123.   * @param  [in] out:  Where the data must be copied.
     
124.   * @param  [in] len:  The size of the destination buffer.
     , \( {! y! f) w$ A% y. `+ X( A& b5 E
125.   * @return The number of copied bytes.
     0 H2 |2 n, @% o( O) B0 A
126.   * @note   This function copies at most @len bytes from the FIFO into
     
127.   *         the @out and returns the number of copied bytes.
     
128.   */
     1 Y6 G! I2 C) C* s3 P. D
129. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len)
     
130. {
     
131.   len = min(len, RingBuffer_Len(fifo));
     
132. 
     
133.   /* First get the data from fifo->out until the end of the buffer. */
     8 G* m: ~6 P& ?
134.   uint32_t l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
     
135.   memcpy(out, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
     4 v+ a  C) R1 _0 h* q
136. 
     . A0 H% G, `$ J& i5 ^, L
137.   /* Then get the rest (if any) from the beginning of the buffer. */
     
138.   memcpy((uint8_t *)out + l, fifo->buffer, len - l);
     % U: u; x: r. U( Q
139. 
     5 P7 ~3 }  Z  M, G# v, \
140.   fifo->out += len;
     " L1 n& B8 H3 u. h' [" _5 h! d
141. 
     
142.   return len;
     / U) U% Z  R: {
143. }
     
144. 
     4 {( P& t  }- b" i# E
145. /**
     
146.   * @brief  Determine whether some value is a power of two.
     - S% F- Z; G) {  c- t0 H  Q8 E, N
147.   * @param  [in] x: The number to be confirmed.
     
148.   * @retval true:   Yes.
     
149.   * @retval false:  No.
     
150.   * @note   Where zero is not considered a power of two.
     
151.   */
     3 ?, o+ t2 f5 c2 j4 U
152. static bool is_power_of_2(uint32_t x)
     1 ?7 E! J9 B" h9 }6 z
153. {
     
154.   return (x != 0) && ((x & (x - 1)) == 0);
     
155. }
     
156. 
     
157. /**
     
158.   * @brief  Round the given value up to nearest power of two.
     
159.   * @param  [in] x: The number to be converted.
     , A+ y* v* k4 U
160.   * @return The power of two.
     
161.   */
     
162. static uint32_t roundup_pow_of_two(uint32_t x)
     
163. {
     
164.   uint32_t b = 0;
     ; [7 N' y( p3 ^7 j$ {0 x3 s
165. 
     " ~: f1 p3 ]! |; g+ c& D: v
166.   for(int i = 0; i < 32; i++)
     . u. E7 B( u/ B. C$ ?5 b* [2 F2 R
167.   {
       {6 Z7 z) z, f( [2 q8 O3 m  }
168.     b = 1UL << i;
     
169. 
     ; B+ x1 o9 ^% y1 v8 Z5 f' R; P
170.     if(x <= b)
     # B6 q. K7 J8 b) b. F1 {4 V/ c
171.     {
     
172.       break;
     # b0 }  x7 C7 ~9 v( V
173.     }
     % @6 s8 _) r7 ~: X
174.   }
     
175. 
     + w3 m1 G/ D2 P" a; z) J
176.   return b;
     
177. }</div><div></div>

复制代码

- c: J2 }9 S0 y/ _% f  ?/ ]CAN.h 文件
- B( m) \8 x3 j2 ^* p: s# ]

1. /**
   
2.   ******************************************************************************
   9 O, k4 x8 U  {, w) F3 X
3.   * @file    CAN.h
   
4.   * @author  XinLi
   
5.   * @version v1.0
   
6.   * @date    24-June-2018
   7 {$ H) b5 I2 c) m
7.   * @brief   Header file for CAN.c module.
   ! O' g5 ]( G7 Z% g8 @, P0 ?
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    . Z) R# }+ d) f  `
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    % _1 s: {& h4 ?% U7 g5 v4 F
14.   * it under the terms of the GNU General Public License as published by
    7 A) V0 P+ }6 k+ W- C2 M  C
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    ( ~' g3 J) D( R+ B, A0 ^8 s7 l
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      P/ i* Z; e: g
21.   * GNU General Public License for more details.
    ) l! S  m! I/ ^4 k/ p
22.   *
    ' ]( N/ L) a. |$ W# a) G
23.   * You should have received a copy of the GNU General Public License
    - f4 Z9 _7 `+ F9 j% R) G8 _* p$ [5 Y  n
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    
25.   *
    6 U. R7 u! p: n1 b6 T/ W
26.   ******************************************************************************
    # ]9 N( k  Z8 [2 h
27.   */
    
28. 
    
29. #ifndef __CAN_H
    
30. #define __CAN_H
    ! Z  c) p, S0 X# H
31. 
    
32. #ifdef __cplusplus
    / J& J3 a$ E3 x- X. d4 C
33. extern "C" {
    0 ?+ s. i, H4 H0 K$ M( k
34. #endif
    ( m) {" u& {: v1 @. @
35. 
    5 L$ i: e8 s/ p* e
36. /* Header includes -----------------------------------------------------------*/
    ) k& E' Q' k  _3 h# |3 X
37. #include "stm32f10x.h"
    : q% A% ]5 s+ h* w7 ^' A) y3 y& ]' [
38. #include <stdbool.h>
    
39. 
    
40. /* Macro definitions ---------------------------------------------------------*/
    
41. 
    + w6 @/ ?* W. i) B
42. /******************************* CAN1 Configure *******************************/
    . K5 [* a& W# Q
43. #define CAN1_TX_BUFFER_SIZE        (16)
    
44. #define CAN1_RX_BUFFER_SIZE        (16)
    
45. 
    ) f  _; b/ {$ e4 k' K1 ]2 w0 O
46. #define CAN1_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    6 r$ l$ E) {( M' G8 L- K" d
47. #define CAN1_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    ' {" S* n3 e3 N1 |$ ~$ i
48. 
    
49. #define CAN1_TX_GPIO_PORT          GPIOB
    
50. #define CAN1_RX_GPIO_PORT          GPIOB
    5 u, j7 W' }7 [( f
51. 
    
52. #define CAN1_TX_GPIO_PIN           GPIO_Pin_9
    
53. #define CAN1_RX_GPIO_PIN           GPIO_Pin_8
    . V6 s- X( I; D* ?9 L
54. 
    
55. #define CAN1_IRQ_PREEMPT_PRIORITY  (0)
    
56. #define CAN1_IRQ_SUB_PRIORITY      (0)
    ( P# x$ V/ b* i6 x3 F- F4 A7 r
57. 
    / f& W& f3 P+ X* S' X- b
58. #define CAN1_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap1_CAN1 , ENABLE)
    1 q: ]- W* W1 O" J" w: X
59. /******************************************************************************/
    
60. 
    1 {- `% U# @0 g
61. #ifdef STM32F10X_CL
    7 O1 K. ?: e# ]( X; T' A
62. /******************************* CAN2 Configure *******************************/
    8 D; R6 ?$ {5 x+ R1 c! [
63. #define CAN2_TX_BUFFER_SIZE        (16)
    
64. #define CAN2_RX_BUFFER_SIZE        (16)
    & \; W3 A9 T; z8 R6 i4 [. B3 o
65. 
    & z9 J# A2 p) b  O
66. #define CAN2_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
67. #define CAN2_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
68. 
    
69. #define CAN2_TX_GPIO_PORT          GPIOB
    
70. #define CAN2_RX_GPIO_PORT          GPIOB
    
71. 
    
72. #define CAN2_TX_GPIO_PIN           GPIO_Pin_13
    
73. #define CAN2_RX_GPIO_PIN           GPIO_Pin_12
    
74. 
    $ {5 N5 M# l' Q
75. #define CAN2_IRQ_PREEMPT_PRIORITY  (0)
    
76. #define CAN2_IRQ_SUB_PRIORITY      (0)
    5 S; a8 T9 o. e1 {% ~2 Z
77. 
    " K5 n: _+ ]% v: X/ d* j
78. #define CAN2_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap_CAN2 , DISABLE)
    - g1 s, ?5 x* K1 c' g. F7 p0 k0 v
79. /******************************************************************************/
    
80. #endif /* STM32F10X_CL */
    
81. 
    
82. /* Type definitions ----------------------------------------------------------*/
    
83. typedef enum
    0 T' ?4 l% X4 N( p! w
84. {
    & ?  i9 F& f/ U9 z
85.   CAN_WorkModeNormal   = CAN_Mode_Normal,
    
86.   CAN_WorkModeLoopBack = CAN_Mode_LoopBack
    : A6 e/ b2 r4 F- g
87. }CAN_WorkMode;
    ) y( [6 `7 _$ P  A0 x4 H0 |3 k
88. 
    
89. typedef enum
    
90. {
    
91.   CAN_BaudRate1000K = 6,
    
92.   CAN_BaudRate500K  = 12,
    
93.   CAN_BaudRate250K  = 24,
    
94.   CAN_BaudRate125K  = 48,
    & M- g5 {% o$ K+ s
95.   CAN_BaudRate100K  = 60,
    4 T" U! X( J$ ?. d
96.   CAN_BaudRate50K   = 120,
    7 P9 E* }" w$ y
97.   CAN_BaudRate20K   = 300,
    4 e& z: f$ A4 x8 r) |! J
98.   CAN_BaudRate10K   = 600
    : s3 Q" Q3 D& p7 n+ [0 ^$ i
99. }CAN_BaudRate;
    . _; f! o8 @# L2 o- w$ N
100. 
     
101. /* Variable declarations -----------------------------------------------------*/
     / @3 f1 c" O- B. a. _( r: _
102. /* Variable definitions ------------------------------------------------------*/
     ( y: [4 X/ M3 m+ l
103. /* Function declarations -----------------------------------------------------*/
     * T. A1 A  r: n$ s4 M
104. void CAN_Configure(CAN_TypeDef *CANx, CAN_WorkMode WorkMode, CAN_BaudRate BaudRate, uint32_t StdId, uint32_t ExtId);
     . \1 A# f. a) }  O0 @) d8 w
105. void CAN_Unconfigure(CAN_TypeDef *CANx);
     ; V1 N# }6 q) c8 d
106. 
     
107. void CAN_SetTransmitFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     
108. void CAN_SetReceiveFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     
109. 
     
110. uint32_t CAN_SetTransmitMessage(CAN_TypeDef *CANx, CanTxMsg *Message, uint32_t Number);
     * E- m+ [2 c( h1 r* [3 X8 p
111. uint32_t CAN_GetReceiveMessage(CAN_TypeDef *CANx, CanRxMsg *Message, uint32_t Number);
     
112. 
     
113. uint32_t CAN_GetUsedTransmitBufferSize(CAN_TypeDef *CANx);
     
114. uint32_t CAN_GetUsedReceiveBufferSize(CAN_TypeDef *CANx);
     - c% s% u5 t% H3 ^
115. uint32_t CAN_GetUnusedTransmitBufferSize(CAN_TypeDef *CANx);
     
116. uint32_t CAN_GetUnusedReceiveBufferSize(CAN_TypeDef *CANx);
     : O" Y. [" S# |6 l
117. 
     + f" X4 n% I5 p' A/ t, r2 A" j9 V7 S
118. bool CAN_IsTransmitBufferEmpty(CAN_TypeDef *CANx);
     + _- Z' I5 g; b: Y; d3 u% z' a
119. bool CAN_IsReceiveBufferEmpty(CAN_TypeDef *CANx);
     
120. bool CAN_IsTransmitBufferFull(CAN_TypeDef *CANx);
     
121. bool CAN_IsReceiveBufferFull(CAN_TypeDef *CANx);
     
122. 
     
123. void CAN_ClearTransmitBuffer(CAN_TypeDef *CANx);
     $ b5 f* C+ z- [; r' t
124. void CAN_ClearReceiveBuffer(CAN_TypeDef *CANx);
     
125. 
     ! g3 l4 S% v5 ]
126. bool CAN_IsTransmitMessage(CAN_TypeDef *CANx);
     * t5 j: \  m" a; }$ |5 ?
127. 
     4 q+ e/ U2 V0 y, Q! o, `$ x
128. /* Function definitions ------------------------------------------------------*/
     
129. 
     
130. #ifdef __cplusplus
     ( D: r  ~& f& e! {" }
131. }
     
132. #endif
     9 E5 s3 g* J! [3 g
133. 
     & O! G, ~( X) @$ J, z/ ?8 Y
134. #endif /* __CAN_H */
     

复制代码

/ P' _1 O: b' {  V+ N) r+ T! p

CAN.c 文件

1. /**
   
2.   ******************************************************************************
   # d1 l) y/ _8 t6 x; c
3.   * @file    CAN.c
   
4.   * @author  XinLi
   
5.   * @version v1.0
   
6.   * @date    24-June-2018
   
7.   * @brief   CAN module driver.
   
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    6 A# U9 b, p+ w+ G
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    ) r* |! O4 R$ g2 |2 B- }0 d
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    : I8 T* O3 D4 F- J8 I7 S# V# }: [
14.   * it under the terms of the GNU General Public License as published by
    
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    # c2 z% w: U7 B# L5 ]: O
22.   *
    9 ~6 D6 l# k1 {2 z2 U, w# V! Q$ [
23.   * You should have received a copy of the GNU General Public License
    
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    
25.   *
    ! u4 q+ a9 ~0 H
26.   ******************************************************************************
    ; X, O" m6 p. |" L/ g
27.   */
    
28. 
    
29. /* Header includes -----------------------------------------------------------*/
    ) y8 }' t- Z! x) A( N. d; [0 m
30. #include "CAN.h"
    
31. #include "RingBuffer.h"
    , |) R+ H. w; o7 e7 v( y2 X4 ?2 b
32. 
    4 g& l- W4 l( e  ^) x, q
33. /* Macro definitions ---------------------------------------------------------*/
    6 ~) b+ E' N; I+ \
34. /* Type definitions ----------------------------------------------------------*/
    
35. /* Variable declarations -----------------------------------------------------*/
    / V# D; K6 J# r% I% q0 r( A
36. static volatile bool can1InitFlag     = false;
    
37. static volatile bool can1TransmitFlag = false;
    
38. 
    
39. static volatile void (*can1TransmitFinishCallback)(void) = 0;
    7 Y9 g' y" \) C  t, V
40. static volatile void (*can1ReceiveFinishCallback)(void)  = 0;
    - I- T9 V7 q: I) \. K( U
41. 
    
42. static RingBuffer *can1TxBuffer = 0;
    % b  E/ Y# g- E8 ]) K; m- G
43. static RingBuffer *can1RxBuffer = 0;
    9 y2 W( }5 ?$ |7 I+ _
44. 
    
45. #ifdef STM32F10X_CL
    . |' k* h# f  N
46. static volatile bool can2InitFlag     = false;
    8 z2 r. j' e# a7 |" c3 l; k' O
47. static volatile bool can2TransmitFlag = false;
    
48. 
    9 {$ m! _6 r% J$ V+ E3 V
49. static volatile void (*can2TransmitFinishCallback)(void) = 0;
    
50. static volatile void (*can2ReceiveFinishCallback)(void)  = 0;
    9 S: Q# Q- c2 s. X6 P$ V
51. 
    * E4 Q# s; T; m: z
52. static RingBuffer *can2TxBuffer = 0;
    
53. static RingBuffer *can2RxBuffer = 0;
    
54. #endif /* STM32F10X_CL */
    5 r- \! z0 @" G( I+ d
55. 
    
56. /* Variable definitions ------------------------------------------------------*/
    
57. /* Function declarations -----------------------------------------------------*/
    ) U% X( \- q: N, A9 }4 Q
58. /* Function definitions ------------------------------------------------------*/
    1 J5 a8 _2 |2 c9 x, {
59. 
    3 U+ i% l0 i% P  n+ w' x
60. /**
    5 m- E6 l- Z- K- Q# B  w1 _
61.   * @brief  CAN configure.
    . X* Y. f' J6 L2 O* v
62.   * @param  [in] CANx:     Where x can be 1 or 2 to select the CAN peripheral.
    
63.   * @param  [in] WorkMode: Work mode.
    4 g2 o! V9 ^8 o1 p0 g. P# ?* M
64.   * @param  [in] BaudRate: Communication baud rate.
    
65.   * @param  [in] StdId:    Filter standard frame ID.
    4 d* B& i1 B: _; A& e+ H
66.   * @param  [in] ExtId:    Filter extended frame ID.
    
67.   * @return None.
    
68.   */
    
69. void CAN_Configure(CAN_TypeDef *CANx, CAN_WorkMode WorkMode, CAN_BaudRate BaudRate, uint32_t StdId, uint32_t ExtId)
    
70. {
    , T. x: e: B" ]
71.   GPIO_InitTypeDef      GPIO_InitStructure      = {0};
    
72.   CAN_InitTypeDef       CAN_InitStructure       = {0};
    
73.   CAN_FilterInitTypeDef CAN_FilterInitStructure = {0};
    
74.   NVIC_InitTypeDef      NVIC_InitStructure      = {0};
    $ _/ A9 {7 ^1 H+ ?+ ~
75. 
    . r, B7 G5 n8 z' V: V3 r* c
76.   if(CANx == CAN1)
    5 M8 w3 G' e8 X0 N2 R1 w) \" {
77.   {
    6 H) Q# K  Z* j- P; f$ O) X7 Y
78.     if(can1InitFlag == false)
    : ^2 |. H" n8 b* g7 _
79.     {
    
80.       can1InitFlag = true;
    
81. 
    
82.       can1TransmitFlag = false;
    0 Y3 k4 G# m/ f8 h: [7 _
83. 
    
84.       can1TransmitFinishCallback = 0;
    
85.       can1ReceiveFinishCallback  = 0;
    ( A$ ]/ X, n- ^2 Z' |- ?3 ?) E
86. 
    
87.       can1TxBuffer = RingBuffer_Malloc(sizeof(CanTxMsg) * CAN1_TX_BUFFER_SIZE);
    
88.       can1RxBuffer = RingBuffer_Malloc(sizeof(CanRxMsg) * CAN1_RX_BUFFER_SIZE);
    * ?2 p( {9 G& C3 I5 B4 Y
89. 
    
90. #ifdef STM32F10X_CL
    5 I5 S: h$ j1 a9 O. _, W4 v- X; _5 c
91.       if(can2InitFlag == false)
    + d' L9 E! Z% B
92. #endif /* STM32F10X_CL */
    
93.       {
    + _% n* V5 y. H; j  S
94.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    
95.       }
    ! s* C; v/ `7 }; V
96. 
    
97.       RCC_APB2PeriphClockCmd(CAN1_TX_GPIO_CLOCK | CAN1_RX_GPIO_CLOCK | RCC_APB2Periph_AFIO, ENABLE);
    
98. 
    
99.       GPIO_InitStructure.GPIO_Pin   = CAN1_TX_GPIO_PIN;
    ( U5 F: |3 |+ i! g
100.       GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
     
101.       GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     8 G3 L7 a& E8 c. b$ S7 n
102.       GPIO_Init(CAN1_TX_GPIO_PORT, &GPIO_InitStructure);
     ; s  Y, H* y( {( p4 m
103. 
     
104.       GPIO_InitStructure.GPIO_Pin   = CAN1_RX_GPIO_PIN;
     . z$ v  D: ?# _' K4 X( Y' M
105.       GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IPU;
     0 W( A9 t1 d# O4 b/ @  G! Q+ ]
106.       GPIO_Init(CAN1_RX_GPIO_PORT, &GPIO_InitStructure);
     
107. 
     4 \- c! f$ x/ v. u
108.       CAN1_PORT_REMAP();
     
109. 
     
110.       CAN_InitStructure.CAN_Prescaler = BaudRate;
     9 D0 G9 \+ |/ h: r; d5 E
111.       CAN_InitStructure.CAN_Mode      = WorkMode;
     3 U7 P7 x- f; h1 I4 ]
112.       CAN_InitStructure.CAN_SJW       = CAN_SJW_1tq;
     
113.       CAN_InitStructure.CAN_BS1       = CAN_BS1_3tq;
     
114.       CAN_InitStructure.CAN_BS2       = CAN_BS2_2tq;
     / U* M, T% h7 L3 L
115.       CAN_InitStructure.CAN_TTCM      = DISABLE;
     
116.       CAN_InitStructure.CAN_ABOM      = ENABLE;
     
117.       CAN_InitStructure.CAN_AWUM      = DISABLE;
     
118.       CAN_InitStructure.CAN_NART      = ENABLE;
     4 S6 A% h8 U# q/ ]  u3 f% o, e
119.       CAN_InitStructure.CAN_RFLM      = DISABLE;
     
120.       CAN_InitStructure.CAN_TXFP      = ENABLE;
     
121. 
     $ z  e+ j, \0 D: q# v/ m0 o
122.       CAN_DeInit(CAN1);
     
123.       CAN_Init(CAN1, &CAN_InitStructure);
     : ^4 a. R# [9 P6 e$ H" M$ V  x( l
124. 
     
125.       CAN_FilterInitStructure.CAN_FilterIdHigh         = (uint16_t)((((StdId<<18)|ExtId)<<3)>>16);
     
126.       CAN_FilterInitStructure.CAN_FilterIdLow          = (uint16_t)(((StdId<<18)|ExtId)<<3);
     # F% |- `  e" m) v1 A
127.       CAN_FilterInitStructure.CAN_FilterMaskIdHigh     = (~((uint16_t)((((StdId<<18)|ExtId)<<3)>>16)))&0xFFFF;
     # e+ U; Z! u. h7 s$ u
128.       CAN_FilterInitStructure.CAN_FilterMaskIdLow      = (~((uint16_t)(((StdId<<18)|ExtId)<<3)))&0xFFF8;
     ( K3 c; N' O4 h- Z8 _; B7 q8 B: l" b
129.       CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_Filter_FIFO0;
     
130.       CAN_FilterInitStructure.CAN_FilterNumber         = 0;
     
131.       CAN_FilterInitStructure.CAN_FilterMode           = CAN_FilterMode_IdMask;
     
132.       CAN_FilterInitStructure.CAN_FilterScale          = CAN_FilterScale_32bit;
     
133.       CAN_FilterInitStructure.CAN_FilterActivation     = ENABLE;
     
134.       CAN_FilterInit(&CAN_FilterInitStructure);
     1 Y6 N1 x' Z0 e6 a9 ^& j; F1 r& x
135. 
     $ ~/ r' x8 n- O) ]6 `
136.       CAN_ITConfig(CAN1, CAN_IT_TME | CAN_IT_FMP0 |CAN_IT_FF0 | CAN_IT_FOV0 | CAN_IT_FMP1 | CAN_IT_FF1 | CAN_IT_FOV1 |
     
137.                          CAN_IT_WKU | CAN_IT_SLK  |CAN_IT_EWG | CAN_IT_EPV  | CAN_IT_BOF  | CAN_IT_LEC | CAN_IT_ERR, DISABLE);
     
138.       CAN_ITConfig(CAN1, CAN_IT_TME | CAN_IT_FMP0, ENABLE);
     2 t8 i7 d7 s% T* I8 p
139. 
     
140. #ifdef STM32F10X_CL
     ; k6 Y, G! A: U9 L2 h
141.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN1_TX_IRQn;
     * \! `6 E/ r$ `5 B" n+ o
142. #else
     1 P# }* s* P5 w8 v) C8 ]- V( i! K
143.       NVIC_InitStructure.NVIC_IRQChannel                   = USB_HP_CAN1_TX_IRQn;
     ! M3 e$ a, g5 j1 e3 H) H( E9 ^
144. #endif /* STM32F10X_CL */
     
145. 
     $ L: D$ J- S5 x. U+ Q$ v7 K. S9 Y
146.       NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = CAN1_IRQ_PREEMPT_PRIORITY;
       K3 |. F- D" r& X# u
147.       NVIC_InitStructure.NVIC_IRQChannelSubPriority        = CAN1_IRQ_SUB_PRIORITY;
     
148.       NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
     ) O. R0 X& P6 w! A6 a
149.       NVIC_Init(&NVIC_InitStructure);
     * V! k; R) g% D  A
150. 
     1 j3 d) e$ x" K8 Y( _, f+ H
151. #ifdef STM32F10X_CL
     ( Q. f1 S9 J9 u# N& i
152.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN1_RX0_IRQn;
     
153. #else
     
154.       NVIC_InitStructure.NVIC_IRQChannel                   = USB_LP_CAN1_RX0_IRQn;
     ! p- a% [* P' ~8 w3 f# p& V
155. #endif /* STM32F10X_CL */
     . ~+ k% L( f; A5 X
156. 
     
157.       NVIC_Init(&NVIC_InitStructure);
     
158.     }
     ( K0 K! G$ {) S. K% h
159.   }
     
160. 
     
161. #ifdef STM32F10X_CL
     
162.   if(CANx == CAN2)
     5 b, U. R! j" z3 Y  f1 t, J
163.   {
     
164.     if(can2InitFlag == false)
     & Y0 f; g, ]3 r/ R, Y
165.     {
     ( D; _. y3 |9 ~# v
166.       can2InitFlag = true;
     
167. 
     / z+ w# E' Y" A) _1 L/ i! ^
168.       can2TransmitFlag = false;
     
169. 
     
170.       can2TransmitFinishCallback = 0;
     % U0 R7 a* `3 K4 f% O3 t, ?
171.       can2ReceiveFinishCallback  = 0;
     / `6 |8 m9 t% i$ _- R5 _
172. 
     1 S5 Z* ~- x+ r  h3 G# I
173.       can2TxBuffer = RingBuffer_Malloc(sizeof(CanTxMsg) * CAN2_TX_BUFFER_SIZE);
     
174.       can2RxBuffer = RingBuffer_Malloc(sizeof(CanRxMsg) * CAN2_RX_BUFFER_SIZE);
     
175. 
     2 L5 B3 |+ x5 @! J" l  S
176.       if(can1InitFlag == false)
     
177.       {
     0 [$ h: p% R/ \3 x
178.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
     % {% d  G4 ?# y* [8 k
179.       }
     : e4 _/ c7 ~) g
180. 
     . C1 G% I2 M* J0 U' {% w$ K; J
181.       RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, ENABLE);
     
182.       RCC_APB2PeriphClockCmd(CAN2_TX_GPIO_CLOCK | CAN2_RX_GPIO_CLOCK | RCC_APB2Periph_AFIO, ENABLE);
     ! H. {0 ^+ V, K+ W
183. 
     
184.       GPIO_InitStructure.GPIO_Pin   = CAN2_TX_GPIO_PIN;
     
185.       GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
     5 O9 C0 B  C, N4 s& G" s, N5 ]
186.       GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     9 B7 J: L+ d) M  }  O$ F1 K: W
187.       GPIO_Init(CAN2_TX_GPIO_PORT, &GPIO_InitStructure);
     
188. 
     
189.       GPIO_InitStructure.GPIO_Pin   = CAN2_RX_GPIO_PIN;
     
190.       GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IPU;
     
191.       GPIO_Init(CAN2_RX_GPIO_PORT, &GPIO_InitStructure);
     
192. 
     
193.       CAN2_PORT_REMAP();
     ! G- q0 Z5 ]+ A/ i9 J2 d
194. 
     6 f. H' W) y& u# C' G
195.       CAN_InitStructure.CAN_Prescaler = BaudRate;
     9 w$ q/ `7 V7 I
196.       CAN_InitStructure.CAN_Mode      = WorkMode;
     / H/ I! l4 {, X0 h: u3 ^- r
197.       CAN_InitStructure.CAN_SJW       = CAN_SJW_1tq;
     
198.       CAN_InitStructure.CAN_BS1       = CAN_BS1_3tq;
     ; n2 R7 t  m: M
199.       CAN_InitStructure.CAN_BS2       = CAN_BS2_2tq;
     
200.       CAN_InitStructure.CAN_TTCM      = DISABLE;
     % V1 t  k. v, |! {" Q7 |, n
201.       CAN_InitStructure.CAN_ABOM      = ENABLE;
     . ?) [% s! n9 {" h  B) q, e
202.       CAN_InitStructure.CAN_AWUM      = DISABLE;
     # c  B3 H0 F0 l
203.       CAN_InitStructure.CAN_NART      = ENABLE;
     " @1 I; E0 S* G3 S8 Q) ~
204.       CAN_InitStructure.CAN_RFLM      = DISABLE;
     
205.       CAN_InitStructure.CAN_TXFP      = ENABLE;
     
206. 
     % q( n7 I) _6 V' }& H( ?
207.       CAN_DeInit(CAN2);
     % N$ N# Q4 c4 q6 D2 k9 _6 Z
208.       CAN_Init(CAN2, &CAN_InitStructure);
     
209. 
     . }+ ~. m" s/ G
210.       CAN_FilterInitStructure.CAN_FilterIdHigh         = (uint16_t)((((StdId<<18)|ExtId)<<3)>>16);
     9 B2 J  H1 C6 R- Z1 r% r, [
211.       CAN_FilterInitStructure.CAN_FilterIdLow          = (uint16_t)(((StdId<<18)|ExtId)<<3);
     2 h- N. X6 Q' `1 a2 u0 H
212.       CAN_FilterInitStructure.CAN_FilterMaskIdHigh     = (~((uint16_t)((((StdId<<18)|ExtId)<<3)>>16)))&0xFFFF;
     ' ], O5 |! Y6 ~6 k/ C* K) j9 J
213.       CAN_FilterInitStructure.CAN_FilterMaskIdLow      = (~((uint16_t)(((StdId<<18)|ExtId)<<3)))&0xFFF8;
     
214.       CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_Filter_FIFO0;
     2 M9 N! y% y) J
215.       CAN_FilterInitStructure.CAN_FilterNumber         = 14;
     
216.       CAN_FilterInitStructure.CAN_FilterMode           = CAN_FilterMode_IdMask;
     
217.       CAN_FilterInitStructure.CAN_FilterScale          = CAN_FilterScale_32bit;
     * P6 K; f( ]0 ~; [; z5 a
218.       CAN_FilterInitStructure.CAN_FilterActivation     = ENABLE;
     ; B) {( P5 U! J+ ]; R4 t
219.       CAN_FilterInit(&CAN_FilterInitStructure);
     4 ~5 @0 @5 H5 K- I4 v" I1 b' `
220. 
     
221.       CAN_ITConfig(CAN2, CAN_IT_TME | CAN_IT_FMP0 |CAN_IT_FF0 | CAN_IT_FOV0 | CAN_IT_FMP1 | CAN_IT_FF1 | CAN_IT_FOV1 |
     6 }: N; ~2 {/ c5 Q, r; v
222.                          CAN_IT_WKU | CAN_IT_SLK  |CAN_IT_EWG | CAN_IT_EPV  | CAN_IT_BOF  | CAN_IT_LEC | CAN_IT_ERR, DISABLE);
     
223.       CAN_ITConfig(CAN2, CAN_IT_TME | CAN_IT_FMP0, ENABLE);
     
224. 
     , q& n" j& A  c# a# G4 ~' }
225.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN2_TX_IRQn;
     
226.       NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = CAN2_IRQ_PREEMPT_PRIORITY;
     
227.       NVIC_InitStructure.NVIC_IRQChannelSubPriority        = CAN2_IRQ_SUB_PRIORITY;
     
228.       NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
     ( \) {  D0 K% e
229.       NVIC_Init(&NVIC_InitStructure);
     
230. 
     ) I, A) q* u. m9 q. f* n% M' J  q; V
231.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN2_RX0_IRQn;
     
232.       NVIC_Init(&NVIC_InitStructure);
     
233.     }
     0 f9 t; D/ t* ^6 G/ ~
234.   }
     
235. #endif /* STM32F10X_CL */
     0 z7 ^9 w0 O! T- U4 b- N
236. }
     
237. 
     2 U" |7 n9 c5 E2 b% [
238. /**
     
239.   * @brief  CAN unconfigure.
     8 U; [' U, G$ j
240.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     
241.   * @return None.
     
242.   */
     " `! M' b& m* {( O( G' }
243. void CAN_Unconfigure(CAN_TypeDef *CANx)
     
244. {
     8 ~2 m7 w9 y6 E$ M6 J
245.   NVIC_InitTypeDef NVIC_InitStructure = {0};
     
246. 
     1 k% M* B! X* }: T
247.   if(CANx == CAN1)
     
248.   {
     9 l4 E6 _& z$ g  R; H
249.     if(can1InitFlag == true)
     ' ~% Q4 C0 ]5 k$ K& R
250.     {
     7 F* h' I  g3 P+ x: T' g
251.       can1InitFlag = false;
     % w3 q7 }3 x) B% o! v& y* S' q
252. 
     
253. #ifdef STM32F10X_CL
     
254.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN1_TX_IRQn;
     ) B5 K% m) L8 H' J! u$ c0 B3 H
255. #else
     
256.       NVIC_InitStructure.NVIC_IRQChannel                   = USB_HP_CAN1_TX_IRQn;
     0 l: W$ @! B4 Z  J
257. #endif /* STM32F10X_CL */
     
258. 
     
259.       NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = CAN1_IRQ_PREEMPT_PRIORITY;
     
260.       NVIC_InitStructure.NVIC_IRQChannelSubPriority        = CAN1_IRQ_SUB_PRIORITY;
     : k# l. R& S& ]! v/ [* ]
261.       NVIC_InitStructure.NVIC_IRQChannelCmd                = DISABLE;
     , ~3 s6 R  Y$ ?- z
262.       NVIC_Init(&NVIC_InitStructure);
     # {* Y$ ]0 w2 Z- u+ _4 O) T3 J& g! |
263. 
     ! b- ]: l( K( K0 {0 X! c8 j7 ^& ^
264. #ifdef STM32F10X_CL
     5 N( |* p# B( u, T# a
265.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN1_RX0_IRQn;
     / }# T# a$ w% I! D
266. #else
     
267.       NVIC_InitStructure.NVIC_IRQChannel                   = USB_LP_CAN1_RX0_IRQn;
     
268. #endif /* STM32F10X_CL */
     
269. 
     
270.       NVIC_Init(&NVIC_InitStructure);
     
271. 
     
272.       CAN_DeInit(CAN1);
     9 J' n: o7 a4 n7 X( E
273. 
     5 t: C& m9 {2 ~9 |* G5 V% F+ A
274. #ifdef STM32F10X_CL
     " J$ w* ?- W; `1 E7 b
275.       if(can2InitFlag == false)
       ~: m% N. b1 F- ^2 }5 g  B: c
276. #endif /* STM32F10X_CL */
     
277.       {
     
278.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, DISABLE);
     
279.       }
     
280. 
     9 W' m" m4 N* r* Z6 M' c
281.       can1TransmitFlag = false;
     
282. 
     
283.       can1TransmitFinishCallback = 0;
     , b( `' m/ R4 o7 U8 B( X1 B- P( p
284.       can1ReceiveFinishCallback  = 0;
     4 ?8 C8 c( Q  C, q9 x/ l
285. 
     2 Z( ]: k3 ]2 l- K/ I8 u4 i
286.       RingBuffer_Free(can1TxBuffer);
     9 Y  _/ A( T$ X: }
287.       RingBuffer_Free(can1RxBuffer);
     
288.     }
     
289.   }
     
290. 
     
291. #ifdef STM32F10X_CL
       s: r4 _1 D. H  P& [# Q
292.   if(CANx == CAN2)
     ; F! @. B! N, y( C9 H8 e7 l
293.   {
     
294.     if(can2InitFlag == true)
     3 Q( ?& P. |! z7 N+ q; S" J
295.     {
     0 z6 W1 k7 }9 p: v3 X. }% u
296.       can2InitFlag = false;
     - Z) L7 w: G* W
297. 
     - \6 j+ B/ N: B/ C
298.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN2_TX_IRQn;
     ( a3 }9 }' F+ e2 b9 ]% x+ u
299.       NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = CAN2_IRQ_PREEMPT_PRIORITY;
     , `; N& I' R: _  M# L  p- y- ?* ^: ?
300.       NVIC_InitStructure.NVIC_IRQChannelSubPriority        = CAN2_IRQ_SUB_PRIORITY;
     - G8 a3 w7 U& u3 z7 p
301.       NVIC_InitStructure.NVIC_IRQChannelCmd                = DISABLE;
     , |$ I: r& n8 ^8 B" q0 o7 a
302.       NVIC_Init(&NVIC_InitStructure);
     
303. 
     ; Q7 h8 i0 [3 W8 g7 [% q' T
304.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN2_RX0_IRQn;
     , I5 H, H0 a1 Z. q- a! }' o
305.       NVIC_Init(&NVIC_InitStructure);
     
306. 
     
307.       CAN_DeInit(CAN2);
     6 @; T$ K+ q, u' f0 u6 {
308. 
     
309.       if(can1InitFlag == false)
     
310.       {
     
311.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, DISABLE);
     
312.       }
     6 c9 n' \6 e6 T4 H5 |  x, C. K+ u6 ]
313. 
     
314.       RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, DISABLE);
     
315. 
     
316.       can2TransmitFlag = false;
     
317. 
     " U& h# k0 W7 w4 u) Y  G; U
318.       can2TransmitFinishCallback = 0;
     . F7 C  ^( C2 |$ f/ U3 G+ m
319.       can2ReceiveFinishCallback  = 0;
     4 @. l; R, e7 B
320. 
     
321.       RingBuffer_Free(can2TxBuffer);
     0 M' \9 o- S8 p# Q0 E- ^; p
322.       RingBuffer_Free(can2RxBuffer);
     & ]. j+ y9 d3 D1 Y7 a5 w
323.     }
     
324.   }
     8 z3 z4 m3 @% D( D
325. #endif /* STM32F10X_CL */
     : z; S2 i( |! E" J8 O) w3 G
326. }
     
327. 
     4 k8 W, T) R- M, U1 H# M) M
328. /**
     
329.   * @brief  CAN set transmit finish callback.
     0 w, U9 u% m+ w: K3 q
330.   * @param  [in] CANx:     Where x can be 1 or 2 to select the CAN peripheral.
     
331.   * @param  [in] Callback: Callback.
     ) g8 W$ P" q' g2 i* d
332.   * @return None.
     
333.   */
     0 r2 ]8 [3 [" o- j+ \
334. void CAN_SetTransmitFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void))
     
335. {
     2 w2 P; G  Y* H( W2 t
336.   if(CANx == CAN1)
     
337.   {
     7 Y' X) O$ M; `: T# w
338.     if(can1InitFlag == true)
     7 \% F0 [/ Q! ^* m) \$ J- d
339.     {
     9 M0 @  i! h$ c: [0 w3 x* n
340.       can1TransmitFinishCallback = (volatile void (*)(void))Callback;
     ! }! S& {  ~% H+ v+ k! w
341.     }
     ) l* |" b4 g( I: A/ k- x
342.   }
     % i# D# h/ d. X" R0 l
343. 
     / b$ M  r& q( F7 \" k# x
344. #ifdef STM32F10X_CL
     $ C: O/ L* C7 S+ z( X
345.   if(CANx == CAN2)
     / t; d' z" U% G( X5 q  v1 ?
346.   {
     
347.     if(can2InitFlag == true)
     
348.     {
     
349.       can2TransmitFinishCallback = (volatile void (*)(void))Callback;
     # o( Y  h  q4 J. q  ?% V+ Q6 h
350.     }
     
351.   }
     
352. #endif /* STM32F10X_CL */
     5 M! u$ Z2 M$ ]8 u% j: L
353. }
       B* ~, P- O9 T7 L4 l
354. 
     0 o" K. t. {. _# I
355. /**
     % f3 T& U3 r& e# X
356.   * @brief  CAN set receive finish callback.
     : N) D% I4 T: ~. b+ o  [
357.   * @param  [in] CANx:     Where x can be 1 or 2 to select the CAN peripheral.
     9 L5 @# {, s8 y! |
358.   * @param  [in] Callback: Callback.
     
359.   * @return None.
     
360.   */
     1 w2 ?) B" x4 {" i0 k
361. void CAN_SetReceiveFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void))
     
362. {
     
363.   if(CANx == CAN1)
     9 p" V: k- ~9 A
364.   {
     + Y4 T) e8 x* y- d" c
365.     if(can1InitFlag == true)
     
366.     {
     
367.       can1ReceiveFinishCallback = (volatile void (*)(void))Callback;
     & ^/ V7 e+ J( r; F7 s, P7 ~: z
368.     }
     ( ^* F' o$ m; ^) y
369.   }
     + R9 w! x8 o' [
370. 
     $ d4 y4 b4 N: S  n
371. #ifdef STM32F10X_CL
     : r1 Y3 @. M' n
372.   if(CANx == CAN2)
     / W/ Z  u. T# l& R" P1 W! }$ f
373.   {
     
374.     if(can2InitFlag == true)
     ; j! n1 o. N" ~3 r4 U6 b% {
375.     {
     
376.       can2ReceiveFinishCallback = (volatile void (*)(void))Callback;
     
377.     }
     
378.   }
     6 t5 S  U4 D% Z; V- Y
379. #endif /* STM32F10X_CL */
     . o. j7 y" A: Q
380. }
     
381. 
     
382. /**
     
383.   * @brief  CAN set transmit message.
       u. F' i3 ?" _# H7 a1 f
384.   * @param  [in] CANx:    Where x can be 1 or 2 to select the CAN peripheral.
     - v. N1 h, S% {  a$ E! j) {
385.   * @param  [in] Message: The address of the message to be transmit.
     . ^" _4 q; \( D# j! T: y& q
386.   * @param  [in] Number:  The number of the message to be transmit.
     
387.   * @return The number of message transmit.
     3 @6 b# w( \; g: ^! [8 T4 G7 O
388.   */
     / z; y/ z' n, O* y4 F
389. uint32_t CAN_SetTransmitMessage(CAN_TypeDef *CANx, CanTxMsg *Message, uint32_t Number)
     ! h! j4 n; m  _& H$ g/ s. i  X
390. {
     * T. Z/ R. m# r. |+ U
391.   if(CANx == CAN1)
     
392.   {
     , r: r+ p& S  H8 d1 r5 V8 ?
393.     if(can1InitFlag == true)
     + Y; z2 h+ \7 f4 g/ ~: m- Z
394.     {
     
395.       uint32_t available = RingBuffer_Avail(can1TxBuffer) / sizeof(CanTxMsg);
     
396. 
     5 d1 v: u# V/ F
397.       if(available > Number)
     
398.       {
     
399.         Number = RingBuffer_In(can1TxBuffer, Message, sizeof(CanTxMsg) * Number) / sizeof(CanTxMsg);
     
400.       }
     
401.       else
     
402.       {
     
403.         Number = RingBuffer_In(can1TxBuffer, Message, sizeof(CanTxMsg) * available) / sizeof(CanTxMsg);
     
404.       }
     / F1 L5 _3 t: B! U+ a
405. 
     
406.       if(Number > 0)
     # `' s; `) v( d# Y. M8 a6 C
407.       {
     
408.         if(can1TransmitFlag == false)
     6 \5 t" F0 v- @6 @2 v  ~* v3 _
409.         {
     0 g( d7 N8 F: l" t3 h! }
410.           can1TransmitFlag = true;
     - s) y3 w. U7 L0 g; j0 W% H* C
411. 
       T  V" a8 h2 t1 B% k
412.           CanTxMsg canTxMsg = {0};
     ! p- `! Y9 k9 g- d) J3 a3 t! U
413.           RingBuffer_Out(can1TxBuffer, &canTxMsg, sizeof(canTxMsg));
     
414.           CAN_Transmit(CAN1, &canTxMsg);
     9 U  J$ F; j& t+ H! w3 G
415.         }
     $ a; p  Q' q: Z' b: ^7 U' e
416.       }
     ; G$ M0 i0 L& w: ^* |
417. 
     
418.       return Number;
     ) u' M' \( j/ O, T1 q
419.     }
     - S7 ~$ g+ _; _
420.   }
     $ d- x8 y! n* ~) J3 ]- z
421. 
     3 j" J1 r) R: E) j# y
422. #ifdef STM32F10X_CL
     
423.   if(CANx == CAN2)
     
424.   {
     , M2 T4 i' L3 _: l* |. O$ v
425.     if(can2InitFlag == true)
     7 o( u3 ^' _" [) T- B/ @
426.     {
     / k" w" T( U, H4 s( U0 P
427.       uint32_t available = RingBuffer_Avail(can2TxBuffer) / sizeof(CanTxMsg);
     3 p* q4 K: j8 Q8 n
428. 
     
429.       if(available > Number)
     ; h  F1 c3 ]4 m8 e) r
430.       {
     
431.         Number = RingBuffer_In(can2TxBuffer, Message, sizeof(CanTxMsg) * Number) / sizeof(CanTxMsg);
     
432.       }
     
433.       else
     
434.       {
     ! C; H6 b2 r6 C/ ?
435.         Number = RingBuffer_In(can2TxBuffer, Message, sizeof(CanTxMsg) * available) / sizeof(CanTxMsg);
     
436.       }
     
437. 
     ! K& @- c+ f7 o" g6 j
438.       if(Number > 0)
     4 S" B/ [% I: ~# b* H
439.       {
     
440.         if(can2TransmitFlag == false)
     / z& R8 Q3 f: T+ C. ~1 |& ~  P
441.         {
     
442.           can2TransmitFlag = true;
     1 B* Z& x3 n8 }( O! O$ s7 n% K
443. 
     1 e$ Q! Z/ j. k- I1 D. ?/ u
444.           CanTxMsg canTxMsg = {0};
     
445.           RingBuffer_Out(can2TxBuffer, &canTxMsg, sizeof(canTxMsg));
     
446.           CAN_Transmit(CAN2, &canTxMsg);
     8 O: J& [" d& i. B# m# i
447.         }
     
448.       }
     " ~4 [1 x5 Y4 y: X7 I% t
449. 
     6 ?3 j. }# K' w
450.       return Number;
     ! z( N" w& K$ ~0 x  {) D
451.     }
     4 ]5 E' [7 J% i9 s) b
452.   }
     8 s! q$ g! W+ I+ ^' c. _) |
453. #endif /* STM32F10X_CL */
     4 [1 {& e6 _1 _
454. 
     
455.   return 0;
     
456. }
     
457. 
     
458. /**
     ; C9 h3 l( B, R' y, U
459.   * @brief  CAN get receive message.
     " `3 t9 ^! r7 }2 I! m
460.   * @param  [in] CANx:    Where x can be 1 or 2 to select the CAN peripheral.
     : M( c8 v% s$ v0 w. w& W; q
461.   * @param  [in] Message: To store the address of the receive message.
     : T: Q  k0 ]# m, M" A2 P2 O) j( T
462.   * @param  [in] Number:  To read the number of the received message.
     
463.   * @return The number of message obtained.
     
464.   */
     
465. uint32_t CAN_GetReceiveMessage(CAN_TypeDef *CANx, CanRxMsg *Message, uint32_t Number)
     
466. {
     
467.   if(CANx == CAN1)
     
468.   {
     ' o( A7 x' T- \3 h
469.     if(can1InitFlag == true)
     
470.     {
     # |% ]) `$ d9 i% K5 y
471.       return RingBuffer_Out(can1RxBuffer, Message, sizeof(CanRxMsg) * Number) / sizeof(CanRxMsg);
     ; B/ @/ V8 D' M. t' [* I4 K
472.     }
     
473.   }
     
474. 
     ( y; ^& j& z' Z& c
475. #ifdef STM32F10X_CL
     
476.   if(CANx == CAN2)
     ' v! L- r) ^2 g
477.   {
     - T' X& T+ i" q: T, u8 `
478.     if(can2InitFlag == true)
     # T3 L/ J) N# Y- N, }9 t
479.     {
     1 p9 b4 F0 Q/ Q. ~; Q; M, v% n
480.       return RingBuffer_Out(can2RxBuffer, Message, sizeof(CanRxMsg) * Number) / sizeof(CanRxMsg);
     
481.     }
     5 O6 Y  _  R1 D" ?! V' I
482.   }
     
483. #endif /* STM32F10X_CL */
     
484. 
     2 C( C8 b2 e& D- q# A7 v
485.   return 0;
     : r5 e. K+ `4 A9 U, C
486. }
     5 H; H# \# m0 a0 r0 \
487. 
     1 g3 ^6 m& P0 Y  Z+ q, j
488. /**
     
489.   * @brief  Get the size of the CAN transmit buffer used.
     2 w& P" A. F- a  F
490.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     
491.   * @return Used the size of the transmit buffer.
     
492.   */
     6 M9 n' ]5 p6 Q; K
493. uint32_t CAN_GetUsedTransmitBufferSize(CAN_TypeDef *CANx)
     
494. {
     * N5 p; [3 L& u/ w
495.   if(CANx == CAN1)
     6 {, B: a$ ?/ V
496.   {
     
497.     if(can1InitFlag == true)
       r8 }/ H+ f  b" H6 a  u
498.     {
     7 G' T5 H8 Z- H! {0 Z/ C7 o* v
499.       return RingBuffer_Len(can1TxBuffer) / sizeof(CanTxMsg);
     0 n# N( C1 P& Z3 ^! Z3 f3 o
500.     }
     * M/ i% f1 e! B4 C0 V5 g0 k
501.   }
     9 L0 z( y. Z1 H3 c5 p% v. n# \% G
502. 
     7 u; C* G3 [! {
503. #ifdef STM32F10X_CL
     
504.   if(CANx == CAN2)
     
505.   {
     ! ^3 g# K- I5 l. W% h. y4 _5 Y
506.     if(can2InitFlag == true)
     4 K) G, k9 n' q3 Z  t
507.     {
     
508.       return RingBuffer_Len(can2TxBuffer) / sizeof(CanTxMsg);
       N6 v, L0 s3 @/ S& x' h, r
509.     }
     
510.   }
     
511. #endif /* STM32F10X_CL */
     7 ^3 o+ V' g6 ^- G7 r
512. 
     
513.   return 0;
     
514. }
     
515. 
     % T4 f' v% L) b& i% N
516. /**
     1 I3 {  R& v! x" ?- e  Q$ O
517.   * @brief  Get the size of the CAN receive buffer used.
     
518.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     , V7 N  T8 H8 o- n+ E# i
519.   * @return Used the size of the receive buffer.
     
520.   */
     " n2 ^3 u# t! W( L6 b
521. uint32_t CAN_GetUsedReceiveBufferSize(CAN_TypeDef *CANx)
     
522. {
     $ J% V4 Z& v: ^2 P
523.   if(CANx == CAN1)
     7 ?/ x- P+ {9 Q* k$ n
524.   {
     
525.     if(can1InitFlag == true)
     4 @* ?" l0 ]2 Z9 E5 V
526.     {
     
527.       return RingBuffer_Len(can1RxBuffer) / sizeof(CanRxMsg);
     
528.     }
     2 ^; r- E, y% y! |* W8 e0 A( y
529.   }
     : T' R7 h2 k8 K: I8 _2 j8 P' W
530. 
     
531. #ifdef STM32F10X_CL
     : o7 _# X2 [( W  A7 F
532.   if(CANx == CAN2)
     # W8 Z) Y- ~: _5 a6 ]# T7 l! ^/ W; c1 M" E
533.   {
     
534.     if(can2InitFlag == true)
     # X! m5 I+ ^7 ^
535.     {
     # A; x, ]# b2 P# X$ n7 c
536.       return RingBuffer_Len(can2RxBuffer) / sizeof(CanRxMsg);
     : r8 `& }* b* s$ {0 T% k# z
537.     }
     & ?6 `) O/ v  |9 h3 \9 K& _2 q
538.   }
     
539. #endif /* STM32F10X_CL */
     
540. 
     
541.   return 0;
     : t* l3 B& d# A0 a8 r
542. }
     
543. 
     : \5 i; A/ N7 n$ t
544. /**
     + j) ~6 N$ l& W/ u
545.   * @brief  Get the size of the CAN transmit buffer unused.
     
546.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     3 W$ Y! d3 Q. T. A  }
547.   * @return Unused the size of the transmit buffer.
     
548.   */
     
549. uint32_t CAN_GetUnusedTransmitBufferSize(CAN_TypeDef *CANx)
     ' _) V( x) d& W0 r; c1 A
550. {
     
551.   if(CANx == CAN1)
     8 A$ P# _4 a* N8 H8 N* `+ r% R
552.   {
     
553.     if(can1InitFlag == true)
     2 v. A7 Y9 \4 V: Z; c% ?0 f! h
554.     {
     
555.       return RingBuffer_Avail(can1TxBuffer) / sizeof(CanTxMsg);
     " y; p  A/ ]) i; s' p
556.     }
     , a2 u% X, f) Z4 V+ C- h1 g
557.   }
     3 q% B1 l, r; r# I* {$ h
558. 
     
559. #ifdef STM32F10X_CL
     
560.   if(CANx == CAN2)
     3 {2 E2 V( K, W/ n- A& r( g1 N
561.   {
     & l' q7 U' g5 Z) l  z5 E5 r
562.     if(can2InitFlag == true)
     + P0 f  x/ Q, x8 o
563.     {
     
564.       return RingBuffer_Avail(can2TxBuffer) / sizeof(CanTxMsg);
     
565.     }
     
566.   }
     
567. #endif /* STM32F10X_CL */
     
568. 
     / c# h" z! u( b$ }
569.   return 0;
     . X! Y+ C$ \5 d- \2 ?3 H# h
570. }
     & D( d6 m) T, x( F
571. 
     
572. /**
     9 [+ M% e* |8 H! T  n# a6 A: x
573.   * @brief  Get the size of the CAN receive buffer unused.
     2 R7 H/ d. w3 y* s' u; p" o6 z
574.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     # N3 _% I# f  w* c  `9 ~
575.   * @return Unused the size of the receive buffer.
     
576.   */
     
577. uint32_t CAN_GetUnusedReceiveBufferSize(CAN_TypeDef *CANx)
     
578. {
     
579.   if(CANx == CAN1)
     
580.   {
     
581.     if(can1InitFlag == true)
     
582.     {
     
583.       return RingBuffer_Avail(can1RxBuffer) / sizeof(CanRxMsg);
     
584.     }
     
585.   }
     2 n# J7 f- N. V0 j8 n, r
586. 
     - P, Z8 p8 {9 \7 \9 j
587. #ifdef STM32F10X_CL
     8 w7 l5 v/ E3 X% Z; o
588.   if(CANx == CAN2)
     ) C& O) H" j. }: u. z
589.   {
     
590.     if(can2InitFlag == true)
     / K' Q' b" T) }8 `4 y
591.     {
     
592.       return RingBuffer_Avail(can2RxBuffer) / sizeof(CanRxMsg);
     , j' Q' U) ?1 L) d0 t; h
593.     }
     ' f% Q9 G9 k- c
594.   }
     
595. #endif /* STM32F10X_CL */
     7 a2 f4 z" D* n* O; y; D* Z
596. 
     
597.   return 0;
     
598. }
     
599. 
     
600. /**
     ; f- K1 z$ J. o% T) Z) v% @
601.   * @brief  Is the CAN transmit buffer empty?
     7 {. W: r) E/ ?; i
602.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     / {3 m) X+ I0 c4 s9 c
603.   * @retval true:      The transmit buffer is empty.
     + h- {% c$ ?: G) C+ r
604.   * @retval false:     The transmit buffer is not empty.
     # M: g* ^! K: Q/ u
605.   */
     
606. bool CAN_IsTransmitBufferEmpty(CAN_TypeDef *CANx)
     . E8 T  v" {7 Y1 _; `0 ^! Z
607. {
       t* X" g: D3 D9 Q1 T1 U- N1 N
608.   if(CANx == CAN1)
     7 `  F+ e: u. ]1 X; s% w, k9 D
609.   {
     
610.     if(can1InitFlag == true)
     
611.     {
     ' |' L7 q; B1 F1 o/ }6 Q. B) }
612.       return !(RingBuffer_Len(can1TxBuffer) / sizeof(CanTxMsg));
     
613.     }
     
614.   }
     ; b% d+ ~: T; v' U  O. u9 u- ]
615. 
     3 T! G+ M7 E6 I# t
616. #ifdef STM32F10X_CL
     / n" g$ l% i& v4 F+ r
617.   if(CANx == CAN2)
     
618.   {
     , G9 H; x3 M, n/ A
619.     if(can2InitFlag == true)
     7 w% B9 ~7 [0 u$ J5 Q! \8 z
620.     {
     # k( N$ [/ [% M+ P
621.       return !(RingBuffer_Len(can2TxBuffer) / sizeof(CanTxMsg));
     * {) U' ?7 R# l
622.     }
     
623.   }
     5 m: Y+ @" \3 r& B( o
624. #endif /* STM32F10X_CL */
     
625. 
     
626.   return false;
     # L+ A! }( r" A7 k- C: }+ |
627. }
     1 z3 _  p' N7 c1 y6 p( q" q
628. 
     
629. /**
     2 X- G) M& A; r* N: m6 V% O
630.   * @brief  Is the CAN receive buffer empty?
     
631.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     
632.   * @retval true:      The receive buffer is empty.
     
633.   * @retval false:     The receive buffer is not empty.
     
634.   */
     
635. bool CAN_IsReceiveBufferEmpty(CAN_TypeDef *CANx)
     6 u0 J5 w* ^6 t) \9 M  w6 f) R
636. {
     
637.   if(CANx == CAN1)
     8 T) `- v+ }) D# y
638.   {
     
639.     if(can1InitFlag == true)
     - P% A4 a8 t& R/ O2 s. I4 ?* j4 H
640.     {
     
641.       return !(RingBuffer_Len(can1RxBuffer) / sizeof(CanRxMsg));
     & \+ I1 _) v9 a4 k7 v( _* J% \
642.     }
     # f) a  w& ~7 F9 u
643.   }
     
644. 
     - T7 D, q4 C- Y% ~1 i. J
645. #ifdef STM32F10X_CL
     * |  h# w! l( M2 e
646.   if(CANx == CAN2)
     5 y* O  |" D1 Q  l+ R& O2 z
647.   {
     ) O' o9 v2 e: o% E# l
648.     if(can2InitFlag == true)
     , E' h) u/ Q* p% G
649.     {
     . J1 Q* ^2 G, Y/ v' j# ~8 b
650.       return !(RingBuffer_Len(can2RxBuffer) / sizeof(CanRxMsg));
     
651.     }
     # A  }7 ~' _* L6 G# \
652.   }
     
653. #endif /* STM32F10X_CL */
     
654. 
     
655.   return false;
     6 V: A  Q$ L0 J: s. @) z2 B" q
656. }
     
657. 
     
658. /**
     ( a9 C7 j- e  F" H" K
659.   * @brief  Is the CAN transmit buffer full?
     
660.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     ; R* v; |( w7 Y- `" W7 E' Q2 Y" S/ S
661.   * @retval true:      The transmit buffer is full.
     
662.   * @retval false:     The transmit buffer is not full.
     / e1 s' h" v% v- k" \
663.   */
     
664. bool CAN_IsTransmitBufferFull(CAN_TypeDef *CANx)
     # r+ s; Z9 ^% [* U& ^
665. {
     
666.   if(CANx == CAN1)
     
667.   {
     : H1 }, B1 N" D, Z
668.     if(can1InitFlag == true)
     
669.     {
     
670.       return !(RingBuffer_Avail(can1TxBuffer) / sizeof(CanTxMsg));
     5 @2 N4 G( B& n- O0 k0 x
671.     }
     
672.   }
     
673. 
     
674. #ifdef STM32F10X_CL
     
675.   if(CANx == CAN2)
       U) N0 K* z" v: \0 K6 A2 [1 f
676.   {
     
677.     if(can2InitFlag == true)
     
678.     {
     ; ?' a; s6 |  T/ m2 i4 A3 k; ?
679.       return !(RingBuffer_Avail(can2TxBuffer) / sizeof(CanTxMsg));
     
680.     }
     
681.   }
     . ?- z5 P" H' G
682. #endif /* STM32F10X_CL */
     
683. 
     
684.   return false;
     5 \* v7 P6 K; O) B
685. }
     
686. 
     7 B& T( w) z$ p) S
687. /**
     
688.   * @brief  Is the CAN receive buffer full?
     
689.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     ( Q5 G  B% B6 m( V; N
690.   * @retval true:      The receive buffer is full.
     
691.   * @retval false:     The receive buffer is not full.
     , B. }7 h+ b6 a' v
692.   */
     * {: a) l$ m8 P( h/ _. M4 `
693. bool CAN_IsReceiveBufferFull(CAN_TypeDef *CANx)
     : c8 l9 f( t; G. h" J) m
694. {
     
695.   if(CANx == CAN1)
     ! v7 C, ]* D& ~8 |$ G9 @3 t9 ~  }* a
696.   {
     
697.     if(can1InitFlag == true)
     - C' x4 F5 k: D6 v
698.     {
     0 g+ Z9 d! }* h$ O* \" h' x
699.       return !(RingBuffer_Avail(can1RxBuffer) / sizeof(CanRxMsg));
     
700.     }
     
701.   }
     
702. 
     
703. #ifdef STM32F10X_CL
     1 c" M- v0 C) v  S
704.   if(CANx == CAN2)
     
705.   {
     6 B# Z4 m# t* ^5 y: F+ e2 }
706.     if(can2InitFlag == true)
     
707.     {
     
708.       return !(RingBuffer_Avail(can2RxBuffer) / sizeof(CanRxMsg));
     1 _$ z/ G3 r, ^+ h$ l; M
709.     }
     
710.   }
     
711. #endif /* STM32F10X_CL */
     , m4 Z$ Z9 m/ M5 k- A1 w$ P
712. 
     
713.   return false;
     * ]; ]9 n0 R! J7 _7 B
714. }
     
715. 
     ' r5 H) y6 q; b( c' r$ s" g
716. /**
     . @4 A  Y+ q8 u; c
717.   * @brief  Clear the CAN transmit buffer.
     
718.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     
719.   * @return None.
     , C! r! h. r2 W; X2 h4 C
720.   */
     
721. void CAN_ClearTransmitBuffer(CAN_TypeDef *CANx)
     
722. {
     
723.   if(CANx == CAN1)
     
724.   {
     ' e% Y  }! f9 U; T/ l$ b; G
725.     if(can1InitFlag == true)
     / E' a) @( ]7 P9 V) l9 ?" C, w
726.     {
     
727.       RingBuffer_Reset(can1TxBuffer);
     " o! P  M# m. a
728.     }
     
729.   }
     
730. 
     2 s- j) E6 c, O9 p/ s1 m
731. #ifdef STM32F10X_CL
     
732.   if(CANx == CAN2)
     
733.   {
     
734.     if(can2InitFlag == true)
       q* }$ U7 r8 v
735.     {
     ) V3 ~7 _7 }5 w" k
736.       RingBuffer_Reset(can2TxBuffer);
     1 U6 b' F; V1 J% R- U# M
737.     }
     
738.   }
     
739. #endif /* STM32F10X_CL */
     % A9 P2 Z) C+ }4 R5 f% Z6 ?) J
740. }
     6 W. J- n/ D5 _: N' t; B
741. 
     
742. /**
     
743.   * @brief  Clear the CAN receive buffer.
     
744.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     
745.   * @return None.
     
746.   */
     
747. void CAN_ClearReceiveBuffer(CAN_TypeDef *CANx)
     
748. {
     * Q: j" U: d) i
749.   if(CANx == CAN1)
     
750.   {
     
751.     if(can1InitFlag == true)
     . u$ a) o% |2 [( Z
752.     {
     3 F5 e6 g" j5 d) W/ ^; D
753.       RingBuffer_Reset(can1RxBuffer);
     8 j( K1 }3 H6 O! \
754.     }
     ( @2 W# R  V; p  a2 C2 s& s5 m
755.   }
     1 Z9 A- e& K  v1 X* Q; ~
756. 
     $ L7 p: s, J$ A7 y% G( [1 R
757. #ifdef STM32F10X_CL
     , Z9 K1 E4 c  [% j8 p1 x8 k$ h" S
758.   if(CANx == CAN2)
     1 R" t2 J2 u- [4 Q7 m
759.   {
     * p- V1 J& G, G+ L! G
760.     if(can2InitFlag == true)
     ' v' k+ ^% o; N; x) E! Q6 @; |1 A
761.     {
     & ?" B% y0 Y/ B4 \' K$ F
762.       RingBuffer_Reset(can2RxBuffer);
     : Y. ]7 b# p# W0 J: i1 f! A
763.     }
     
764.   }
     ! R* j2 a2 s- G" w3 ~" {
765. #endif /* STM32F10X_CL */
     
766. }
     5 V) [( x- g) v7 l
767. 
     ! L" ^6 u; g0 ~, v
768. /**
     
769.   * @brief  Is the CAN transmit a message?
     . C" d) u7 c- C  G
770.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     $ B% |+ x& a- H; @/ c
771.   * @retval true:      Is transmit a message.
     4 W* Y& A3 p3 k- C7 }
772.   * @retval false:     Not transmit a message.
     
773.   */
     
774. bool CAN_IsTransmitMessage(CAN_TypeDef *CANx)
     " ]  Z6 M& v. k( A, K$ L6 @
775. {
     
776.   if(CANx == CAN1)
     
777.   {
     
778.     if(can1InitFlag == true)
     0 O" @1 a/ H, u) d9 x
779.     {
     1 {; R; a/ _" _4 T: i& e
780.       return can1TransmitFlag;
     
781.     }
     - b4 }3 `. \. \* _
782.   }
     
783. 
     ) W5 b" ^/ u  I4 q" [
784. #ifdef STM32F10X_CL
     
785.   if(CANx == CAN2)
     5 A  T& N. r* p
786.   {
     ) {: [" s" D% D
787.     if(can2InitFlag == true)
     
788.     {
     % S, L* N1 S9 _+ J+ k" R: A5 a3 v
789.       return can2TransmitFlag;
     
790.     }
     6 m# Q! O; w2 R2 j
791.   }
     
792. #endif /* STM32F10X_CL */
     
793. 
     
794.   return false;
     
795. }
     ( ^4 t5 O2 t. O: f2 c% k
796. 
     
797. /**
     * e& A+ F! K# V1 M# M+ Y
798.   * @brief  This function handles CAN1 TX Handler.
     
799.   * @param  None.
     
800.   * @return None.
     
801.   */
     
802. #ifdef STM32F10X_CL
     
803. void CAN1_TX_IRQHandler(void)
     # y6 c8 y9 A! w& r" Z2 M' s
804. #else
     
805. void USB_HP_CAN1_TX_IRQHandler(void)
     ) Y9 f, [2 P" I+ Y7 _% M9 B
806. #endif /* STM32F10X_CL */
     
807. {
     
808.   if(CAN_GetITStatus(CAN1, CAN_IT_TME) != RESET)
     7 @% q( C% L- k) @% D: a. D7 F
809.   {
     
810.     CAN_ClearITPendingBit(CAN1, CAN_IT_TME);
     
811. 
     9 S) Z+ W. n6 s
812.     CanTxMsg canTxMsg = {0};
     9 @# r! b  A, t' h% Q7 f
813.     uint8_t  number   = RingBuffer_Out(can1TxBuffer, &canTxMsg, sizeof(canTxMsg)) / sizeof(canTxMsg);
     
814. 
     
815.     if(number > 0)
     
816.     {
     
817.       CAN_Transmit(CAN1, &canTxMsg);
     8 a" J, h9 U3 s! M- o% M
818.     }
     6 h' ~7 ?( X  U, L5 M4 {% L
819.     else
     , k7 A1 N$ h9 ^3 g0 Z# j, m  G
820.     {
     
821.       can1TransmitFlag = false;
     5 i# a/ f8 M6 [0 L9 Z) q8 I% D( r
822. 
     
823.       if(can1TransmitFinishCallback != 0)
     
824.       {
     
825.         can1TransmitFinishCallback();
     
826.       }
     - B/ V% T8 w  \2 s! Q& b: q
827.     }
     5 X  G/ o, L6 ?' _1 w0 k' x
828.   }
     
829. }
     + B# |7 w& z+ J5 q. }
830. 
     : M3 w$ U, k$ t! s
831. /**
     & X/ |8 u0 g4 x# l. ^# F
832.   * @brief  This function handles CAN1 RX0 Handler.
     
833.   * @param  None.
     
834.   * @return None.
     6 l" M2 G) L. h8 k9 j: p
835.   */
     
836. #ifdef STM32F10X_CL
     
837. void CAN1_RX0_IRQHandler(void)
     
838. #else
     ) P) C; G* V& x4 t+ f5 [
839. void USB_LP_CAN1_RX0_IRQHandler(void)
     
840. #endif /* STM32F10X_CL */
     
841. {
     ' L9 ]8 W  A& t% X$ |- |
842.   if(CAN_GetITStatus(CAN1, CAN_IT_FMP0) != RESET)
     
843.   {
     
844.     CAN_ClearITPendingBit(CAN1, CAN_IT_FMP0);
     
845. 
     7 t0 J8 t2 H! p9 ]* V0 S
846.     CanRxMsg canRxMsg = {0};
     
847.     CAN_Receive(CAN1, CAN_FIFO0, &canRxMsg);
     
848. 
     
849.     if(RingBuffer_Avail(can1RxBuffer) / sizeof(CanRxMsg) > 0)
       j( t% g1 J; _5 g- t; g( ~2 W
850.     {
     
851.       RingBuffer_In(can1RxBuffer, &canRxMsg, sizeof(canRxMsg));
     
852.     }
       h8 ^3 V  a& R) F3 Z3 _, o/ u- J
853. 
     
854.     if(can1ReceiveFinishCallback != 0)
     
855.     {
     2 `; T$ a8 e: g$ A7 f# p1 h
856.       can1ReceiveFinishCallback();
     
857.     }
     ' J: [- I3 ^, H+ K6 U1 v- d5 o
858.   }
     % A" S$ L( g8 \' U- T  c4 {. r; G& Q
859. }
     
860. 
     ) Q2 B4 c5 q3 {' u  ]
861. #ifdef STM32F10X_CL
     
862. /**
     ) F( t. z5 ^6 M6 ^* f0 O
863.   * @brief  This function handles CAN2 TX Handler.
     ' |$ o) U: s$ i
864.   * @param  None.
     
865.   * @return None.
     
866.   */
     7 }# r# V/ \7 M% g+ C
867. void CAN2_TX_IRQHandler(void)
     , A1 F& {- L! l6 g' Q
868. {
     
869.   if(CAN_GetITStatus(CAN2, CAN_IT_TME) != RESET)
     
870.   {
     
871.     CAN_ClearITPendingBit(CAN2, CAN_IT_TME);
     ) `/ r$ K. M: o" L( t
872. 
     " h% }4 V' m& A8 [. R# X
873.     CanTxMsg canTxMsg = {0};
     
874.     uint8_t  number   = RingBuffer_Out(can2TxBuffer, &canTxMsg, sizeof(canTxMsg)) / sizeof(canTxMsg);
     * t) s' c( e7 R# O
875. 
     + D5 V; H. m+ z/ M8 x; |
876.     if(number > 0)
     ! \' F# R2 b5 _
877.     {
     
878.       CAN_Transmit(CAN2, &canTxMsg);
     7 M( t8 K3 V6 d" p5 {$ H
879.     }
     
880.     else
     
881.     {
     
882.       can2TransmitFlag = false;
     
883. 
     
884.       if(can2TransmitFinishCallback != 0)
     4 t5 C& Y/ u% O. I% f- q: a
885.       {
     
886.         can2TransmitFinishCallback();
     
887.       }
     
888.     }
     ' U' B: f9 w6 y( a3 a+ ^2 C2 K4 V
889.   }
     
890. }
     
891. 
     * R9 E$ K" a; p5 G5 R
892. /**
     
893.   * @brief  This function handles CAN2 RX0 Handler.
     
894.   * @param  None.
     . }/ O/ G$ U6 _1 W' D  R, m
895.   * @return None.
     
896.   */
     ! F( g6 k+ `! l0 h4 k1 D. [
897. void CAN2_RX0_IRQHandler(void)
     7 Y* o; |! s3 E7 v2 ]: c+ i
898. {
     
899.   if(CAN_GetITStatus(CAN2, CAN_IT_FMP0) != RESET)
     
900.   {
     
901.     CAN_ClearITPendingBit(CAN2, CAN_IT_FMP0);
     4 _" Q7 C/ D8 m7 j
902. 
     
903.     CanRxMsg canRxMsg = {0};
     
904.     CAN_Receive(CAN2, CAN_FIFO0, &canRxMsg);
     ' p. D0 k* J( k" D
905. 
     
906.     if(RingBuffer_Avail(can2RxBuffer) / sizeof(CanRxMsg) > 0)
     
907.     {
     $ ~- w: P1 R. P5 H) d
908.       RingBuffer_In(can2RxBuffer, &canRxMsg, sizeof(canRxMsg));
     2 J. L0 U+ `- [+ p. S
909.     }
     
910. 
     
911.     if(can2ReceiveFinishCallback != 0)
     * n- |  @# O/ F! p/ P7 ~
912.     {
     
913.       can2ReceiveFinishCallback();
     9 E  E; s  u, H' U; i
914.     }
     ; y! B6 _$ C1 N8 `+ N
915.   }
     
916. }
     
917. #endif /* STM32F10X_CL */
     

复制代码

" ~, q; i/ P/ ?4 zmain.h 文件

1. /**
   
2.   ******************************************************************************
   / ?5 ]! Y4 ^8 b& a, n1 M
3.   * @file    main.h
   / A" `. R  M. b9 i. k/ Z5 n9 {' r
4.   * @author  XinLi
   
5.   * @version v1.0
   
6.   * @date    24-June-2018
   1 C3 z; w. t. m
7.   * @brief   Header file for main.c module.
   0 N" ?. Y$ y' w$ x, s' c* o: \% x
8.   ******************************************************************************
   & g( E) o5 B/ A- a2 ^% P/ }
9.   * @attention
   : A7 f/ o. D# s
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    : I/ }5 }% s/ P0 P$ j+ F. b
12.   *
    0 E- M$ N8 N! u4 @
13.   * This program is free software: you can redistribute it and/or modify
    
14.   * it under the terms of the GNU General Public License as published by
    - T# U; [( B' u2 ~0 g/ K* B
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    - f5 D1 Q$ g7 k( m/ c
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    , B2 }$ }) p5 H, t. Y; @0 X
22.   *
    5 @! @$ e7 q3 j# @" b! @: ~
23.   * You should have received a copy of the GNU General Public License
    : ], Z8 {5 y- v0 G" j5 a0 z; _
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    
25.   *
    9 |1 N, Y5 I3 y/ w, ], l' F0 L$ \
26.   ******************************************************************************
    5 ?5 _. S5 f3 D) I7 c+ {2 c
27.   */
    
28. 
    
29. #ifndef __MAIN_H
    3 u+ s  k' I7 d6 p* R; \7 S9 Y1 }
30. #define __MAIN_H
    * r: O4 j$ I" |6 V  v9 ?+ n# ^
31. 
    
32. #ifdef __cplusplus
    
33. extern "C" {
    1 W( [" t; @5 D3 m6 ]8 b! m+ M
34. #endif
    
35. 
    
36. /* Header includes -----------------------------------------------------------*/
    , _; Y6 Z) i- o" L
37. #include "stm32f10x.h"
    
38. 
      N+ D$ t* Q6 X5 H% Z2 @
39. /* Macro definitions ---------------------------------------------------------*/
    8 @9 ]- m5 ?5 O: t
40. /* Type definitions ----------------------------------------------------------*/
    9 W) G. f/ ]6 P) F
41. /* Variable declarations -----------------------------------------------------*/
    $ I2 \* a8 B( N; p  q$ I1 J
42. /* Variable definitions ------------------------------------------------------*/
    . y2 ~7 g1 J% I6 V/ t7 e( |7 N
43. /* Function declarations -----------------------------------------------------*/
    
44. /* Function definitions ------------------------------------------------------*/
    6 y( D+ z1 h9 S& D  R
45. 
    
46. #ifdef __cplusplus
    3 T( H" [+ F' e& x" y6 G7 t/ @9 Y
47. }
    / B9 H* T5 W; [
48. #endif
    
49. 
    7 `* y8 ?$ _- ]7 [/ h( C
50. #endif /* __MAIN_H */

复制代码

. @$ I8 h0 F+ e5 g8 K3 Y0 jmain.c 文件

1. /**
   4 {0 h: U' V* e6 R8 t
2.   ******************************************************************************
   
3.   * @file    main.c
   
4.   * @author  XinLi
   
5.   * @version v1.0
   # R8 s5 i- F  D% l4 P
6.   * @date    24-June-2018
   + m3 W0 V6 x4 R9 ]8 K+ r
7.   * @brief   Main program body.
   
8.   ******************************************************************************
   5 J, q! U% u+ M4 w
9.   * @attention
   ! a( s/ [* y! b: g* ?1 N
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    0 T8 T, G# Q! c0 Q  A9 T
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    
14.   * it under the terms of the GNU General Public License as published by
    
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
      h- x% }$ b3 D
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    ) q/ e( H2 n' j8 s/ X% Z' s2 d
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    " _, A& f% N  @9 U# g% |+ w
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    . D7 N- D0 ?, L3 ~6 P5 L  h% p" b
21.   * GNU General Public License for more details.
    " o/ ~8 t/ J4 X: ]5 ?/ ^
22.   *
    7 q) j6 n* ]# |4 v* m1 {6 a
23.   * You should have received a copy of the GNU General Public License
    8 K- C; N/ \8 U: W) n$ @: q$ c
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    
25.   *
    
26.   ******************************************************************************
    1 t: r+ _9 @9 W& G8 f
27.   */
    
28. 
    ; a) j" f) B& Y. c4 X* ]/ I
29. /* Header includes -----------------------------------------------------------*/
      @0 G5 q) X: @* d$ B- n
30. #include "main.h"
    
31. #include "CAN.h"
    
32. 
    2 j+ M& F& r0 Z( ^4 e3 g2 W
33. #ifdef _RTE_
    ! C' V/ T! N6 v" f! k' _& P
34. #include "RTE_Components.h"
    * d1 |$ Z! J' Z; Q5 @
35. #endif
    
36. 
    
37. #ifdef RTE_CMSIS_RTOS2
    ; n2 {5 ?' d" p, o- g
38. #include "cmsis_os2.h"
    
39. #endif
    3 k4 D% J- l6 u" e3 s
40. 
    
41. /* Macro definitions ---------------------------------------------------------*/
    ; @3 _# c1 d$ v. T$ f  X
42. /* Type definitions ----------------------------------------------------------*/
    
43. /* Variable declarations -----------------------------------------------------*/
    - P- P9 z" P) v( z
44. /* Variable definitions ------------------------------------------------------*/
    ( P0 I& g9 b4 F
45. static CanTxMsg canTxMsg = {0};
    
46. static CanRxMsg canRxMsg = {0};
    & n6 g# O0 @8 r* R
47. 
    
48. /* Function declarations -----------------------------------------------------*/
    
49. static void SystemClock_Config(void);
    7 ~3 S2 S" D# x& k  n6 d
50. 
    
51. /* Function definitions ------------------------------------------------------*/
    ! A. t! m# G+ B& Q' r9 r5 Q3 k
52. 
      Q; Z/ r8 r6 F8 I$ D7 b+ m
53. /**
    ) a  Z1 D# e6 s5 [/ m1 F: O
54.   * @brief  Main program.
    ! u- @' u: {8 t2 K1 `! a0 u+ I
55.   * @param  None.
    
56.   * @return None.
    
57.   */
    ; W: ^; b, V$ i
58. int main(void)
    
59. {
    , t0 S8 p2 T% X& H1 i$ y0 h
60.   /* Configure the system clock to 72 MHz */
    0 s4 C9 q' @8 t3 r3 p4 j
61.   SystemClock_Config();
    6 O+ O2 P: P8 ~+ m) `
62.   SystemCoreClockUpdate();
    9 M- b; P6 r5 d/ v
63. 
    
64.   /* Add your application code here */
    
65.   CAN_Configure(CAN1, CAN_WorkModeLoopBack, CAN_BaudRate250K, 0xAA55, 0x55AA);
    4 m3 {' H( p: {" m
66. 
    
67. #ifdef RTE_CMSIS_RTOS2
    ' I* [" N2 E4 H3 I
68.   /* Initialize CMSIS-RTOS2 */
    # r2 o/ v* m. q, a+ y
69.   osKernelInitialize();
    8 _' W0 l1 g1 h! j0 _. i& `
70. 
    * J0 D% ^1 R& ~; Z
71.   /* Create thread functions that start executing,
    
72.   Example: osThreadNew(app_main, NULL, NULL); */
    
73. 
    
74.   /* Start thread execution */
    4 p3 f5 R* E- E+ w
75.   osKernelStart();
    0 W9 U$ T  z% z3 b  Z$ M! O
76. #endif
    
77. 
    ( t9 l) ^: e& a0 d2 c
78.   /* Infinite loop */
    
79.   while(1)
    
80.   {
    ! f: }( ^2 T- Y
81.     canTxMsg.StdId = 0xAA55;
    $ b" v2 f/ z6 n# T0 e
82.     canTxMsg.ExtId = 0x55AA;
    . V4 F1 S# t- y) v
83.     canTxMsg.IDE   = CAN_ID_STD;
    9 V- S2 d; k7 z, t) G0 ~$ y, X$ N. Z* m
84.     canTxMsg.RTR   = CAN_RTR_DATA;
    * c2 |8 D" J  I4 G! R
85.     canTxMsg.DLC   = 8;
    . V; R, o- g# ?( j+ ~) V* s
86. 
    
87.     canTxMsg.Data[0]++;
    
88.     canTxMsg.Data[1]++;
    ; p5 W( n( M: ~& o5 M  m/ G/ s
89.     canTxMsg.Data[2]++;
    
90.     canTxMsg.Data[3]++;
    
91.     canTxMsg.Data[4]++;
    
92.     canTxMsg.Data[5]++;
    ; r4 s7 \- X9 @0 @6 X: x
93.     canTxMsg.Data[6]++;
    
94.     canTxMsg.Data[7]++;
    
95. 
    & j2 v* [/ k; ~
96.     CAN_SetTransmitMessage(CAN1, &canTxMsg, 1);
    & V3 ]/ L- M7 L8 W0 M$ ?+ j! T" w
97. 
      H* a; i* }( D& m7 r
98.     while(CAN_IsReceiveBufferEmpty(CAN1) == true);
    
99. 
    
100.     CAN_GetReceiveMessage(CAN1, &canRxMsg, 1);
     
101.   }
     : Y4 p4 V1 w" p$ l$ z& z
102. }
     ; o& ^( s2 J" L: ~+ @, H
103. 
     
104. /**
     
105.   * @brief  System Clock Configuration.
     
106.   *         The system Clock is configured as follow :
     
107.   *            System Clock source            = PLL (HSE)
     ! _3 t% V% v* G- Y
108.   *            SYSCLK(Hz)                     = 72000000
     
109.   *            HCLK(Hz)                       = 72000000
     
110.   *            AHB Prescaler                  = 1
     " M) y, |) a- l' U/ w+ N
111.   *            APB1 Prescaler                 = 2
     
112.   *            APB2 Prescaler                 = 1
     1 l. U9 L, h( D
113.   *            HSE Frequency(Hz)              = 8000000
     3 k& q. ?. l. m/ V% e
114.   *            HSE PREDIV1                    = 1
     ; R' p2 q: u4 c7 U4 ~1 }4 u, `' W
115.   *            PLLMUL                         = 9
     ; g+ T2 ^0 \9 N$ O
116.   *            Flash Latency(WS)              = 2
     
117.   * @param  None.
     
118.   * @return None.
     
119.   */
     
120. static void SystemClock_Config(void)
     4 ^7 i0 ~, _5 n7 L9 |
121. {
     8 B/ Z1 Z& z! X
122.   /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration */
     1 T1 J& S7 v1 |9 x! b
123.   /* RCC system reset */
     # i) [9 F& [& ^  d% Q2 z
124.   RCC_DeInit();
     
125. 
     
126.   /* Enable HSE */
     1 V4 x; n4 F/ ~6 I8 I
127.   RCC_HSEConfig(RCC_HSE_ON);
     
128. 
     
129.   /* Wait till HSE is ready */
       s: O, n! J7 s. r9 O* h
130.   ErrorStatus HSEStartUpStatus = RCC_WaitForHSEStartUp();
     # L) n% H. q# s# W! }" T
131. 
     0 M( Q1 v  m6 h, i4 ]3 d
132.   if(HSEStartUpStatus == SUCCESS)
     
133.   {
     
134.     /* Enable Prefetch Buffer */
     
135.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     
136. 
     * \; X# k, C- @
137.     /* Flash 2 wait state */
     
138.     FLASH_SetLatency(FLASH_Latency_2);
     ( d. ^9 z! ]4 I$ R
139. 
     6 ^: j) X! A0 y6 h2 b
140.     /* HCLK = SYSCLK */
     
141.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     # B+ d  t# e# o8 J) }+ T
142. 
     . \+ _4 ?+ R' o2 M1 V
143.     /* PCLK2 = HCLK */
     1 n: e$ G8 h* H: A) m* Z
144.     RCC_PCLK2Config(RCC_HCLK_Div1);
     
145. 
     - i7 v# m' i& \& i  I
146.     /* PCLK1 = HCLK / 2 */
     2 }$ M. T/ f& W# A2 K8 ?' d
147.     RCC_PCLK1Config(RCC_HCLK_Div2);
     ' S9 R# T6 {# e9 ]/ a! s* L8 i) V
148. 
     9 v: H. T: K& u) Y3 H1 F
149.     /* Configure PLLs */
     
150. #ifdef STM32F10X_CL
     3 b1 ^% v! a7 b0 f( I5 {, p4 _
151.     /* PLL2 configuration: PLL2CLK = (HSE(8MHz) / 2) * 10 = 40MHz */
     
152.     RCC_PREDIV2Config(RCC_PREDIV2_Div2);
     
153.     RCC_PLL2Config(RCC_PLL2Mul_10);
     3 r8 X, w" u' f6 ]
154. 
     ' o- R3 P5 z: Z  W: |
155.     /* Enable PLL2 */
     
156.     RCC_PLL2Cmd(ENABLE);
     
157. 
     : |" f! `6 H7 W! O+ K& ]
158.     /* Wait till PLL2 is ready */
     
159.     while(RCC_GetFlagStatus(RCC_FLAG_PLL2RDY) == RESET);
     
160. 
     3 V. R* j; m" W8 z8 @6 y
161.     /* PLL configuration: PLLCLK = (PLL2(40MHz) / 5) * 9 = 72MHz */
     2 ^1 I9 k2 w; i' d5 Z, t0 g
162.     RCC_PREDIV1Config(RCC_PREDIV1_Source_PLL2, RCC_PREDIV1_Div5);
     
163.     RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_9);
     ' q" n4 t7 d1 o* @
164. #else
     * B/ A& L3 Q  I: D  y/ d
165.     /* PLLCLK = HSE(8MHz) * 9 = 72MHz */
     $ J# @" E+ z8 g1 ~9 C% N& t$ \
166.     RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
     
167. #endif
     
168. 
     $ I- ?* ^/ j8 y( e
169.     /* Enable PLL */
     - M- E8 z8 ?4 y* y, C
170.     RCC_PLLCmd(ENABLE);
     : Z# s& w, [' H4 e
171. 
     $ D3 I: Z  b- x5 x) q
172.     /* Wait till PLL is ready */
     9 e: q1 `( s* o6 O3 \
173.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     ' c$ ~( M; l! |, o* L
174. 
     7 h( ], e- W; Q* a
175.     /* Select PLL as system clock source */
     5 F: l$ [; ?/ P1 G
176.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     
177. 
     ' {+ p: u% G9 C, U, x
178.     /* Wait till PLL is used as system clock source */
     8 ]6 [/ ~: D# L; c. ?
179.     while(RCC_GetSYSCLKSource() != 0x08);
     
180.   }
     ' l6 v* N7 {7 d, f! U* |
181.   else
     8 T2 U3 h+ a) Y3 c
182.   {
     8 u/ w- q+ @: H2 U4 I
183.     /* Disable HSE */
     
184.     RCC_HSEConfig(RCC_HSE_OFF);
     
185. 
     7 O5 d7 ]4 X8 I. {9 f
186.     /* Enable HSI */
     
187.     RCC_HSICmd(ENABLE);
     * B8 `  j& c2 k3 @
188. 
     + a2 @; {6 z% S$ G6 t# e& K, y
189.     /* Enable Prefetch Buffer */
     + y) g8 b1 Z6 f; n* K! s1 J
190.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     
191. 
     5 M+ P4 P: I. W. n
192.     /* Flash 1 wait state */
     ! {4 A  h6 \# [& b$ ?! T, `
193.     FLASH_SetLatency(FLASH_Latency_1);
     6 f4 t6 \' }; Y+ M
194. 
     * k# Z) b) k5 k9 [
195.     /* HCLK = SYSCLK */
     * q& q- P) H/ F
196.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     
197. 
     
198.     /* PCLK2 = HCLK */
     & O6 e  D3 p: D8 m7 h) D3 v
199.     RCC_PCLK2Config(RCC_HCLK_Div1);
     ; ^1 `9 n% \$ g. R$ O* S; E
200. 
     
201.     /* PCLK1 = HCLK */
     ; c" R' ^$ Z  z9 b
202.     RCC_PCLK1Config(RCC_HCLK_Div1);
     3 s5 d  B- u! Q. `6 n* |$ F+ F6 s( w
203. 
     8 ^( v$ a1 }% C6 [4 z: i# N
204.     /* Configure PLLs */
     9 K+ r4 Q5 i! `  O, z' o) Z1 M7 S
205.     /* PLLCLK = HSI(8MHz) / 2 * 9 = 36MHz */
     
206.     RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_9);
     
207. 
     
208.     /* Enable PLL */
     2 G6 V9 e  j2 b8 ^) V! J: v7 H$ c" l
209.     RCC_PLLCmd(ENABLE);
     
210. 
       M. o: d/ W% q2 Y0 s
211.     /* Wait till PLL is ready */
     4 c1 I* ]2 v7 O: }0 ~* K
212.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     . \6 w) _! `; Z0 S9 F4 ~- E) v+ N
213. 
     ( I) V/ r4 l5 _" A# E( E4 l7 M. z
214.     /* Select PLL as system clock source */
     
215.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     
216. 
     ! ^* r6 I3 R! q: u( H
217.     /* Wait till PLL is used as system clock source */
     # d' _4 I( j# F* H2 U2 a
218.     while(RCC_GetSYSCLKSource() != 0x08);
     
219.   }
     / V# p8 ]3 ^, z" Z0 s9 d* Z
220. }
     0 E8 N& [9 ]4 u0 L! ?
221. 
     " n8 B) ^" \0 A/ B, t
222. #ifdef USE_FULL_ASSERT
     " ~9 _- d( x: H2 X' d6 T# O
223. /**
       n  q9 j, o. J, _) h
224.   * @brief  Reports the name of the source file and the source line number
     # F* @# |. {4 s" o% O, R/ k3 w2 L
225.   *         where the assert_param error has occurred.
     , `/ `. L! c% o
226.   * @param  file: pointer to the source file name.
       i) u6 X! |+ {6 e8 @
227.   * @param  line: assert_param error line source number.
     * o1 V: v7 j! `* M( e% ^( H. E: v
228.   * @return None.
     # ^7 n) L4 X2 T
229.   */
     
230. void assert_failed(uint8_t *file, uint32_t line)
     
231. {
     
232.   /* User can add his own implementation to report the file name and line number,
     9 D3 s0 {+ j9 }) b  e: ~3 V
233.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     
234. 
     
235.   /* Infinite loop */
     4 X' {  ^$ j8 k! J( b
236.   while(1)
     
237.   {
     
238.   }
     
239. }
     
240. #endif

复制代码

# U2 |2 C0 m  M) z3，注意

CAN 消息发送缓冲区和接收缓冲区的大小，可以根据应用的需求进行修改，缓冲区使用的是堆内存，需要根据缓冲区大小和应用程序中堆内存使用情况进行配置。

) J) C/ Y& W! }, T  W9 i
1 D. R/ q' S2 h; B# c" B