1，开发环境
2 `+ ~9 ]- l! g2 k9 `  ^
1，固件库：STM32F10x_StdPeriph_Lib_V3.5.0
, {# c# }# M& q
2，编译器：ARMCC V5.06
2 b* \' U9 f& e7 n& G0 x! ^
+ q  y1 N9 E5 O; {5 J& P3，IDE：Keil uVision5
2 E/ P% P7 I* q% \
4，操作系统：Windows 10 专业版
3 h: T  I0 y, j* @: _9 J

6 n( h, Y# q. c0 m$ Q& U2，程序源码
, d/ D; `, q* [; E7 K  k& S
RingBuffer.h 文件
# W) n8 ^7 i) }; S

1. /**
   
2.   ******************************************************************************
   * @. H3 [) K, w: `: p
3.   * @file    RingBuffer.h
   
4.   * @author  XinLi
   
5.   * @version v1.1
   
6.   * @date    15-January-2018
   
7.   * @brief   Header file for RingBuffer.c module.
   
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    6 P% j5 S2 I+ u% V8 U
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    ) ~6 I: _, P* K" c9 Q  O* i
14.   * it under the terms of the GNU General Public License as published by
    : c6 F- X% {* \6 `
15.   * the Free Software Foundation, either version 3 of the License, or
    $ C: T" V9 i: i9 w$ }
16.   * (at your option) any later version.
    4 ^5 ^+ ~! Q9 T
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    ) [3 C8 j2 T) Z; T
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    + P* f( c! Z6 a/ H/ ?
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    # X: t' m/ k9 }
22.   *
    
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>
    # z2 M0 G! g! Y8 u  V: o* W+ O
25.   *
    2 h4 s( _% R2 s8 T# L. z* Z
26.   ******************************************************************************
    
27.   */
    9 u. k" e$ X; D+ {* }+ T
28. 
    ; F  |7 P( s0 z: S- k$ r
29. #ifndef __RINGBUFFER_H
    
30. #define __RINGBUFFER_H
    
31. 
    
32. #ifdef __cplusplus
    
33. extern "C" {
    & \, p9 y! E8 e
34. #endif
    
35. 
    1 m, D/ C) C- |6 ^/ P8 _8 e
36. /* Header includes -----------------------------------------------------------*/
    
37. #include <stdint.h>
    
38. #include <stdbool.h>
    # e/ R; x. C% b6 P7 ]& _
39. #include <stdlib.h>
    
40. 
      F8 I8 d) n1 C3 v( d: z
41. /* Macro definitions ---------------------------------------------------------*/
    
42. #define RING_BUFFER_MALLOC(size)  malloc(size)
    & m  H8 K" Z3 B/ ]) k1 Y
43. #define RING_BUFFER_FREE(block)   free(block)
    
44. 
    . n" E0 x8 ]) f
45. /* Type definitions ----------------------------------------------------------*/
      ^9 p8 B3 ~( k$ O0 r9 U+ J
46. typedef struct
    4 p; T% \. k/ d; I
47. {
    : `8 n& M& `8 P8 U- [, X( l
48.   uint8_t *buffer;
    & }8 j/ ~- ?3 C
49.   uint32_t size;
    
50.   uint32_t in;
    * E$ x4 S1 N& Y( J! b
51.   uint32_t out;
    
52. }RingBuffer;
    
53. 
    " ~. B/ \2 @9 H6 l0 l
54. /* Variable declarations -----------------------------------------------------*/
    # ?5 r! h5 _1 P: O' ]! \" ~. f  b/ Y7 i/ P
55. /* Variable definitions ------------------------------------------------------*/
    
56. /* Function declarations -----------------------------------------------------*/
    2 z. ~- X' a$ O1 y" [- r
57. RingBuffer *RingBuffer_Malloc(uint32_t size);
    
58. void RingBuffer_Free(RingBuffer *fifo);
    4 ?  ]7 h3 b, g
59. 
    
60. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len);
    
61. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len);
    2 ]( H% ?9 p# c/ D0 z1 V- I, `" @
62. 
    
63. /* Function definitions ------------------------------------------------------*/
    8 ]- b2 P* }9 V& o' u9 z4 I# r- @
64. 
    
65. /**
    6 a  _& t7 @4 b% l' C
66.   * @brief  Removes the entire FIFO contents.
    
67.   * @param  [in] fifo: The fifo to be emptied.
    
68.   * @return None.
    * p* }& T& h8 U3 A- v+ }" y# T
69.   */
    
70. static inline void RingBuffer_Reset(RingBuffer *fifo)
    
71. {
    
72.   fifo->in = fifo->out = 0;
    6 x" y, `4 L6 L: e
73. }
    
74. 
    - \& P" G# p1 c7 Z7 ^5 K
75. /**
    
76.   * @brief  Returns the size of the FIFO in bytes.
    1 O' T* f+ T) l9 T
77.   * @param  [in] fifo: The fifo to be used.
    
78.   * @return The size of the FIFO.
    
79.   */
    
80. static inline uint32_t RingBuffer_Size(RingBuffer *fifo)
    
81. {
    & c! c% `! p4 w9 z
82.   return fifo->size;
    
83. }
    
84. 
    , _# X3 v4 @; q
85. /**
    
86.   * @brief  Returns the number of used bytes in the FIFO.
    
87.   * @param  [in] fifo: The fifo to be used.
    9 j! Q- @8 o. Y' C. V4 R) e
88.   * @return The number of used bytes.
    8 B5 d2 }9 ?/ ~* {) I0 o
89.   */
    ( q. N. @: E) R; A6 U9 R
90. static inline uint32_t RingBuffer_Len(RingBuffer *fifo)
    6 e% [( J* J4 A1 `# J7 ~4 Z
91. {
    . g+ i# o9 a% b- }0 E2 A
92.   return fifo->in - fifo->out;
    
93. }
    , S: Z! U: V8 O" W, P9 K( e
94. 
    
95. /**
    
96.   * @brief  Returns the number of bytes available in the FIFO.
    
97.   * @param  [in] fifo: The fifo to be used.
    ; p! f$ C0 G  H; c/ z, c( w  l
98.   * @return The number of bytes available.
    
99.   */
    
100. static inline uint32_t RingBuffer_Avail(RingBuffer *fifo)
     * S1 {8 m% I: m4 {5 A
101. {
     
102.   return RingBuffer_Size(fifo) - RingBuffer_Len(fifo);
     
103. }
     . x1 w5 L- A$ `- T) h9 b/ i
104. 
     . L3 u4 z! J9 ?
105. /**
     , p0 h5 t$ s) [
106.   * @brief  Is the FIFO empty?
     
107.   * @param  [in] fifo: The fifo to be used.
       j/ |1 M' J& v1 ^! |) [+ |
108.   * @retval true:      Yes.
     % x% L9 e& y6 Q: T. c
109.   * @retval false:     No.
     2 V' v/ L- U* ?& T0 M% i
110.   */
     
111. static inline bool RingBuffer_IsEmpty(RingBuffer *fifo)
     ! P% A4 C- S# h, {% B' ]* h1 s
112. {
     $ H9 R- w% {: D0 k8 u( b8 K1 b
113.   return RingBuffer_Len(fifo) == 0;
     ' a; `( C7 ?# T8 p
114. }
     
115. 
     
116. /**
     3 y( m! t9 |1 D$ i; y" ?- {* T7 O- k
117.   * @brief  Is the FIFO full?
     " H& J4 _6 g- M6 I- B# K
118.   * @param  [in] fifo: The fifo to be used.
     / D& Z* ~2 X; O; T9 u% A$ g4 |' p
119.   * @retval true:      Yes.
     
120.   * @retval false:     No.
     - l! ^5 _1 T; ~, J. q
121.   */
     
122. static inline bool RingBuffer_IsFull(RingBuffer *fifo)
     
123. {
     ) c8 |- M* _$ w# j6 `4 ?
124.   return RingBuffer_Avail(fifo) == 0;
     
125. }
     
126. 
     
127. #ifdef __cplusplus
     7 d4 f: P, _6 g
128. }
     1 U3 W& n: E1 |2 ?: c4 p7 _/ {
129. #endif
     
130. 
     ) {1 k9 o1 x0 z3 D  n2 P
131. #endif /* __RINGBUFFER_H */
     * W1 X) P) }" I

