1，开发环境
8 H0 W8 k& P( t; j: Q, P( ?
1，固件库：STM32F10x_StdPeriph_Lib_V3.5.0

  @# P; X7 \2 q  K% ~! o0 O2 C2，编译器：ARMCC V5.06

" N: w% t3 k1 X3，IDE：Keil uVision5
" @" R4 u& x) z! u- T
" ~4 t8 _, c3 e  r9 t  j* N- p4，操作系统：Windows 10 专业版
1 @6 i: R. L! i" Z9 U7 M

/ |& G( t! u% b8 g& \/ E" U2，程序源码
. `! a9 i5 R( \! T* p. J
8 I/ [! W8 ^4 U6 jRingBuffer.h 文件
1 v# E1 |6 J7 z, Y. ]* e; ?

1. /**
   
2.   ******************************************************************************
   
3.   * @file    RingBuffer.h
   
4.   * @author  XinLi
   
5.   * @version v1.1
   
6.   * @date    15-January-2018
   
7.   * @brief   Header file for RingBuffer.c module.
   
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    ) p& Y% p8 J) B0 I' {$ }* u0 e- y
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
      D7 e' X4 L. V7 J1 ^1 \) ~8 b/ r
13.   * This program is free software: you can redistribute it and/or modify
    - I" V" Z; o; r0 {/ @
14.   * it under the terms of the GNU General Public License as published by
    2 s* A- ~# W2 o$ \5 |' O3 t
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    , d# c# T( n3 j4 C' v# |# x' ?
17.   *
    - V9 k8 ~1 I. C
18.   * This program is distributed in the hope that it will be useful,
    % \2 i( m- }0 y. n9 J& W
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    . w: h8 }' e2 \. n8 o# O
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    9 i& d  ]6 u6 n4 G( r* [( F+ T
22.   *
    . x- @, C6 Y9 P1 j5 r
23.   * You should have received a copy of the GNU General Public License
      z. U/ S5 I- v+ j8 J
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    
25.   *
    & y4 o: g3 c! w1 b5 q' M
26.   ******************************************************************************
    3 l+ U* a0 z( b' ~
27.   */
    8 j8 C8 [6 {2 L! C0 p
28. 
    6 Y0 D, `2 W1 O8 z, s6 k
29. #ifndef __RINGBUFFER_H
    7 j2 L% i: e2 ]+ I# s; V9 Y
30. #define __RINGBUFFER_H
    ( b; y4 ]1 l8 |
31. 
    : W% ^2 p( x( j9 `1 u8 f! l4 U; w
32. #ifdef __cplusplus
    
33. extern "C" {
    
34. #endif
    
35. 
    + ]1 |1 r$ ^+ E4 k7 n% B* u  b
36. /* Header includes -----------------------------------------------------------*/
    
37. #include <stdint.h>
    
38. #include <stdbool.h>
    . C3 q- B. x8 P0 d. M+ d
39. #include <stdlib.h>
    
40. 
    
41. /* Macro definitions ---------------------------------------------------------*/
    
42. #define RING_BUFFER_MALLOC(size)  malloc(size)
    
43. #define RING_BUFFER_FREE(block)   free(block)
    
44. 
    # m  J3 S, S9 Q4 S8 @( w
45. /* Type definitions ----------------------------------------------------------*/
    $ `7 }, U$ z; [2 r1 ]4 d% V1 u" u
46. typedef struct
    
47. {
    
48.   uint8_t *buffer;
    : |. A5 }+ E* ?7 @
49.   uint32_t size;
    
50.   uint32_t in;
    
51.   uint32_t out;
    
52. }RingBuffer;
    1 o+ m/ Y1 |+ t/ l3 A. k
53. 
    
54. /* Variable declarations -----------------------------------------------------*/
    * a" ?5 C! G" r' h
55. /* Variable definitions ------------------------------------------------------*/
    1 Y$ d3 l5 l- E9 i
56. /* Function declarations -----------------------------------------------------*/
    
57. RingBuffer *RingBuffer_Malloc(uint32_t size);
    " _4 B9 z+ Y' W1 a/ x
58. void RingBuffer_Free(RingBuffer *fifo);
    : ?) b% ?9 s( N0 V
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 ------------------------------------------------------*/
    
64. 
    7 Z- Y& s! }$ X  S! M
65. /**
    
66.   * @brief  Removes the entire FIFO contents.
    
67.   * @param  [in] fifo: The fifo to be emptied.
    8 ~9 a$ ^, B' e$ f
68.   * @return None.
    5 O4 }' t( d; F% I8 j" C
69.   */
    + ]( a) A$ \% T" d
70. static inline void RingBuffer_Reset(RingBuffer *fifo)
    
71. {
    
72.   fifo->in = fifo->out = 0;
    
73. }
    ' _+ I- A  ?1 ?. H0 n9 t
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.
    / }9 b8 ^- `2 c: H3 O- K
79.   */
    
80. static inline uint32_t RingBuffer_Size(RingBuffer *fifo)
    : ~% a& @3 B2 o4 h! |  y
81. {
    * p0 W. {. K' q1 D
82.   return fifo->size;
    
83. }
    ; h2 E1 I1 p8 D! r7 u8 a
84. 
    ; M5 ]$ C4 u1 v$ }: E6 E( Z
85. /**
    
86.   * @brief  Returns the number of used bytes in the FIFO.
    
87.   * @param  [in] fifo: The fifo to be used.
    
88.   * @return The number of used bytes.
    ! x* D' R" e, V4 ^% x+ |  U& x
89.   */
    2 R5 F9 S& B) `9 }
90. static inline uint32_t RingBuffer_Len(RingBuffer *fifo)
    / D* e9 G: O: f
