1，开发环境
5 y. H7 v' U! W, m! g0 ~9 T
/ g( q6 `/ @) H+ i5 O1，固件库：STM32F10x_StdPeriph_Lib_V3.5.0

7 }% ^5 O/ q8 D/ `* V7 _3 Y9 j2，编译器：ARMCC V5.06
9 T* R: D7 t, X# D
+ J; G4 c7 {0 C) K: E0 S3，IDE：Keil uVision5
- t, @7 H6 i5 y  c- U
& x5 e- j. b" q: R4，操作系统：Windows 10 专业版
6 n& Q4 n. g( n! X

; P# {2 H! C5 `' t2 d4 V# O2，程序源码

2 D, J. R8 E" `3 X0 hRingBuffer.h 文件

1. /**
   
2.   ******************************************************************************
   
3.   * @file    RingBuffer.h
   : m: C; G5 g% N5 I
4.   * @author  XinLi
   2 F6 ?) B3 I" }- k8 R' w) X$ u3 y- C
5.   * @version v1.1
   1 l) s% G! V! z
6.   * @date    15-January-2018
   
7.   * @brief   Header file for RingBuffer.c module.
   
8.   ******************************************************************************
   ) S2 C# k1 l' M6 S$ g! c
9.   * @attention
   ( v7 M! ~8 J- ~5 e+ `* f* A& P, I
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    9 f$ Q2 @- k+ L
14.   * it under the terms of the GNU General Public License as published by
    $ Q4 O6 ^  N# K4 V, W+ |1 q! @+ R6 l
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    4 B+ p. x' L2 V# Y* F
17.   *
    1 f* V2 b% [0 S8 T# d
18.   * This program is distributed in the hope that it will be useful,
    + A3 T- k( C! k9 i6 b
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>
    + D0 K" D( U0 O5 J1 u8 h3 a8 H( o
25.   *
    
26.   ******************************************************************************
    + d; G7 y; s% a! E# {% }
27.   */
    
28. 
    
29. #ifndef __RINGBUFFER_H
    
30. #define __RINGBUFFER_H
    
31. 
    5 p0 |& }/ d! H1 _, E
32. #ifdef __cplusplus
    
33. extern "C" {
    ' T. \- i% P* W8 b
34. #endif
    
35. 
    " ~% q: M: r$ w  W) _
36. /* Header includes -----------------------------------------------------------*/
    
37. #include <stdint.h>
    
38. #include <stdbool.h>
    
39. #include <stdlib.h>
    
40. 
    - j- a2 E8 {6 }% r7 T0 O5 j
41. /* Macro definitions ---------------------------------------------------------*/
    3 `" T- a! E" ~: g- v$ h
42. #define RING_BUFFER_MALLOC(size)  malloc(size)
    
43. #define RING_BUFFER_FREE(block)   free(block)
    
44. 
    
45. /* Type definitions ----------------------------------------------------------*/
    * ?# N- b+ C% Y/ e0 U7 |
46. typedef struct
    
47. {
    $ Z" `3 p7 N. U
48.   uint8_t *buffer;
    7 k4 S1 R' y5 l; F  n
49.   uint32_t size;
    5 S' g  x8 Q2 z9 c3 Q# E. I
50.   uint32_t in;
    
51.   uint32_t out;
    ! w- `- Y- k1 N5 ~
52. }RingBuffer;
    ! h' O! t3 _& l/ b# k
53. 
    ; S) J% Q8 x' B& N
54. /* Variable declarations -----------------------------------------------------*/
    0 _+ M9 }* g1 V
55. /* Variable definitions ------------------------------------------------------*/
    
56. /* Function declarations -----------------------------------------------------*/
    ! d+ R7 C# Q- d  @. w
57. RingBuffer *RingBuffer_Malloc(uint32_t size);
    
58. void RingBuffer_Free(RingBuffer *fifo);
    . `9 @, U' c2 S( c  Q1 f
59. 
    + Q2 S6 L1 x: N8 G8 H; N
60. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len);
    
61. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len);
    " _: ^& k/ m5 {2 x' S, O( L$ V
62. 
    
63. /* Function definitions ------------------------------------------------------*/
    
64. 
    . [% d" K3 N5 v3 h# N
65. /**
    
66.   * @brief  Removes the entire FIFO contents.
    
67.   * @param  [in] fifo: The fifo to be emptied.
    3 [) [: d/ R2 [3 \2 v
68.   * @return None.
    
69.   */
    
70. static inline void RingBuffer_Reset(RingBuffer *fifo)
    
71. {
    
72.   fifo->in = fifo->out = 0;
    
73. }
    
74. 
    % k! Y+ M: i; t
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.
    
79.   */
    ( J8 o# \# p' b" u
80. static inline uint32_t RingBuffer_Size(RingBuffer *fifo)
    
81. {
    
82.   return fifo->size;
    
83. }
    7 n, Z0 f3 C6 Q! L# z9 h: u9 y
84. 
      y1 S; O) F: b+ C/ o2 G* W8 W
85. /**
    & M0 N: ]3 `$ R2 {
86.   * @brief  Returns the number of used bytes in the FIFO.
    
87.   * @param  [in] fifo: The fifo to be used.
    
88.   * @return The number of used bytes.
    * m4 }. X/ a6 C* R. a( `
89.   */
    + d9 A8 ]) ~: ~" l
90. static inline uint32_t RingBuffer_Len(RingBuffer *fifo)
    2 o. S" N, O' @/ i2 a
91. {
    
92.   return fifo->in - fifo->out;
    
93. }
    
94. 
    " s- |3 r; _3 R- I
95. /**
    
96.   * @brief  Returns the number of bytes available in the FIFO.
    8 w: s& s# }' @5 H( z) C
97.   * @param  [in] fifo: The fifo to be used.
    - R. S* J0 v! `: ^6 d+ }- C: H
98.   * @return The number of bytes available.
    
99.   */
    
