1，开发环境
* c+ J3 m, x9 w# H! L" N
6 e9 u# k( `8 ?- Y2 [& j' j$ w% Y* j1，固件库：STM32F10x_StdPeriph_Lib_V3.5.0
9 Q; K4 J( J( s# \* }6 [
/ E1 \: g! a! h! ]0 s5 d2，编译器：ARMCC V5.06
4 s5 {4 f' N$ H$ F0 s  Q; b+ ?* Q
3，IDE：Keil uVision5

/ e1 \* g" t" E  }+ @$ T, t% ~4，操作系统：Windows 10 专业版
- q) _" Z6 u: Q7 @4 D. L. d/ G
* @3 R( u& u9 X8 g8 V
/ h' x6 @% R2 U8 e/ |2，程序源码

( c: D- Q0 ~" @RingBuffer.h 文件
5 N: h: _! D* a: c8 u9 [

1. /**
   ! A; m7 y' Z! ^7 p* y
2.   ******************************************************************************
   ; d5 ?, {# j+ ]( f
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.   ******************************************************************************
   0 [1 d' ^+ y2 U" {
9.   * @attention
   
10.   *
    ! O1 R# x- e: f5 u
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    + U* d  ^  t( d% @" T; {9 q
12.   *
    0 `* E; i2 ^7 y0 }) w# x1 \& t
13.   * This program is free software: you can redistribute it and/or modify
    . E0 a: U2 ^6 a) i+ 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.
    7 I: P( M+ C: V/ d3 r& v
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    5 ?0 p7 M" Q# y1 }: Q0 k7 f/ ?
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    . J6 z% \2 S) E
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    * L- s9 M- T# i% L
21.   * GNU General Public License for more details.
    - V0 m  d5 ^, ^! E8 |0 Q
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    5 w. Z. `5 ~9 Y! ?' z4 D
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    1 h* k3 O! \3 V3 W: O5 }
25.   *
    
26.   ******************************************************************************
    $ f# E( g9 v/ `* ]0 C8 B& U8 j
27.   */
    6 U: g5 h3 f0 U0 ~6 K2 |
28. 
    ) r; q5 Z' ~! q. m9 m
29. #ifndef __RINGBUFFER_H
    4 [' h8 t& n9 b
30. #define __RINGBUFFER_H
    
31. 
    
32. #ifdef __cplusplus
    
33. extern "C" {
    , {$ q6 h+ k* A) r
34. #endif
    
35. 
    3 Z* U; l! }5 m+ D  v- B
36. /* Header includes -----------------------------------------------------------*/
    
37. #include <stdint.h>
    # \3 k' C. ?/ ~/ G' z- e; O( M
38. #include <stdbool.h>
    
39. #include <stdlib.h>
    
40. 
    
41. /* Macro definitions ---------------------------------------------------------*/
    
42. #define RING_BUFFER_MALLOC(size)  malloc(size)
    
43. #define RING_BUFFER_FREE(block)   free(block)
    : V8 }. T+ i  ?% W/ h8 H0 E
44. 
    3 k4 o/ t2 m) Y4 o" K
45. /* Type definitions ----------------------------------------------------------*/
    2 R: k8 P/ A& q# Y0 k
46. typedef struct
    
47. {
    + O4 ^( N: F5 p: k2 {
48.   uint8_t *buffer;
    
49.   uint32_t size;
      L/ `7 V* X) M' h9 K) K
50.   uint32_t in;
    
51.   uint32_t out;
    - q4 D4 n8 i9 f+ O( w0 {9 |
52. }RingBuffer;
    : w1 J. m- b0 W9 t. s; a+ V
53. 
    ( m. u4 _( @  V0 W  |# V( u7 k
54. /* Variable declarations -----------------------------------------------------*/
    , m) o- _0 w$ B/ w
55. /* Variable definitions ------------------------------------------------------*/
    $ B& C. j3 ^! F" Q3 }
56. /* Function declarations -----------------------------------------------------*/
    
57. RingBuffer *RingBuffer_Malloc(uint32_t size);
    # h% A  B# L8 e
58. void RingBuffer_Free(RingBuffer *fifo);
    & o9 J. |3 }8 v$ b2 a2 B
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);
    
62. 
    
63. /* Function definitions ------------------------------------------------------*/
    ; E9 m+ V2 U, l* q5 Z3 Z
64. 
    : V2 J) ]2 w; j, `" ^
65. /**
    
66.   * @brief  Removes the entire FIFO contents.
    
67.   * @param  [in] fifo: The fifo to be emptied.
    
68.   * @return None.
    " t6 A$ K, ]9 k/ G# ~# G
69.   */
    
70. static inline void RingBuffer_Reset(RingBuffer *fifo)
    # w- Y, J& O' t* W6 {
71. {
    ( J9 k) B& \* E" y' D- q
72.   fifo->in = fifo->out = 0;
      A1 E. b* s( A* F$ N
73. }
    
74. 
    
75. /**
    
76.   * @brief  Returns the size of the FIFO in bytes.
    
77.   * @param  [in] fifo: The fifo to be used.
    
78.   * @return The size of the FIFO.
    + \* n6 F  Q; y" g0 y+ c' H
79.   */
    ' M9 S, E. x, D2 U
80. static inline uint32_t RingBuffer_Size(RingBuffer *fifo)
    
81. {
    & B. e% s2 U: E
82.   return fifo->size;
    
83. }
    0 L  D2 K7 u" z2 k. P
84. 
    
85. /**
    
86.   * @brief  Returns the number of used bytes in the FIFO.
    , L$ @6 e) ^4 K* e6 s3 E
87.   * @param  [in] fifo: The fifo to be used.
    : p' H# Y6 H* h3 i' d' a
88.   * @return The number of used bytes.
    2 b) Y9 r/ l: L' b; E, R. r- C( M4 t
89.   */
    
90. static inline uint32_t RingBuffer_Len(RingBuffer *fifo)
    8 n) n; ~2 s: L; D! Y% Y, f- v
91. {
    * |; M! T* v0 L. q, X2 E' h
92.   return fifo->in - fifo->out;
    / F- T, n# x, P* q7 O
93. }
    " P. Q% k+ Y+ r3 k& V
94. 
    
95. /**
    
96.   * @brief  Returns the number of bytes available in the FIFO.
    , e) j2 ]2 y* I6 I3 H! T) r
97.   * @param  [in] fifo: The fifo to be used.
    % {+ p! b# w( e0 v" L
98.   * @return The number of bytes available.
    / N7 s( n+ g7 r. ~
99.   */
    
100. static inline uint32_t RingBuffer_Avail(RingBuffer *fifo)
     
101. {
     
102.   return RingBuffer_Size(fifo) - RingBuffer_Len(fifo);
     
103. }
     
104. 
     
105. /**
     1 _$ b$ ^3 J5 Z( N% J" z
106.   * @brief  Is the FIFO empty?
     ! e# }4 \5 ?/ f8 ]
107.   * @param  [in] fifo: The fifo to be used.
     9 m9 I, y/ f) S$ l5 w0 J
108.   * @retval true:      Yes.
     - k! U- t# B' i( u0 f4 x) ~3 F. ?+ d
109.   * @retval false:     No.
       ?4 P5 c  @2 j9 H1 S: t
110.   */
     " [! c1 i- V" Q  \1 F/ g
111. static inline bool RingBuffer_IsEmpty(RingBuffer *fifo)
     
112. {
     
113.   return RingBuffer_Len(fifo) == 0;
     * H4 q7 W) q3 _6 Y- A7 b1 _
114. }
     6 t8 t/ O# q- i+ q  A# k2 B
115. 
     5 ~# s  q! d3 \4 u: C
116. /**
     , c5 Y7 d9 Y, e& I
117.   * @brief  Is the FIFO full?
     
118.   * @param  [in] fifo: The fifo to be used.
     
119.   * @retval true:      Yes.
     + r9 d; C# |( A: {" ?
120.   * @retval false:     No.
     + s* t0 X8 p( c2 O3 r4 x2 {" B4 r
121.   */
     % K4 g" N+ O4 m5 m/ s; j" i
122. static inline bool RingBuffer_IsFull(RingBuffer *fifo)
     1 t* R  o" J( P/ G& b
123. {
     
124.   return RingBuffer_Avail(fifo) == 0;
     * l2 }6 k/ T! D
125. }
     
126. 
     
127. #ifdef __cplusplus
     * [) W6 k4 ^( q7 M) a1 g+ K4 l
128. }
     
129. #endif
     
130. 
     ( ^& T4 P: U7 J5 D1 F' d7 R
131. #endif /* __RINGBUFFER_H */
     

复制代码

. {$ Q9 z5 y0 Y: r' G' {5 e
RingBuffer.c 文件

1. <div>/**
   
2.   ******************************************************************************
   4 X) ?" |" b, H% H
3.   * @file    RingBuffer.c
   1 N0 j! x% p% ]/ N' f9 q
4.   * @author  XinLi
   
5.   * @version v1.1
   
6.   * @date    15-January-2018
   2 v7 S9 [' h1 F
7.   * @brief   Ring buffer module source file.
   0 b6 Z  U) G: w
8.   ******************************************************************************
   9 H. Y; B: d, n
9.   * @attention
   , {, H" R* P' l4 O8 F3 h5 X$ `1 d
10.   *
    * o3 l2 [& m$ R5 ~3 T
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    5 g# v2 K6 c' v- w
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.   *
    
18.   * This program is distributed in the hope that it will be useful,
    0 ?) L  |# x, ^; I. v) C
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.
    - f) E7 s9 S- H2 J
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>
    
25.   *
    # Q+ Q) ?- `/ E' v1 D6 W7 l" t0 h
26.   ******************************************************************************
    % ~  ~: V, d1 y# l3 H5 |
27.   */
    
28. 
    
29. /* Header includes -----------------------------------------------------------*/
    $ S) E. C' r: ^% z3 Z# Q( ~! v7 ^
30. #include "RingBuffer.h"
    ! d1 ]' S0 G* D3 M- |" I
31. #include <string.h>
    ) H7 u8 n0 T( F
32. 
    
33. /* Macro definitions ---------------------------------------------------------*/
    1 s/ V5 |# G% z' }4 N3 F: a8 D, N
34. #define min(a, b)  (((a) < (b)) ? (a) : (b))
    ( o! d; F2 f' g) U
35. 
    
36. /* Type definitions ----------------------------------------------------------*/
    + Y4 t6 ~0 b$ p9 R& I* r
37. /* Variable declarations -----------------------------------------------------*/
    ) P( k; s0 d# J
38. /* Variable definitions ------------------------------------------------------*/
    
39. /* Function declarations -----------------------------------------------------*/
    2 q1 r: j4 f1 H) j5 m
40. static bool is_power_of_2(uint32_t x);
    8 b1 I. c6 {+ S* v( H* c
41. static uint32_t roundup_pow_of_two(uint32_t x);
    8 r/ ?5 b6 S! w; n' W' _; Q( ^# [
42. 
    
43. /* Function definitions ------------------------------------------------------*/
    + H" p8 Y# ?. V4 Q% K
44. 
    
45. /**
    
46.   * @brief  Allocates a new FIFO and its internal buffer.
    
47.   * @param  [in] size: The size of the internal buffer to be allocated.
    . c& x3 _+ l! h/ [
48.   * @note   The size will be rounded-up to a power of 2.
    
49.   * @return RingBuffer pointer.
    
50.   */
    
51. RingBuffer *RingBuffer_Malloc(uint32_t size)
    & f. w/ x* u2 J( A
52. {
    $ {) F& `+ D6 f+ f+ ^$ }
53.   RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer));
    3 e; n" R5 A" c2 [; n: m4 B
54. 
    4 f3 G$ c, S5 J$ q( V, p
55.   if(fifo != NULL)
    
56.   {
    
57.     if(is_power_of_2(size) != true)
    " H3 [- C! [1 f, k
58.     {
    " T1 p2 ^+ Q, I+ W7 N2 E& ?" p
59.       if(size > 0x80000000UL)
    , `/ \; f+ J0 u8 n4 ^& v
60.       {
    ) w. V. Q1 o& i# C
61.         RING_BUFFER_FREE(fifo);
    ! F/ Z: T* y+ H' \
62.         return NULL;
    
63.       }
    
64. 
    
65.       size = roundup_pow_of_two(size);
    
66.     }
    % h$ H$ R6 C4 d+ Q) K; F
67. 
    
68.     fifo->buffer = RING_BUFFER_MALLOC(size);
    1 t; B# y# O& A
69. 
    ) s! I# ^% W& P/ c1 O2 n1 P, {- V6 ^% T
70.     if(fifo->buffer == NULL)
    : ], {, ]3 Z0 }$ [4 ]
71.     {
    ) O6 s, h$ k6 ?0 h5 i+ J/ n6 v8 @
72.       RING_BUFFER_FREE(fifo);
    
73.       return NULL;
    ( p/ i, C+ m6 r3 S% W8 _: {& O) V
74.     }
    
75. 
    + U4 T3 {9 Z2 A, y+ f# P
76.     fifo->size = size;
    
77.     fifo->in = fifo->out = 0;
    7 A( j6 j6 [, z5 ?
78.   }
    ! b( ~8 R; |! b( l- R" `% ^9 Z
79. 
    
80.   return fifo;
    
81. }
    
82. 
    " t! Z/ F( _* X0 v; b
83. /**
    
84.   * @brief  Frees the FIFO.
    
85.   * @param  [in] fifo: The fifo to be freed.
    " `1 b) l9 ^+ w; ~  m$ u+ p, i7 D
86.   * @return None.
    8 `2 k9 l, k5 S6 z% C" D
87.   */
    
88. void RingBuffer_Free(RingBuffer *fifo)
    
89. {
    5 O) A* I) N8 o4 U% g
90.   RING_BUFFER_FREE(fifo->buffer);
    " \+ ^( T$ W0 O$ W- y: G1 t
91.   RING_BUFFER_FREE(fifo);
    " ^9 O2 D* j. |9 L- g5 F/ z( Y0 r0 |
92. }
    
93. 
    & _, U& \# a; w+ f5 |0 t  b
94. /**
    * x3 C8 q. ?/ I) V
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.
    ( w3 ?  h5 a, c3 o$ x! p
98.   * @param  [in] len:  The length of the data to be added.
    8 @4 `2 R" `" N( v2 _) T1 l. u
99.   * @return The number of bytes copied.
    1 \7 \3 G  i4 ]5 |
100.   * @note   This function copies at most @len bytes from the @in into
     3 ?* w: D, i6 r1 ?3 K
101.   *         the FIFO depending on the free space, and returns the number
     
102.   *         of bytes copied.
     8 W" \% f8 P8 ~9 C" A1 S
103.   */
     
104. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len)
     
105. {
     
106.   len = min(len, RingBuffer_Avail(fifo));
     5 D% }# y& ~5 B& j/ F
107. 
       B) S$ ]' E2 _! ^% J8 b
