1，开发环境
; T; F' N8 ~- h
; |% Z) x& J7 h8 n1，固件库：STM32F10x_StdPeriph_Lib_V3.5.0
  v$ S5 Y" N, ^7 h% h
2，编译器：ARMCC V5.06
' |! p+ G3 T1 {: ?2 m
7 _0 P/ T" b9 }+ \8 O. O, |3，IDE：Keil uVision5
$ K. X' v) r8 I5 k( Z. E6 t: Y3 X
4，操作系统：Windows 10 专业版
$ F; v2 X/ s" ?6 g# f7 q7 f
; b: m& V) p( S3 O+ s6 @# V
" `9 }2 `* X6 w% }# C- X8 `2，程序源码
7 }, h' U5 c9 Z  h/ O, Z9 P
6 ~4 t: D) |- Z  Y7 h8 t: `RingBuffer.h 文件

1. /**
   
2.   ******************************************************************************
   5 Y9 N8 A% u1 G8 V+ K+ c, i# [# A
3.   * @file    RingBuffer.h
   : \0 n) ^# G, }4 E; ?; g0 b7 P
4.   * @author  XinLi
   
5.   * @version v1.1
   ; `- `0 p/ N7 Q4 W$ v6 [- z* _/ ]
6.   * @date    15-January-2018
   0 O3 ?& w& M; i
7.   * @brief   Header file for RingBuffer.c module.
   & z& Z/ D. p3 z8 q: S; h
8.   ******************************************************************************
   7 R( ^5 N1 S' y+ B# n! e
9.   * @attention
   $ f! Y" _1 ]8 _, G( n# V, n  k
10.   *
    1 z8 s- o0 U* L, O$ {2 F$ 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
    7 R# T% y$ a8 O5 K
15.   * the Free Software Foundation, either version 3 of the License, or
    : f1 b0 t/ Y6 ?4 L: Y+ }6 d0 P( F
16.   * (at your option) any later version.
    
17.   *
    " Q4 `0 O9 C" G- u4 ]
18.   * This program is distributed in the hope that it will be useful,
    " v) x. K7 H& b9 A1 O. U
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    6 G- \0 ]( f0 s/ m* d
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
    2 y/ t. Z6 a+ Z3 @7 J
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    , t/ C/ ~- w% w) G& T
25.   *
    " I# f. Q8 I/ W" ^* {9 {
26.   ******************************************************************************
    
27.   */
    
28. 
    
29. #ifndef __RINGBUFFER_H
    7 ]) L3 c7 ?9 i4 f: t
30. #define __RINGBUFFER_H
    
31. 
    
32. #ifdef __cplusplus
    7 F. U9 P3 ]4 M0 p" `
33. extern "C" {
    9 c! Y( r2 q8 |4 J
34. #endif
    4 ?" c8 C; y/ f- B, b
35. 
    $ F( K8 h" F" ~
36. /* Header includes -----------------------------------------------------------*/
    7 y4 q; x" O, }' A1 |' N
37. #include <stdint.h>
    
38. #include <stdbool.h>
    / Y/ _+ O& R4 |2 e' }; U1 k
39. #include <stdlib.h>
    , d7 u1 M0 `4 F/ t$ ^, R
40. 
    
41. /* Macro definitions ---------------------------------------------------------*/
    
42. #define RING_BUFFER_MALLOC(size)  malloc(size)
    2 f4 p  l5 K5 m* q& t9 d$ e" O$ K! O  `
43. #define RING_BUFFER_FREE(block)   free(block)
    : {! E# N, v8 U$ h3 H6 b# }
44. 
    
45. /* Type definitions ----------------------------------------------------------*/
    7 y4 C6 z8 I* q: e! l8 R2 Q
46. typedef struct
    ' [, [% M# @9 c+ W8 k1 m) U
47. {
    
48.   uint8_t *buffer;
    
49.   uint32_t size;
    ) ?9 H7 m- H8 d! @/ n4 I3 Z7 \+ A5 j
50.   uint32_t in;
    ) l: Y) i* }' R5 d5 a7 G7 F
51.   uint32_t out;
    6 ~% T) l5 S: E. x" W: t$ i
52. }RingBuffer;
    
53. 
    # k" r: W2 u7 f
54. /* Variable declarations -----------------------------------------------------*/
    - o1 r+ ?, [) f3 g# N& j! G
55. /* Variable definitions ------------------------------------------------------*/
    9 {' e6 w; {- V* ^; C2 {
56. /* Function declarations -----------------------------------------------------*/
    % V3 a$ G! X+ q5 [7 L
57. RingBuffer *RingBuffer_Malloc(uint32_t size);
    
58. void RingBuffer_Free(RingBuffer *fifo);
    
59. 
    
60. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len);
    $ [* x0 A) d* Q$ U7 r. d' N, a! A
61. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len);
      x: e" R$ N% {; D* g8 N
62. 
    
63. /* Function definitions ------------------------------------------------------*/
    # P/ j2 E" a$ o
64. 
    
65. /**
    
66.   * @brief  Removes the entire FIFO contents.
    ' M3 u! s/ S' i" H/ K* S: g, E
67.   * @param  [in] fifo: The fifo to be emptied.
    
68.   * @return None.
    
69.   */
    $ i$ G& Y" s- s% H6 T- [/ ]
70. static inline void RingBuffer_Reset(RingBuffer *fifo)
    . `' K+ p3 I. L! R0 W" H* _! u
71. {
    
72.   fifo->in = fifo->out = 0;
    ( u0 a1 k9 z- [# ~1 p$ [
73. }
    1 g% ~# H' W, `) A# G
74. 
    
75. /**
      a5 {+ z* @/ D) E* w8 n
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.   */
    & e" z1 T" S1 g