100. static inline uint32_t RingBuffer_Avail(RingBuffer *fifo)
     : @) A) W# R4 |4 W9 g
101. {
     * U- E0 Q, W( ?) W8 @& _
102.   return RingBuffer_Size(fifo) - RingBuffer_Len(fifo);
     6 \# s5 y- K0 M4 R" _) P
103. }
     $ n- t, ^& C3 W' u
104. 
     
105. /**
     
106.   * @brief  Is the FIFO empty?
     
107.   * @param  [in] fifo: The fifo to be used.
     
108.   * @retval true:      Yes.
     * Z# h/ w8 j" n8 R
109.   * @retval false:     No.
     
110.   */
     + ^" V. p" L9 }6 h2 y% ?0 R" Q
111. static inline bool RingBuffer_IsEmpty(RingBuffer *fifo)
     2 U+ Q/ d: ~0 j, Y2 _
112. {
     
113.   return RingBuffer_Len(fifo) == 0;
     
114. }
     
115. 
     
116. /**
     1 V0 e0 U; R6 T/ K
117.   * @brief  Is the FIFO full?
     - w; T6 X1 {( X! W' P: O: p+ W0 E
118.   * @param  [in] fifo: The fifo to be used.
     ( z# O7 Q( F8 d) q* u
119.   * @retval true:      Yes.
     
120.   * @retval false:     No.
     
121.   */
     ( Q6 l  E6 y1 C: o
122. static inline bool RingBuffer_IsFull(RingBuffer *fifo)
     . o9 ~/ O* a1 M' R6 e
123. {
     
124.   return RingBuffer_Avail(fifo) == 0;
     
125. }
     ' ]# w0 X/ m8 M- N
126. 
     
127. #ifdef __cplusplus
     1 J  K- Y& W9 a) s
128. }
     
129. #endif
     / ?, f+ N  z7 ?1 `  r
130. 
     2 ~- z9 k* w4 p, E5 u
131. #endif /* __RINGBUFFER_H */
     7 r$ E+ q( F3 p: G' a

复制代码

7 V( [, U% f9 Z# k6 T- }
RingBuffer.c 文件
/ M5 U# s/ Q* f3 D- @

1. <div>/**
   
2.   ******************************************************************************
   
3.   * @file    RingBuffer.c
   0 x9 U+ H+ I& y; b6 J
4.   * @author  XinLi
   - B4 G% f- v5 ]
5.   * @version v1.1
   0 r' p6 K! I% J; ^1 L
6.   * @date    15-January-2018
   6 u( D6 R/ ]3 `9 o
7.   * @brief   Ring buffer module source file.
   0 v) P- ]$ d: p0 k
8.   ******************************************************************************
   ( G. O" q6 ]# h
9.   * @attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
      d7 r. h3 [; U
12.   *
    0 ~! U/ ~$ ?" A. r5 a! Y4 [/ }
13.   * This program is free software: you can redistribute it and/or modify
    / k3 @' ~, e  m$ s4 R2 F
14.   * it under the terms of the GNU General Public License as published by
    + Q2 X2 }6 _9 a" W
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    . A0 p! g8 |: V8 {) S* \: o2 e
17.   *
    ( g" e8 K' _: u$ g
18.   * This program is distributed in the hope that it will be useful,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    / Z5 i; }$ Z1 g7 t) K- C
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    % w: ~. O9 q/ [5 ?
22.   *
    ; x) f% H. Q; \8 `  G
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.   *
    8 n6 Y+ @" P3 P& C% J; ~
26.   ******************************************************************************
    
27.   */
    6 q" ?! g7 F0 r7 p/ d
28. 
    ) ?1 `7 M1 i4 S: O5 P
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "RingBuffer.h"
    
31. #include <string.h>
    
32. 
    
33. /* Macro definitions ---------------------------------------------------------*/
    , {' ~4 I  d3 W
34. #define min(a, b)  (((a) < (b)) ? (a) : (b))
    
35. 
    
36. /* Type definitions ----------------------------------------------------------*/
    
37. /* Variable declarations -----------------------------------------------------*/
    
38. /* Variable definitions ------------------------------------------------------*/
    + d5 m, W% S2 U% W. Y. W5 D
39. /* Function declarations -----------------------------------------------------*/
    1 }5 H& r; f& N) u( l. X# t4 f
40. static bool is_power_of_2(uint32_t x);
    ) N; Y: s; w: h% a+ U; i
41. static uint32_t roundup_pow_of_two(uint32_t x);
    
42. 
    
43. /* Function definitions ------------------------------------------------------*/
    : }& v  v& q2 S- A! c
44. 
    & M- [; e" I5 G# D/ ^: ~. C
45. /**
    + E8 g) i+ u) f2 Z5 v$ l
46.   * @brief  Allocates a new FIFO and its internal buffer.
    
47.   * @param  [in] size: The size of the internal buffer to be allocated.
    
48.   * @note   The size will be rounded-up to a power of 2.
    
49.   * @return RingBuffer pointer.
    - I& Y/ M) W+ J% x% M
50.   */
    4 w7 ~: O  \0 S8 ~: P- C1 D# l
51. RingBuffer *RingBuffer_Malloc(uint32_t size)
    
52. {
    
53.   RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer));
    ( |- O7 |6 }% A1 Q3 n, Y7 |
54. 
    
55.   if(fifo != NULL)
    
56.   {
    
57.     if(is_power_of_2(size) != true)
    
58.     {
    ! o) |' G) c% q: w
59.       if(size > 0x80000000UL)
    5 J7 X' G5 _6 z. d
60.       {
    $ G+ J9 @# n) s0 Z
61.         RING_BUFFER_FREE(fifo);
    * P. c, P. E% Y; w, B
62.         return NULL;
      F: z. P+ s0 E: \# W
63.       }
    ' T5 E$ b' R% v6 O* q+ e  V
64. 
    ) |# d1 t) M, Z9 [