108.   /* First put the data starting from fifo->in to buffer end. */
     $ U7 u- j- b9 s- U
109.   uint32_t l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
     
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. */
     
113.   memcpy(fifo->buffer, (uint8_t *)in + l, len - l);
     - D, P8 l& V; c1 }4 @8 u. K! a( E
114. 
     ; A! j& k, N! Y& }& U( Y( n
115.   fifo->in += len;
     
116. 
     
117.   return len;
     . L, V3 f" G+ u! k% q
118. }
     7 F& x5 H6 g" \' ?2 O6 r0 u4 D
119. 
     , T% B, r5 n9 r' p/ }9 @
120. /**
     
121.   * @brief  Gets some data from the FIFO.
     
122.   * @param  [in] fifo: The fifo to be used.
     
123.   * @param  [in] out:  Where the data must be copied.
     ; @1 L8 {! b6 n1 p! X9 f
124.   * @param  [in] len:  The size of the destination buffer.
     
125.   * @return The number of copied bytes.
     ) v, {0 j9 y/ s* s. f6 g; S9 z7 d
126.   * @note   This function copies at most @len bytes from the FIFO into
     
127.   *         the @out and returns the number of copied bytes.
     
128.   */
     - y8 S9 a! K  C1 [! j
129. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len)
     ! Y2 j2 P3 b: p7 O2 ?2 i) {
130. {
     " T$ W. @" [  C( }
131.   len = min(len, RingBuffer_Len(fifo));
     
132. 
     
133.   /* First get the data from fifo->out until the end of the buffer. */
     ; t# E" }# a. _) Y
134.   uint32_t l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
     & B7 v5 [" n3 O  d( ?7 @5 @+ P- v
135.   memcpy(out, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
     7 A3 ?' _  a  _' _4 d) Y* a
136. 
     / O8 c: b) y) w% h; T
137.   /* Then get the rest (if any) from the beginning of the buffer. */
     
138.   memcpy((uint8_t *)out + l, fifo->buffer, len - l);
     
139. 
     - }4 V: E: ^& G" `& @
140.   fifo->out += len;
     
141. 
     $ Y/ T: [5 @7 F- H' K1 F6 U
142.   return len;
     . |: |& Z; s) p
143. }
     