复制代码

RingBuffer.c 文件
0 V7 w( V! V% T3 r8 z! L% i' U% {

1. <div>/**
   , q( e! q. d4 w/ f' p
2.   ******************************************************************************
   
3.   * @file    RingBuffer.c
     S) w" y9 E  K+ n$ p3 d& n
4.   * @author  XinLi
   
5.   * @version v1.1
   " Y; C0 C/ T. J2 l. n
6.   * @date    15-January-2018
   
7.   * @brief   Ring buffer module source file.
   ( ^2 E, p, O, [2 z9 ^8 n. R
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    : G0 V& P1 Q5 ?& G& w. j
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
    9 t. j+ G' G2 _6 a  a
16.   * (at your option) any later version.
    3 @" v( A0 B7 u6 G4 f" v( o6 A6 y
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    / `6 f9 q5 d7 ]/ {) O7 p
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.
    
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    $ [' R- G, b  B
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    
25.   *
    & C) W, D9 @4 A/ e  W" L8 \
26.   ******************************************************************************
    9 m- x* B. k8 W0 `' G
27.   */
    " q0 P* f+ @( I6 E# D
28. 
    8 Z$ d0 J0 e5 o5 y. ]* j
29. /* Header includes -----------------------------------------------------------*/
    $ r! d2 B  i* n7 i
30. #include "RingBuffer.h"
    ( R! m" B' n2 e4 V9 }4 V
31. #include <string.h>
    5 _" ^; [3 L$ y' _" _! G/ v4 m+ k
32. 
    
33. /* Macro definitions ---------------------------------------------------------*/
    
34. #define min(a, b)  (((a) < (b)) ? (a) : (b))
    $ e+ M! {) \6 R; I$ W2 e
35. 
    . d$ b; ]8 U6 ]" R: k2 }
36. /* Type definitions ----------------------------------------------------------*/
      L+ N  t) P1 o8 c; n2 I
37. /* Variable declarations -----------------------------------------------------*/
    
38. /* Variable definitions ------------------------------------------------------*/
    
39. /* Function declarations -----------------------------------------------------*/
    
40. static bool is_power_of_2(uint32_t x);
    ! d4 o+ q. e8 R1 E/ I
41. static uint32_t roundup_pow_of_two(uint32_t x);
    
42. 
    
43. /* Function definitions ------------------------------------------------------*/
    
44. 
    