65.       size = roundup_pow_of_two(size);
    6 H/ [- j( B. @) m3 _8 ~. R  ?3 b
66.     }
    
67. 
    ) d6 z- Q4 N, L! S: `3 ?
68.     fifo->buffer = RING_BUFFER_MALLOC(size);
    5 I. m1 T9 g, g2 w" d
69. 
    
70.     if(fifo->buffer == NULL)
      _. h# j4 K, T& ?; l; p
71.     {
    
72.       RING_BUFFER_FREE(fifo);
    3 x9 O8 R, D, ?% v. Z
73.       return NULL;
    
74.     }
    
75. 
    
76.     fifo->size = size;
    
77.     fifo->in = fifo->out = 0;
    # A0 \+ z4 F  r2 i
78.   }
    # x1 e2 n0 O. \7 i& D3 L
79. 
    , @5 m% b9 B  U. S: {
80.   return fifo;
    
81. }
    % m& Q7 K  C+ t# X$ c* V
82. 
    # M% r, E2 G* J2 ]7 b
83. /**
    
84.   * @brief  Frees the FIFO.
    ( Z) S# z- S2 ]2 y( X- s
85.   * @param  [in] fifo: The fifo to be freed.
    ' _, u5 G4 K5 Z, ~% ?8 \9 k; i6 P
86.   * @return None.
    0 c; o) g& [8 l
87.   */
    * s# y) X: C3 x* f6 F. q( D5 u0 H# e
88. void RingBuffer_Free(RingBuffer *fifo)
    
89. {
    
90.   RING_BUFFER_FREE(fifo->buffer);
    
91.   RING_BUFFER_FREE(fifo);
    * y7 F  T; P6 }. W/ j* q  Q
92. }
    ) f* I6 p' d9 E+ u
93. 
    
94. /**
    ! l# M0 }  ]- l+ P5 J" t
95.   * @brief  Puts some data into the FIFO.
    # q/ D  I7 d0 @, ?0 F
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.
    4 U9 |/ y" x8 O  z) T/ O" d+ c$ G9 l
99.   * @return The number of bytes copied.
      Q) o9 V% S4 O  e$ X% }0 E
100.   * @note   This function copies at most @len bytes from the @in into
     
101.   *         the FIFO depending on the free space, and returns the number
     3 j8 a( L( H+ V/ g# h
102.   *         of bytes copied.
     9 u7 |& ~# `7 T# \
103.   */
     
104. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len)
       G3 Q1 [6 I% Z' y5 C! G- n
105. {
     . m7 N( z( C2 u4 m9 Q
106.   len = min(len, RingBuffer_Avail(fifo));
     
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)));
     8 `6 D& H! P7 y: z9 x: {+ k* P. n
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);
     
114. 
     
115.   fifo->in += len;
     " A5 v. ]7 d( I7 h3 R$ B0 A
116. 
     
117.   return len;
     
118. }
     - S1 Y0 h/ P. k3 d
119. 
     ' A) e) P; ]6 ~+ a
120. /**
     
121.   * @brief  Gets some data from the FIFO.
     # x; M9 T8 a) b7 }) q! H8 R: D- e
122.   * @param  [in] fifo: The fifo to be used.
     5 @4 G+ v2 i% G+ E
123.   * @param  [in] out:  Where the data must be copied.
     $ b, _2 y8 |1 C4 U7 Z! A5 D9 {
124.   * @param  [in] len:  The size of the destination buffer.
     
125.   * @return The number of copied bytes.
       i7 l( ?5 b/ x, x$ p" J1 v
126.   * @note   This function copies at most @len bytes from the FIFO into
     
127.   *         the @out and returns the number of copied bytes.
     7 O, u: H" G* O4 |; E
128.   */
     $ A+ y9 C' |7 H; b1 M
129. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len)
     7 M0 @/ n! `9 V3 v9 i! i  a3 w' Q
130. {
     
131.   len = min(len, RingBuffer_Len(fifo));
     6 [( }) R$ X+ C6 b4 E
132. 
     
133.   /* First get the data from fifo->out until the end of the buffer. */
     $ B+ h' j6 C: j& m$ B: R9 ^. L
134.   uint32_t l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
     & J+ L, p, }+ }- J+ t
135.   memcpy(out, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
     1 X* |. B; q* [4 r6 X) H
136. 
       v' G5 b2 x8 t
137.   /* Then get the rest (if any) from the beginning of the buffer. */
     8 k7 z) e) m+ y9 r
138.   memcpy((uint8_t *)out + l, fifo->buffer, len - l);
     / b) ?: M* P$ g0 \  b; r
139. 
     
140.   fifo->out += len;
     ' Q" i) l0 V) W, V( s
141. 
     
142.   return len;
     
143. }
     # V, U% l' d5 G; ^
144. 
     
145. /**
     
146.   * @brief  Determine whether some value is a power of two.
     ; H" X3 \$ S3 `+ y1 z* M& d3 a! m
147.   * @param  [in] x: The number to be confirmed.
     
148.   * @retval true:   Yes.
     
149.   * @retval false:  No.
     
150.   * @note   Where zero is not considered a power of two.
     8 b, P. ?. ^" Y2 s7 q: M
151.   */
     $ @% R+ _3 o. U$ T4 K
152. static bool is_power_of_2(uint32_t x)
     7 @! g9 z  q* B) H9 o& d
153. {
     4 y! }6 B4 f+ P5 i
154.   return (x != 0) && ((x & (x - 1)) == 0);
     
155. }
     
156. 
     