91. {
    8 E+ C& i, f* y' P3 g, M! M
92.   return fifo->in - fifo->out;
    ( j, }. `8 y7 s: l
93. }
    
94. 
    
95. /**
    
96.   * @brief  Returns the number of bytes available in the FIFO.
    
97.   * @param  [in] fifo: The fifo to be used.
    3 `/ y: t# u( ^) p- \% i
98.   * @return The number of bytes available.
    
99.   */
    ; Q  T+ `! k* j+ {
100. static inline uint32_t RingBuffer_Avail(RingBuffer *fifo)
     
101. {
     4 x& B3 ]/ ]  T" M3 u& p
102.   return RingBuffer_Size(fifo) - RingBuffer_Len(fifo);
     * @1 C% M+ `( i% e) E
103. }
     
104. 
     
105. /**
     % B6 V$ ^1 N/ M
106.   * @brief  Is the FIFO empty?
     
107.   * @param  [in] fifo: The fifo to be used.
     
108.   * @retval true:      Yes.
     
109.   * @retval false:     No.
     
110.   */
     
111. static inline bool RingBuffer_IsEmpty(RingBuffer *fifo)
     
112. {
     6 F2 ~+ z% f7 ]
113.   return RingBuffer_Len(fifo) == 0;
     7 a5 j$ i2 h4 _$ P0 S( G
114. }
     
115. 
     ! J0 y, [, Q7 Z0 Q: L
116. /**
     3 G% I. N5 g% U0 |- g' S: b
117.   * @brief  Is the FIFO full?
     ' W# m1 O/ ~/ H3 c5 V8 ?4 F; `
118.   * @param  [in] fifo: The fifo to be used.
     
119.   * @retval true:      Yes.
     
120.   * @retval false:     No.
     
121.   */
     3 r; `1 D5 q  r3 z- J
122. static inline bool RingBuffer_IsFull(RingBuffer *fifo)
     # @  o6 w9 T* C: R; X5 F7 K
123. {
     
124.   return RingBuffer_Avail(fifo) == 0;
     
125. }
     # C1 X& v: ^2 Y) W
126. 
     * _7 u2 g5 v6 A6 i* W- U. r
127. #ifdef __cplusplus
     
128. }
     ) Y8 J0 E0 U% j7 z6 @% [
129. #endif
     
130. 
     * d/ C& H+ a3 I! h: `  r) S
131. #endif /* __RINGBUFFER_H */
     

复制代码

" S) x# O4 b* T7 P* }RingBuffer.c 文件

1. <div>/**
   7 B, d9 x: U6 l) g# ]
2.   ******************************************************************************
   ; J$ U3 H$ W2 S2 l
3.   * @file    RingBuffer.c
   
4.   * @author  XinLi
   1 j, Q* g- o" ~0 r1 {  L
5.   * @version v1.1
   
6.   * @date    15-January-2018
   1 D/ C, d& F" m' ?) b: q5 F2 j0 d. d2 o
7.   * @brief   Ring buffer module source file.
   % m! ]5 i7 G- E3 ~" m
8.   ******************************************************************************
   
9.   * @attention
   ! p' V1 a# X$ ?: U0 h
10.   *
    1 C$ }' A" q4 q+ n
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    
14.   * it under the terms of the GNU General Public License as published by
    
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    
17.   *
    , a7 ~2 s7 J0 ~/ V$ ~6 X
18.   * This program is distributed in the hope that it will be useful,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    * v8 O  o- Z2 ^: {
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    + [& @9 c; @2 a
21.   * GNU General Public License for more details.
    ; Q7 Z* E6 e. S3 O
22.   *
    5 Q: _9 s' I9 q4 W; n* }. q
23.   * You should have received a copy of the GNU General Public License
    9 F# k8 i  z7 W- N, n
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    : _$ t  g9 _) }. {1 x
25.   *
    
26.   ******************************************************************************
    0 P; C( i5 X9 j; K* q
27.   */
    ; R! [) X* u+ P5 ^" C6 Q
28. 
    2 \/ y) t: b+ v. R) }