45. /**
    ( @! x& |" k* B4 ~! O" x
46.   * @brief  Allocates a new FIFO and its internal buffer.
    
47.   * @param  [in] size: The size of the internal buffer to be allocated.
    3 y7 }0 I! k8 l% c5 X$ F
48.   * @note   The size will be rounded-up to a power of 2.
    
49.   * @return RingBuffer pointer.
    
50.   */
    4 p. N7 A4 D( P+ e$ h' q, O9 |
51. RingBuffer *RingBuffer_Malloc(uint32_t size)
    
52. {
    
53.   RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer));
    ( k% [# Q4 Z0 I* n) d
54. 
    1 ~: [; ?) t% q, X: Z& J8 |
55.   if(fifo != NULL)
    
56.   {
    5 @4 [$ O' E" V
57.     if(is_power_of_2(size) != true)
    
58.     {
    1 ~2 X; \* \7 \& V( f5 m2 h# |
59.       if(size > 0x80000000UL)
    
60.       {
    + a7 |" Y! X# G% p$ D* A
61.         RING_BUFFER_FREE(fifo);
    
62.         return NULL;
    
63.       }
    , L7 P9 K' H. d: f$ T+ S0 i" O
64. 
    
65.       size = roundup_pow_of_two(size);
    
66.     }
    4 i" ^% x7 h* y; r
67. 
    0 n+ Z6 p; Z% U- N
68.     fifo->buffer = RING_BUFFER_MALLOC(size);
    ; ]4 n# M6 m, W8 }: R
69. 
    
70.     if(fifo->buffer == NULL)
    ( B" J0 I7 e5 _2 [) x4 M
71.     {
    
72.       RING_BUFFER_FREE(fifo);
    
73.       return NULL;
    
74.     }
    ' Y) g5 b. t0 p1 _
75. 
    
76.     fifo->size = size;
    7 V5 Z& e* [0 ?/ |9 w8 R$ ?
77.     fifo->in = fifo->out = 0;
    3 i. }: P- A2 L- W! \- E4 B( c
78.   }
    
79. 
    
80.   return fifo;
    ) W) c! ]; b+ G" `, _
81. }
    
82. 
    + h$ a, `6 w5 ~
83. /**
    
84.   * @brief  Frees the FIFO.
    
85.   * @param  [in] fifo: The fifo to be freed.
    
86.   * @return None.
    3 H8 D! m! k" R( s; u" c" d' C
87.   */
    * L0 z2 @; y- y' `  h
88. void RingBuffer_Free(RingBuffer *fifo)
    
89. {
    5 A9 f, m" a: b0 b6 Z" h6 I
90.   RING_BUFFER_FREE(fifo->buffer);
    
91.   RING_BUFFER_FREE(fifo);
    8 Z3 F1 F/ G; b4 M2 l  ~; L; q. l
92. }
    % G9 s' \) t+ }- {$ u: g
93. 
    
94. /**
    ; d+ b" u, R- N1 l3 y, A0 D
95.   * @brief  Puts some data into the FIFO.
    
96.   * @param  [in] fifo: The fifo to be used.
    
97.   * @param  [in] in:   The data to be added.
    
98.   * @param  [in] len:  The length of the data to be added.
    
99.   * @return The number of bytes copied.
    4 _% r  ]- W: o% P8 `; S0 i7 e$ z% m9 t
100.   * @note   This function copies at most @len bytes from the @in into
     9 q) U/ v8 Q1 [. u  S
101.   *         the FIFO depending on the free space, and returns the number
     
102.   *         of bytes copied.
     
103.   */
     5 k$ o" B/ u9 y2 L5 n
104. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len)
     
105. {
     4 H: P7 H, L. f! G
106.   len = min(len, RingBuffer_Avail(fifo));
     7 ^  |$ u! V! F* V2 l* a
107. 
     
108.   /* First put the data starting from fifo->in to buffer end. */
     
109.   uint32_t l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
     * O" }: R( x% Q$ L9 c, D8 p
110.   memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), in, l);
     
111. 
     $ j1 Q* W6 M7 h) ^* K
112.   /* Then put the rest (if any) at the beginning of the buffer. */
     - P( U& S& a3 W0 `7 A6 w) ?8 b+ g
113.   memcpy(fifo->buffer, (uint8_t *)in + l, len - l);
     
114. 
     
115.   fifo->in += len;
     
116. 
     
117.   return len;
     
118. }
       Y6 H+ G3 M, {% u' m
119. 
     9 e# e+ i7 L9 @9 o6 b+ f! t0 e! `  ~
120. /**
     4 A# Z* u9 T4 N0 s0 B% i
121.   * @brief  Gets some data from the FIFO.
     
122.   * @param  [in] fifo: The fifo to be used.
       [: F; H2 |5 J5 S# @
123.   * @param  [in] out:  Where the data must be copied.
     
124.   * @param  [in] len:  The size of the destination buffer.
     " {* Q; b& z9 C( x( X$ u' Q4 X
125.   * @return The number of copied bytes.
     
126.   * @note   This function copies at most @len bytes from the FIFO into
     
127.   *         the @out and returns the number of copied bytes.
     " m, d6 Q( i/ |
128.   */
     
129. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len)
     
130. {
     
131.   len = min(len, RingBuffer_Len(fifo));
     
132. 
     . N# U0 b2 Z/ b# D4 s: @
133.   /* First get the data from fifo->out until the end of the buffer. */
     
134.   uint32_t l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
     
135.   memcpy(out, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
     
136. 
     
137.   /* Then get the rest (if any) from the beginning of the buffer. */
     
138.   memcpy((uint8_t *)out + l, fifo->buffer, len - l);
     
139. 
     8 @) i: x0 W0 q- O1 Y- c
140.   fifo->out += len;
     : `. q' B, l( I' [
141. 
     . m% h2 C& t/ r% e, P
142.   return len;
     
143. }
     2 k8 O; G# _# Z* Y2 @, V' ^
144. 
     
145. /**
     8 V! I2 ?9 E' f' L0 Q1 P
146.   * @brief  Determine whether some value is a power of two.
     * U; w/ _  N6 Z9 P+ |( s/ v& a( K
147.   * @param  [in] x: The number to be confirmed.
     - t; G8 f  b; t
148.   * @retval true:   Yes.
     ) u# b' U, n, y" k
149.   * @retval false:  No.
     1 x) v! I) E/ x* C5 ]& r) }
150.   * @note   Where zero is not considered a power of two.
     
151.   */
     ' S0 {- ?8 _2 t0 S+ U, b8 `: L
152. static bool is_power_of_2(uint32_t x)
     
153. {
     5 k) W6 d/ J4 i5 H
154.   return (x != 0) && ((x & (x - 1)) == 0);
     
155. }
     