157. /**
     # \+ r( p# X) o9 l) v. Z5 V+ V
158.   * @brief  Round the given value up to nearest power of two.
     
159.   * @param  [in] x: The number to be converted.
     
160.   * @return The power of two.
     0 D1 ~( y' _7 Q5 |$ c5 U5 U
161.   */
     # `2 _) f/ ~3 b  I0 \6 K# [
162. static uint32_t roundup_pow_of_two(uint32_t x)
     ! O! K+ a9 G" M, A
163. {
     
164.   uint32_t b = 0;
     2 S$ E9 z4 [' m" x$ g7 g$ t: d5 i
165. 
     ( _6 M& O# t/ E
166.   for(int i = 0; i < 32; i++)
     5 ?$ _* v+ o; Z
167.   {
     
168.     b = 1UL << i;
     
169. 
     
170.     if(x <= b)
     
171.     {
     
172.       break;
     
173.     }
     2 [% ~& r# M7 S, X, v
174.   }
     . G7 q' g; z1 H. A( H2 E4 D, O3 N
175. 
     
176.   return b;
     
177. }</div><div></div>

复制代码

* w2 y4 o" Y. L8 j: |1 v% D6 Y+ `
CAN.h 文件
# Q! x; \1 w% ?! c- Q0 o* |

1. /**
   2 F+ P6 }, O9 ]! k
2.   ******************************************************************************
   ; |$ y5 q% D: {1 Y9 K4 u# d8 p
3.   * @file    CAN.h
   4 F+ ]; |9 _8 v# t0 \
4.   * @author  XinLi
   " G( s7 Z6 }1 n# O) G
5.   * @version v1.0
   % a6 \: T& V. A$ P- S9 m  o+ h
6.   * @date    24-June-2018
   7 s' H; E( X+ j0 `; H0 K' N
7.   * @brief   Header file for CAN.c module.
   
8.   ******************************************************************************
   * |1 D" x( J: q% v+ }  t
9.   * @attention
   
10.   *
    # V) h' c1 m  Y% R$ T
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    - r5 |4 I1 X1 C7 g6 L, U
12.   *
    : I6 M5 Y( o. G0 n
13.   * This program is free software: you can redistribute it and/or modify
    5 v( c8 w; k0 B- Z" }0 U
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
    - `) i0 n+ c$ _
16.   * (at your option) any later version.
    
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    ' Z+ Z6 }! |6 g$ U' l! k: ]
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    * L$ d- |! P: O" \: x7 S( j% }
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    ) ?, p4 Q1 ?8 g' h* X# w3 I
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    4 W2 o" v: B1 \+ u- g
25.   *
    - L* v: A( b8 ]0 t
26.   ******************************************************************************
    
27.   */
    
28. 
    
29. #ifndef __CAN_H
    
30. #define __CAN_H
    . Y7 R0 h( Z: z8 Y( k
31. 
    " V3 @* L9 t" L
32. #ifdef __cplusplus
    
33. extern "C" {
    
34. #endif
    / O# A, ~1 Y) t# e  s; }. v
35. 
    
36. /* Header includes -----------------------------------------------------------*/
    ; [" H9 w( b$ `  Y* Z! e9 G) z/ l
37. #include "stm32f10x.h"
    4 C4 c* g0 N8 V; f
38. #include <stdbool.h>
    # `) C5 }( ]& Y+ i+ g& k
39. 
    / Y9 p  e$ f0 P8 ^7 R
40. /* Macro definitions ---------------------------------------------------------*/
    1 C, x& e( x5 c$ u  _; C
41. 
    
42. /******************************* CAN1 Configure *******************************/
    
43. #define CAN1_TX_BUFFER_SIZE        (16)
    
44. #define CAN1_RX_BUFFER_SIZE        (16)
    ! |" F& T+ }; x% j5 d1 j. G" P
45. 
    
46. #define CAN1_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
47. #define CAN1_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    / O  H( S6 s, j: s2 v6 s: O( G
48. 
    
49. #define CAN1_TX_GPIO_PORT          GPIOB
    
50. #define CAN1_RX_GPIO_PORT          GPIOB
    
51. 
    - a! F, E( p& p* I0 H4 [, \1 s2 f
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)
    
56. #define CAN1_IRQ_SUB_PRIORITY      (0)
    ; M5 ~6 t" i$ G( S9 }# M
57. 
    
58. #define CAN1_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap1_CAN1 , ENABLE)
    % F/ |' {1 S6 `' C2 {0 t- N- y% I
59. /******************************************************************************/
    
60. 
    + F* Q! c- i# U  d( g
61. #ifdef STM32F10X_CL
    
62. /******************************* CAN2 Configure *******************************/
    8 S6 M0 {5 X1 X% P7 q2 F
63. #define CAN2_TX_BUFFER_SIZE        (16)
    
64. #define CAN2_RX_BUFFER_SIZE        (16)
    
65. 
    
66. #define CAN2_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
67. #define CAN2_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
68. 
    + k6 R8 \9 B) x4 n4 Y6 J2 `3 Y
69. #define CAN2_TX_GPIO_PORT          GPIOB
    ( Y0 b$ g& q4 C2 p9 H
70. #define CAN2_RX_GPIO_PORT          GPIOB
    , s& A0 S( `0 k, Q3 q0 m# m
71. 
    
72. #define CAN2_TX_GPIO_PIN           GPIO_Pin_13
      w9 H$ h1 V, l/ Q+ p
73. #define CAN2_RX_GPIO_PIN           GPIO_Pin_12
    
74. 
    6 A' L5 z  h" A/ g/ V9 D
75. #define CAN2_IRQ_PREEMPT_PRIORITY  (0)
    
76. #define CAN2_IRQ_SUB_PRIORITY      (0)
    % ~8 ]9 }1 Y$ u! J. \0 @
77. 
    
78. #define CAN2_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap_CAN2 , DISABLE)
    & ^0 ?4 P* J( \8 n( }2 h: S
79. /******************************************************************************/
    
80. #endif /* STM32F10X_CL */
    
81. 
    
82. /* Type definitions ----------------------------------------------------------*/
    
83. typedef enum
    
84. {
    # W) w6 S6 a3 \
85.   CAN_WorkModeNormal   = CAN_Mode_Normal,
    9 y) p4 [; R7 ~  l2 ?; B
86.   CAN_WorkModeLoopBack = CAN_Mode_LoopBack
    
87. }CAN_WorkMode;
    
88. 
    ! G$ W& w: P, Y& H/ \2 B. a# K
89. typedef enum
    * \; S  ]  G* w" e- Q! }
90. {
    % s3 p" \. X; u; k
91.   CAN_BaudRate1000K = 6,
    : d" _4 W0 Y$ k
92.   CAN_BaudRate500K  = 12,
    & E) ~$ B! ?! f8 f
93.   CAN_BaudRate250K  = 24,
    
94.   CAN_BaudRate125K  = 48,
    
95.   CAN_BaudRate100K  = 60,
    7 ?3 b, j" Y" ^% N' M9 R
96.   CAN_BaudRate50K   = 120,
    4 f" p* e0 [' H
97.   CAN_BaudRate20K   = 300,
      u  v2 F9 A6 H7 n, t$ r& x! R( {
98.   CAN_BaudRate10K   = 600
    
99. }CAN_BaudRate;
    " ]% f7 I* B6 B8 G8 I9 D: J( g- f
100. 
     
101. /* Variable declarations -----------------------------------------------------*/
     & `7 Y6 a# t" y) i: F* p: M# k
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);
     8 ^! ?5 s0 Y/ z& Z, r" {* G
105. void CAN_Unconfigure(CAN_TypeDef *CANx);
     
106. 
     
107. void CAN_SetTransmitFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     $ |- b! y1 {2 ^% ~; G, M
108. void CAN_SetReceiveFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     
109. 
     8 H! m6 G; F8 ?2 Z
110. uint32_t CAN_SetTransmitMessage(CAN_TypeDef *CANx, CanTxMsg *Message, uint32_t Number);
     1 y6 {9 h+ @% N# N0 ?* Q
111. uint32_t CAN_GetReceiveMessage(CAN_TypeDef *CANx, CanRxMsg *Message, uint32_t Number);
     ! W/ W; C7 {. t$ H$ L$ U1 s& C
112. 
     8 a, @# t  y; X
113. uint32_t CAN_GetUsedTransmitBufferSize(CAN_TypeDef *CANx);
     ; _2 g& d. n' ~! x! z/ T
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. 
     2 r( f1 Z  i% h7 y" O) g+ [9 b
118. bool CAN_IsTransmitBufferEmpty(CAN_TypeDef *CANx);
     
119. bool CAN_IsReceiveBufferEmpty(CAN_TypeDef *CANx);
     
120. bool CAN_IsTransmitBufferFull(CAN_TypeDef *CANx);
     
121. bool CAN_IsReceiveBufferFull(CAN_TypeDef *CANx);
     , w- }0 z; l; u3 O9 n' U* z
122. 
     # u  E& v- y! {
123. void CAN_ClearTransmitBuffer(CAN_TypeDef *CANx);
     
124. void CAN_ClearReceiveBuffer(CAN_TypeDef *CANx);
     
125. 
     
126. bool CAN_IsTransmitMessage(CAN_TypeDef *CANx);
     5 Z& r8 R2 S+ h
127. 
     ; D9 B% s  j9 m
128. /* Function definitions ------------------------------------------------------*/
     
129. 
     
130. #ifdef __cplusplus
     : r$ Z" g; n! U
131. }
     
132. #endif
     7 q  `* a4 {* H, M0 B1 o0 Z
133. 
     
134. #endif /* __CAN_H */
     

复制代码

. r% i) b6 G9 b0 Q( xCAN.c 文件
" b- N: Z- L+ s6 N, ^
* @2 |8 ~8 x- `' X  H5 P" |

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

复制代码

8 Y1 K  m5 B$ O. }
; H8 a+ z- a/ t/ [1 H/ nmain.h 文件

1. /**
   # S& e2 M- F% m+ T; S& }" \2 N" K2 r
2.   ******************************************************************************
   
3.   * @file    main.h
   
4.   * @author  XinLi
   
5.   * @version v1.0
   6 C% E+ X6 m" q" c0 s
6.   * @date    24-June-2018
   
7.   * @brief   Header file for main.c module.
   3 b7 p. t6 S7 Q' l
8.   ******************************************************************************
   6 |1 T! \6 ?* s: p
9.   * @attention
   : h! S# S3 q# J( m8 T% J
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    7 z5 `! ^5 l% U$ t' d
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    1 A/ h; M2 [4 {( U
14.   * it under the terms of the GNU General Public License as published by
    2 F- ?  q4 I8 G' E; ?1 }
15.   * the Free Software Foundation, either version 3 of the License, or
    % C; o  w- A4 o( l. u# n: ]
16.   * (at your option) any later version.
    
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    - }1 A- D0 o" u3 ?
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    5 t8 \8 W  l" R7 N% b
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    $ [4 O+ c$ D! b+ J- C. M# M
21.   * GNU General Public License for more details.
      \1 M% R) |3 I- B8 j, |, O4 {5 q1 k
22.   *
    $ M) Q6 C& _! I9 V' e, M( N* h! x$ |
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.   *
    2 K& m# o, L) H' ]
26.   ******************************************************************************
    
27.   */
    
28. 
    
29. #ifndef __MAIN_H
      O7 Q* R( O$ Z7 f
30. #define __MAIN_H
    & X/ p1 l# e! b5 d
31. 
    
32. #ifdef __cplusplus
    ) ?0 a2 n4 b, q# |8 P; D( G
33. extern "C" {
    9 e" @: k) e, @; z1 `6 I
34. #endif
    
35. 
    
36. /* Header includes -----------------------------------------------------------*/
    7 M' x( {4 _+ q0 H7 H& y% O
37. #include "stm32f10x.h"
    3 t# ^) H8 q  H0 @6 s: `0 |& a
38. 
    3 M, p. M3 Z% e3 L1 b4 \( d) q( K
39. /* Macro definitions ---------------------------------------------------------*/
    7 g% q* s0 V/ I* S+ o3 R2 D
40. /* Type definitions ----------------------------------------------------------*/
    ) r+ _; h& Q. {
41. /* Variable declarations -----------------------------------------------------*/
    
42. /* Variable definitions ------------------------------------------------------*/
    2 X/ l" Q, R# d* j& x4 n" E: {7 K
43. /* Function declarations -----------------------------------------------------*/
    
44. /* Function definitions ------------------------------------------------------*/
    
45. 
    
46. #ifdef __cplusplus
    
47. }
    
48. #endif
    
49. 
    ) ~! K$ i$ R: N6 H) S& z
50. #endif /* __MAIN_H */

复制代码

3 g. ]  \6 ^+ X5 @4 F
4 y: c7 z# E1 [* M8 \main.c 文件

1. /**
   - d, W! U& g& _- }) [+ D) y8 ]. f
2.   ******************************************************************************
   
3.   * @file    main.c
   
4.   * @author  XinLi
   
5.   * @version v1.0
   
6.   * @date    24-June-2018
   
7.   * @brief   Main program body.
   6 R# L1 q: i; N
8.   ******************************************************************************
   / x7 F' E: k) y
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
    0 }( ^0 q" K6 @
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.   *
    3 O! y' D) L2 I4 n$ _
18.   * This program is distributed in the hope that it will be useful,
    1 t7 ]' }" z: p. R- y+ S
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.
    ' R" U1 }) t( m+ }0 N+ k
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    % P5 d) `" M: z9 [
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    6 Y5 A( \( B) w# g3 N# |
25.   *
    : S! R, ?6 ?. w0 L) R; L
26.   ******************************************************************************
    7 _7 S# Q( n6 y3 N* j" ^- z
27.   */
    
28. 
    : @" ]" [0 i4 b" J
29. /* Header includes -----------------------------------------------------------*/
    ) N! M  K, c; p. s5 L
30. #include "main.h"
    
31. #include "CAN.h"
    
32. 
    
33. #ifdef _RTE_
    
34. #include "RTE_Components.h"
    
35. #endif
    $ w- h$ J- F$ R
36. 
    ) h* _, A7 u# A" @, s) L8 X9 N
37. #ifdef RTE_CMSIS_RTOS2
    
38. #include "cmsis_os2.h"
    
39. #endif
    - B! m9 d# p1 Y0 u
40. 
    ; C  \0 g- S, w0 W
41. /* Macro definitions ---------------------------------------------------------*/
    0 O) t) W( w6 ~
42. /* Type definitions ----------------------------------------------------------*/
    2 O0 i% E# H" x' G7 r$ x& Q
43. /* Variable declarations -----------------------------------------------------*/
      ^2 ?0 V( \. Y$ C" h2 v0 j* E
44. /* Variable definitions ------------------------------------------------------*/
    
45. static CanTxMsg canTxMsg = {0};
    # U* w$ b4 w- g0 s9 m
46. static CanRxMsg canRxMsg = {0};
    & F0 S) {  S3 P  c1 S
47. 
    ( Y4 ~7 C1 Z/ n4 J! z" V
48. /* Function declarations -----------------------------------------------------*/
    4 Y7 c: R' u) p: T5 G
49. static void SystemClock_Config(void);
      M9 U* D4 ~1 T& L- ]( |8 ?; i5 ?
50. 
    % e& Y# N' @" u- A# V
51. /* Function definitions ------------------------------------------------------*/
    
52. 
    
53. /**
    
54.   * @brief  Main program.
    1 ]; D# S- s$ [8 ~
55.   * @param  None.
    ; ?6 k0 l% r  }* m6 B1 Q6 ^2 z
56.   * @return None.
    * V: l; t. E8 @3 y
57.   */
    
58. int main(void)
    4 E3 s) A) v6 R6 F3 [4 I" e4 z
59. {
    * W+ S" m' w( J- Q8 K
60.   /* Configure the system clock to 72 MHz */
    
61.   SystemClock_Config();
    ( e7 x5 V+ _$ h6 _
62.   SystemCoreClockUpdate();
    
63. 
    5 o9 a" w0 L9 _( }; t) B
64.   /* Add your application code here */
    
65.   CAN_Configure(CAN1, CAN_WorkModeLoopBack, CAN_BaudRate250K, 0xAA55, 0x55AA);
    
66. 
    , z8 B, O% Y% ~8 ^+ Z
67. #ifdef RTE_CMSIS_RTOS2
    
68.   /* Initialize CMSIS-RTOS2 */
    6 K0 W  a+ o7 b0 ]9 C& B5 z
69.   osKernelInitialize();
    9 K7 [# G" K& p" Z2 T6 K
70. 
    5 o; S7 m4 X" L- H1 O; o9 x
71.   /* Create thread functions that start executing,
    & L% ?  \4 ?+ K- o
72.   Example: osThreadNew(app_main, NULL, NULL); */
    * z8 {: i% S, s. C# c8 O. J
73. 
    
74.   /* Start thread execution */
    0 I+ @& U- }4 I
75.   osKernelStart();
    
76. #endif
    
77. 
    
78.   /* Infinite loop */
    
79.   while(1)
    
80.   {
    . e. g" g  |( U1 ~3 ]
81.     canTxMsg.StdId = 0xAA55;
    
82.     canTxMsg.ExtId = 0x55AA;
      Y2 X4 F. R' p: v) R) I
83.     canTxMsg.IDE   = CAN_ID_STD;
    ( D3 A. G! b, b+ W5 ^; ?3 O( S
84.     canTxMsg.RTR   = CAN_RTR_DATA;
    1 X: b9 }1 I- b4 _$ B: z4 |2 I$ ]
85.     canTxMsg.DLC   = 8;
    ' B1 P' {% S0 o% j4 k
86. 
    
87.     canTxMsg.Data[0]++;
    9 }& z) z  S- d5 U& r
88.     canTxMsg.Data[1]++;
    3 B& \( O7 l- D3 @
89.     canTxMsg.Data[2]++;
    - E9 L" x6 ?& S2 _2 ~6 W# b9 L* z
90.     canTxMsg.Data[3]++;
    
91.     canTxMsg.Data[4]++;
    : r! _! i  E+ n1 x( S8 q+ v4 l1 Q
92.     canTxMsg.Data[5]++;
    7 k5 X9 O3 F/ X" P+ b7 @. i% F
93.     canTxMsg.Data[6]++;
    9 J6 K/ r- H. S& w
94.     canTxMsg.Data[7]++;
    8 J% L- u4 C  d6 ?( d
95. 
    1 q/ O. j! j, h. g7 l
96.     CAN_SetTransmitMessage(CAN1, &canTxMsg, 1);
    
97. 
    
98.     while(CAN_IsReceiveBufferEmpty(CAN1) == true);
    
99. 
    3 O. G- U0 {* s( W2 _
100.     CAN_GetReceiveMessage(CAN1, &canRxMsg, 1);
     
101.   }
     
102. }
     - x  U, _% j0 p( Y2 E
103. 
     
104. /**
     , k/ m( I  C( }# L0 V
105.   * @brief  System Clock Configuration.
     0 H& v& l0 D) I% t, x
106.   *         The system Clock is configured as follow :
     
107.   *            System Clock source            = PLL (HSE)
     0 x* ~* Q- `9 Z, Y( n6 ^7 U
108.   *            SYSCLK(Hz)                     = 72000000
     ) b8 j+ l/ _' c( @. j
109.   *            HCLK(Hz)                       = 72000000
     
110.   *            AHB Prescaler                  = 1
     
111.   *            APB1 Prescaler                 = 2
     
112.   *            APB2 Prescaler                 = 1
     / o: A. Z5 i0 f# \
113.   *            HSE Frequency(Hz)              = 8000000
     5 W& u' E" j: U2 u6 z- e& x
114.   *            HSE PREDIV1                    = 1
     
115.   *            PLLMUL                         = 9
     
116.   *            Flash Latency(WS)              = 2
       y1 t4 e9 |1 M1 v
117.   * @param  None.
     
118.   * @return None.
     
119.   */
     
120. static void SystemClock_Config(void)
     
121. {
     * E. K/ X, q, n6 @9 a$ F2 W  v5 ~
122.   /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration */
     
123.   /* RCC system reset */
     
124.   RCC_DeInit();
     
125. 
     * l8 G" U2 Q8 w- k8 w
126.   /* Enable HSE */
     3 v( a1 j' \, o4 S
127.   RCC_HSEConfig(RCC_HSE_ON);
     5 c  N& q( h! S) |& O/ ?
128. 
     
129.   /* Wait till HSE is ready */
     
130.   ErrorStatus HSEStartUpStatus = RCC_WaitForHSEStartUp();
     
131. 
     0 [% \) \. I: H* s
132.   if(HSEStartUpStatus == SUCCESS)
     ; r/ R: H0 |+ Y8 w$ D6 _0 P) I
133.   {
     ! o  |  Z" n. Z
134.     /* Enable Prefetch Buffer */
     , }4 [4 L5 g+ X4 z
135.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     
136. 
     
137.     /* Flash 2 wait state */
     
138.     FLASH_SetLatency(FLASH_Latency_2);
     
139. 
     
140.     /* HCLK = SYSCLK */
     
141.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     
142. 
     : \; L1 x, N% u/ N- {" }. h& ^8 Q3 }
143.     /* PCLK2 = HCLK */
     
144.     RCC_PCLK2Config(RCC_HCLK_Div1);
     
145. 
     9 f) _  V* y0 i5 D% @; E% |
146.     /* PCLK1 = HCLK / 2 */
     
147.     RCC_PCLK1Config(RCC_HCLK_Div2);
     
148. 
     1 C7 h$ a, s. \9 P' u' Y0 j
149.     /* Configure PLLs */
     
150. #ifdef STM32F10X_CL
     
151.     /* PLL2 configuration: PLL2CLK = (HSE(8MHz) / 2) * 10 = 40MHz */
     ( d+ {% }$ X1 F
152.     RCC_PREDIV2Config(RCC_PREDIV2_Div2);
     % g/ L8 O1 R* F* e4 D9 D/ P" b' j- D( X
153.     RCC_PLL2Config(RCC_PLL2Mul_10);
     & _2 O- r3 O% M+ Q$ i- S
154. 
     " M' y& H$ |/ S& n! ^. r0 J
155.     /* Enable PLL2 */
     : r4 Y4 l/ Z% u  w
156.     RCC_PLL2Cmd(ENABLE);
     ' X! V5 A# m* h* l) j
157. 
     
158.     /* Wait till PLL2 is ready */
     ' l# Q' K2 K! N5 S, X# g3 @9 H
159.     while(RCC_GetFlagStatus(RCC_FLAG_PLL2RDY) == RESET);
     " b! |  i  O. |
160. 
       Y% k7 H( G" M, T$ y
161.     /* PLL configuration: PLLCLK = (PLL2(40MHz) / 5) * 9 = 72MHz */
     " K2 M3 x9 H0 j, l
162.     RCC_PREDIV1Config(RCC_PREDIV1_Source_PLL2, RCC_PREDIV1_Div5);
     ' Z% q% ]% I0 i' T
163.     RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_9);
     
164. #else
     ' Q. S' j/ p1 ]) w0 B" A
165.     /* PLLCLK = HSE(8MHz) * 9 = 72MHz */
     6 _7 t* r2 v9 m  T6 O2 t
166.     RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
     
167. #endif
     
168. 
     3 O1 a! @$ V4 G$ j4 H5 p! O* R
169.     /* Enable PLL */
     8 G, \8 E& g* {0 e3 _9 G& L- ]
170.     RCC_PLLCmd(ENABLE);
     - o  M  O" M/ j% d3 [, N
171. 
     . w+ P8 \  Z4 ~# t0 p0 C
172.     /* Wait till PLL is ready */
     
173.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     % G+ L+ M- ^( m2 j
174. 
       H( B: I0 y7 Y+ I2 i9 G
175.     /* Select PLL as system clock source */
     
176.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     , s1 U, k7 _- ?
177. 
     % J$ G3 A; l, w5 a+ P
178.     /* Wait till PLL is used as system clock source */
     
179.     while(RCC_GetSYSCLKSource() != 0x08);
     / Z* H3 x- _! r4 X, o# S
180.   }
     
181.   else
     - z% `) T2 R& ^+ h
182.   {
     " [9 x+ E' ^) N/ k- s
183.     /* Disable HSE */
     2 P' t9 t5 T6 u! G, b; x
184.     RCC_HSEConfig(RCC_HSE_OFF);
     0 _' Y! v1 J$ K
185. 
     + u( |- B$ w8 g% w. u$ `# }
186.     /* Enable HSI */
     
187.     RCC_HSICmd(ENABLE);
     ) L; ?2 n& D9 }8 m
188. 
     $ |9 U/ U0 ^8 m/ v2 U  n# f" i% X$ v
189.     /* Enable Prefetch Buffer */
     8 s8 N4 v, [: v! N) m1 w1 f0 j2 ]
190.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     
191. 
     / V; r. Z% t9 J6 ]
192.     /* Flash 1 wait state */
     
193.     FLASH_SetLatency(FLASH_Latency_1);
     
194. 
     
195.     /* HCLK = SYSCLK */
     " c4 A6 y" M$ y" S$ G# Q% @/ |  t7 W
196.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     
197. 
     
198.     /* PCLK2 = HCLK */
     
199.     RCC_PCLK2Config(RCC_HCLK_Div1);
     
200. 
     0 F9 K3 K! A3 Z4 `
201.     /* PCLK1 = HCLK */
     
202.     RCC_PCLK1Config(RCC_HCLK_Div1);
     4 `% ~1 z7 o) W8 [5 K! y* Z
203. 
     
204.     /* Configure PLLs */
     1 ?- ^; h4 B& k4 z# R
205.     /* PLLCLK = HSI(8MHz) / 2 * 9 = 36MHz */
     " a# I" }  b0 x# H, N0 I
206.     RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_9);
     
207. 
     / X; n% ^! n0 _% f7 H& \: g
208.     /* Enable PLL */
     - }2 D4 s8 L  |/ x- |/ b
209.     RCC_PLLCmd(ENABLE);
     
210. 
     
211.     /* Wait till PLL is ready */
     * c. [. I5 f7 h7 v* W3 V- [0 B! N, q
212.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     8 R+ V  s* r! ?. o3 z  |5 `
213. 
     
214.     /* Select PLL as system clock source */
     3 @2 @; b" p$ E/ R
215.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     " v! ~2 `% [1 a7 ?5 X" r" b
216. 
     
217.     /* Wait till PLL is used as system clock source */
     - _* J; R) s* d% A: \) |- p4 s
218.     while(RCC_GetSYSCLKSource() != 0x08);
     4 {+ n1 f2 R& [9 h% h
219.   }
     
220. }
       J, }) e$ n0 c. \1 N0 c
221. 
     5 g. V5 l1 `9 H: c+ W
222. #ifdef USE_FULL_ASSERT
     
223. /**
     $ @0 s, H4 S* @1 r5 ~( F
224.   * @brief  Reports the name of the source file and the source line number
     . s" S. V9 ~8 O7 y* _/ v7 l
225.   *         where the assert_param error has occurred.
     - {+ A5 C' C1 M* {  A& G
226.   * @param  file: pointer to the source file name.
     
227.   * @param  line: assert_param error line source number.
     7 v- q( G1 H$ H$ N+ }: W
228.   * @return None.
     ; `; Y5 c- D5 ?$ L
229.   */
     7 \% w& z0 a9 `& X% X) w
230. void assert_failed(uint8_t *file, uint32_t line)
     7 ]2 ?  ]' e7 l5 s7 L
231. {
     
232.   /* User can add his own implementation to report the file name and line number,
     . d; k+ n3 E; Q2 O* f, M: A" Z& U
233.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     6 w! F9 t$ x% |- Z  Y1 G
234. 
     , g+ a( b, [: m* I( z
235.   /* Infinite loop */
     
236.   while(1)
     / d% h: ~# c% r6 m3 ]* U" f" m
237.   {
     + t# W7 s# h0 k7 Y
238.   }
     # x: R: Z- e# Y7 q: O2 C7 S' u4 x
239. }
     
240. #endif

复制代码

3，注意
' l9 G0 e$ {4 V0 f
7 Q( `0 g2 X& O( z4 yCAN 消息发送缓冲区和接收缓冲区的大小，可以根据应用的需求进行修改，缓冲区使用的是堆内存，需要根据缓冲区大小和应用程序中堆内存使用情况进行配置。
: ~8 d- t' ~* y1 y+ D. e
4 L4 u6 E8 y0 |' b, X1 A' U

4 L3 ~/ c! q" W1 `; U% L% q( ~