144. 
     
145. /**
     
146.   * @brief  Determine whether some value is a power of two.
     
147.   * @param  [in] x: The number to be confirmed.
     
148.   * @retval true:   Yes.
     - I/ K- u3 {( @' ?
149.   * @retval false:  No.
     
150.   * @note   Where zero is not considered a power of two.
     ( v+ N6 F, [: ~% f& x2 y* q
151.   */
     
152. static bool is_power_of_2(uint32_t x)
     " j& t! F% |( W7 _" O  ~% K2 o
153. {
     
154.   return (x != 0) && ((x & (x - 1)) == 0);
     
155. }
     
156. 
     
157. /**
     " S6 O/ g: c. S4 ?4 ~
158.   * @brief  Round the given value up to nearest power of two.
     - z8 h2 e6 u! h! Z
159.   * @param  [in] x: The number to be converted.
     
160.   * @return The power of two.
     3 y) d( G+ L2 N: b# {+ S
161.   */
     : P; I: o" \2 p; U7 ?9 ~7 Q
162. static uint32_t roundup_pow_of_two(uint32_t x)
     ( E! y" N; |; z! A: m
163. {
     ; f* W4 ~# T2 G
164.   uint32_t b = 0;
     3 Q6 y% N  n: B) C: F( v4 R5 q$ ~8 ~
165. 
     + [. l  O, X; E+ @; ~& l( A3 }* D4 }
166.   for(int i = 0; i < 32; i++)
     
167.   {
     
168.     b = 1UL << i;
     
169. 
     9 j3 E4 `7 v1 r& L
170.     if(x <= b)
     
171.     {
     3 y7 a4 t: W9 p) v) Z* ?, e
172.       break;
     ( U; r6 @9 B" E2 `
173.     }
     
174.   }
     
175. 
     ) ~. Q6 t+ S" v* t) N- \
176.   return b;
     