156. 
     6 U1 T  {9 D8 O2 c
157. /**
     
158.   * @brief  Round the given value up to nearest power of two.
     ( m7 g; G6 E+ u) M, N
159.   * @param  [in] x: The number to be converted.
     
160.   * @return The power of two.
     
161.   */
     
162. static uint32_t roundup_pow_of_two(uint32_t x)
     
163. {
     
164.   uint32_t b = 0;
     
165. 
     $ P' f3 g% E( d/ C! T4 D
166.   for(int i = 0; i < 32; i++)
     % F2 i5 b0 P4 z9 i4 A; @7 e
167.   {
     
168.     b = 1UL << i;
     3 _  _$ J6 ?! o0 G
169. 
     9 o, I4 {  i. T8 b9 e
170.     if(x <= b)
     ) ~* I0 ?2 O0 {! Y) B( U' H
171.     {
     
172.       break;
     : u0 g" P! c% ]7 [5 R
173.     }
     
174.   }
     
175. 
     $ Z7 k. Z: o1 M/ @1 i
176.   return b;
     
177. }</div><div></div>

复制代码

, g3 X, Y/ L: f$ B. y% G4 ]CAN.h 文件

1. /**
   2 b" O6 Y. \6 J: q
2.   ******************************************************************************
   
3.   * @file    CAN.h
   3 f6 |3 v  F+ I% o  w
4.   * @author  XinLi
   & e2 o0 s! b5 e: h; \3 h8 H
5.   * @version v1.0
   
6.   * @date    24-June-2018
   6 d+ A, a: n# C' W& z4 S8 Q5 l1 w
7.   * @brief   Header file for CAN.c module.
   9 Y( [0 D( r9 M: G! U9 c
8.   ******************************************************************************
   : n4 r& o6 W; W/ E
9.   * @attention
   % {1 k" j" s$ |* b; v9 e: A
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    ! C) t# d0 R2 L) {$ r
12.   *
    0 I3 R2 E7 f0 H' U
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
    2 p! R) ?* \7 ^  p8 u! y* _; g* |) w
15.   * the Free Software Foundation, either version 3 of the License, or
    - F* n+ V, w$ o# @, K# y7 d! ~- f; x% S
16.   * (at your option) any later version.
    
17.   *
    4 F  D: K( \/ [* N
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.
    
22.   *
    
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>
    6 V" p8 ?" k$ l% N; f9 r* c
25.   *
    
26.   ******************************************************************************
    # g+ K% ~" e6 x$ m8 [( G& ^9 R7 C6 c
27.   */
    9 H: j3 u/ X5 @; l( `. z( e
28. 
    
29. #ifndef __CAN_H
    ) ~) i# _) Q& V7 B( I$ H' g& }
30. #define __CAN_H
    
31. 
    8 w8 X3 N& k* I% B3 ~
32. #ifdef __cplusplus
    
33. extern "C" {
    
34. #endif
    
35. 
    
36. /* Header includes -----------------------------------------------------------*/
    
37. #include "stm32f10x.h"
    8 _6 Q6 T: s* w! C* z/ I6 j: ?
38. #include <stdbool.h>
    
39. 
    
40. /* Macro definitions ---------------------------------------------------------*/
    ) p: B1 ^) ^' Y' {+ h( X3 z
41. 
    
42. /******************************* CAN1 Configure *******************************/
    ( L. [' @5 F# E9 ?: V
43. #define CAN1_TX_BUFFER_SIZE        (16)
    5 T7 a+ M- \- ?' Q) s. V/ E
44. #define CAN1_RX_BUFFER_SIZE        (16)
    
45. 
    & H7 \  \5 @- Z( M4 ^1 c" ?
46. #define CAN1_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
47. #define CAN1_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    3 B" N# X' m4 d
48. 
    
49. #define CAN1_TX_GPIO_PORT          GPIOB
    $ x$ w( Y, \% T, M$ l( c- ^" t
50. #define CAN1_RX_GPIO_PORT          GPIOB
    
51. 
    
52. #define CAN1_TX_GPIO_PIN           GPIO_Pin_9
    6 Q' ^1 H1 u1 e. m- [3 U4 X# f
53. #define CAN1_RX_GPIO_PIN           GPIO_Pin_8
    
54. 
    " h* V' j9 G  l- X$ b7 p
55. #define CAN1_IRQ_PREEMPT_PRIORITY  (0)
    
56. #define CAN1_IRQ_SUB_PRIORITY      (0)
    
57. 
    
58. #define CAN1_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap1_CAN1 , ENABLE)
    / I3 H+ ?  h$ q: v
59. /******************************************************************************/
    2 j: V5 z/ N: w5 D6 h$ K
60. 
    + ^, k' m6 @6 c
61. #ifdef STM32F10X_CL
    
62. /******************************* CAN2 Configure *******************************/
      ?. l* ?' Z/ g1 ~, C" g
63. #define CAN2_TX_BUFFER_SIZE        (16)
    3 _1 @, R. ?/ b( Q! T9 |1 B: \
64. #define CAN2_RX_BUFFER_SIZE        (16)
    
65. 
    
66. #define CAN2_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    ; c( x' q5 W' F
67. #define CAN2_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
68. 
    
69. #define CAN2_TX_GPIO_PORT          GPIOB
    / v" s/ h4 U$ V- W5 m4 c$ Y1 }
70. #define CAN2_RX_GPIO_PORT          GPIOB
    
71. 
    3 @; ?$ _: `; R' X5 A- x
72. #define CAN2_TX_GPIO_PIN           GPIO_Pin_13
    7 r. ]# f: [3 I
73. #define CAN2_RX_GPIO_PIN           GPIO_Pin_12
    
74. 
    
75. #define CAN2_IRQ_PREEMPT_PRIORITY  (0)
    
76. #define CAN2_IRQ_SUB_PRIORITY      (0)
    
77. 
    8 C$ f8 |9 v+ H
78. #define CAN2_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap_CAN2 , DISABLE)
    
79. /******************************************************************************/
    ; k1 f/ {0 c6 L3 s
80. #endif /* STM32F10X_CL */
    9 o% J' T: U! H, d
81. 
    
82. /* Type definitions ----------------------------------------------------------*/
    6 [$ A4 Q# m$ i3 r1 P& ?
83. typedef enum
    5 S. }0 e1 Z- h
84. {
    . C0 v# `% E* ]
85.   CAN_WorkModeNormal   = CAN_Mode_Normal,
    ! |) w! L9 \9 U* I) \/ J* o4 }