80. static inline uint32_t RingBuffer_Size(RingBuffer *fifo)
    
81. {
    
82.   return fifo->size;
    
83. }
    ) B$ y+ u, b$ k
84. 
    - B& r! A# o- i; |* V
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.
    
89.   */
    " {5 z: e  @+ S  n. ~. X
90. static inline uint32_t RingBuffer_Len(RingBuffer *fifo)
    
91. {
    
92.   return fifo->in - fifo->out;
    
93. }
    
94. 
    
95. /**
    ; h4 u' V  T, P: d! J
96.   * @brief  Returns the number of bytes available in the FIFO.
    
97.   * @param  [in] fifo: The fifo to be used.
    " a5 Z" W0 H& V& W$ S9 M0 F/ `
98.   * @return The number of bytes available.
      z$ x/ F& A8 A6 T1 e
99.   */
    . r0 O; m9 Z/ D: y! I8 V( x5 m) ?# k
100. static inline uint32_t RingBuffer_Avail(RingBuffer *fifo)
     / J( ]! B  O- C
101. {
     
102.   return RingBuffer_Size(fifo) - RingBuffer_Len(fifo);
     
103. }
     
104. 
     
105. /**
     
106.   * @brief  Is the FIFO empty?
     
107.   * @param  [in] fifo: The fifo to be used.
     ; U' G$ p) [% k
108.   * @retval true:      Yes.
     
109.   * @retval false:     No.
     
110.   */
     $ z7 f, k  j+ `1 i
111. static inline bool RingBuffer_IsEmpty(RingBuffer *fifo)
     
112. {
     6 z5 T. \* k/ r
113.   return RingBuffer_Len(fifo) == 0;
     & ]8 N! m! ?$ I
114. }
     
115. 
     1 U8 Q* o# V4 [* h: C
116. /**
     
117.   * @brief  Is the FIFO full?
     
118.   * @param  [in] fifo: The fifo to be used.
     ( N) T, Q. ?4 h& K$ X5 r
119.   * @retval true:      Yes.
     
120.   * @retval false:     No.
     - @/ c( C$ V- V: ~5 A% E9 n& ]
121.   */
     1 R( ^7 M( e/ P
122. static inline bool RingBuffer_IsFull(RingBuffer *fifo)
     
123. {
     6 U3 a% y: ?. m
124.   return RingBuffer_Avail(fifo) == 0;
     6 A1 m4 b8 E" W1 x$ B
125. }
     / d9 g' i- _; L1 c4 [; T5 y
126. 
     ( r- P2 p! @3 H2 y9 T
127. #ifdef __cplusplus
     
128. }
     
129. #endif
       L! u( Y/ d# L% U6 J5 t
130. 
     
131. #endif /* __RINGBUFFER_H */
     

复制代码

$ ~1 K9 G, K* {! CRingBuffer.c 文件

1. <div>/**
   7 R  k* [) q5 d2 R7 q
2.   ******************************************************************************
   5 }# H2 ^# F* Y; J* ]3 s
3.   * @file    RingBuffer.c
   
4.   * @author  XinLi
   ; T; S& e- i  a/ j0 N
5.   * @version v1.1
   
6.   * @date    15-January-2018
   
7.   * @brief   Ring buffer module source file.
   
8.   ******************************************************************************
     d3 e6 ~# o& ^, f9 ^
9.   * @attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    ) i8 W6 k7 |# x- i9 O
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
      r6 r# ]& }  f2 [) G
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    
17.   *
    * N; k/ C( O" _9 v2 d' [2 C6 V
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
    : L3 T! _- z0 f
21.   * GNU General Public License for more details.
    
22.   *
    , r3 Y! q- B& Q4 O+ A
23.   * You should have received a copy of the GNU General Public License
    & A. j( A( b8 m2 m$ d) r( r
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    % Q+ w8 K! q1 q2 `9 P; T6 H% \7 k
25.   *
    
26.   ******************************************************************************
    7 i9 E4 f7 ?5 i( B7 o, K$ O9 p
27.   */
    
28. 
      k0 ^' O. G7 T, ~1 [2 ~
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "RingBuffer.h"
    ' U7 y" J' Q0 P0 m5 e/ X4 `% n
31. #include <string.h>
    1 [" M) t* Y0 M/ d4 k/ Z- I1 G
32. 
    
33. /* Macro definitions ---------------------------------------------------------*/
    
34. #define min(a, b)  (((a) < (b)) ? (a) : (b))
    
35. 
    
36. /* Type definitions ----------------------------------------------------------*/
    
37. /* Variable declarations -----------------------------------------------------*/
    
38. /* Variable definitions ------------------------------------------------------*/
    
39. /* Function declarations -----------------------------------------------------*/
    
40. static bool is_power_of_2(uint32_t x);
    % C, Q! J6 `$ Y) ~
41. static uint32_t roundup_pow_of_two(uint32_t x);
    
42. 
    
43. /* Function definitions ------------------------------------------------------*/
    6 o. I, X7 X; w8 p0 \* O" R  G& m1 f
44. 
    4 a$ M6 q7 w! i+ P3 v+ h% E! S
45. /**
    
46.   * @brief  Allocates a new FIFO and its internal buffer.
    % o, M8 i/ ]) h" @' D  b
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.
    . X6 T% i- N# t- j5 {& A& z+ u
49.   * @return RingBuffer pointer.
    
50.   */
    8 `& k# _& v5 ^, w4 F2 b& V* G
51. RingBuffer *RingBuffer_Malloc(uint32_t size)
    4 f$ D. g' N- A& N+ z& `% [3 a
52. {
    " |. X5 U  ~7 i
53.   RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer));
    7 H; \0 M* a9 I