177. }</div><div></div>

复制代码

) g- b" v5 ?- ZCAN.h 文件

1. /**
   
2.   ******************************************************************************
   ; G3 a* j8 q% Q
3.   * @file    CAN.h
   9 E" f3 k6 Z& [# t
4.   * @author  XinLi
   
5.   * @version v1.0
   & w2 G6 u2 I5 L/ z4 Q% ^+ K
6.   * @date    24-June-2018
   # Q9 l/ N6 v% ?& t
7.   * @brief   Header file for CAN.c module.
   # z/ s& J4 y/ C$ W
8.   ******************************************************************************
   ( o/ J* [) C' n' M8 [: x3 L* `
9.   * @attention
   ' I  F$ E; g" [& O# L
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    : k' M/ O4 @7 h
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.
    ! s& H6 @# u6 p  d
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
    " ~$ v6 w! y, p/ Y: F1 v: p1 J
21.   * GNU General Public License for more details.
    
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    4 T1 ?/ X7 B" ]2 T( T- ~. o
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    
25.   *
    ; W: J  M* @, o& y* j, P
26.   ******************************************************************************
    
27.   */
    5 V9 e2 G7 m" |# z3 Y& q1 g* {
28. 
    
29. #ifndef __CAN_H
    
30. #define __CAN_H
    