86.   CAN_WorkModeLoopBack = CAN_Mode_LoopBack
    8 H' @6 ]- Q8 q/ r: ~+ F  s' E% T
87. }CAN_WorkMode;
    $ X: }  Z1 J4 j. |) ]9 e/ [
88. 
    
89. typedef enum
    
90. {
    5 V% v6 D% @; e( _
91.   CAN_BaudRate1000K = 6,
    * V6 \- o4 D; V: ]$ X
92.   CAN_BaudRate500K  = 12,
    ) L. y8 Y; |, s- ]
93.   CAN_BaudRate250K  = 24,
    7 ^) X6 s% u; D8 p! w7 z: m* U
94.   CAN_BaudRate125K  = 48,
    
95.   CAN_BaudRate100K  = 60,
    0 u/ r+ M8 Y2 G- M0 O+ e/ G
96.   CAN_BaudRate50K   = 120,
    6 z! A- K0 c! e" ]. e
97.   CAN_BaudRate20K   = 300,
    8 A1 L0 w* N9 p7 _0 ?
98.   CAN_BaudRate10K   = 600
    
99. }CAN_BaudRate;
    1 _* c6 g6 B# @; P3 Z+ @7 Z
100. 
     & W: A+ B- @$ x! _
101. /* Variable declarations -----------------------------------------------------*/
     # q" X9 C# d1 |( A" d
102. /* Variable definitions ------------------------------------------------------*/
     
103. /* Function declarations -----------------------------------------------------*/
     
104. void CAN_Configure(CAN_TypeDef *CANx, CAN_WorkMode WorkMode, CAN_BaudRate BaudRate, uint32_t StdId, uint32_t ExtId);
     : y/ d' y/ r+ m9 Q
105. void CAN_Unconfigure(CAN_TypeDef *CANx);
     
106. 
     
107. void CAN_SetTransmitFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     
108. void CAN_SetReceiveFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     5 H; d6 x; V9 Q; S6 \
109. 
     
110. uint32_t CAN_SetTransmitMessage(CAN_TypeDef *CANx, CanTxMsg *Message, uint32_t Number);
     $ _' |4 t, |* m0 C- n
111. uint32_t CAN_GetReceiveMessage(CAN_TypeDef *CANx, CanRxMsg *Message, uint32_t Number);
     & ?+ i; d, E' p
112. 
     
113. uint32_t CAN_GetUsedTransmitBufferSize(CAN_TypeDef *CANx);
     
114. uint32_t CAN_GetUsedReceiveBufferSize(CAN_TypeDef *CANx);
     2 v6 q9 I4 b6 D, x3 n& Z4 X, X" H
115. uint32_t CAN_GetUnusedTransmitBufferSize(CAN_TypeDef *CANx);
     
116. uint32_t CAN_GetUnusedReceiveBufferSize(CAN_TypeDef *CANx);
     ; z( k7 _, [& B
117. 
     / D5 D0 ]5 C, T' ?8 S
118. bool CAN_IsTransmitBufferEmpty(CAN_TypeDef *CANx);
     ( |) S3 E) L/ o! I2 I
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);
     . p. ^* T5 r" _; e4 h6 B9 D$ o
124. void CAN_ClearReceiveBuffer(CAN_TypeDef *CANx);
     5 u& b& q: P) C8 W7 P
125. 
     + q. E+ M7 U' C' \7 ^
126. bool CAN_IsTransmitMessage(CAN_TypeDef *CANx);
       |  H: D$ V& f" H3 R7 ]
127. 
     
128. /* Function definitions ------------------------------------------------------*/
     8 h  B$ ?# N3 y+ G; ~
129. 
     2 [7 T" g1 k. e8 N' z
130. #ifdef __cplusplus
     % v. p. @& J( A4 K
131. }
     
132. #endif
     1 }) |: K1 f0 e
133. 
     
134. #endif /* __CAN_H */
     

复制代码

  z" ]2 r; ^# F4 r

3 \) v3 v$ Y# A3 K3 ]4 D+ yCAN.c 文件