54. 
    2 m  P$ N6 V( Z$ p; a, o# h7 B7 J
55.   if(fifo != NULL)
    
56.   {
    : I4 n6 E8 Y- O5 z* E1 I  s
57.     if(is_power_of_2(size) != true)
    
58.     {
    6 \% b; Y2 Q9 ]- G% w5 t% t
59.       if(size > 0x80000000UL)
    / Z# U2 s: t& Y3 Y: z3 d
60.       {
    
61.         RING_BUFFER_FREE(fifo);
      A# C" }! m: d/ s! ?1 v% b) Y
62.         return NULL;
    + u9 z  M3 X3 d( U! F( V% Y
63.       }
    
64. 
    ( r& E  j( V$ R
65.       size = roundup_pow_of_two(size);
    
66.     }
    7 r9 Z( `2 n3 @- D/ j. q
67. 
    
68.     fifo->buffer = RING_BUFFER_MALLOC(size);
    . f6 i' W  W$ F# B8 N
69. 
    * [* O9 B% d" s- ?
70.     if(fifo->buffer == NULL)
    8 e$ t" U- A' `/ o( R; ^1 ?+ W  H
71.     {
    
72.       RING_BUFFER_FREE(fifo);
    
73.       return NULL;
    4 I, t# Z  e# S, I3 x
74.     }
    
75. 
    
76.     fifo->size = size;
    6 }! j6 |6 S8 [! D
77.     fifo->in = fifo->out = 0;
    
78.   }
    0 ^+ J6 j8 g* S& r# ^, W$ w
79. 
    
80.   return fifo;
    
81. }
    
82. 
    , ]: n+ ]/ v: Z$ X& d8 H
83. /**
    ) S# B2 x# J" _! m
84.   * @brief  Frees the FIFO.
    
85.   * @param  [in] fifo: The fifo to be freed.
      @" K+ J1 x* r
86.   * @return None.
    
87.   */
    / @7 @# w1 j$ G# H" }) ]
88. void RingBuffer_Free(RingBuffer *fifo)
    
89. {
    6 Q% N: x& R8 S5 C
90.   RING_BUFFER_FREE(fifo->buffer);
    7 A# `$ g  [* n4 X" s" q. Z
91.   RING_BUFFER_FREE(fifo);
    
92. }
    $ X+ |6 ?! V6 U% ~4 V9 n- Y4 ~
93. 
    ; x7 {6 \' C$ N: b) {
94. /**
    ' ^) h; w9 ~$ s. [  |* G
95.   * @brief  Puts some data into the FIFO.
    
96.   * @param  [in] fifo: The fifo to be used.
    
97.   * @param  [in] in:   The data to be added.
    
98.   * @param  [in] len:  The length of the data to be added.
    7 g$ L3 {: p4 t& P( c
99.   * @return The number of bytes copied.
    
100.   * @note   This function copies at most @len bytes from the @in into
     
101.   *         the FIFO depending on the free space, and returns the number
     
102.   *         of bytes copied.
     
103.   */
     $ a$ U1 n+ v/ d# e
104. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len)
     
105. {
     , d( z# x: e( [( ?$ ^& Z
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);
     
111. 
     $ B8 a0 J1 ~8 v$ |
112.   /* Then put the rest (if any) at the beginning of the buffer. */
     " i; Y9 x5 @' E! ^/ Q+ U. C7 h
113.   memcpy(fifo->buffer, (uint8_t *)in + l, len - l);
     - [( @& l" m- ?5 s; P9 K
114. 
     
115.   fifo->in += len;
     3 G: O3 q" h$ ^0 W2 ^- a
116. 
     7 |" `/ f( x- r$ B
117.   return len;
     : a; r7 u* {2 |5 d$ h8 Q# V
118. }
     . ^; H: z/ g' F$ k% ]/ E
119. 
     : E* _) ^2 |: ~5 l3 Q* T) R( e
120. /**
     
121.   * @brief  Gets some data from the FIFO.
     
122.   * @param  [in] fifo: The fifo to be used.
     
123.   * @param  [in] out:  Where the data must be copied.
     5 \* q! c: m% ?8 Y6 c
124.   * @param  [in] len:  The size of the destination buffer.
     9 Y3 p- D4 v/ d- d1 I7 L
125.   * @return The number of copied bytes.
     ( E) J5 V/ }3 i/ N/ t" L/ c4 l
126.   * @note   This function copies at most @len bytes from the FIFO into
     0 Z0 w, b: ^3 `9 o4 ~
127.   *         the @out and returns the number of copied bytes.
     
128.   */
     
129. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len)
     3 O. t& O1 M& G: Q3 S) `
130. {
     
131.   len = min(len, RingBuffer_Len(fifo));
     
132. 
     
133.   /* First get the data from fifo->out until the end of the buffer. */
     2 g$ r; G; @5 J! A+ E8 n: }
134.   uint32_t l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
     
135.   memcpy(out, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
     8 {1 @' A. Z9 |$ u) g0 f
136. 
     
137.   /* Then get the rest (if any) from the beginning of the buffer. */
     9 J' x& x0 n9 i) \0 T
138.   memcpy((uint8_t *)out + l, fifo->buffer, len - l);
     3 C& J- U( A. B) L1 Y* V
139. 
     
140.   fifo->out += len;
     - x( B! o3 [, [8 ]# y' j3 l* U$ e
141. 
     
142.   return len;
     + G" Q  Z& d' A) d1 U* I. [; t
143. }
     0 {2 F1 H! M. m, B( ^2 c
144. 
     ; u0 U. W* F0 J$ }! M9 W: D* F$ Q
145. /**
     
146.   * @brief  Determine whether some value is a power of two.
     
147.   * @param  [in] x: The number to be confirmed.
     6 w4 X) \7 _, o
148.   * @retval true:   Yes.
     & U1 O9 l& O& k- t
149.   * @retval false:  No.
     ( t0 d. T  X% J9 I
150.   * @note   Where zero is not considered a power of two.
     6 v% W" h- R7 Z& ^! k
151.   */
     
152. static bool is_power_of_2(uint32_t x)
     , v9 J) X0 p4 d
153. {
     
154.   return (x != 0) && ((x & (x - 1)) == 0);
     
155. }
     
156. 
     
157. /**
     
158.   * @brief  Round the given value up to nearest power of two.
     
159.   * @param  [in] x: The number to be converted.
     & A4 P1 n. E. n/ [6 [1 i
160.   * @return The power of two.
     * Y" _) c! M" Y; d# a$ R6 Q* _
161.   */
     
162. static uint32_t roundup_pow_of_two(uint32_t x)
     + E' ?2 }6 M: B$ e* ^7 I
163. {
     
164.   uint32_t b = 0;
     
165. 
     , E6 [6 l+ A4 {" `
166.   for(int i = 0; i < 32; i++)
     
167.   {
     1 v5 N: n4 L4 n& G2 Q) ^. u' ^
168.     b = 1UL << i;
     ; {- X$ w0 S/ D1 b: \1 e
169. 
     1 {0 d, g2 c; f) m9 r  U% r2 P4 `3 @
170.     if(x <= b)
     
171.     {
     
172.       break;
     
173.     }
     
174.   }
     . [% }/ A+ \$ e3 B8 r: E3 ?
175. 
     # I: ]/ i& \  m4 u& z
176.   return b;
     
177. }</div><div></div>

复制代码

: P8 [0 H4 h5 d8 P
CAN.h 文件

1. /**
   " R2 l  U$ [. G7 Z  K
2.   ******************************************************************************
   ( t, X2 ~. C3 D" Q; _
3.   * @file    CAN.h
   
4.   * @author  XinLi
   
5.   * @version v1.0
   
6.   * @date    24-June-2018
   * k- B' _, {8 y. M4 `& h
7.   * @brief   Header file for CAN.c module.
   
8.   ******************************************************************************
   # o7 b& _3 Y. m
9.   * @attention
   
10.   *
      D5 E1 g) s- y3 _4 B( P
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    : [9 H. L$ n7 U4 D9 F
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    5 w+ X0 P% ^* h+ f% ~. N
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.
    6 Z" c  X  t6 z" s" x
17.   *
    " S+ c% Y3 [1 h4 U) T
18.   * This program is distributed in the hope that it will be useful,
    7 [& g& N9 J+ P! o' y
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    1 e1 K8 f+ R6 S2 t  ?) G
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    + g( _3 h( r! ]
22.   *
    9 W! I- e' S/ W( e: \# q# S2 c
23.   * You should have received a copy of the GNU General Public License
    . A3 p/ H# c( V( n9 N+ I: N% p; m
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    
25.   *
    , ?+ M8 W1 F, |8 I( R: F, z
26.   ******************************************************************************
    & v6 h& Z( v7 V9 K$ C7 G, l
27.   */
    
28. 
    ) s6 R& G9 H/ X4 k7 B: ?1 L
29. #ifndef __CAN_H
    ' G4 _1 N7 u0 o( _: {+ I
30. #define __CAN_H
    7 B9 e. F8 _1 [' q* a7 k! X
31. 
    
32. #ifdef __cplusplus
    
33. extern "C" {
    6 L  Z0 g$ I$ l
34. #endif
    
35. 
    
36. /* Header includes -----------------------------------------------------------*/
    
37. #include "stm32f10x.h"
    
38. #include <stdbool.h>
    : t$ _/ T( n3 Q. m
39. 
    
40. /* Macro definitions ---------------------------------------------------------*/
    
41. 
    
42. /******************************* CAN1 Configure *******************************/
    
43. #define CAN1_TX_BUFFER_SIZE        (16)
    , T8 g6 W: ^9 t6 c$ j& S) S
44. #define CAN1_RX_BUFFER_SIZE        (16)
    
45. 
    
46. #define CAN1_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    - T5 C! F1 |, J  V  N# A% {: F! \
47. #define CAN1_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    ! ?& y2 }2 n4 q( q/ I
48. 
    
49. #define CAN1_TX_GPIO_PORT          GPIOB
    
50. #define CAN1_RX_GPIO_PORT          GPIOB
    
51. 
    * @& N) c# I, w! A! o
52. #define CAN1_TX_GPIO_PIN           GPIO_Pin_9
    , b0 E! g6 U2 w/ n$ W+ D
53. #define CAN1_RX_GPIO_PIN           GPIO_Pin_8
    
54. 
    
55. #define CAN1_IRQ_PREEMPT_PRIORITY  (0)
    
56. #define CAN1_IRQ_SUB_PRIORITY      (0)
    ! z0 h4 R$ A& r
57. 
    
58. #define CAN1_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap1_CAN1 , ENABLE)
    & O" y+ `& Y6 o9 O
59. /******************************************************************************/
    
60. 
    ! `. z! j. N+ @
61. #ifdef STM32F10X_CL
    1 |1 c! e( q  }2 N$ v! V. `
62. /******************************* CAN2 Configure *******************************/
    
63. #define CAN2_TX_BUFFER_SIZE        (16)
    ( U* Z! |) f5 Z* S
64. #define CAN2_RX_BUFFER_SIZE        (16)
    
65. 
    
66. #define CAN2_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    8 p- ]3 p2 H7 Z, S1 |1 }0 K7 \
67. #define CAN2_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    ) i- t7 P+ ?2 N( k! J
68. 
    / s6 c7 A/ x( p' ?5 K+ O9 u7 [* j
69. #define CAN2_TX_GPIO_PORT          GPIOB
    3 P- E1 g8 o9 n3 n: ~- ^8 h
70. #define CAN2_RX_GPIO_PORT          GPIOB
    
71. 
    * R8 y) i/ Z5 Q+ m- V4 @6 m4 m
72. #define CAN2_TX_GPIO_PIN           GPIO_Pin_13
    
73. #define CAN2_RX_GPIO_PIN           GPIO_Pin_12
    % k7 Q1 M  B: P2 v& k4 H0 O2 [
74. 
    : o9 L( h1 R! f$ B0 L
75. #define CAN2_IRQ_PREEMPT_PRIORITY  (0)
    8 b$ b* E  ^$ G
76. #define CAN2_IRQ_SUB_PRIORITY      (0)
    
77. 
    ; w# ?/ l' B; q9 y  j
78. #define CAN2_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap_CAN2 , DISABLE)
    5 N! F4 i  a( _" z5 D* q" r' E1 T
79. /******************************************************************************/
    
80. #endif /* STM32F10X_CL */
    
81. 
    
82. /* Type definitions ----------------------------------------------------------*/
    
83. typedef enum
    6 L, j8 {& T2 K# V2 i  f* V7 k
84. {
    8 h+ U# n  p9 s. [
85.   CAN_WorkModeNormal   = CAN_Mode_Normal,
    
86.   CAN_WorkModeLoopBack = CAN_Mode_LoopBack
    
87. }CAN_WorkMode;
    
88. 
    ! v2 k9 c7 x4 [" w- f9 [
89. typedef enum
    : m5 |: x( A+ u6 r* ?% i' p
90. {
    2 x) e7 P6 ]; F7 j- V- S! N" \
91.   CAN_BaudRate1000K = 6,
    
92.   CAN_BaudRate500K  = 12,
    
93.   CAN_BaudRate250K  = 24,
    ; V* l8 _/ B; v
94.   CAN_BaudRate125K  = 48,
    
95.   CAN_BaudRate100K  = 60,
    * H5 E7 K+ Z6 k, W+ a, V* ?
96.   CAN_BaudRate50K   = 120,
    9 o& @6 i: F; Y& ]6 l
97.   CAN_BaudRate20K   = 300,
    
98.   CAN_BaudRate10K   = 600
    9 M5 M& S& q+ u  p- \- n& i$ }! i
99. }CAN_BaudRate;
    
100. 
     
101. /* Variable declarations -----------------------------------------------------*/
     7 i. S) N1 M9 D) b
102. /* Variable definitions ------------------------------------------------------*/
     
103. /* Function declarations -----------------------------------------------------*/
     4 v# S& r1 |2 e6 O! I
104. void CAN_Configure(CAN_TypeDef *CANx, CAN_WorkMode WorkMode, CAN_BaudRate BaudRate, uint32_t StdId, uint32_t ExtId);
     1 [5 ]( z+ }. H; l# T( l
105. void CAN_Unconfigure(CAN_TypeDef *CANx);
     
106. 
     
107. void CAN_SetTransmitFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     
108. void CAN_SetReceiveFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     9 ~* d9 C& }) \
109. 
     
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);
     # G8 G8 ^, I/ n- p) ~  H
112. 
     , \5 f4 H' T9 h! [, i5 \
113. uint32_t CAN_GetUsedTransmitBufferSize(CAN_TypeDef *CANx);
     
114. uint32_t CAN_GetUsedReceiveBufferSize(CAN_TypeDef *CANx);
     3 U! @$ P% K* p6 P; ?. m
115. uint32_t CAN_GetUnusedTransmitBufferSize(CAN_TypeDef *CANx);
     " ?3 K' e! J% U2 O& \  l/ o
116. uint32_t CAN_GetUnusedReceiveBufferSize(CAN_TypeDef *CANx);
     
117. 
       y& q, X0 o  j! [
118. bool CAN_IsTransmitBufferEmpty(CAN_TypeDef *CANx);
     
119. bool CAN_IsReceiveBufferEmpty(CAN_TypeDef *CANx);
     ( W/ g$ {  `! J. `& r- {. N& c4 C* p
120. bool CAN_IsTransmitBufferFull(CAN_TypeDef *CANx);
     5 [! A* l$ r! H" U' I, B
121. bool CAN_IsReceiveBufferFull(CAN_TypeDef *CANx);
     " `2 l7 @) M+ V
122. 
     + H1 K; b. ~  n
123. void CAN_ClearTransmitBuffer(CAN_TypeDef *CANx);
     ' ~# T8 d7 |' @& W8 [
124. void CAN_ClearReceiveBuffer(CAN_TypeDef *CANx);
     , k) p/ o6 n0 F. I
125. 
     
126. bool CAN_IsTransmitMessage(CAN_TypeDef *CANx);
     1 d9 H1 q7 \1 A) D% s
127. 
     
128. /* Function definitions ------------------------------------------------------*/
     * e) q9 `: [# T
129. 
     
130. #ifdef __cplusplus
     5 {# K3 n- v6 O& s5 e8 e
131. }
     * M5 Z7 ?4 |3 p. l% {& {
132. #endif
     8 A; _8 g  x. A, A9 a4 ~
133. 
     + a- y: g; w8 s0 E, \: B' \
134. #endif /* __CAN_H */
     

复制代码

' u& h  }, l- U: u) Q0 a% B% ECAN.c 文件
8 \% |" U6 Y0 A! `* t+ {/ ~

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

复制代码

# W9 F8 z4 y7 {4 O  lmain.h 文件

1. /**
   : O  E. c2 g8 l9 z6 K5 D
2.   ******************************************************************************
   
3.   * @file    main.h
   6 D0 `2 Y4 ^6 p' C1 @% ~% H
4.   * @author  XinLi
   ; _: ^) t, L$ G% i1 G7 [
5.   * @version v1.0
   
6.   * @date    24-June-2018
   . e( F) U; q" T0 ?
7.   * @brief   Header file for main.c module.
   4 |- d3 z8 B8 p; a  h- P
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    4 G* L2 j2 S. i; U
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    9 ?6 w3 x: e/ F0 b4 U. i) ]
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
    1 Q- M' v( a7 F/ E0 ~1 M" {  M
15.   * the Free Software Foundation, either version 3 of the License, or
    5 y- W+ e9 y, r/ Z" D: t' I
16.   * (at your option) any later version.
    ; H! G- y0 `8 X6 |! o# q& i
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
      n: ], r& V1 }2 l) H/ F  ~' q
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    ; t2 v7 P$ x4 l
22.   *
    # S/ V5 O0 ?8 K
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.   *
    % D5 ^; U) P0 Q
26.   ******************************************************************************
    7 [2 \' Q6 q. A! O. f
27.   */
    
28. 
    " `' V4 W7 _  \
29. #ifndef __MAIN_H
    ) j9 f/ v$ J+ v( h3 s$ A6 ^% @
30. #define __MAIN_H
    ' B2 d+ ^( [* z8 M
31. 
    2 i! l9 ~0 r' E0 x
32. #ifdef __cplusplus
    1 G7 D: x+ @, z8 l+ h$ V7 N
33. extern "C" {
    + h2 i! O/ G: H" ~
34. #endif
    $ Z: P. L" C/ W& ?/ k  e9 [, z
35. 
      s  l; F. ^" I/ X* Q
36. /* Header includes -----------------------------------------------------------*/
    9 F# [! U: O6 }/ K. P' @8 u% @
37. #include "stm32f10x.h"
    
38. 
    & k' m6 X" H6 ]  ~$ I4 r
39. /* Macro definitions ---------------------------------------------------------*/
    
40. /* Type definitions ----------------------------------------------------------*/
    
41. /* Variable declarations -----------------------------------------------------*/
    
42. /* Variable definitions ------------------------------------------------------*/
    / j% f6 R$ f  R! I" O1 U: E6 X
43. /* Function declarations -----------------------------------------------------*/
    
44. /* Function definitions ------------------------------------------------------*/
    
45. 
    
46. #ifdef __cplusplus
    ( }* T* W5 l$ \, K: [& S; d
47. }
    5 Y7 ?8 D1 ]  T. Z9 p- g# u
48. #endif
    
49. 
    
50. #endif /* __MAIN_H */

复制代码

* z; r1 Y+ f  i. H! |main.c 文件
  D" p+ \; D( I" d# [& v: c

1. /**
   5 l6 \1 I3 M+ N: i# g  w- R
2.   ******************************************************************************
   
3.   * @file    main.c
   - u3 i3 g1 W7 E1 k' _' R
4.   * @author  XinLi
   
5.   * @version v1.0
   6 L# _% b1 Z+ U  I# q* Y
6.   * @date    24-June-2018
   * f% M+ v& G  `2 W6 J/ A. q
7.   * @brief   Main program body.
   
8.   ******************************************************************************
   ( O2 U/ Q" l# \3 |; f
9.   * @attention
   
10.   *
    9 R; Y* H; N2 r; z+ n! J
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    . @, |9 e" U! U& A+ n8 t
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    ! s5 s/ f) ^8 c
14.   * it under the terms of the GNU General Public License as published by
    # w+ D4 T) F+ U5 z# }0 e
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    - {) U! c1 N' V' j5 y( |! [3 {
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
      S. o% M' E8 o$ w. |0 O& k
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    , L4 ?; F, T- v* q) J
22.   *
    & S& z4 b; S$ U* t' u
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>
    5 ]5 i9 H8 x4 J) f, k# A$ a: {' N
25.   *
    % B* b# X% ?7 P0 c% K
26.   ******************************************************************************
    : J6 b) E6 Q6 c7 Y$ q
27.   */
    
28. 
    
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "main.h"
    # x4 U2 o! l( j8 Q( \! m# |
31. #include "CAN.h"
    8 p' K! F1 T1 a; ^
32. 
    
33. #ifdef _RTE_
    
34. #include "RTE_Components.h"
    * ?0 W% ]: d/ |! G* N' }
35. #endif
    : w! Z. c' B* F0 E/ h. j! V
36. 
    : ?0 t* V2 s3 x/ g4 r& S
37. #ifdef RTE_CMSIS_RTOS2
    * c# @' H5 f: d) k! t
38. #include "cmsis_os2.h"
    
39. #endif
    - @% S0 I0 D: {( c
40. 
    
41. /* Macro definitions ---------------------------------------------------------*/
    5 F! O! S! l; ?; N' Z- S  e
42. /* Type definitions ----------------------------------------------------------*/
    
43. /* Variable declarations -----------------------------------------------------*/
    1 k# s, [  T1 n: o
44. /* Variable definitions ------------------------------------------------------*/
    . g% K! L; I" L3 E
45. static CanTxMsg canTxMsg = {0};
    
46. static CanRxMsg canRxMsg = {0};
    $ c5 Y. H1 u2 P6 k7 T
47. 
    , y, J5 M  b' m% ?3 r
48. /* Function declarations -----------------------------------------------------*/
    
49. static void SystemClock_Config(void);
    
50. 
    
51. /* Function definitions ------------------------------------------------------*/
    4 [; B* L; U" H3 `& J
52. 
    # m8 g% D; J( r! z! g, w
53. /**
    2 j) c& \) @: Y; h( W
54.   * @brief  Main program.
    
55.   * @param  None.
    
56.   * @return None.
    
57.   */
    
58. int main(void)
    1 t* J8 }0 z2 c: k5 q
59. {
    
60.   /* Configure the system clock to 72 MHz */
    8 T+ U  R' K1 f& e
61.   SystemClock_Config();
    " }6 W: [" B: k
62.   SystemCoreClockUpdate();
    0 ~% W  F5 s) S4 P9 ]
63. 
    
64.   /* Add your application code here */
    
65.   CAN_Configure(CAN1, CAN_WorkModeLoopBack, CAN_BaudRate250K, 0xAA55, 0x55AA);
    4 T! {! Z7 V* |9 h8 q
66. 
    
67. #ifdef RTE_CMSIS_RTOS2
    + |7 e6 S2 G/ J- V+ q
68.   /* Initialize CMSIS-RTOS2 */
    
69.   osKernelInitialize();
    
70. 
    
71.   /* Create thread functions that start executing,
    1 j' b: E3 Q: L; m. z4 P
72.   Example: osThreadNew(app_main, NULL, NULL); */
    
73. 
    , ^  G7 L* R$ s" H
74.   /* Start thread execution */
    
75.   osKernelStart();
    3 {1 N- W) u0 F( W" r  E& n+ j2 v
76. #endif
    , a$ G/ ~4 i% f: k. M+ O( K" ?
77. 
    
78.   /* Infinite loop */
    
79.   while(1)
    
80.   {
    
81.     canTxMsg.StdId = 0xAA55;
    
82.     canTxMsg.ExtId = 0x55AA;
    
83.     canTxMsg.IDE   = CAN_ID_STD;
    5 T0 c: n4 I+ ?% C/ q
84.     canTxMsg.RTR   = CAN_RTR_DATA;
    ) l- H. s8 l; ]% K/ b
85.     canTxMsg.DLC   = 8;
    
86. 
    
87.     canTxMsg.Data[0]++;
    
88.     canTxMsg.Data[1]++;
    
89.     canTxMsg.Data[2]++;
    - F( ?& b1 T0 n- x: B
90.     canTxMsg.Data[3]++;
    
91.     canTxMsg.Data[4]++;
    
92.     canTxMsg.Data[5]++;
    . P+ [0 Q2 q$ a2 B- |% L0 c
93.     canTxMsg.Data[6]++;
    1 b  w/ H3 c. ^! x& c. }
94.     canTxMsg.Data[7]++;
    
95. 
    
96.     CAN_SetTransmitMessage(CAN1, &canTxMsg, 1);
    - \5 w' b  A# q9 Z9 R0 K
97. 
    
98.     while(CAN_IsReceiveBufferEmpty(CAN1) == true);
    , p  P7 L: O- X# |( F
99. 
    
100.     CAN_GetReceiveMessage(CAN1, &canRxMsg, 1);
     
101.   }
     
102. }
     
103. 
     
104. /**
     
105.   * @brief  System Clock Configuration.
     
106.   *         The system Clock is configured as follow :
     
107.   *            System Clock source            = PLL (HSE)
     - Q% q8 i% Y* |. V, X
108.   *            SYSCLK(Hz)                     = 72000000
     ; w; t& A# l/ Y3 ~
109.   *            HCLK(Hz)                       = 72000000
     5 i* k/ y0 f1 ?6 y$ e5 \1 k$ }
110.   *            AHB Prescaler                  = 1
     
111.   *            APB1 Prescaler                 = 2
     
112.   *            APB2 Prescaler                 = 1
       {7 G# J: _2 Q7 a
113.   *            HSE Frequency(Hz)              = 8000000
     6 ~/ ?% [4 R# _& f# F" i
114.   *            HSE PREDIV1                    = 1
     # w- R4 T  ]. {2 ?6 l
115.   *            PLLMUL                         = 9
     
116.   *            Flash Latency(WS)              = 2
     / ^- V- x: V" Y! t: b
117.   * @param  None.
     ) W' ~+ A# C# k" I! }4 i3 ^
118.   * @return None.
     
119.   */
     + J+ P( ?% Q- ]. S7 x5 u7 a1 x
120. static void SystemClock_Config(void)
     , o6 x/ w- [. J( w
121. {
     
122.   /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration */
     
123.   /* RCC system reset */
     . S4 [$ }# N1 b  ]8 V
124.   RCC_DeInit();
     # j# X$ H8 M1 S7 b4 B0 o, a
125. 
     + C5 J; V+ L! N: m( D+ p4 \4 d( x
126.   /* Enable HSE */
     9 `* F' d" [" o% v2 M+ i% n: H
127.   RCC_HSEConfig(RCC_HSE_ON);
     
128. 
     $ e8 X* b+ m0 ]8 C
129.   /* Wait till HSE is ready */
     
130.   ErrorStatus HSEStartUpStatus = RCC_WaitForHSEStartUp();
     
131. 
     
132.   if(HSEStartUpStatus == SUCCESS)
     % q2 b+ U% `; ^5 z
133.   {
     
134.     /* Enable Prefetch Buffer */
     ! S4 y- Z/ M: i* S' C
135.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     % a% @5 f" j  z+ D2 X2 W! ~; m
136. 
     
137.     /* Flash 2 wait state */
     
138.     FLASH_SetLatency(FLASH_Latency_2);
     
139. 
     ! b' F  i4 v% a" b6 Q" u
140.     /* HCLK = SYSCLK */
     ! }' S" r8 y, A8 R. b. J; N- I
141.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     
142. 
     8 N2 E3 u" z* D! r9 s, m
143.     /* PCLK2 = HCLK */
     , |+ R* X% m9 y3 [9 w6 P
144.     RCC_PCLK2Config(RCC_HCLK_Div1);
     9 _% q/ @; m, O( D. \: @
145. 
     ! d% N9 D7 C7 o3 U
146.     /* PCLK1 = HCLK / 2 */
     
147.     RCC_PCLK1Config(RCC_HCLK_Div2);
     
148. 
     
149.     /* Configure PLLs */
     
150. #ifdef STM32F10X_CL
     
151.     /* PLL2 configuration: PLL2CLK = (HSE(8MHz) / 2) * 10 = 40MHz */
     
152.     RCC_PREDIV2Config(RCC_PREDIV2_Div2);
     
153.     RCC_PLL2Config(RCC_PLL2Mul_10);
     
154. 
     ( F7 A$ ~1 W7 C/ Q8 X
155.     /* Enable PLL2 */
     + g  A6 i( g  E+ N# E" N" ]: Y9 |, r
156.     RCC_PLL2Cmd(ENABLE);
     
157. 
     
158.     /* Wait till PLL2 is ready */
     
159.     while(RCC_GetFlagStatus(RCC_FLAG_PLL2RDY) == RESET);
     
160. 
     
161.     /* PLL configuration: PLLCLK = (PLL2(40MHz) / 5) * 9 = 72MHz */
     
162.     RCC_PREDIV1Config(RCC_PREDIV1_Source_PLL2, RCC_PREDIV1_Div5);
     $ Z5 a$ R9 E& I9 q
163.     RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_9);
     " Y% M( c" ^' N! _
164. #else
     
165.     /* PLLCLK = HSE(8MHz) * 9 = 72MHz */
     
166.     RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
     
167. #endif
     ' s, _2 D9 z  H% `
168. 
     4 g: l7 d$ x0 w0 z2 V. ]' X; b2 e/ K
169.     /* Enable PLL */
     
170.     RCC_PLLCmd(ENABLE);
     
171. 
     
172.     /* Wait till PLL is ready */
     
173.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     
174. 
     5 M( Q5 Q0 A# @
175.     /* Select PLL as system clock source */
     
176.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     : U1 c! y+ L% G
177. 
     
178.     /* Wait till PLL is used as system clock source */
     $ ^- _0 ?  l- I
179.     while(RCC_GetSYSCLKSource() != 0x08);
     
180.   }
     
181.   else
     
182.   {
     
183.     /* Disable HSE */
     ( [. v! ?% e8 L3 d8 k
184.     RCC_HSEConfig(RCC_HSE_OFF);
     
185. 
     5 {8 W" `$ j- n2 c8 K0 q
186.     /* Enable HSI */
     
187.     RCC_HSICmd(ENABLE);
     
188. 
     2 D" R5 l8 Q% }4 ]
189.     /* Enable Prefetch Buffer */
     * s9 o+ p# a6 [$ ~
190.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     
191. 
     
192.     /* Flash 1 wait state */
     
193.     FLASH_SetLatency(FLASH_Latency_1);
     7 N6 u# e) A( u  n6 ^- U7 M
194. 
     + i, a' l! _3 c
195.     /* HCLK = SYSCLK */
     3 |1 T) R7 S4 }4 z2 m& |/ D
196.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     4 r8 J' ^7 h* |6 _
197. 
     ) n9 m* f, t6 G% U2 E: b
198.     /* PCLK2 = HCLK */
     
199.     RCC_PCLK2Config(RCC_HCLK_Div1);
     ; n. |8 v# Y8 O, D/ F/ z% q' ~
200. 
     $ n$ R( M) Z2 ?4 E
201.     /* PCLK1 = HCLK */
     6 i3 `  F) v8 F( V' q+ Z- u
202.     RCC_PCLK1Config(RCC_HCLK_Div1);
     
203. 
     
204.     /* Configure PLLs */
     7 C2 r! m+ b! d& R0 o: q: G
205.     /* PLLCLK = HSI(8MHz) / 2 * 9 = 36MHz */
     9 |8 |% }( m& c
206.     RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_9);
     " n% D' {5 a! b
207. 
     $ U. \/ |  T# C) k" I/ l
208.     /* Enable PLL */
     
209.     RCC_PLLCmd(ENABLE);
     ' j( h+ u+ R9 ~7 ^7 ~6 S, S( G
210. 
     
211.     /* Wait till PLL is ready */
     
212.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     : a- w1 b  q) V/ h* ?
213. 
     
214.     /* Select PLL as system clock source */
     4 c+ E  a% }0 M& V
215.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     3 n. i* y# i! E- I! S% _' I6 }* z' [
216. 
     ! R( I  s8 d0 P- M, X+ }2 {
217.     /* Wait till PLL is used as system clock source */
     
218.     while(RCC_GetSYSCLKSource() != 0x08);
     
219.   }
     ! W5 e' z' k7 i0 j/ _
220. }
     : s) B: K6 k4 I
221. 
     
222. #ifdef USE_FULL_ASSERT
     
223. /**
     
224.   * @brief  Reports the name of the source file and the source line number
     + _% _* A5 k0 a8 X
225.   *         where the assert_param error has occurred.
     
226.   * @param  file: pointer to the source file name.
     ) I3 W$ y$ {9 n
227.   * @param  line: assert_param error line source number.
     : s  j; \  R- j+ d+ r, h
228.   * @return None.
     # g8 s: k* X" l- b
229.   */
     
230. void assert_failed(uint8_t *file, uint32_t line)
     5 m$ X$ O$ B* O# c- a3 ~
231. {
     " U4 x9 s$ n8 |2 F* S8 H
232.   /* User can add his own implementation to report the file name and line number,
     
233.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     
234. 
     + a% M2 E0 D3 L8 e2 v- [: S
235.   /* Infinite loop */
     
236.   while(1)
     ) O! L; g9 P" w! k4 Z5 V/ z+ U
237.   {
     
238.   }
     
239. }
     # d) k% I( [: E6 N! \3 X* R
240. #endif

复制代码

3，注意

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

2 Q2 |# G9 m  I2 n0 Z- D! ?( p
, o8 J$ q6 G  r+ k; R