29. /* Header includes -----------------------------------------------------------*/
    ! V( H# t  a, x& a2 C' n
30. #include "RingBuffer.h"
    
31. #include <string.h>
    
32. 
    
33. /* Macro definitions ---------------------------------------------------------*/
    0 |( d- }( @: u: N6 C3 n
34. #define min(a, b)  (((a) < (b)) ? (a) : (b))
    6 W' u; D8 \8 `# T" {4 Y
35. 
    
36. /* Type definitions ----------------------------------------------------------*/
    ( \$ \( c8 H( n( M  T! b
37. /* Variable declarations -----------------------------------------------------*/
    
38. /* Variable definitions ------------------------------------------------------*/
    $ H& H" a6 y9 x& N
39. /* Function declarations -----------------------------------------------------*/
    2 H. A$ b# J' _0 A9 H
40. static bool is_power_of_2(uint32_t x);
    
41. static uint32_t roundup_pow_of_two(uint32_t x);
    
42. 
    
43. /* Function definitions ------------------------------------------------------*/
    9 @8 K, N& e2 e% }. U
44. 
    + S' g3 [; J+ s5 E: \# S3 k9 X
45. /**
    
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.
    
50.   */
    4 y, N5 e4 g+ {( n  q/ {
51. RingBuffer *RingBuffer_Malloc(uint32_t size)
    4 H) J* u* ~" e) e% ]8 P
52. {
    
53.   RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer));
    
54. 
    $ V" s7 S. g/ l! {( `! u7 F( t2 r
55.   if(fifo != NULL)
    1 ~7 x( m1 z6 F3 [( r6 ~) g$ a
56.   {
    
57.     if(is_power_of_2(size) != true)
    ( N! [; W' w% p5 t$ t5 v
58.     {
    $ t8 w2 z3 A# Q" A4 K7 [0 L
59.       if(size > 0x80000000UL)
    
60.       {
    
61.         RING_BUFFER_FREE(fifo);
    1 X/ v: c* N* g* S
62.         return NULL;
    
63.       }
    
64. 
    ' [+ g4 r% s/ E% k* r6 ?, N  [7 I
65.       size = roundup_pow_of_two(size);
    
66.     }
    
67. 
    
68.     fifo->buffer = RING_BUFFER_MALLOC(size);
    ( Y! e5 r% a! O3 Q* d2 ~
69. 
    0 I& s: N6 p0 y1 |# R
70.     if(fifo->buffer == NULL)
    
71.     {
    
72.       RING_BUFFER_FREE(fifo);
    
73.       return NULL;
    0 z) T0 y/ T- [. J& e+ D0 |
74.     }
    
75. 
    
76.     fifo->size = size;
    
77.     fifo->in = fifo->out = 0;
    
78.   }
    
79. 
    
80.   return fifo;
    & f) o# D4 c5 Y; G  \" \
81. }
    
82. 
    
83. /**
    
84.   * @brief  Frees the FIFO.
    & ^0 y& N- A2 |, y8 \
85.   * @param  [in] fifo: The fifo to be freed.
    - v0 L. |/ ^; ~6 ?- {- Q
86.   * @return None.
    
87.   */
    
88. void RingBuffer_Free(RingBuffer *fifo)
    + }; R+ O9 Q, Y
89. {
    " j1 Z% V' o4 [( z6 I+ x- h
90.   RING_BUFFER_FREE(fifo->buffer);
    
91.   RING_BUFFER_FREE(fifo);
    " ?  {, d2 T2 r
92. }
    9 {/ c/ c" q  I* u" Q
93. 
    ( E, I  k( Q9 N5 C5 S
94. /**
    6 i) D* v, ~, l, V" m
95.   * @brief  Puts some data into the FIFO.
    - t0 b$ `, T& x
96.   * @param  [in] fifo: The fifo to be used.
    8 h3 d" D' d" Y8 i9 @1 }9 k
97.   * @param  [in] in:   The data to be added.
    ! {8 R6 ?) a. J0 P% O( S
98.   * @param  [in] len:  The length of the data to be added.
    $ ?! m& B! y5 t5 r0 e7 y) A. w6 J
99.   * @return The number of bytes copied.
    7 K% X; ~! @! C
100.   * @note   This function copies at most @len bytes from the @in into
     2 G4 n  q7 \: Z2 }- z
101.   *         the FIFO depending on the free space, and returns the number
     
102.   *         of bytes copied.
     
103.   */
     * d3 R$ M; B5 \, G1 A
104. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len)
     8 u. O" c  m6 g! d" d
105. {
     ) B" c+ m& Q( V2 E/ w. \' x1 [) a
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)));
     
110.   memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), in, l);
       @) V' A- y. J- Z
111. 
     
112.   /* Then put the rest (if any) at the beginning of the buffer. */
     / `  }; L7 a7 c4 ~& G8 t; i
113.   memcpy(fifo->buffer, (uint8_t *)in + l, len - l);
     
114. 
     
115.   fifo->in += len;
     . D; [) L7 `- `4 \, o; f5 ~; g
116. 
     7 u& H- l# Y3 g/ f: g
117.   return len;
     
118. }
     
119. 
     
120. /**
     
121.   * @brief  Gets some data from the FIFO.
     & _' a. Y% [" l# Q# Q8 B- l
122.   * @param  [in] fifo: The fifo to be used.
     
123.   * @param  [in] out:  Where the data must be copied.
     
124.   * @param  [in] len:  The size of the destination buffer.
     : C( [3 A$ |4 a: N, P- v
125.   * @return The number of copied bytes.
     
126.   * @note   This function copies at most @len bytes from the FIFO into
     " T% q" b- O$ j; C
127.   *         the @out and returns the number of copied bytes.
     4 d8 g$ i6 b' l
128.   */
     . k9 I$ u+ n5 V
129. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len)
     
130. {
     3 x9 I! B2 P# ]7 E' h
131.   len = min(len, RingBuffer_Len(fifo));
     ' d( y! @* E/ h
132. 
     
133.   /* First get the data from fifo->out until the end of the buffer. */
     
134.   uint32_t l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
     . I4 N: j* Z: j
135.   memcpy(out, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
     2 R( t8 ^) i% x' F" P6 a
136. 
     
137.   /* Then get the rest (if any) from the beginning of the buffer. */
     
138.   memcpy((uint8_t *)out + l, fifo->buffer, len - l);
     8 U7 B3 a0 K( Z+ `" E6 [0 B
139. 
     / y1 Z) R  Z" _/ z/ ]
140.   fifo->out += len;
     
141. 
     * D: z6 z( J& L  S
142.   return len;
     4 `# j0 v; `) l' g) [/ n
143. }
     
144. 
     
145. /**
     / x1 F3 I1 M/ k
146.   * @brief  Determine whether some value is a power of two.
     
147.   * @param  [in] x: The number to be confirmed.
     , s$ L( a+ {. ?3 P( J
148.   * @retval true:   Yes.
     / p/ N+ i: l, {1 I) R" l
149.   * @retval false:  No.
     
150.   * @note   Where zero is not considered a power of two.
     9 g' C$ @# s( V; ]
151.   */
     # g+ {! K( z* F  B, Y! W  b
152. static bool is_power_of_2(uint32_t x)
     % u+ Q- k) g7 b, J0 W7 D
153. {
     
154.   return (x != 0) && ((x & (x - 1)) == 0);
     4 h8 {- @0 V- L, t$ T
155. }
     & w: W7 l" W% S, y
156. 
     
157. /**
       K3 w& }4 n/ ^2 W6 r
158.   * @brief  Round the given value up to nearest power of two.
       J& H/ J8 T( s" C5 |, n! _! \! N
159.   * @param  [in] x: The number to be converted.
     
160.   * @return The power of two.
     2 x/ ?+ l$ _4 v9 f
161.   */
     
162. static uint32_t roundup_pow_of_two(uint32_t x)
     
163. {
     
164.   uint32_t b = 0;
     
165. 
     4 p- t2 v7 v( I: o
166.   for(int i = 0; i < 32; i++)
     1 w( A, u3 h. C8 D/ M1 b7 `) b& a
167.   {
     
168.     b = 1UL << i;
     
169. 
     # S: `, P2 H1 V* C% {" A+ s# d8 ?
170.     if(x <= b)
     
171.     {
     . _5 u+ B! }$ ~, I+ Y
172.       break;
     
173.     }
     1 L+ E# C+ b5 {7 O" s8 P/ A2 e# J2 i
174.   }
     1 C( B- V5 v- z$ Q% i! E
175. 
       a/ @) `  ~3 N8 i+ T+ B9 e& }2 E
176.   return b;
     
177. }</div><div></div>

复制代码

CAN.h 文件
# N5 V9 n3 c9 u) [3 E; V% l

1. /**
   
2.   ******************************************************************************
   4 O1 X3 P; ~! Y% b9 w
3.   * @file    CAN.h
   7 _7 C( ]) d  O# w9 C
4.   * @author  XinLi
   9 L3 \1 H, o; O, X- K' r% j/ B
5.   * @version v1.0
   
6.   * @date    24-June-2018
   # ]" ~! J% ?) g1 Q5 ^: f
7.   * @brief   Header file for CAN.c module.
   
8.   ******************************************************************************
   * K7 m: S- q8 M
9.   * @attention
   1 x* L% Z0 \' o$ J  g) {" T* `" ^
10.   *
    5 q- J) y. P& I+ d, }0 J& V! k
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    & |, k- J, E# K+ C. D- Z/ z
14.   * it under the terms of the GNU General Public License as published by
    $ n) j5 m* X& k. q" h: P
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    
17.   *
    " n& A4 Z) L( r; H3 z
18.   * This program is distributed in the hope that it will be useful,
    % w1 ?* d1 a7 Z* t/ b. `
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    + T& p( B4 O1 E6 m& v: d: t2 a
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      ~0 N7 ^; t$ @# t
21.   * GNU General Public License for more details.
    - n& T$ g/ I! j7 e
22.   *
    4 }  W8 \7 _$ S4 f* G4 E9 c
23.   * You should have received a copy of the GNU General Public License
    2 u" l; `' m* u. H! C
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    # U1 J& w: c7 s, k" s( e0 y" L
25.   *
    $ Z) ?8 i/ ]9 J6 F6 I