( r1 D/ t5 t4 j# t9 K

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

复制代码

  s3 k! S+ e3 C4 j" l/ j( xmain.h 文件
, N+ i( |: s4 P0 n. u6 d

1. /**
   
2.   ******************************************************************************
   
3.   * @file    main.h
   
4.   * @author  XinLi
   3 T7 }5 A5 n: i  X& ~7 P$ a- B
5.   * @version v1.0
   
6.   * @date    24-June-2018
   
7.   * @brief   Header file for main.c module.
     }: C: Z1 Y, C+ z' {$ A# e1 l
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    : [, W# p# X/ {) b$ S) b. N
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    . C+ z6 j* B5 K# B( Z- K: d
14.   * it under the terms of the GNU General Public License as published by
    + I2 k) h5 R# z! k! r( B/ s
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    
17.   *
    & O: `, ?! q: Y
18.   * This program is distributed in the hope that it will be useful,
    $ e5 y4 Z  ^+ h* f) s! ~. u' \' Q
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.
    
22.   *
    + \6 G' k1 S! i6 J* _! m4 C# r
23.   * You should have received a copy of the GNU General Public License
    0 Z7 @& r% V$ D2 f  a0 B
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.   ******************************************************************************
    5 _. N  d: C" l2 n& Z5 u
27.   */
    3 `/ H, j7 i& p9 {1 V* j' T
28. 
    2 F- C3 i, A% O) C
29. #ifndef __MAIN_H
    / [/ N" L, A* Z; z) H4 Q+ ?; U
30. #define __MAIN_H
    0 J% x" T" X. j0 N% H, L
31. 
    ' g3 R7 m  P) S% U2 o) v
32. #ifdef __cplusplus
    
33. extern "C" {
    8 h/ ?$ o( _5 D
34. #endif
    
35. 
    
36. /* Header includes -----------------------------------------------------------*/
    ) K4 U* G) p% A% r" |: ]0 r, ~
37. #include "stm32f10x.h"
    
38. 
    7 e- {6 i6 `" F: Q
39. /* Macro definitions ---------------------------------------------------------*/
    
40. /* Type definitions ----------------------------------------------------------*/
    
41. /* Variable declarations -----------------------------------------------------*/
    
42. /* Variable definitions ------------------------------------------------------*/
    
43. /* Function declarations -----------------------------------------------------*/
    
44. /* Function definitions ------------------------------------------------------*/
    1 z& v- f" O2 S' ~6 Q& {+ P3 E& E
45. 
    
46. #ifdef __cplusplus
    
47. }
    3 e, t8 w& }8 p+ g7 L
48. #endif
    
49. 
    ' f$ H9 U4 L7 c. F: [
50. #endif /* __MAIN_H */

复制代码

6 j4 p/ I0 L9 `7 U" h8 H5 dmain.c 文件

1. /**
   
2.   ******************************************************************************
   5 O5 B- w* P0 o% z1 v
3.   * @file    main.c
   
4.   * @author  XinLi
   
5.   * @version v1.0
   
6.   * @date    24-June-2018
   
7.   * @brief   Main program body.
     T3 B' D( W! F- c9 {  i7 S
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    6 Q+ h: c! y3 E, J5 {2 D
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    2 d  ^/ _( r; y6 t
13.   * This program is free software: you can redistribute it and/or modify
    0 k- y4 k0 ]4 o3 Q& O) [
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
    " I  ]6 ]$ @  g$ `  m
16.   * (at your option) any later version.
    
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    9 m7 o+ a, B" o+ ^/ w& K& K
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    8 g" l3 Y4 Y" S3 V- X4 a
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    9 H/ j% d5 g- s
21.   * GNU General Public License for more details.
    
22.   *
    7 \2 N4 b& R$ ^- }4 E5 @) _/ q
23.   * You should have received a copy of the GNU General Public License
    0 s' i* |' D  o+ s1 J0 d
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    
25.   *
    - i4 l. W2 H0 [. h) J6 z6 \
26.   ******************************************************************************
    
27.   */
    1 G4 t8 }+ e8 x* I* |: Y4 V
28. 
    
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "main.h"
    
31. #include "CAN.h"
    - }$ ]9 W2 t) i5 C5 e% K
32. 
    
33. #ifdef _RTE_
    1 o- b+ Y+ w; [% Q* i2 q
34. #include "RTE_Components.h"
    
35. #endif
    
36. 
    / u8 h/ B: L$ n0 j1 E4 k
37. #ifdef RTE_CMSIS_RTOS2
    
38. #include "cmsis_os2.h"
    
39. #endif
    
40. 
    / N* a, R; O. h
41. /* Macro definitions ---------------------------------------------------------*/
    . q/ V7 y& S' E1 A3 R  e$ P
42. /* Type definitions ----------------------------------------------------------*/
    
43. /* Variable declarations -----------------------------------------------------*/
    ! l) o. w' |4 \+ `& f" u
44. /* Variable definitions ------------------------------------------------------*/
    
45. static CanTxMsg canTxMsg = {0};
    ) q% _% x9 }; D6 p; e
46. static CanRxMsg canRxMsg = {0};
    
47. 
    ( W7 `0 E  H/ j( k1 x* ?
48. /* Function declarations -----------------------------------------------------*/
    5 H$ S/ \0 K. O0 r5 P5 K- ~
49. static void SystemClock_Config(void);
    ! Y% L# O- e1 H" m
50. 
    
51. /* Function definitions ------------------------------------------------------*/
    2 ?- P7 f9 {; S& O% T# e
52. 
    
53. /**
    . C4 A/ o4 P- g1 b. J% X" X
54.   * @brief  Main program.
    0 g- v6 l& h; k3 T7 D' S
55.   * @param  None.
    5 [& I1 d( T+ K6 g% _
56.   * @return None.
    
57.   */
    1 A. _( s6 l% j) \2 U
58. int main(void)
    
59. {
    
60.   /* Configure the system clock to 72 MHz */
    
61.   SystemClock_Config();
    # M$ L7 R0 x+ c  v  S" ^* c
62.   SystemCoreClockUpdate();
    0 c" e1 |6 y& J( X2 e! w( a' f
63. 
      H' l% L  p( V; ?! L) R2 z  ]( K
64.   /* Add your application code here */
    
65.   CAN_Configure(CAN1, CAN_WorkModeLoopBack, CAN_BaudRate250K, 0xAA55, 0x55AA);
    + A" ^4 L6 ]! a% Y5 H( c
66. 
    
67. #ifdef RTE_CMSIS_RTOS2
    
68.   /* Initialize CMSIS-RTOS2 */
    ! W+ t" x- M7 C* C6 X# z# s. l7 u
69.   osKernelInitialize();
    
70. 
    
71.   /* Create thread functions that start executing,
    ) F) a1 `& N1 n9 h2 K* P, r! f% \. d
72.   Example: osThreadNew(app_main, NULL, NULL); */
    
73. 
    
74.   /* Start thread execution */
    0 }5 e4 Q* }2 v6 }/ j8 c