31. 
    6 R! h( \' N3 f: L7 ^2 }+ y
32. #ifdef __cplusplus
    6 J8 o$ @( u6 B7 B* g6 ~1 [+ Z, G
33. extern "C" {
    
34. #endif
    
35. 
    9 i; _/ {" r8 C- i4 L, i% X
36. /* Header includes -----------------------------------------------------------*/
    
37. #include "stm32f10x.h"
    9 h$ j8 b+ t3 B( o7 j
38. #include <stdbool.h>
    
39. 
    
40. /* Macro definitions ---------------------------------------------------------*/
    $ n( Y9 ^! Z. L# {( A6 x7 F# }; M
41. 
    
42. /******************************* CAN1 Configure *******************************/
    ' n; e+ m2 C' E7 v/ C" A- G
43. #define CAN1_TX_BUFFER_SIZE        (16)
    
44. #define CAN1_RX_BUFFER_SIZE        (16)
    
45. 
    % m# m  q2 c: [; e! Y
46. #define CAN1_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    # G: r9 m. K# C7 X' n) j
47. #define CAN1_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    ( b6 i3 z* i3 K' e1 d" x
48. 
    
49. #define CAN1_TX_GPIO_PORT          GPIOB
    ( p9 y0 L2 c8 G4 }6 |% K5 u, L
50. #define CAN1_RX_GPIO_PORT          GPIOB
    . f! _  r! U0 e0 n/ z
51. 
    
52. #define CAN1_TX_GPIO_PIN           GPIO_Pin_9
    
53. #define CAN1_RX_GPIO_PIN           GPIO_Pin_8
    
54. 
    
55. #define CAN1_IRQ_PREEMPT_PRIORITY  (0)
      u( P- F( Y1 v6 x# }
56. #define CAN1_IRQ_SUB_PRIORITY      (0)
    # O* u: t+ U# G8 d* g7 |- A- @
57. 
    ( X9 i2 r4 z( \3 n* ]+ W
58. #define CAN1_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap1_CAN1 , ENABLE)
    1 E$ N( c: E( v1 u/ K  x1 n$ e- R
59. /******************************************************************************/
    5 ~, }% l* L! Y
60. 
    ! B( @) p) ?, h
61. #ifdef STM32F10X_CL
    # K  u2 k, W4 i( t
62. /******************************* CAN2 Configure *******************************/
    
63. #define CAN2_TX_BUFFER_SIZE        (16)
    8 K$ x% E8 Q2 o2 J: a
64. #define CAN2_RX_BUFFER_SIZE        (16)
    : h9 L" d& N( C' T" ~
65. 
    $ n& \! p! X7 f0 q4 e0 ~- T
66. #define CAN2_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    5 y  E, ^9 F) F9 a* i- ^$ s
67. #define CAN2_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
68. 
    , o3 [4 C3 G. T6 P" z
69. #define CAN2_TX_GPIO_PORT          GPIOB
    ) J, t) ?8 s' {5 Y) D6 P# I+ u
70. #define CAN2_RX_GPIO_PORT          GPIOB
    
71. 
    5 c9 ]! h. o3 I' f0 X, a5 ]& e
72. #define CAN2_TX_GPIO_PIN           GPIO_Pin_13
    * ]0 [( f% d- O0 V1 Y1 K
73. #define CAN2_RX_GPIO_PIN           GPIO_Pin_12
    0 C" Y. m% [$ w' T, n
74. 
    
75. #define CAN2_IRQ_PREEMPT_PRIORITY  (0)
    
76. #define CAN2_IRQ_SUB_PRIORITY      (0)
    
77. 
    
78. #define CAN2_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap_CAN2 , DISABLE)
    4 s+ R- [% [4 u6 }2 s, z
79. /******************************************************************************/
    & x# d2 s2 S0 Z* n2 U
80. #endif /* STM32F10X_CL */
    
81. 
    ; a$ L0 U! [0 E$ z
82. /* Type definitions ----------------------------------------------------------*/
    
83. typedef enum
    
84. {
      S. _0 r& H8 O% f
85.   CAN_WorkModeNormal   = CAN_Mode_Normal,
    % `  p% i- r3 w8 |- |5 ^
86.   CAN_WorkModeLoopBack = CAN_Mode_LoopBack
    9 D. a3 H9 u* F: ^) N+ X& L; }) _
87. }CAN_WorkMode;
      G& j) M: n( ?( O. O8 R
88. 
    
89. typedef enum
    / i- W; e9 M6 M8 _' Y/ t( _- D
90. {
    
91.   CAN_BaudRate1000K = 6,
    
92.   CAN_BaudRate500K  = 12,
    ) T5 ^( ?6 k- ~; ~
93.   CAN_BaudRate250K  = 24,
    ; y9 }3 N" K& V
94.   CAN_BaudRate125K  = 48,
    
95.   CAN_BaudRate100K  = 60,
    % N! \; V/ x# D
96.   CAN_BaudRate50K   = 120,
    
97.   CAN_BaudRate20K   = 300,
    
98.   CAN_BaudRate10K   = 600
    
99. }CAN_BaudRate;
    
100. 
     
101. /* Variable declarations -----------------------------------------------------*/
     . L" U0 b+ R+ D" ?& v3 t
102. /* Variable definitions ------------------------------------------------------*/
     
103. /* Function declarations -----------------------------------------------------*/
     , }7 w9 V$ `$ y. _
104. void CAN_Configure(CAN_TypeDef *CANx, CAN_WorkMode WorkMode, CAN_BaudRate BaudRate, uint32_t StdId, uint32_t ExtId);
     0 B7 }, X* M# G& _
105. void CAN_Unconfigure(CAN_TypeDef *CANx);
     
106. 
     8 k  @, |1 Y' A/ n6 d! d% A' W
107. void CAN_SetTransmitFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     
108. void CAN_SetReceiveFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     $ D4 s3 p, q1 b5 y0 P* i# W$ Q
109. 
     
110. uint32_t CAN_SetTransmitMessage(CAN_TypeDef *CANx, CanTxMsg *Message, uint32_t Number);
     - f# y# |( d( E- a! F" s' V9 d* Y1 C
111. uint32_t CAN_GetReceiveMessage(CAN_TypeDef *CANx, CanRxMsg *Message, uint32_t Number);
     2 K% H+ o4 l6 j; c
112. 
     
113. uint32_t CAN_GetUsedTransmitBufferSize(CAN_TypeDef *CANx);
     + j: O. _7 s2 e- {
114. uint32_t CAN_GetUsedReceiveBufferSize(CAN_TypeDef *CANx);
     
115. uint32_t CAN_GetUnusedTransmitBufferSize(CAN_TypeDef *CANx);
     
116. uint32_t CAN_GetUnusedReceiveBufferSize(CAN_TypeDef *CANx);
     
117. 
     % t' O; A- ~6 p
118. bool CAN_IsTransmitBufferEmpty(CAN_TypeDef *CANx);
     
119. bool CAN_IsReceiveBufferEmpty(CAN_TypeDef *CANx);
     
120. bool CAN_IsTransmitBufferFull(CAN_TypeDef *CANx);
     & @% ^) b. U4 {) i
121. bool CAN_IsReceiveBufferFull(CAN_TypeDef *CANx);
     / D1 {" m2 r- s# _, A5 r0 x; [
122. 
     
123. void CAN_ClearTransmitBuffer(CAN_TypeDef *CANx);
     ( z. H' O6 b' W2 W- U8 Z
124. void CAN_ClearReceiveBuffer(CAN_TypeDef *CANx);
     # J0 X9 e! g8 H6 t+ R8 y' A
125. 
     7 P! v( ^, X( d# e$ C1 u
126. bool CAN_IsTransmitMessage(CAN_TypeDef *CANx);
     
127. 
     ( ?6 v' ]$ R3 B, v  |- F
128. /* Function definitions ------------------------------------------------------*/
     0 G8 U+ r1 o3 a* g
129. 
     5 h5 T! F' g9 z) t- M; Z
130. #ifdef __cplusplus
     
131. }
     ' y* H& s  @5 u  C8 x
132. #endif
     
133. 
     
134. #endif /* __CAN_H */
     + \: S* B$ n: {, Q* e7 Y

复制代码

! \- F- N: z( G. p

* o( U" ~3 Q' \CAN.c 文件
; d: q& U% c' @7 R1 `* f
8 ?, u  O- \- H8 k5 r3 H

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

复制代码

main.h 文件
5 M. S0 u2 M5 x; b* C

1. /**
   ! d. c* h% y1 i0 P" l4 R
2.   ******************************************************************************
   
3.   * @file    main.h
   
4.   * @author  XinLi
   & L1 G- k% M1 u$ ]$ v9 s, R: n
5.   * @version v1.0
   
6.   * @date    24-June-2018
   
7.   * @brief   Header file for main.c module.
   7 c9 ~# i$ |5 u
8.   ******************************************************************************
   + M2 O) {! R% N
9.   * @attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    ( b) V( o! P- p2 E1 ?
12.   *
    * V% l3 |+ P. O! v/ R; \/ D* X
13.   * This program is free software: you can redistribute it and/or modify
    % F! D) C0 B( `6 I5 A  f
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.
    ( V3 W( U' a) O. R1 Q
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    ; d8 l3 J. B1 O- B! 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.   *
    0 A1 r( v' s* Y; j, d& Y9 Q
23.   * You should have received a copy of the GNU General Public License
    7 `! S0 W' g/ W" k* 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.   *
    5 ^, ]2 n' ?2 }9 F, C6 f
26.   ******************************************************************************
    ( T" c8 ?: H1 n: T4 S
27.   */
    
28. 
    ; {. Z& s6 e, Q' q8 `
29. #ifndef __MAIN_H
    , B' h6 T9 ]% \% G5 d, f
30. #define __MAIN_H
    
31. 
    
32. #ifdef __cplusplus
    9 C: _  W$ c; v
33. extern "C" {
    + D% c) G$ K$ k/ \
34. #endif
    + r+ f4 L: y6 {( _* T6 @1 ~. S
35. 
    
36. /* Header includes -----------------------------------------------------------*/
    3 k" D& X% A; [6 u' R( T* M' ?
37. #include "stm32f10x.h"
    
38. 
    
39. /* Macro definitions ---------------------------------------------------------*/
    
40. /* Type definitions ----------------------------------------------------------*/
    : x# N8 o+ n% Z, B
41. /* Variable declarations -----------------------------------------------------*/
    
42. /* Variable definitions ------------------------------------------------------*/
    ' o, S; s- Q# ]! n$ n& n  J2 ^( `3 \
43. /* Function declarations -----------------------------------------------------*/
    
44. /* Function definitions ------------------------------------------------------*/
    
45. 
    4 [. C. P) N- r; \! c
46. #ifdef __cplusplus
    
47. }
    ! }, q' i% z& w" a
48. #endif
    
49. 
    
50. #endif /* __MAIN_H */

复制代码

main.c 文件
- S  Q5 [% H6 `. j8 @

1. /**
   5 Z* M) B) l' r2 H# T% d- L
2.   ******************************************************************************
   
3.   * @file    main.c
   + |2 @( U4 J* ?- g' u$ p& G
4.   * @author  XinLi
   
5.   * @version v1.0
   . u8 z+ p; }$ d: Z5 ?
6.   * @date    24-June-2018
   & y- H& {7 T8 l3 {, M
7.   * @brief   Main program body.
   
8.   ******************************************************************************
   
9.   * @attention
   , }4 i; u# b- a, P1 R
10.   *
    - L7 a( v% W5 P+ f/ ^
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    8 B# A, E8 h' z8 [
13.   * This program is free software: you can redistribute it and/or modify
    - x; O' v9 \* D# ~4 K
14.   * it under the terms of the GNU General Public License as published by
    . H# Q( O5 U7 q9 F' t' Z% G
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    * x; G2 P' u  ^; S1 I5 ]
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
    $ ^) o( P2 Z/ d& \5 U
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    
22.   *
    ! T4 [$ T7 Y! u* h
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>
    ) Q8 k5 W, u7 s$ y; D, o
25.   *
    7 F, V1 v2 j0 \: G9 y
26.   ******************************************************************************
    
27.   */
    
28. 
    
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "main.h"
    2 |: p% o$ {# L" o! I
31. #include "CAN.h"
    
32. 
    + K5 m/ a! o) d& c( C
33. #ifdef _RTE_
    ; _. f" ^1 y7 [6 P( ^
34. #include "RTE_Components.h"
    4 ]' ~& I: t; A. c! F
35. #endif
    
36. 
    ! y4 K, w& d/ J( ^& Y0 L8 C
37. #ifdef RTE_CMSIS_RTOS2
    $ V5 g  ?  ]- W- {) h: W
38. #include "cmsis_os2.h"
    
39. #endif
      n3 c1 Y* u& }& t5 \! A
40. 
    : v; s0 L$ t1 K# v
41. /* Macro definitions ---------------------------------------------------------*/
    
42. /* Type definitions ----------------------------------------------------------*/
    
43. /* Variable declarations -----------------------------------------------------*/
    & [: `1 W6 v1 v! V
44. /* Variable definitions ------------------------------------------------------*/
    # a' f- ~  b: {; E9 v
45. static CanTxMsg canTxMsg = {0};
    ( X1 ~7 V8 R0 T' S: a1 x1 v1 r
46. static CanRxMsg canRxMsg = {0};
    # w' |- d) p- i1 ]% Y- \+ z
47. 
    ' E( W: T) B; N1 w' x
48. /* Function declarations -----------------------------------------------------*/
    
49. static void SystemClock_Config(void);
    * E& h6 ^5 i0 d+ m0 i
50. 
    
51. /* Function definitions ------------------------------------------------------*/
    1 ^8 `9 B& J) P* L! f
52. 
    3 ]- {" Y" g: R
53. /**
    ' y, V/ N$ U8 x0 K+ @
54.   * @brief  Main program.
    % J- l( K' j' r: q4 v9 H
55.   * @param  None.
    , A' J+ p4 u. {4 {- g$ E. u
56.   * @return None.
    
57.   */
    2 K* Q( Y0 f9 ?
58. int main(void)
    
59. {
    & {, C4 m& b8 F3 m# L* z! X4 v! U
60.   /* Configure the system clock to 72 MHz */
    
61.   SystemClock_Config();
    
62.   SystemCoreClockUpdate();
    3 m9 F+ g0 ]2 M% g
63. 
    
64.   /* Add your application code here */
    ; I2 s+ Y3 d8 Q* O
65.   CAN_Configure(CAN1, CAN_WorkModeLoopBack, CAN_BaudRate250K, 0xAA55, 0x55AA);
    
66. 
    
67. #ifdef RTE_CMSIS_RTOS2
    
68.   /* Initialize CMSIS-RTOS2 */
    
69.   osKernelInitialize();
    
70. 
    
71.   /* Create thread functions that start executing,
    
72.   Example: osThreadNew(app_main, NULL, NULL); */
    - Z3 S8 q! O  a! Y
73. 
    0 }# a% F0 B6 p7 ~* y4 P
74.   /* Start thread execution */
      W( }0 q' w4 W! b5 S4 A
75.   osKernelStart();
    
76. #endif
    . @2 K$ j  W: o: u
77. 
    
78.   /* Infinite loop */
    
79.   while(1)
      J* t- {1 D- \/ Z6 Q
80.   {
    ; ~' v% Y* _4 |5 g
81.     canTxMsg.StdId = 0xAA55;
    
82.     canTxMsg.ExtId = 0x55AA;
    " w) L) C4 W( w+ i: q' s' ~
83.     canTxMsg.IDE   = CAN_ID_STD;
    
84.     canTxMsg.RTR   = CAN_RTR_DATA;
    
85.     canTxMsg.DLC   = 8;
    
86. 
    - h" F4 r; s  y9 \3 `3 m( ^
87.     canTxMsg.Data[0]++;
    - p2 Z% d4 T; q0 O: r- l
88.     canTxMsg.Data[1]++;
    # j. S, i0 E! `$ l' S9 ?: ~
89.     canTxMsg.Data[2]++;
    
90.     canTxMsg.Data[3]++;
    
91.     canTxMsg.Data[4]++;
    2 C" w7 h: R9 _1 v! C3 d8 ?
92.     canTxMsg.Data[5]++;
    / X4 N9 H/ v5 p* `9 C, [
93.     canTxMsg.Data[6]++;
    ; @3 A9 U, |; Y- W7 u1 z
94.     canTxMsg.Data[7]++;
    5 c! H5 {7 U2 |9 G
95. 
    % i) ^, u/ l% J$ _- q4 Y
96.     CAN_SetTransmitMessage(CAN1, &canTxMsg, 1);
    0 H: J& h5 o7 P5 U
97. 
    
98.     while(CAN_IsReceiveBufferEmpty(CAN1) == true);
    
99. 
    
100.     CAN_GetReceiveMessage(CAN1, &canRxMsg, 1);
     , a% v' R: k$ i2 n, V
101.   }
     $ i+ A& v, H: ?0 c9 E4 P9 Z; u6 |
102. }
     : z" H$ N, ]( v7 p
103. 
     7 T4 o* ^' s5 g2 k3 ?
104. /**
     . ]- \: T. k6 b5 i5 O
105.   * @brief  System Clock Configuration.
     / u5 k4 d. n3 J( m/ q2 i3 j
106.   *         The system Clock is configured as follow :
     ) ~6 s2 R% L/ F: Y8 F4 I1 w4 _* W
107.   *            System Clock source            = PLL (HSE)
     6 n( T. |: g% p5 Z' s- a
108.   *            SYSCLK(Hz)                     = 72000000
     1 y  _# X, h& g6 F- o( C
109.   *            HCLK(Hz)                       = 72000000
     4 Q/ A. y- z( l7 ~. `
110.   *            AHB Prescaler                  = 1
     : Q' A( U, h* Z; C$ k
111.   *            APB1 Prescaler                 = 2
     
112.   *            APB2 Prescaler                 = 1
     
113.   *            HSE Frequency(Hz)              = 8000000
     " B' J4 M8 O, P; _3 k) N
114.   *            HSE PREDIV1                    = 1
     $ }" d0 e9 p7 \7 C/ O4 s4 F
115.   *            PLLMUL                         = 9
     ; s, S8 V, Q* O5 a7 b/ \- y
116.   *            Flash Latency(WS)              = 2
     
117.   * @param  None.
     
118.   * @return None.
     1 |0 h3 `) S9 {6 z; V* i  Q
119.   */
     
120. static void SystemClock_Config(void)
     
121. {
     / E  ^8 H* U7 J
122.   /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration */
     4 \: I1 {2 {2 x3 A
123.   /* RCC system reset */
     
124.   RCC_DeInit();
     + p0 \& v8 }; Q- o
125. 
     
126.   /* Enable HSE */
     * z  X1 I3 ?$ s
127.   RCC_HSEConfig(RCC_HSE_ON);
     ( T+ Y% P$ w) x, y
128. 
     
129.   /* Wait till HSE is ready */
     4 J1 T0 t# h+ n. T! m7 O& x
130.   ErrorStatus HSEStartUpStatus = RCC_WaitForHSEStartUp();
     
131. 
     # J& G; s6 L: Y. {& Q; A0 \0 [/ R
132.   if(HSEStartUpStatus == SUCCESS)
     1 ]1 X: T% H" y* @% L5 F8 g& P3 U
133.   {
     
134.     /* Enable Prefetch Buffer */
     
135.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     
136. 
     
137.     /* Flash 2 wait state */
     8 t+ W! T, l; ~
138.     FLASH_SetLatency(FLASH_Latency_2);
     
139. 
     
140.     /* HCLK = SYSCLK */
     
141.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     
142. 
     ; J, }, S. O0 T/ V7 t
143.     /* PCLK2 = HCLK */
     
144.     RCC_PCLK2Config(RCC_HCLK_Div1);
     ) n5 `3 Q; V: M( A! K
145. 
     , X! h, o' p4 I9 f6 W" H4 A
146.     /* PCLK1 = HCLK / 2 */
     : X' r9 w/ T* m* p2 Y; {9 ?
147.     RCC_PCLK1Config(RCC_HCLK_Div2);
     1 x( Q% g+ E1 P( b4 z
148. 
     * t. B) }% E2 C3 \& k
149.     /* Configure PLLs */
     
150. #ifdef STM32F10X_CL
     0 H2 j& J! A8 b( ^
151.     /* PLL2 configuration: PLL2CLK = (HSE(8MHz) / 2) * 10 = 40MHz */
     
152.     RCC_PREDIV2Config(RCC_PREDIV2_Div2);
     
153.     RCC_PLL2Config(RCC_PLL2Mul_10);
     
154. 
     
155.     /* Enable PLL2 */
     ; B, N7 a6 b+ v. @9 Z& P
156.     RCC_PLL2Cmd(ENABLE);
     1 r$ I: ^& P' V! E
157. 
     
158.     /* Wait till PLL2 is ready */
     
159.     while(RCC_GetFlagStatus(RCC_FLAG_PLL2RDY) == RESET);
     
160. 
     1 [/ |) ]: z- s4 k; R& z2 |
161.     /* PLL configuration: PLLCLK = (PLL2(40MHz) / 5) * 9 = 72MHz */
     
162.     RCC_PREDIV1Config(RCC_PREDIV1_Source_PLL2, RCC_PREDIV1_Div5);
     
163.     RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_9);
     * k6 g7 g% K+ n
164. #else
     * H+ J5 O  b( I0 Z
165.     /* PLLCLK = HSE(8MHz) * 9 = 72MHz */
     
166.     RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
     / P; O' _( h6 v$ a( g7 M# c% d  J9 \
167. #endif
     5 _- ?. s/ I% Z% l7 J* b: U
168. 
     
169.     /* Enable PLL */
     
170.     RCC_PLLCmd(ENABLE);
     
171. 
     
172.     /* Wait till PLL is ready */
     
173.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     , q/ p& W% r4 J1 U! p
174. 
     
175.     /* Select PLL as system clock source */
     . K0 i2 Q1 {5 a/ ^
176.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     
177. 
     
178.     /* Wait till PLL is used as system clock source */
     * p$ x0 L( n# n
179.     while(RCC_GetSYSCLKSource() != 0x08);
     
180.   }
     % c2 L0 V" C* j& ?0 l
181.   else
     
182.   {
     ' m3 w# U3 m$ c  R' r$ i+ D1 y
183.     /* Disable HSE */
     
184.     RCC_HSEConfig(RCC_HSE_OFF);
     2 D" u; P. [8 h' [7 w, X/ N
185. 
     5 \; w8 @1 U0 u9 x  A9 h$ {2 w
186.     /* Enable HSI */
     # y# @) Z' }4 x& y
187.     RCC_HSICmd(ENABLE);
     . F# N+ r0 ^- L2 x- H- @0 v" Z0 k
188. 
     
189.     /* Enable Prefetch Buffer */
     
190.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     1 X% V- u  e5 w9 L
191. 
     " g$ ^9 f& e& ]- G9 I
192.     /* Flash 1 wait state */
     2 D& l% J0 C- N( M
193.     FLASH_SetLatency(FLASH_Latency_1);
     
194. 
     # R) ^7 j8 p3 ^0 {0 D2 e( x3 k
195.     /* HCLK = SYSCLK */
     
196.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     
197. 
     / {, h; C$ Z) u& B7 B
198.     /* PCLK2 = HCLK */
     . _8 k/ n4 X( e% z- z: }( }( A
199.     RCC_PCLK2Config(RCC_HCLK_Div1);
     
200. 
     : E$ a! _2 E" j3 T
201.     /* PCLK1 = HCLK */
     
202.     RCC_PCLK1Config(RCC_HCLK_Div1);
     
203. 
     ) f9 V0 I1 A: Q5 g& K; H( e
204.     /* Configure PLLs */
     7 W2 B& ]$ W  }& j
205.     /* PLLCLK = HSI(8MHz) / 2 * 9 = 36MHz */
     ) f  L  N2 ~6 E2 V" \+ Q
206.     RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_9);
     
207. 
     
208.     /* Enable PLL */
     
209.     RCC_PLLCmd(ENABLE);
     
210. 
     
211.     /* Wait till PLL is ready */
     , g; D+ @7 P' S! Z+ {  g
212.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     3 R- r3 X- V! S9 g" T( [6 \
213. 
     
214.     /* Select PLL as system clock source */
     , |& b# g. N, _4 o
215.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     
216. 
     ( b% l' F* V% p$ T, t
217.     /* Wait till PLL is used as system clock source */
     
218.     while(RCC_GetSYSCLKSource() != 0x08);
     . j/ b0 K$ }  ?. z4 S& R- s2 x' D
219.   }
     ; k4 {1 ~4 m& @# O, V& h
220. }
     
221. 
     2 ~/ r, D% S9 h* R
222. #ifdef USE_FULL_ASSERT
     
223. /**
     
224.   * @brief  Reports the name of the source file and the source line number
     # M6 h. ?  h: \* o; A/ Q; q0 o
225.   *         where the assert_param error has occurred.
     2 S( _" s4 l# s
226.   * @param  file: pointer to the source file name.
     ' m* O1 Q  `; H) [9 ~' K
227.   * @param  line: assert_param error line source number.
     
228.   * @return None.
     ; p$ n" ~3 J9 a4 O
229.   */
     ' W4 L% h  I0 u- H8 j" w9 `
230. void assert_failed(uint8_t *file, uint32_t line)
     
231. {
     * Y' H, {) i$ i* d4 c
232.   /* User can add his own implementation to report the file name and line number,
     4 }" N: d4 C  z
233.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     
234. 
     
235.   /* Infinite loop */
     
236.   while(1)
     - w% Q$ i( n6 W
237.   {
     
238.   }
     * b& O, l0 F4 K+ I; _& ?
239. }
     3 |/ Z. W$ ?0 K) G6 z
240. #endif

复制代码

3，注意

( v; t1 j* a8 k; J. w- NCAN 消息发送缓冲区和接收缓冲区的大小，可以根据应用的需求进行修改，缓冲区使用的是堆内存，需要根据缓冲区大小和应用程序中堆内存使用情况进行配置。
2 T& S2 D1 _1 J( `# s  l, W) s
, j8 J: @0 d( p
" a2 F/ u4 r& ~  [9 T9 }4 ^
. \# U# J0 q- c0 D5 y; ?6 o