26.   ******************************************************************************
    
27.   */
    2 k+ H" w( d% m
28. 
    
29. #ifndef __CAN_H
    " b4 R9 `. ]$ O9 b9 g% T; k5 i
30. #define __CAN_H
    
31. 
    5 I- M% B8 r" e7 l6 \' j2 r- G0 ?
32. #ifdef __cplusplus
    + x- i+ A4 p4 r. ~" O4 H# h
33. extern "C" {
    ' ~3 J: C( _' f; m) Q2 s$ Y4 T- s
34. #endif
    
35. 
    / L2 @4 x- u7 S! _" [8 q
36. /* Header includes -----------------------------------------------------------*/
    
37. #include "stm32f10x.h"
    
38. #include <stdbool.h>
    # }- P2 S2 t- J, Y0 d% Z( U! `$ \
39. 
    
40. /* Macro definitions ---------------------------------------------------------*/
    
41. 
    
42. /******************************* CAN1 Configure *******************************/
    
43. #define CAN1_TX_BUFFER_SIZE        (16)
    ( |8 F  {* a5 O7 {" k$ W& `
44. #define CAN1_RX_BUFFER_SIZE        (16)
    ( d0 C7 Z3 p" h; ?5 h
45. 
    
46. #define CAN1_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    . K9 D8 H8 U. s$ t
47. #define CAN1_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
48. 
    & |6 \$ g  n: q
49. #define CAN1_TX_GPIO_PORT          GPIOB
    
50. #define CAN1_RX_GPIO_PORT          GPIOB
    3 l/ x4 X1 Q% {- W4 y# U
51. 
    # |4 k( {$ s, r5 T/ E' P! l
52. #define CAN1_TX_GPIO_PIN           GPIO_Pin_9
    6 U; @; \0 C. ?9 [) q7 [! N* v( l3 P
53. #define CAN1_RX_GPIO_PIN           GPIO_Pin_8
    
54. 
    
55. #define CAN1_IRQ_PREEMPT_PRIORITY  (0)
    ) z$ V; f2 \( Y2 ^& s7 A. L
56. #define CAN1_IRQ_SUB_PRIORITY      (0)
    
57. 
    
58. #define CAN1_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap1_CAN1 , ENABLE)
    
59. /******************************************************************************/
    # d+ d  G% q: b; a: l' t1 ~
60. 
    * O$ e$ k! h. E/ V( ?. J0 c3 Z
61. #ifdef STM32F10X_CL
    
62. /******************************* CAN2 Configure *******************************/
    0 s% l% J2 a9 y8 t# X# O
63. #define CAN2_TX_BUFFER_SIZE        (16)
    
64. #define CAN2_RX_BUFFER_SIZE        (16)
    ' @( D4 }/ j% O. T* u# B% a4 z
65. 
    " ]; U+ u. ^1 ~  X% R' {/ T
66. #define CAN2_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
67. #define CAN2_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
68. 
    
69. #define CAN2_TX_GPIO_PORT          GPIOB
    2 F! O, u3 H% R. `: r
70. #define CAN2_RX_GPIO_PORT          GPIOB
    0 Q8 V2 C* N8 ~" w# ?% @
71. 
    
72. #define CAN2_TX_GPIO_PIN           GPIO_Pin_13
    # W" O6 A( A7 a4 e. I+ T# {' `
73. #define CAN2_RX_GPIO_PIN           GPIO_Pin_12
      o; B$ |8 R3 k! v" y$ I# x0 @6 w
74. 
    
75. #define CAN2_IRQ_PREEMPT_PRIORITY  (0)
    
76. #define CAN2_IRQ_SUB_PRIORITY      (0)
    ; V9 G5 ]/ t8 ~+ k+ E, H9 V: ?
77. 
    
78. #define CAN2_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap_CAN2 , DISABLE)
    / \. A% T, s0 \" i
79. /******************************************************************************/
    3 W$ S6 Y9 x% S9 G* H9 S* ]: Z
80. #endif /* STM32F10X_CL */
    1 I( J0 ~! E3 ?) l3 c( e
81. 
    
82. /* Type definitions ----------------------------------------------------------*/
    
83. typedef enum
    
84. {
    / ~/ |; p4 S) R! a" Y+ B  C
85.   CAN_WorkModeNormal   = CAN_Mode_Normal,
    6 `& B0 ^( Z, V& X( G7 {
86.   CAN_WorkModeLoopBack = CAN_Mode_LoopBack
    " ^5 A, t/ ^) a
87. }CAN_WorkMode;
    
88. 
    
89. typedef enum
    
90. {
    
91.   CAN_BaudRate1000K = 6,
    
92.   CAN_BaudRate500K  = 12,
    ( j: t3 o, }2 B8 E  M! M% ?
93.   CAN_BaudRate250K  = 24,
    % D' K' t4 M" u1 S, D. g0 g. u0 ^
94.   CAN_BaudRate125K  = 48,
    # I" q, F; ?6 R
95.   CAN_BaudRate100K  = 60,
    " M$ r% U6 o# ]4 B3 y+ m
96.   CAN_BaudRate50K   = 120,
    ; \2 G* u3 M1 {- w! D8 j( b: W
97.   CAN_BaudRate20K   = 300,
    3 o: P. ?7 Q4 b, _9 O' L
98.   CAN_BaudRate10K   = 600
    ; ^6 a$ W- Q- P" T7 U# ^1 w
99. }CAN_BaudRate;
    % E4 m/ M) w7 m0 l
100. 
     
101. /* Variable declarations -----------------------------------------------------*/
     
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);
     
105. void CAN_Unconfigure(CAN_TypeDef *CANx);
     
106. 
     9 ?% I0 r- e0 @. R
107. void CAN_SetTransmitFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     4 W! [3 m- Z+ X) x
108. void CAN_SetReceiveFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     
109. 
     + M- E; \4 h# h$ `% X
110. uint32_t CAN_SetTransmitMessage(CAN_TypeDef *CANx, CanTxMsg *Message, uint32_t Number);
     
111. uint32_t CAN_GetReceiveMessage(CAN_TypeDef *CANx, CanRxMsg *Message, uint32_t Number);
     3 Z+ b4 r) T& q/ i! Y$ m* [
112. 
     
113. uint32_t CAN_GetUsedTransmitBufferSize(CAN_TypeDef *CANx);
     
114. uint32_t CAN_GetUsedReceiveBufferSize(CAN_TypeDef *CANx);
     
115. uint32_t CAN_GetUnusedTransmitBufferSize(CAN_TypeDef *CANx);
     & t0 t& U) e( _  z# q& }
116. uint32_t CAN_GetUnusedReceiveBufferSize(CAN_TypeDef *CANx);
     
117. 
     / S6 b: B3 z; C% @* V) B& j
118. bool CAN_IsTransmitBufferEmpty(CAN_TypeDef *CANx);
     " n5 P- g. v0 e* m3 N7 h% @+ f* k
119. bool CAN_IsReceiveBufferEmpty(CAN_TypeDef *CANx);
     
120. bool CAN_IsTransmitBufferFull(CAN_TypeDef *CANx);
     
121. bool CAN_IsReceiveBufferFull(CAN_TypeDef *CANx);
     
122. 
     
123. void CAN_ClearTransmitBuffer(CAN_TypeDef *CANx);
     
124. void CAN_ClearReceiveBuffer(CAN_TypeDef *CANx);
     
125. 
     
126. bool CAN_IsTransmitMessage(CAN_TypeDef *CANx);
     1 {+ q- y4 B5 H2 S. K( G2 f5 B
127. 
     ' a+ \9 {( k# M& s/ {2 J3 Q3 X
128. /* Function definitions ------------------------------------------------------*/
     
129. 
     
130. #ifdef __cplusplus
     
131. }
     
132. #endif
     5 L! A+ U; |- P1 R( C
133. 
     ' N( h- }7 @1 B" s' W- l' `
134. #endif /* __CAN_H */
     4 W$ A* \0 ^9 Q# R  @) R4 [2 C9 c

复制代码

- \; i7 Z8 e1 l2 ICAN.c 文件

1 s+ A( G4 z, p. E" {

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

复制代码

main.h 文件

1. /**
   0 q; v3 z- @- }1 n. h' I& c0 O
2.   ******************************************************************************
   
3.   * @file    main.h
   
4.   * @author  XinLi
   
5.   * @version v1.0
   . z6 R8 p; I0 e; h! E* f/ k
6.   * @date    24-June-2018
   ) M8 X" O6 n: d/ h- S2 b1 f- C( I
7.   * @brief   Header file for main.c module.
   % w. S9 {& @- U+ ]/ u& V1 Z
8.   ******************************************************************************
   
9.   * @attention
     M6 E$ I) o, A: J# I4 O
10.   *
    " P" n; s' G& d4 w; L9 R
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    ' Q: F7 x& m6 Y) Q5 }
13.   * This program is free software: you can redistribute it and/or modify
      T! ]2 }! {9 R) u
14.   * it under the terms of the GNU General Public License as published by
    ! E% r- H2 W0 z% X" }" G
15.   * the Free Software Foundation, either version 3 of the License, or
    / q# ]; N/ V( g
16.   * (at your option) any later version.
    
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    4 w; J0 f) R9 v
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    9 N& @( A& Q( O- X
21.   * GNU General Public License for more details.
    
22.   *
    4 `# [4 N  [( T5 o+ i& Y
23.   * You should have received a copy of the GNU General Public License
    8 S! x# j9 ^+ O# h/ x: n
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    
25.   *
      M- j  W6 t2 @0 |) u* K
26.   ******************************************************************************
    
27.   */
    $ U4 y5 t$ H5 N
28. 
    + Q9 R$ U' `( H6 V9 s/ P
29. #ifndef __MAIN_H
    
30. #define __MAIN_H
    8 w7 v, C* j) c( y  q* |
31. 
    9 R3 z+ I" p7 Q6 v% T1 I. H
32. #ifdef __cplusplus
    
33. extern "C" {
    
34. #endif
    
35. 
    
36. /* Header includes -----------------------------------------------------------*/
    : R! s- I- Y) z
37. #include "stm32f10x.h"
    
38. 
    ' E/ m! _. }# L/ M- r  z" e
39. /* Macro definitions ---------------------------------------------------------*/
    
40. /* Type definitions ----------------------------------------------------------*/
    
41. /* Variable declarations -----------------------------------------------------*/
    
42. /* Variable definitions ------------------------------------------------------*/
    
43. /* Function declarations -----------------------------------------------------*/
    # h2 G$ H( ~, U5 j
44. /* Function definitions ------------------------------------------------------*/
    9 P! v2 q  O9 P. a% Q# a1 o
45. 
    8 l( K- ~& q. c& X
46. #ifdef __cplusplus
    - h  K2 {$ v: K- g$ a) _' [1 i
47. }
    
48. #endif
    
49. 
    + ~8 H2 O4 i$ }8 D; M# d9 f
50. #endif /* __MAIN_H */

复制代码

$ e( w& z4 W1 @- p( R: N: Jmain.c 文件
4 Y! h9 Y; R' A) L" p$ E6 ~

1. /**
   - a0 Z$ |, N8 u3 V5 o
2.   ******************************************************************************
   " s. s6 P( X9 p& r# p  v
3.   * @file    main.c
   
4.   * @author  XinLi
   - H# l8 A# p" S; Y: |
5.   * @version v1.0
   : X1 }' p; M' X# J- @. j
6.   * @date    24-June-2018
   
7.   * @brief   Main program body.
   1 r4 E4 `& a+ d% C% l* Q0 s7 A7 A
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    7 e& Y: R( Q0 q* B; K; K  z
12.   *
    4 ]0 |. J5 j: a5 ^5 H- 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
    * V) f) Z) n: C* \5 l9 H0 e( a
15.   * the Free Software Foundation, either version 3 of the License, or
    ' |* @" ]& B& |0 k
16.   * (at your option) any later version.
    
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    ' `+ t3 w* a+ O7 O$ |
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.
    + p& J5 g( q  r1 j% F7 i6 X
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>
    * K2 Z9 l5 k: i$ m; v! O" d3 N
25.   *
    
26.   ******************************************************************************
    
27.   */
    ) H1 P7 x. }, J% v0 k
28. 
      L& r. N( t9 p9 ^# N. ~( J# i
29. /* Header includes -----------------------------------------------------------*/
    ) t% j/ _2 L* ?
30. #include "main.h"
    
31. #include "CAN.h"
    1 w! K! N3 c, ^1 a. F! L
32. 
    . B* ?1 o9 `7 {  y
33. #ifdef _RTE_
    
34. #include "RTE_Components.h"
    
35. #endif
    
36. 
    2 p+ C; g  T& K. h  G
37. #ifdef RTE_CMSIS_RTOS2
    
38. #include "cmsis_os2.h"
    + [  }# O- _5 o* A; x; e
39. #endif
    4 k! I3 l- K, F# ~% H  T3 a
40. 
    % Y5 j1 R1 h+ Q6 o+ K
41. /* Macro definitions ---------------------------------------------------------*/
    
42. /* Type definitions ----------------------------------------------------------*/
    
43. /* Variable declarations -----------------------------------------------------*/
    , l: ~1 Q8 ]( ^: e7 y
44. /* Variable definitions ------------------------------------------------------*/
    & |" ~5 `  h8 G
45. static CanTxMsg canTxMsg = {0};
    7 |- j0 g. a7 d
46. static CanRxMsg canRxMsg = {0};
    
47. 
    
48. /* Function declarations -----------------------------------------------------*/
    
49. static void SystemClock_Config(void);
    
50. 
    5 H' C  [/ p, A# P& h
51. /* Function definitions ------------------------------------------------------*/
    
52. 
    $ S' Q) o6 y3 N( C  f# ?* p6 P& Z
53. /**
    
54.   * @brief  Main program.
    $ x) U8 L: }& E; K' b
55.   * @param  None.
    / p. W" U2 u* s$ I1 \$ ]* M& Z+ T, B
56.   * @return None.
    ; ^+ u4 X0 R' d9 F
57.   */
    " D2 }# Q! H4 Z6 C" |( _- p5 U
58. int main(void)
    
59. {
    
60.   /* Configure the system clock to 72 MHz */
    
61.   SystemClock_Config();
    
62.   SystemCoreClockUpdate();
    
63. 
    
64.   /* Add your application code here */
    * g. S7 V. R* I$ _/ r
65.   CAN_Configure(CAN1, CAN_WorkModeLoopBack, CAN_BaudRate250K, 0xAA55, 0x55AA);
    
66. 
    
67. #ifdef RTE_CMSIS_RTOS2
    9 Y) D6 d6 L, K5 l
68.   /* Initialize CMSIS-RTOS2 */
    
69.   osKernelInitialize();
    
70. 
    % p: J* |/ f' t. ~5 ]& |3 z9 I/ |0 t
71.   /* Create thread functions that start executing,
    
72.   Example: osThreadNew(app_main, NULL, NULL); */
    7 F! l/ b. H3 Y9 f
73. 
    ; U- n! J! ?9 c
74.   /* Start thread execution */
    " Y) k1 D- `2 F
75.   osKernelStart();
    / D. l) n5 I9 s+ J( S  U/ Z
76. #endif
    # o8 P& A- U4 e8 V, A+ j$ X: P* D
77. 
    0 E# j& B5 ~" h' u) D
78.   /* Infinite loop */
    $ W3 p$ W! F7 p+ W7 C
79.   while(1)
    # ^& Z+ S( |9 x
80.   {
    
81.     canTxMsg.StdId = 0xAA55;
    
82.     canTxMsg.ExtId = 0x55AA;
    1 y4 s$ g7 E2 y: _# H! t( H
83.     canTxMsg.IDE   = CAN_ID_STD;
    0 y$ \" @6 t4 V* r
84.     canTxMsg.RTR   = CAN_RTR_DATA;
    
85.     canTxMsg.DLC   = 8;
    7 z3 {0 m. F/ g7 y8 c$ K
86. 
    
87.     canTxMsg.Data[0]++;
    
88.     canTxMsg.Data[1]++;
    
89.     canTxMsg.Data[2]++;
    9 M8 [( k; I; ~, ]- }
90.     canTxMsg.Data[3]++;
    ( {+ C9 f* `$ j/ @' k, ]- d- N
91.     canTxMsg.Data[4]++;
    
92.     canTxMsg.Data[5]++;
    
93.     canTxMsg.Data[6]++;
    8 |  A- _1 Q. {! ]6 y) D+ \, a
94.     canTxMsg.Data[7]++;
    
95. 
    2 b9 ]  n# b; y# u/ n$ Y0 g+ w4 [
96.     CAN_SetTransmitMessage(CAN1, &canTxMsg, 1);
    7 Z3 Z. B4 N. [( A! z; L
97. 
    ! ?9 q* d3 l+ V* A" G6 V$ O' Q) j
98.     while(CAN_IsReceiveBufferEmpty(CAN1) == true);
    
99. 
    
100.     CAN_GetReceiveMessage(CAN1, &canRxMsg, 1);
     
101.   }
     ) ?! e* v, U8 e! k& r7 M
102. }
     , Z. N( @8 ^, P, R: J" G) U
103. 
     
104. /**
     
105.   * @brief  System Clock Configuration.
     
106.   *         The system Clock is configured as follow :
     
107.   *            System Clock source            = PLL (HSE)
     
108.   *            SYSCLK(Hz)                     = 72000000
     4 Q' d) t* `+ B, l  |, L
109.   *            HCLK(Hz)                       = 72000000
     
110.   *            AHB Prescaler                  = 1
     ( N  A) p' N: Q5 [+ x
111.   *            APB1 Prescaler                 = 2
     % |7 x: j9 g$ W! [0 {
112.   *            APB2 Prescaler                 = 1
     
113.   *            HSE Frequency(Hz)              = 8000000
     ; l+ q- U5 ]$ m9 R( ^* J
114.   *            HSE PREDIV1                    = 1
     % v0 j8 H0 ]4 M" ]5 D; m: ^, r1 j
115.   *            PLLMUL                         = 9
     % n! C) @% k) x; r2 s" {) @; |7 U7 @8 a
116.   *            Flash Latency(WS)              = 2
     0 y( w) \' ?3 k; z9 W! z" ~
117.   * @param  None.
     # p0 W% T& U% J5 `/ x7 I' a
118.   * @return None.
     & j1 J( l- @( D. l1 V. ~
119.   */
     
120. static void SystemClock_Config(void)
     . a2 K, ^  U+ D, b. N
121. {
     ) \: B$ |& ~+ }+ l3 W
122.   /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration */
     # E' j5 P% x! j! p9 w4 _
123.   /* RCC system reset */
     ) u' B& O- i+ @- g
124.   RCC_DeInit();
     : S$ l$ c* d. ^8 m8 T2 |$ H# g7 Q
125. 
     
126.   /* Enable HSE */
     
127.   RCC_HSEConfig(RCC_HSE_ON);
     
128. 
     
129.   /* Wait till HSE is ready */
     
130.   ErrorStatus HSEStartUpStatus = RCC_WaitForHSEStartUp();
     
131. 
     . C1 _5 w1 m8 j4 {9 S3 L0 n
132.   if(HSEStartUpStatus == SUCCESS)
       j" @) ?8 M* K  @
133.   {
     
134.     /* Enable Prefetch Buffer */
     5 q% N0 z' E( F0 N
135.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     8 O! T' ^8 C( d; [4 M: Z
136. 
     * p0 o% G+ j$ K* r6 j0 ]
137.     /* Flash 2 wait state */
     
138.     FLASH_SetLatency(FLASH_Latency_2);
     
139. 
     2 G( _- l6 K$ v* r, [$ u
140.     /* HCLK = SYSCLK */
     ( s/ \" V+ ]9 C! j* i# d
141.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     
142. 
     
143.     /* PCLK2 = HCLK */
     
144.     RCC_PCLK2Config(RCC_HCLK_Div1);
     5 v& c. u' T( r; o! M
145. 
     1 H, I* A8 ]3 M, x1 f
146.     /* PCLK1 = HCLK / 2 */
     1 f% Q7 i: M- d
147.     RCC_PCLK1Config(RCC_HCLK_Div2);
     + [) V  R. I9 T
148. 
     6 W4 Q5 n; J: m. P2 A/ b5 `
149.     /* Configure PLLs */
     
150. #ifdef STM32F10X_CL
     
151.     /* PLL2 configuration: PLL2CLK = (HSE(8MHz) / 2) * 10 = 40MHz */
     , y' p. {" ~; u' s8 n  ?. K/ s. p
152.     RCC_PREDIV2Config(RCC_PREDIV2_Div2);
     
153.     RCC_PLL2Config(RCC_PLL2Mul_10);
     
154. 
     
155.     /* Enable PLL2 */
     . r) @3 G- A3 ^; s. e9 e. `) t
156.     RCC_PLL2Cmd(ENABLE);
     ' Q& Y$ a2 Q% U
157. 
     
158.     /* Wait till PLL2 is ready */
     
159.     while(RCC_GetFlagStatus(RCC_FLAG_PLL2RDY) == RESET);
     
160. 
     # T" E: t+ M6 s- M# S! y0 j
161.     /* PLL configuration: PLLCLK = (PLL2(40MHz) / 5) * 9 = 72MHz */
     1 y8 e4 d7 C$ e
162.     RCC_PREDIV1Config(RCC_PREDIV1_Source_PLL2, RCC_PREDIV1_Div5);
     
163.     RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_9);
     & z; a* @/ S) A2 M6 j3 l+ D
164. #else
     
165.     /* PLLCLK = HSE(8MHz) * 9 = 72MHz */
     4 H* F/ p9 A# Y* U) q, H7 v
166.     RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
     
167. #endif
     
168. 
     
169.     /* Enable PLL */
     
170.     RCC_PLLCmd(ENABLE);
     2 J- Z8 _; _# [$ a, ], H
171. 
     5 [2 f! g0 q  q2 x% i& m' w. w
172.     /* Wait till PLL is ready */
     
173.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     ( v) }9 f0 m; T2 }3 q
174. 
     * ]! A6 J# D" I8 p! V, F- s, {4 |
175.     /* Select PLL as system clock source */
     
176.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     
177. 
     
178.     /* Wait till PLL is used as system clock source */
     % w7 p% n( v* f- @1 d- v
179.     while(RCC_GetSYSCLKSource() != 0x08);
     ' _. N- W3 O3 |
180.   }
     - J# p5 \) |+ B2 [) N9 }! ^; `
181.   else
     
182.   {
     ' @# A- _3 Z( v
183.     /* Disable HSE */
     0 z$ B3 `0 W( q: |, `7 q: z2 S
184.     RCC_HSEConfig(RCC_HSE_OFF);
     % R* G, m5 a3 {0 a# o
185. 
     3 D  J' P) _) z" B# V# P
186.     /* Enable HSI */
     3 s  |6 p5 E5 h. l1 H) U
187.     RCC_HSICmd(ENABLE);
     % W4 h! P0 V" S
188. 
     $ z. E: X. ?8 V6 l" \* ]
189.     /* Enable Prefetch Buffer */
     & U: C/ b% _7 l5 Q( V* K5 l4 H
190.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     ( q7 \: ~1 V9 F4 Y3 E4 W
191. 
     
192.     /* Flash 1 wait state */
     # _9 M" b: X2 o. l/ z2 F( `+ c2 d
193.     FLASH_SetLatency(FLASH_Latency_1);
     
194. 
     . T& f! K" S- J) }# L( l
195.     /* HCLK = SYSCLK */
     5 m- D" u$ y8 X9 K  ]8 H
196.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     ( Q, m/ I  B6 E
197. 
     ' }6 A# X) s+ K# R+ R; {
198.     /* PCLK2 = HCLK */
     5 [* r+ _+ W" s' V( i
199.     RCC_PCLK2Config(RCC_HCLK_Div1);
     
200. 
     
201.     /* PCLK1 = HCLK */
     
202.     RCC_PCLK1Config(RCC_HCLK_Div1);
     0 H# ?6 W% [/ F9 `8 M6 f' E
203. 
     # ?) {) K: s, F2 g! A4 l; j
204.     /* Configure PLLs */
     
205.     /* PLLCLK = HSI(8MHz) / 2 * 9 = 36MHz */
     1 G" {3 D# r0 @& E8 X9 v" R# D
206.     RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_9);
     7 U2 `8 U; _3 Q( H
207. 
     
208.     /* Enable PLL */
     
209.     RCC_PLLCmd(ENABLE);
     ' ^7 n( ]) W, \+ Y7 u
210. 
     
211.     /* Wait till PLL is ready */
     
212.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     
213. 
     
214.     /* Select PLL as system clock source */
     8 W& V$ t+ f- O4 }, Q* Y! _% I
215.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     
216. 
     " N% j% x# w  o
217.     /* Wait till PLL is used as system clock source */
     / j/ l  V; Q  k9 Y, Z5 ]
218.     while(RCC_GetSYSCLKSource() != 0x08);
     3 A5 a8 j' r- Q2 G' E, p
219.   }
     / J& i& g, v  n# F
220. }
     
221. 
     ) M4 p5 o' H# W- Z
222. #ifdef USE_FULL_ASSERT
     1 L. G6 d& y# T1 ]. H( k
223. /**
     
224.   * @brief  Reports the name of the source file and the source line number
     ' _8 l1 x/ |8 W  c: P; b3 V
225.   *         where the assert_param error has occurred.
     
226.   * @param  file: pointer to the source file name.
     
227.   * @param  line: assert_param error line source number.
     
228.   * @return None.
     
229.   */
     
230. void assert_failed(uint8_t *file, uint32_t line)
     , W' ?" m' q4 X
231. {
     
232.   /* User can add his own implementation to report the file name and line number,
     . F+ Y- z8 b3 s
233.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     
234. 
     
235.   /* Infinite loop */
     
236.   while(1)
     . L& Z: C2 g; V- T
237.   {
     5 N0 C) c* ~# p; @+ e
238.   }
     , o5 F4 H- ^* {& P$ A
239. }
     : h& I" Z( l9 y1 ^
240. #endif

复制代码

. e9 X2 [/ f8 w; D3，注意
* r0 j5 y' i' Z8 G! M! E( H+ d/ t1 ?
CAN 消息发送缓冲区和接收缓冲区的大小，可以根据应用的需求进行修改，缓冲区使用的是堆内存，需要根据缓冲区大小和应用程序中堆内存使用情况进行配置。

) y& [' w8 v! h# W5 `
- {# @/ D3 a" i" q1 a