75.   osKernelStart();
    1 M2 S6 i% I) W3 V. l! |
76. #endif
    1 T, C& |6 \( n9 [; O# k% K3 p
77. 
    
78.   /* Infinite loop */
    ' x; R& X- a: \) Z/ t
79.   while(1)
    
80.   {
    
81.     canTxMsg.StdId = 0xAA55;
    
82.     canTxMsg.ExtId = 0x55AA;
    
83.     canTxMsg.IDE   = CAN_ID_STD;
      ]9 v* K: M' {& Q, e% u5 H, w' I
84.     canTxMsg.RTR   = CAN_RTR_DATA;
    8 ~) @3 c% e4 h8 F8 W% z2 i! e
85.     canTxMsg.DLC   = 8;
    
86. 
    
87.     canTxMsg.Data[0]++;
    ! O& U5 z5 {! x+ l' D
88.     canTxMsg.Data[1]++;
    
89.     canTxMsg.Data[2]++;
    
90.     canTxMsg.Data[3]++;
    , V2 s! X" E- a( \8 D" g8 I2 l
91.     canTxMsg.Data[4]++;
    " B* k4 [$ Q) o5 e3 n, b6 g
92.     canTxMsg.Data[5]++;
    
93.     canTxMsg.Data[6]++;
    
94.     canTxMsg.Data[7]++;
    6 }0 O. b. B/ E
95. 
    
96.     CAN_SetTransmitMessage(CAN1, &canTxMsg, 1);
    
97. 
    
98.     while(CAN_IsReceiveBufferEmpty(CAN1) == true);
    
99. 
    ; I; ?4 L: s2 r  m4 ^
100.     CAN_GetReceiveMessage(CAN1, &canRxMsg, 1);
     
101.   }
     
102. }
     , `7 d* K) l4 A$ O# Q
103. 
     
104. /**
     # k1 m5 E! P# i) }  x1 O; ?
105.   * @brief  System Clock Configuration.
     
106.   *         The system Clock is configured as follow :
     
107.   *            System Clock source            = PLL (HSE)
     , u" O$ b' K" u
108.   *            SYSCLK(Hz)                     = 72000000
     
109.   *            HCLK(Hz)                       = 72000000
     
110.   *            AHB Prescaler                  = 1
     4 w8 |0 _$ `, D" m5 V
111.   *            APB1 Prescaler                 = 2
     
112.   *            APB2 Prescaler                 = 1
     
113.   *            HSE Frequency(Hz)              = 8000000
     
114.   *            HSE PREDIV1                    = 1
     8 K3 \/ a& G$ w! f, _
115.   *            PLLMUL                         = 9
     
116.   *            Flash Latency(WS)              = 2
     5 e! d( z: d/ p4 E$ h
117.   * @param  None.
     
118.   * @return None.
     
119.   */
     
120. static void SystemClock_Config(void)
     
121. {
     
122.   /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration */
     # T; F; ~) k' ]2 c2 F
123.   /* RCC system reset */
     " u8 C3 h1 `5 ~2 v( p
124.   RCC_DeInit();
     
125. 
     
126.   /* Enable HSE */
     
127.   RCC_HSEConfig(RCC_HSE_ON);
     
128. 
     , d% }0 u' h% f7 _: U6 M4 ^
129.   /* Wait till HSE is ready */
     & \4 Y) y! e1 \& B2 Q0 c# R' O
130.   ErrorStatus HSEStartUpStatus = RCC_WaitForHSEStartUp();
     8 q  s4 ]  }* S0 g. C) g
131. 
     
132.   if(HSEStartUpStatus == SUCCESS)
     
133.   {
     
134.     /* Enable Prefetch Buffer */
     , w! C) f- h  o; f6 s8 K) _
135.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     " {4 s4 E$ T9 U
136. 
     + G& {; F5 \6 A4 V* ~
137.     /* Flash 2 wait state */
     
138.     FLASH_SetLatency(FLASH_Latency_2);
     - D7 [& r- w- s  n* O; u
139. 
     : z4 S: F! t- ~
140.     /* HCLK = SYSCLK */
     
141.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     9 q& D1 j+ L4 I6 Z& b# J
142. 
     
143.     /* PCLK2 = HCLK */
     
144.     RCC_PCLK2Config(RCC_HCLK_Div1);
     0 N8 E; u: J' f# n  c
145. 
     
146.     /* PCLK1 = HCLK / 2 */
     
147.     RCC_PCLK1Config(RCC_HCLK_Div2);
     & ?/ F( \) o: p4 C* d8 T
148. 
     
149.     /* Configure PLLs */
     4 r& ^# n# M* h0 [. U! F! b9 A. k
150. #ifdef STM32F10X_CL
     - n1 L# s$ \  D. X) n4 X
151.     /* PLL2 configuration: PLL2CLK = (HSE(8MHz) / 2) * 10 = 40MHz */
     
152.     RCC_PREDIV2Config(RCC_PREDIV2_Div2);
     3 e5 _- c; h, l/ F* F# D: p- [4 {
153.     RCC_PLL2Config(RCC_PLL2Mul_10);
     , v8 `+ s7 P* D$ t* ~4 c
154. 
     
155.     /* Enable PLL2 */
     + }. @3 L& h( v" T, Z0 C" Q
156.     RCC_PLL2Cmd(ENABLE);
     
157. 
     . p2 ^$ W% J; I' ~# e: x
158.     /* Wait till PLL2 is ready */
     + k# V+ f# o2 Q# m0 @/ o
159.     while(RCC_GetFlagStatus(RCC_FLAG_PLL2RDY) == RESET);
     
160. 
       G+ J+ l/ m! U$ z
161.     /* PLL configuration: PLLCLK = (PLL2(40MHz) / 5) * 9 = 72MHz */
     
162.     RCC_PREDIV1Config(RCC_PREDIV1_Source_PLL2, RCC_PREDIV1_Div5);
     7 L% T2 Q7 g2 L! c& T  J9 U
163.     RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_9);
     
164. #else
     
165.     /* PLLCLK = HSE(8MHz) * 9 = 72MHz */
     
166.     RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
     9 T& Z" t( z: v3 d2 U( O4 R  f
167. #endif
     8 v+ g# X! u9 U. j" g, u+ d. `
168. 
     
169.     /* Enable PLL */
     , n$ D! q1 S3 ~1 f0 t+ R& o
170.     RCC_PLLCmd(ENABLE);
     
171. 
     
172.     /* Wait till PLL is ready */
     
173.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     
174. 
     1 C7 q% q' k/ S1 l
175.     /* Select PLL as system clock source */
     
176.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     : b  x: ~: S" }) L8 q
177. 
     / `% l1 Z- c3 j9 b6 D, M3 Z
178.     /* Wait till PLL is used as system clock source */
     
179.     while(RCC_GetSYSCLKSource() != 0x08);
     2 ^$ W4 Q9 c: l7 k! X! v
180.   }
     
181.   else
     
182.   {
     0 n0 N" S" i7 Y
183.     /* Disable HSE */
     
184.     RCC_HSEConfig(RCC_HSE_OFF);
     7 _  j2 y4 w8 [( X
185. 
     
186.     /* Enable HSI */
     
187.     RCC_HSICmd(ENABLE);
     
188. 
     - }9 f0 g" x6 \: @/ d
189.     /* Enable Prefetch Buffer */
     8 F9 m* f0 j# {8 L, |, s3 e
190.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     
191. 
     
192.     /* Flash 1 wait state */
     9 c! n. h" K" J! K1 ?0 ?) g6 j. f3 ]
193.     FLASH_SetLatency(FLASH_Latency_1);
     2 T- [) P5 r  F% `3 {0 D
194. 
     
195.     /* HCLK = SYSCLK */
     
196.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     2 i0 L$ `8 J& O  q; j9 X
197. 
     : @/ q7 n; r+ z; B
198.     /* PCLK2 = HCLK */
     
199.     RCC_PCLK2Config(RCC_HCLK_Div1);
     / v8 t. r7 [8 K  o5 E
200. 
     
201.     /* PCLK1 = HCLK */
     5 q5 s1 T; A# h( f5 [
202.     RCC_PCLK1Config(RCC_HCLK_Div1);
     
203. 
     ! F/ G) H, G  w
204.     /* Configure PLLs */
     
205.     /* PLLCLK = HSI(8MHz) / 2 * 9 = 36MHz */
     
206.     RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_9);
     % e' C9 r2 X. h0 s) f- X/ d2 B
207. 
     ) A% B. N9 W0 }# i( X" G; R
208.     /* Enable PLL */
     
209.     RCC_PLLCmd(ENABLE);
     - n  _3 k4 E; A* Y# U, A
210. 
     & l/ W; B: X4 Q& C* y8 [, y
211.     /* Wait till PLL is ready */
     ; K2 o: Q- U, N
212.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     
213. 
     
214.     /* Select PLL as system clock source */
     
215.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     
216. 
     
217.     /* Wait till PLL is used as system clock source */
     
218.     while(RCC_GetSYSCLKSource() != 0x08);
     
219.   }
     
220. }
     6 M. i, j7 k+ V8 |8 b2 c" s
221. 
     
222. #ifdef USE_FULL_ASSERT
     9 f% ]( p. T) |* _0 L6 l8 S
223. /**
     % t* k+ g- T6 T" M& S
224.   * @brief  Reports the name of the source file and the source line number
     0 K. P$ u* a: p6 E
225.   *         where the assert_param error has occurred.
     , h: t& M/ @) V8 ^6 ~) S! x6 {3 B, p
226.   * @param  file: pointer to the source file name.
     9 r0 h- P  G- ]  p- J
227.   * @param  line: assert_param error line source number.
     
228.   * @return None.
     
229.   */
     $ q2 j, o; c9 X- X3 G
230. void assert_failed(uint8_t *file, uint32_t line)
     6 J5 O( a5 J' u! V; a0 ~# g. ^5 l
231. {
     
232.   /* User can add his own implementation to report the file name and line number,
     
233.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     1 C& w% N- X/ h) W  J3 T
234. 
     9 I; n+ H/ a* f, z! z
235.   /* Infinite loop */
     5 {# Y! r( n* U, r! O
236.   while(1)
     
237.   {
     / b1 x3 i0 r# @/ x/ a2 e& N
238.   }
     
239. }
     
240. #endif

复制代码

5 _$ g5 Z4 F  h6 ~1 c! J' G) u3，注意
, c1 j& s4 T& T2 |/ h
/ F9 k9 F/ ]- d3 cCAN 消息发送缓冲区和接收缓冲区的大小，可以根据应用的需求进行修改，缓冲区使用的是堆内存，需要根据缓冲区大小和应用程序中堆内存使用情况进行配置。

* Q& X4 A$ v. }% g7 j& w4 d
" q* t+ _5 b- W' f, |8 B+ g