1，开发环境

1，固件库：STM32F10x_StdPeriph_Lib_V3.5.0

0 T; C$ r: T% T9 l4 |0 `2，编译器：ARMCC V5.06
& A2 `( X% X; y
( J& \0 o2 t0 k3 T. m$ a" E3，IDE：Keil uVision5
, Y$ x$ t: e& j/ V/ k
4，操作系统：Windows 10 专业版


- @/ y- w1 ?2 A! Z  n* M2，程序源码
1 X/ z+ C+ [- B, _& J. M- }2 b, |
! r9 f* k3 v8 ?* L* ERingBuffer.h 文件

1. /**
   , F( M& r% F( ~0 f
2.   ******************************************************************************
   . \$ ~: |# x$ Z% {
3.   * @file    RingBuffer.h
   " q7 s- r* K+ Z! v
4.   * @author  XinLi
   / a4 q3 G( k4 V# @: ]
5.   * @version v1.1
   
6.   * @date    15-January-2018
   9 Z/ u, X" K& i  S" g3 d, c4 ]+ l& l
7.   * @brief   Header file for RingBuffer.c module.
   
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    8 L. r. v+ A; {' G3 v; R
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    / W( `5 ?- ^$ v# `( N( ^
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    % ?9 R0 B3 K1 {/ H
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
      P* m. b1 [% ?" s( ]5 U
16.   * (at your option) any later version.
    9 |, D1 s5 e& s3 s5 M! d  Y
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    / ]; J1 v, m' h3 v. _# y: a
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.
    - V9 ?) u5 l/ _" t2 u& u
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    8 T2 |0 Z% ?& D: o  }+ O9 h2 d
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    # e3 Y$ ~; g$ Q& k: ^3 {
25.   *
    
26.   ******************************************************************************
    
27.   */
    
28. 
    
29. #ifndef __RINGBUFFER_H
    
30. #define __RINGBUFFER_H
    
31. 
    
32. #ifdef __cplusplus
    7 a) `* K, N9 k' U4 P, D
33. extern "C" {
    ( k/ s- w! l: S6 g2 c4 Z. J! f1 Q
34. #endif
    
35. 
    
36. /* Header includes -----------------------------------------------------------*/
    
37. #include <stdint.h>
    
38. #include <stdbool.h>
    
39. #include <stdlib.h>
    
40. 
    ! {* q; Z% X- V; W* m
41. /* Macro definitions ---------------------------------------------------------*/
    5 o3 ]- Y# C5 t+ m( T8 Y3 P! S6 s
42. #define RING_BUFFER_MALLOC(size)  malloc(size)
    7 L; A, s* C' @+ ?
43. #define RING_BUFFER_FREE(block)   free(block)
      V$ d/ B! S/ `/ O* K/ U% ^
44. 
    
45. /* Type definitions ----------------------------------------------------------*/
    $ u4 L; o+ M+ }2 z, E! X7 `
46. typedef struct
    / z) q/ s7 ^, ?# k% r3 s
47. {
    ( g. c- ?8 `1 e/ G2 Z( ?/ ^9 L  R
48.   uint8_t *buffer;
    
49.   uint32_t size;
    : g% c  B+ G' \5 j3 o* ]
50.   uint32_t in;
    
51.   uint32_t out;
    
52. }RingBuffer;
    5 K5 N& Z9 f5 n" ?  j
53. 
    
54. /* Variable declarations -----------------------------------------------------*/
      C2 H3 f& {* C, h$ L/ z5 v
55. /* Variable definitions ------------------------------------------------------*/
    4 ~" Y+ e& q' k
56. /* Function declarations -----------------------------------------------------*/
    
57. RingBuffer *RingBuffer_Malloc(uint32_t size);
    
58. void RingBuffer_Free(RingBuffer *fifo);
    & m3 I4 r  l7 |1 i% r
59. 
    0 e  P5 U6 Q5 @) M( `
60. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len);
    
61. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len);
    ( _  s7 W' ^5 t
62. 
    & o9 V; q% V4 d# W' P. {) X
63. /* Function definitions ------------------------------------------------------*/
    4 f2 e5 O' {, j. G% i/ T- h
64. 
    4 F  B) K4 R' q  z9 z" ^2 m* K
65. /**
    3 {: K. l8 n) x% `1 B
66.   * @brief  Removes the entire FIFO contents.
    # K5 ?. k8 _9 Q- J; i% z8 v  V, H
67.   * @param  [in] fifo: The fifo to be emptied.
    
68.   * @return None.
    
69.   */
    % r$ b' _+ G3 @. b3 O
70. static inline void RingBuffer_Reset(RingBuffer *fifo)
    3 I% I/ d' d5 ^1 E* G9 s0 M) ?* T3 v
71. {
    
72.   fifo->in = fifo->out = 0;
    * M: C  k$ P& q( q  R
73. }
    # R; [8 M8 X/ V2 k/ W
74. 
    . Z. ~  E; }! G& V
75. /**
    
76.   * @brief  Returns the size of the FIFO in bytes.
    0 v* T& V: k% q$ n# P: d% f
77.   * @param  [in] fifo: The fifo to be used.
    
78.   * @return The size of the FIFO.
    
79.   */
    
80. static inline uint32_t RingBuffer_Size(RingBuffer *fifo)
    # m+ ?/ u: ?4 H  k4 E
81. {
    
82.   return fifo->size;
    9 z: @  N2 F2 I% U7 u# v% P/ g8 r
83. }
    
84. 
    
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.   */
    
90. static inline uint32_t RingBuffer_Len(RingBuffer *fifo)
    3 M* S6 ?/ H) W7 t+ O
91. {
    3 v: e5 [2 u7 T' R$ C- P
92.   return fifo->in - fifo->out;
    * U7 C" P, A% v* k% h
93. }
    ) ?% ~) x; ?" A, o1 |: t  w* g
94. 
    7 |( G  p# Q! k
95. /**
    
96.   * @brief  Returns the number of bytes available in the FIFO.
    
97.   * @param  [in] fifo: The fifo to be used.
    
98.   * @return The number of bytes available.
    
99.   */
    0 S9 A& w9 p$ ]: S" y
100. static inline uint32_t RingBuffer_Avail(RingBuffer *fifo)
     0 Q* H9 ^( ]! p$ ?
101. {
     
102.   return RingBuffer_Size(fifo) - RingBuffer_Len(fifo);
     
103. }
     2 {, Z4 e- v; Y  c' S3 W' ^4 X( Q
104. 
     % Y, ?3 i  k  Q2 ]& W3 t0 V
105. /**
     
106.   * @brief  Is the FIFO empty?
     % Z$ \( y# T2 l( T* d0 o
107.   * @param  [in] fifo: The fifo to be used.
     # |: U6 a8 c! i+ k. W
108.   * @retval true:      Yes.
     
109.   * @retval false:     No.
     ; w$ R: e+ u5 N' P* I2 d8 k
110.   */
     
111. static inline bool RingBuffer_IsEmpty(RingBuffer *fifo)
     
112. {
     
113.   return RingBuffer_Len(fifo) == 0;
     
114. }
     
115. 
     
116. /**
       y0 E, c* i" ?& g( }6 b4 b  R
117.   * @brief  Is the FIFO full?
     
118.   * @param  [in] fifo: The fifo to be used.
     6 G( G$ ~5 a, K  P( }+ A+ W2 P
119.   * @retval true:      Yes.
     
120.   * @retval false:     No.
     
121.   */
     2 \  T4 A3 m' A) }
122. static inline bool RingBuffer_IsFull(RingBuffer *fifo)
     5 d& V* L9 b: Y/ e/ D/ I# M
123. {
     % C- w! P, ^! j' {: A
124.   return RingBuffer_Avail(fifo) == 0;
     
125. }
     
126. 
     : N3 E) `) u  {  k/ }2 c
127. #ifdef __cplusplus
     
128. }
     4 M% _1 e7 I, }# w
129. #endif
     - N( W4 y0 O3 X& k9 r0 a% q/ E
130. 
     8 q& w8 p) m1 l
131. #endif /* __RINGBUFFER_H */
     & {0 A3 B: _9 |" b2 D$ O% m( i

复制代码

9 {* n# T2 g: i  RRingBuffer.c 文件
: c8 V% B% u# Q' B; k9 f

1. <div>/**
   9 x6 K0 A* q7 ~% Y; e7 h4 l
2.   ******************************************************************************
   2 w/ o) A) g+ S% M# r
3.   * @file    RingBuffer.c
   
4.   * @author  XinLi
   3 n% X4 l  E) m$ y$ x! x0 K
5.   * @version v1.1
   2 e  e5 I& @/ u* h  Y+ v- ^
6.   * @date    15-January-2018
   ! l$ S4 D- n- @( `/ K
7.   * @brief   Ring buffer module source file.
   
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    0 a0 y6 u- g. |+ U- C' `- O4 _2 m. k
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    5 j7 D2 }5 S; Q+ k- p' _
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
    4 x+ s: r6 ?4 O3 L* g
15.   * the Free Software Foundation, either version 3 of the License, or
    ' {) _0 H+ I5 b' u
16.   * (at your option) any later version.
    " R; G5 E0 k- \$ X  `# U# ]
17.   *
    - ~. ?  o2 N. h# `$ [$ C5 h
18.   * This program is distributed in the hope that it will be useful,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    + R3 S% Z: d& r+ Q1 [' Y
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    6 M, l' Q5 a. k' T3 i0 e
21.   * GNU General Public License for more details.
    
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    
25.   *
    ! d2 S0 \& S4 n  z: K9 Z
26.   ******************************************************************************
    9 k6 a* o. L" c: W: Q
27.   */
    
28. 
    7 G; b  X4 V0 H8 u! N2 m
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "RingBuffer.h"
    6 d" G% f/ d  [+ T% Q
31. #include <string.h>
    4 |. e, J- F& f( a
32. 
    
33. /* Macro definitions ---------------------------------------------------------*/
    & z+ L% |7 S5 }1 `& x
34. #define min(a, b)  (((a) < (b)) ? (a) : (b))
    
35. 
    : |) A) Z+ B  `: {" Q  E9 T
36. /* Type definitions ----------------------------------------------------------*/
    + [! ]' X( y! C* b+ C  v2 G! ^, N
37. /* Variable declarations -----------------------------------------------------*/
    2 d4 u2 A7 {- C$ C
38. /* Variable definitions ------------------------------------------------------*/
    
39. /* Function declarations -----------------------------------------------------*/
    
40. static bool is_power_of_2(uint32_t x);
    1 |2 _  S" E$ L. A
41. static uint32_t roundup_pow_of_two(uint32_t x);
    
42. 
    ; H& u; u2 h3 m: c: C
43. /* Function definitions ------------------------------------------------------*/
    # ~2 |+ o: D3 R: k* {! k/ d( G
44. 
    ) E0 w+ L+ r  G- X- a
45. /**
    
46.   * @brief  Allocates a new FIFO and its internal buffer.
    
47.   * @param  [in] size: The size of the internal buffer to be allocated.
    ( A6 t4 b. K- K" t, H; ]" r5 ~/ F
48.   * @note   The size will be rounded-up to a power of 2.
    
49.   * @return RingBuffer pointer.
    % ]4 k$ i# P5 H& `4 o
50.   */
    7 ^4 E( Y) D+ r- B* W
51. RingBuffer *RingBuffer_Malloc(uint32_t size)
    
52. {
    
53.   RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer));
    
54. 
    
55.   if(fifo != NULL)
    7 c% B0 W+ e; r; d/ g
56.   {
    1 J( g) Z7 ]9 y0 X
57.     if(is_power_of_2(size) != true)
    : U+ n8 Y' E8 A4 j9 X
58.     {
    1 a5 M4 T) w& a' W' k
59.       if(size > 0x80000000UL)
    0 V# G4 v: R- ~3 I5 ^7 d
60.       {
    
61.         RING_BUFFER_FREE(fifo);
    : I& g8 u% S- p5 `
62.         return NULL;
    ) w9 k: H- X( s/ P
63.       }
    9 s: V% B% i( Y& E: R
64. 
    
65.       size = roundup_pow_of_two(size);
    - ~; f) [/ a5 {) w/ J- E
66.     }
    
67. 
    * }* R3 U# s, w/ b" S3 c
68.     fifo->buffer = RING_BUFFER_MALLOC(size);
    
69. 
    1 a0 r# z+ X! J3 A( K
70.     if(fifo->buffer == NULL)
    
71.     {
    
72.       RING_BUFFER_FREE(fifo);
    : t, o& o; R' m( F) \) I+ M
73.       return NULL;
    
74.     }
      Q' j. {) E! n, d* f0 K6 r
75. 
    4 C0 S, k# O; t
76.     fifo->size = size;
    6 J+ O2 _- U/ N0 I
77.     fifo->in = fifo->out = 0;
    3 p8 v# j$ p5 C- p$ d
78.   }
    & t0 {% ?9 }. Z  X9 E
79. 
      D! ?' N0 |0 b8 t; c
80.   return fifo;
    
81. }
    2 g3 X& J& Q" g+ y
82. 
    . o( C$ O1 I! |' h, A# N! R
83. /**
    0 C. K  l/ P9 \/ i
84.   * @brief  Frees the FIFO.
    8 R' U& j; P5 h  ~. `7 v7 C
85.   * @param  [in] fifo: The fifo to be freed.
    % D4 K1 L& r$ i4 N1 P
86.   * @return None.
    3 p0 e' A8 q1 S' T* V- x* H: [& j
87.   */
    ( g, _, ~6 z/ x6 G& }! r; v
88. void RingBuffer_Free(RingBuffer *fifo)
    
89. {
    - D4 X2 C: [) s: ]  Q3 l
90.   RING_BUFFER_FREE(fifo->buffer);
    
91.   RING_BUFFER_FREE(fifo);
    * L1 ~* H3 A- W7 A2 w0 y, I
92. }
    
93. 
    
94. /**
    
95.   * @brief  Puts some data into the FIFO.
    ( u) f5 q6 Z8 p5 N. b4 t- u2 i
96.   * @param  [in] fifo: The fifo to be used.
    2 e2 }% p: [" s
97.   * @param  [in] in:   The data to be added.
    
98.   * @param  [in] len:  The length of the data to be added.
    
99.   * @return The number of bytes copied.
    # O- t8 ^( |: G9 c' w5 U
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.   */
     ; D, ~% Q* H$ q- o% K% X" s
104. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len)
     
105. {
     
106.   len = min(len, RingBuffer_Avail(fifo));
     , o! t- L- M# d2 z/ ?4 n
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);
     9 @' x2 e9 r, L! c! o
111. 
     ; J% ]; O; ~* j( o9 `; h% h
112.   /* Then put the rest (if any) at the beginning of the buffer. */
     
113.   memcpy(fifo->buffer, (uint8_t *)in + l, len - l);
     
114. 
     
115.   fifo->in += len;
     
116. 
     2 E9 \' r' N/ |. @( T
117.   return len;
     
118. }
     5 [, W1 O9 h8 ~7 b
119. 
     
120. /**
     
121.   * @brief  Gets some data from the FIFO.
     
122.   * @param  [in] fifo: The fifo to be used.
     ) t  a% z/ L6 b' V0 Z
123.   * @param  [in] out:  Where the data must be copied.
     
124.   * @param  [in] len:  The size of the destination buffer.
     
125.   * @return The number of copied bytes.
     2 |+ h) k( G* c0 w' s5 \- H
126.   * @note   This function copies at most @len bytes from the FIFO into
     - r  u8 t' i6 Z/ m1 Q6 p  C) O
127.   *         the @out and returns the number of copied bytes.
     
128.   */
     
129. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len)
     
130. {
     6 D( T9 k# p! k
131.   len = min(len, RingBuffer_Len(fifo));
     
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)));
     
135.   memcpy(out, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
     # m/ r- R1 J# H6 z% H4 z
136. 
     
137.   /* Then get the rest (if any) from the beginning of the buffer. */
     / t- X  {. a  H
138.   memcpy((uint8_t *)out + l, fifo->buffer, len - l);
     % o* F2 X: V: Q, r
139. 
     
140.   fifo->out += len;
     
141. 
     ; E; p) e+ _3 q6 D, @+ a
142.   return len;
     6 c8 Q' p" z1 Z- X5 z1 k- g! x
143. }
     # ?( t  `; s/ N/ g, I) x
144. 
     4 r9 \# a/ v! S7 i2 U1 s
145. /**
     $ y- T9 ^" I. W/ y1 q; ~6 m
146.   * @brief  Determine whether some value is a power of two.
     - C& E- P# \& x0 d  ]/ v- M( h8 I
147.   * @param  [in] x: The number to be confirmed.
     - @, }* ?3 q: A
148.   * @retval true:   Yes.
     . ?. j' M9 [) a6 ~' l: K
149.   * @retval false:  No.
     
150.   * @note   Where zero is not considered a power of two.
     2 Y% O' W: h9 e4 y% u
151.   */
     
152. static bool is_power_of_2(uint32_t x)
     
153. {
     ! k: a! U5 q6 y1 A0 w0 O" m$ D
154.   return (x != 0) && ((x & (x - 1)) == 0);
       t4 [: h4 v5 R3 ^, E2 i/ O9 O  Z
155. }
     $ d- p" Z$ L3 R- O; w# }
156. 
     
157. /**
     
158.   * @brief  Round the given value up to nearest power of two.
     
159.   * @param  [in] x: The number to be converted.
     7 m0 i. n, ^' d  b
160.   * @return The power of two.
     
161.   */
     
162. static uint32_t roundup_pow_of_two(uint32_t x)
     
163. {
     1 B' f+ t: w$ X; g
164.   uint32_t b = 0;
     3 ]8 @" M& o' ?
165. 
     
166.   for(int i = 0; i < 32; i++)
     
167.   {
     
168.     b = 1UL << i;
     
169. 
     1 Y8 c6 e) b( H* r3 f
170.     if(x <= b)
     
171.     {
     ! n& R# ~8 p7 [6 L  V
172.       break;
     
173.     }
     
174.   }
     
175. 
     
176.   return b;
     
177. }</div><div></div>

复制代码

CAN.h 文件

1. /**
   
2.   ******************************************************************************
   ! g2 D4 I6 K6 T
3.   * @file    CAN.h
   $ I: }$ }, P$ J# ]* ]
4.   * @author  XinLi
     q% e/ u/ S! V% p# t
5.   * @version v1.0
   
6.   * @date    24-June-2018
   
7.   * @brief   Header file for CAN.c module.
   
8.   ******************************************************************************
   4 _8 J3 i0 u8 o6 i( K* J2 s
9.   * @attention
   
10.   *
    0 S6 M4 l/ V- j# X
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
    4 E+ Y  S' Q. e7 {, r6 \4 c- l
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,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    % _9 ]& \  d: n" g1 K$ v/ D
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    : A7 R2 v% r3 H, k0 w  e( l
21.   * GNU General Public License for more details.
    
22.   *
    ; ^" X; b( ^9 [4 v
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.   *
    9 h! G* Y& k) A5 j; \5 T
26.   ******************************************************************************
    
27.   */
    
28. 
    7 \8 U. J' _" j+ I4 X# R. V
29. #ifndef __CAN_H
    
30. #define __CAN_H
    
31. 
    # R( y4 u# {/ B6 x  W' o$ i$ F
32. #ifdef __cplusplus
    
33. extern "C" {
    
34. #endif
    1 S  x" o! J& H" M- }) b
35. 
    2 r& p5 @( q- y* L7 e0 }3 y2 n
36. /* Header includes -----------------------------------------------------------*/
    
37. #include "stm32f10x.h"
    1 z6 ^- H4 O* M/ I0 z
38. #include <stdbool.h>
    7 \. M4 d# T6 j8 |  j
39. 
    
40. /* Macro definitions ---------------------------------------------------------*/
    9 t: [: N1 t  m) @! C
41. 
    + P7 K( m( U. w8 ~; q
42. /******************************* CAN1 Configure *******************************/
    . Y0 @4 S9 |3 B; K/ `4 {* F4 ?
43. #define CAN1_TX_BUFFER_SIZE        (16)
    
44. #define CAN1_RX_BUFFER_SIZE        (16)
    4 z+ p0 _- M' j# Z% \
45. 
    
46. #define CAN1_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
47. #define CAN1_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
48. 
    & u: j6 ?- i% n: l
49. #define CAN1_TX_GPIO_PORT          GPIOB
    # v1 A( q- ~& W$ ?& H7 V/ i% ?6 P
50. #define CAN1_RX_GPIO_PORT          GPIOB
    
51. 
    9 O$ _9 D1 ~7 s3 C6 Q( C
52. #define CAN1_TX_GPIO_PIN           GPIO_Pin_9
    
53. #define CAN1_RX_GPIO_PIN           GPIO_Pin_8
    # q5 D* W7 W. p. M/ a( @
54. 
    ( m3 x3 p+ I% Z! O
55. #define CAN1_IRQ_PREEMPT_PRIORITY  (0)
    + Z5 ?+ t6 h1 T
56. #define CAN1_IRQ_SUB_PRIORITY      (0)
    7 n1 ^- k/ z1 J# U+ X
57. 
    
58. #define CAN1_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap1_CAN1 , ENABLE)
    
59. /******************************************************************************/
      ?$ U3 ]) F" e1 \5 H
60. 
    
61. #ifdef STM32F10X_CL
    
62. /******************************* CAN2 Configure *******************************/
    2 D8 q6 S: {/ l9 H* Z" c# K
63. #define CAN2_TX_BUFFER_SIZE        (16)
    . e7 n$ D2 C# o7 p# i$ W" c. L; ^
64. #define CAN2_RX_BUFFER_SIZE        (16)
    - P- H- I$ q7 s' |9 z$ N
65. 
    / q/ x6 n8 ?5 D$ b
66. #define CAN2_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    ! o, A8 y; W( X: R& ]5 [8 T
67. #define CAN2_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
68. 
    # L- m4 U9 k0 V  o' |* I: W8 A: |7 F) A9 P
69. #define CAN2_TX_GPIO_PORT          GPIOB
    
70. #define CAN2_RX_GPIO_PORT          GPIOB
    ! n* }  b( ^+ E& p1 J. `7 X
71. 
    
72. #define CAN2_TX_GPIO_PIN           GPIO_Pin_13
    $ o5 L6 ^8 X$ y& Y  H. W
73. #define CAN2_RX_GPIO_PIN           GPIO_Pin_12
    7 @, g: g: G: }. p$ h
74. 
    1 \( r+ q% t3 M3 x. q
75. #define CAN2_IRQ_PREEMPT_PRIORITY  (0)
    + H" \! h! H& r
76. #define CAN2_IRQ_SUB_PRIORITY      (0)
    ( P/ p3 a1 r- m
77. 
    . q) g. k+ V- F' e! X+ n+ N$ \
78. #define CAN2_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap_CAN2 , DISABLE)
    
79. /******************************************************************************/
      d) e9 ]& C8 G# a* s3 o$ M, {; t
80. #endif /* STM32F10X_CL */
    ; l, |# r6 P* M  H& V
81. 
    6 s) ^/ N( {$ V3 T
82. /* Type definitions ----------------------------------------------------------*/
    
83. typedef enum
    ( _+ N$ x% {) A  t
84. {
    
85.   CAN_WorkModeNormal   = CAN_Mode_Normal,
    
86.   CAN_WorkModeLoopBack = CAN_Mode_LoopBack
    0 \( I1 e* K, `$ l
87. }CAN_WorkMode;
    5 V- ]) C# l9 Q/ a6 h/ z/ \
88. 
    ; ?! Q# ]1 x: Y1 W
89. typedef enum
    - k% y. l1 e6 _3 y5 ?
90. {
    6 D7 b5 R" e- H( [5 |
91.   CAN_BaudRate1000K = 6,
    ( E5 |/ [% H3 _6 |) W5 ^
92.   CAN_BaudRate500K  = 12,
    9 [! c5 O/ B  r8 i& Z* h0 O! j- a
93.   CAN_BaudRate250K  = 24,
    9 h4 `* s7 H* V  a- _
94.   CAN_BaudRate125K  = 48,
    
95.   CAN_BaudRate100K  = 60,
    ; ]% l; Q& P! ?
96.   CAN_BaudRate50K   = 120,
    - f% s1 z0 n4 _9 M* m  h
97.   CAN_BaudRate20K   = 300,
    % ^2 }) n2 M6 I$ |% w2 ]  l( M" V
98.   CAN_BaudRate10K   = 600
    ( k. t5 y4 ?8 Y$ C: \2 p+ M
99. }CAN_BaudRate;
    
100. 
     
101. /* Variable declarations -----------------------------------------------------*/
     
102. /* Variable definitions ------------------------------------------------------*/
     9 i3 j6 F( n9 ^  [9 `0 N$ q
103. /* Function declarations -----------------------------------------------------*/
     
104. void CAN_Configure(CAN_TypeDef *CANx, CAN_WorkMode WorkMode, CAN_BaudRate BaudRate, uint32_t StdId, uint32_t ExtId);
     6 m  Q3 |9 m6 p4 ~6 a% q
105. void CAN_Unconfigure(CAN_TypeDef *CANx);
     % Z) ~- Z& G; F4 @& c
106. 
     : l& f# n: r; ~
107. void CAN_SetTransmitFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     , l5 Q, a- X/ v4 H) I
108. void CAN_SetReceiveFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     
109. 
     8 n# h, l5 p* L4 f, t
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);
     
112. 
     3 m  q4 o  D: \7 f5 x1 n; q
113. uint32_t CAN_GetUsedTransmitBufferSize(CAN_TypeDef *CANx);
     
114. uint32_t CAN_GetUsedReceiveBufferSize(CAN_TypeDef *CANx);
     
115. uint32_t CAN_GetUnusedTransmitBufferSize(CAN_TypeDef *CANx);
     
116. uint32_t CAN_GetUnusedReceiveBufferSize(CAN_TypeDef *CANx);
     : g2 K6 X& U$ Y+ }
117. 
     . ?9 V8 z( z# y; d' n! W
118. bool CAN_IsTransmitBufferEmpty(CAN_TypeDef *CANx);
     + P. d& L( h# T- t1 J
119. bool CAN_IsReceiveBufferEmpty(CAN_TypeDef *CANx);
     
120. bool CAN_IsTransmitBufferFull(CAN_TypeDef *CANx);
     
121. bool CAN_IsReceiveBufferFull(CAN_TypeDef *CANx);
     & _1 E- X5 |8 q5 i  X+ @1 X- E2 {
122. 
     6 n. s3 A8 R3 D( K7 ~3 K0 t; I$ F1 e
123. void CAN_ClearTransmitBuffer(CAN_TypeDef *CANx);
     
124. void CAN_ClearReceiveBuffer(CAN_TypeDef *CANx);
     
125. 
     - j+ o3 F2 I1 {7 I0 I, I6 F7 ?4 P( u" I+ S
126. bool CAN_IsTransmitMessage(CAN_TypeDef *CANx);
     0 C# z9 @' X2 r5 o$ y9 r
127. 
     ; t! J( Q  R+ Z3 q# A) G$ T! j9 o
128. /* Function definitions ------------------------------------------------------*/
     
129. 
     4 [+ ]# y8 W* E* u6 ~$ O
130. #ifdef __cplusplus
     
131. }
     
132. #endif
     
133. 
     
134. #endif /* __CAN_H */
     ; x2 Q  x8 Y; ]/ o5 l; d* V

复制代码

+ x/ n- h5 R. HCAN.c 文件
' L1 h4 j/ _# ]" |0 X* `1 Z

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

复制代码

& p* z, I8 T2 c% z0 Lmain.h 文件
8 S  z3 f) [3 v) {1 a$ X

1. /**
   
2.   ******************************************************************************
   ( _% |" m4 Q7 `' J
3.   * @file    main.h
   
4.   * @author  XinLi
   . T, Q& j+ D7 \, r1 w
5.   * @version v1.0
   
6.   * @date    24-June-2018
   ( Q. a1 E4 {$ E6 |6 W! ~
7.   * @brief   Header file for main.c module.
   ( Z6 N1 V4 s+ B8 B/ [
8.   ******************************************************************************
   ' d; P" U9 G5 J) w- v$ r' h
9.   * @attention
   
10.   *
    ) Z8 L; E; K/ }6 Z+ D! e4 T9 y
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    ! q) T( D: m' Y4 h3 q: z3 I; N
12.   *
    9 [  I7 }& O5 s  W$ Q
13.   * This program is free software: you can redistribute it and/or modify
    + F/ c& u# Y; s9 W1 ~' A- Q
14.   * it under the terms of the GNU General Public License as published by
    8 o9 P1 s3 S0 S
15.   * the Free Software Foundation, either version 3 of the License, or
    + m7 M# v+ o  v* }# H$ N
16.   * (at your option) any later version.
    
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    8 Z7 U4 O: M2 G1 l$ c& [1 r
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    # i; B% u2 p( ?, z+ X
21.   * GNU General Public License for more details.
    
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    ) _; _0 Z6 u% ]* x1 Y; t( r  e' y6 a
25.   *
    
26.   ******************************************************************************
    . g* E: t: H- i( c  n
27.   */
    
28. 
    
29. #ifndef __MAIN_H
    
30. #define __MAIN_H
    6 v: F# \5 s( I$ c  V. k8 e
31. 
    
32. #ifdef __cplusplus
    
33. extern "C" {
    4 q( n5 w' t7 S, s
34. #endif
    : f6 x1 n) G; t
35. 
    
36. /* Header includes -----------------------------------------------------------*/
    6 B  a6 S& f9 [4 t
37. #include "stm32f10x.h"
    
38. 
    
39. /* Macro definitions ---------------------------------------------------------*/
    
40. /* Type definitions ----------------------------------------------------------*/
    
41. /* Variable declarations -----------------------------------------------------*/
    ( ^& L3 B6 \1 I2 Q+ X" J
42. /* Variable definitions ------------------------------------------------------*/
    . P- R3 s; U& h( t
43. /* Function declarations -----------------------------------------------------*/
    * h$ e1 H% [0 d: x4 z! X3 T
44. /* Function definitions ------------------------------------------------------*/
    # @8 n" a1 k! D) p: H1 k9 T6 \
45. 
    0 y6 S- b4 v/ r( ~2 D- Q2 G
46. #ifdef __cplusplus
    * ~% c2 {+ }; Y/ _% ]  B
47. }
    
48. #endif
    
49. 
    
50. #endif /* __MAIN_H */

复制代码

main.c 文件
  s6 T# j) W6 ]

1. /**
   
2.   ******************************************************************************
   
3.   * @file    main.c
   + H3 k& H6 l3 n9 D/ H; U
4.   * @author  XinLi
   
5.   * @version v1.0
   
6.   * @date    24-June-2018
   7 v$ M! u; k# d3 w  q; r- b  U
7.   * @brief   Main program body.
   
8.   ******************************************************************************
   $ r! Q. O$ c, l6 n% {8 _8 H6 r
9.   * @attention
   " q8 \( N6 |% ^" y
10.   *
    / ~  y+ \2 y4 m5 D/ V' m
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    + T/ h3 ~/ k: _3 G
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
    % y. N. @& g- p2 k. m
16.   * (at your option) any later version.
    ! C2 f- X  R. V. F7 k
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    ' A; l: r" p  ]( w1 w( s( s
22.   *
    * E1 p' G9 _1 N. K+ Q
23.   * You should have received a copy of the GNU General Public License
    1 J6 n$ t) e$ U
24.   * along with this program.  If not, see <<a href="https://www.gnu.org/licenses/>." target="_blank">https://www.gnu.org/licenses/>.</a>
    3 o& G( _1 n- w. E9 W. k( G
25.   *
    & ^4 |8 Q+ t$ \4 n* f! a
26.   ******************************************************************************
    
27.   */
    
28. 
    1 q! t+ Z% L% n* g8 q$ o
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "main.h"
    
31. #include "CAN.h"
    
32. 
    
33. #ifdef _RTE_
    % P0 S8 |) c, i! h7 e
34. #include "RTE_Components.h"
    
35. #endif
    ) A8 M, Z# L1 X& [. R+ K
36. 
    
37. #ifdef RTE_CMSIS_RTOS2
    
38. #include "cmsis_os2.h"
    : H3 T4 y- v( X" k1 r0 w
39. #endif
    ) ^0 I% s5 a; r3 E2 T! |
40. 
    ( {1 ~; `" [# A0 `$ _
41. /* Macro definitions ---------------------------------------------------------*/
    
42. /* Type definitions ----------------------------------------------------------*/
    + {4 ]9 v5 e- @+ |
43. /* Variable declarations -----------------------------------------------------*/
    
44. /* Variable definitions ------------------------------------------------------*/
    - f, z' q0 e+ H* S0 I9 e8 ~! T
45. static CanTxMsg canTxMsg = {0};
    ( L7 s' o  e" p8 T; F$ Y" ^4 I
46. static CanRxMsg canRxMsg = {0};
    
47. 
    " i' ~8 x2 o& j
48. /* Function declarations -----------------------------------------------------*/
    
49. static void SystemClock_Config(void);
    , i# ^* B" Y" s0 m9 J4 b& `6 O
50. 
    % G7 S) A1 X% Y" T" ~$ Y
51. /* Function definitions ------------------------------------------------------*/
    
52. 
    
53. /**
    
54.   * @brief  Main program.
    * v, I4 L. F$ l! K, y4 z% I3 J
55.   * @param  None.
    , l$ T3 z! B1 d; D
56.   * @return None.
    0 j! S! b* q7 H! b( H- A
57.   */
    
58. int main(void)
    
59. {
    $ K, @4 z7 \0 I7 t' R7 }) z. \
60.   /* Configure the system clock to 72 MHz */
    
61.   SystemClock_Config();
    
62.   SystemCoreClockUpdate();
    
63. 
    
64.   /* Add your application code here */
    
65.   CAN_Configure(CAN1, CAN_WorkModeLoopBack, CAN_BaudRate250K, 0xAA55, 0x55AA);
    & R0 T5 e6 ^( O, Q0 ~- o0 k
66. 
    # B& y+ {. M! M. j# Z
67. #ifdef RTE_CMSIS_RTOS2
    
68.   /* Initialize CMSIS-RTOS2 */
    
69.   osKernelInitialize();
    
70. 
    
71.   /* Create thread functions that start executing,
    6 Z* k$ U2 F7 Q1 U4 B4 ]
72.   Example: osThreadNew(app_main, NULL, NULL); */
    
73. 
    4 t) q' r: m6 E/ r
74.   /* Start thread execution */
    
75.   osKernelStart();
    * e: i; g6 l% q
76. #endif
    9 B4 g" R: }7 ]8 {( d3 K0 j1 K
77. 
    ! \9 R) a: f# i
78.   /* Infinite loop */
    
79.   while(1)
    
80.   {
    
81.     canTxMsg.StdId = 0xAA55;
    , S3 b& Z6 H) m# |: M; [
82.     canTxMsg.ExtId = 0x55AA;
    / w+ v' r- B4 P6 g
83.     canTxMsg.IDE   = CAN_ID_STD;
      h! c) U: x8 |4 d
84.     canTxMsg.RTR   = CAN_RTR_DATA;
    7 l( i8 L4 C% k3 x7 p: v, h/ _9 t
85.     canTxMsg.DLC   = 8;
    
86. 
    
87.     canTxMsg.Data[0]++;
    4 @6 L% m6 ^2 d/ _  e  e
88.     canTxMsg.Data[1]++;
    
89.     canTxMsg.Data[2]++;
      @0 s+ h1 T9 B. f
90.     canTxMsg.Data[3]++;
    
91.     canTxMsg.Data[4]++;
    
92.     canTxMsg.Data[5]++;
    
93.     canTxMsg.Data[6]++;
    
94.     canTxMsg.Data[7]++;
    
95. 
    * s9 P5 W: y9 [; O( c
96.     CAN_SetTransmitMessage(CAN1, &canTxMsg, 1);
    0 ?: G' `5 [$ s+ A
97. 
    ) W. e) F' t, H% [3 [, p
98.     while(CAN_IsReceiveBufferEmpty(CAN1) == true);
    * ?' N1 E; B$ D% c  i
99. 
    
100.     CAN_GetReceiveMessage(CAN1, &canRxMsg, 1);
     
101.   }
     
102. }
     
103. 
     2 f; o* ?2 R7 @6 C
104. /**
     2 O  W1 \% r9 n( r% i0 M
105.   * @brief  System Clock Configuration.
     
106.   *         The system Clock is configured as follow :
     
107.   *            System Clock source            = PLL (HSE)
     : p1 Y! O8 L( O4 Y
108.   *            SYSCLK(Hz)                     = 72000000
     
109.   *            HCLK(Hz)                       = 72000000
     # Z" m: q# d% }* F/ b. F- i
110.   *            AHB Prescaler                  = 1
     
111.   *            APB1 Prescaler                 = 2
     
112.   *            APB2 Prescaler                 = 1
     
113.   *            HSE Frequency(Hz)              = 8000000
       n4 o2 k) _: V: g
114.   *            HSE PREDIV1                    = 1
     
115.   *            PLLMUL                         = 9
     
116.   *            Flash Latency(WS)              = 2
     2 A1 i+ n* V9 S9 |) ~  w
117.   * @param  None.
     
118.   * @return None.
     
119.   */
     * f9 {8 I$ E. ]1 X. e
120. static void SystemClock_Config(void)
     
121. {
     0 w. g7 {. V: O/ x6 D' i+ R$ M
122.   /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration */
     * h6 q9 t1 E" p4 P. I
123.   /* RCC system reset */
     
124.   RCC_DeInit();
     
125. 
     
126.   /* Enable HSE */
     + L; t! J1 e" o/ S- z
127.   RCC_HSEConfig(RCC_HSE_ON);
     
128. 
     ) q! @; `8 ?$ ?1 j9 t$ t* ?
129.   /* Wait till HSE is ready */
     
130.   ErrorStatus HSEStartUpStatus = RCC_WaitForHSEStartUp();
     , |" M7 g2 c- L  r! l
131. 
     
132.   if(HSEStartUpStatus == SUCCESS)
     4 M: L% p/ ~, |( Z
133.   {
     
134.     /* Enable Prefetch Buffer */
     
135.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     
136. 
       V$ t% M7 _& R9 R2 H! S
137.     /* Flash 2 wait state */
     * L7 F; l- R" u
138.     FLASH_SetLatency(FLASH_Latency_2);
     
139. 
     
140.     /* HCLK = SYSCLK */
     4 M0 ~8 x( Z* G4 X6 b# Q' B: i
141.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     
142. 
     ; C! }7 N7 I+ E0 g# D8 P
143.     /* PCLK2 = HCLK */
     
144.     RCC_PCLK2Config(RCC_HCLK_Div1);
     
145. 
     7 R: ^$ Q4 b8 B9 K
146.     /* PCLK1 = HCLK / 2 */
     ' S, B3 N* P8 |
147.     RCC_PCLK1Config(RCC_HCLK_Div2);
     + r( P  W6 U3 p: H5 ^
148. 
     & z! A% N8 e; p: W
149.     /* Configure PLLs */
     4 B3 q+ [+ B6 P5 a/ D
150. #ifdef STM32F10X_CL
     
151.     /* PLL2 configuration: PLL2CLK = (HSE(8MHz) / 2) * 10 = 40MHz */
     , o! a* E' z9 j
152.     RCC_PREDIV2Config(RCC_PREDIV2_Div2);
     
153.     RCC_PLL2Config(RCC_PLL2Mul_10);
     ; @, O0 y0 d1 |; {
154. 
     9 N4 j: ^& F, p5 x6 q0 W7 y
155.     /* Enable PLL2 */
     
156.     RCC_PLL2Cmd(ENABLE);
     
157. 
     % `  J1 |4 |9 {# O
158.     /* Wait till PLL2 is ready */
     
159.     while(RCC_GetFlagStatus(RCC_FLAG_PLL2RDY) == RESET);
     2 T* q" X$ |5 I, I( D
160. 
     5 w+ v- P( t% E& n9 k5 [
161.     /* PLL configuration: PLLCLK = (PLL2(40MHz) / 5) * 9 = 72MHz */
     
162.     RCC_PREDIV1Config(RCC_PREDIV1_Source_PLL2, RCC_PREDIV1_Div5);
     / c/ I5 g* e. f$ x, D2 T- N
163.     RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_9);
     . Q0 o2 A* R- e, ?$ S) r1 ~
164. #else
     2 w! _  ], Z9 W. @' Y( h5 k- h* \# K
165.     /* PLLCLK = HSE(8MHz) * 9 = 72MHz */
     8 @  Z5 A7 f6 O8 Q6 a  ~4 y! K
166.     RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
     
167. #endif
     4 J7 L6 H( `1 U$ k5 b. T7 T: w/ e! n
168. 
     2 c/ q4 s/ @+ T( Y6 V/ G. S
169.     /* Enable PLL */
     4 v! K; ~/ C: x/ D6 w* v
170.     RCC_PLLCmd(ENABLE);
     / R1 `! G& S9 d6 `4 X# p7 q
171. 
     5 N7 x- J5 l; `4 h2 _: {3 ]/ H
172.     /* Wait till PLL is ready */
     
173.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     
174. 
     - O, X% ^( B' g" a
175.     /* Select PLL as system clock source */
     - z  h. @0 D8 f& w% i
176.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     * y2 p4 C* x% L
177. 
     " c, C7 _' B+ |- z
178.     /* Wait till PLL is used as system clock source */
     
179.     while(RCC_GetSYSCLKSource() != 0x08);
     
180.   }
     " O; H) `4 A4 w0 V8 F' s4 v5 ?( {* H
181.   else
     
182.   {
     
183.     /* Disable HSE */
     
184.     RCC_HSEConfig(RCC_HSE_OFF);
     4 _) z! b# R3 e% n: a# h0 ]  H
185. 
     $ P- A& ?2 Y. ~: n* k
186.     /* Enable HSI */
     
187.     RCC_HSICmd(ENABLE);
     . t  A! Z& H  G7 u5 ?
188. 
     / b7 W: P8 D( u3 u! H
189.     /* Enable Prefetch Buffer */
     
190.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     & z2 B, @- Y' p3 E
191. 
     9 {% ?0 O+ o" {) w2 ]+ |. M
192.     /* Flash 1 wait state */
     
193.     FLASH_SetLatency(FLASH_Latency_1);
     5 {9 p# z0 r3 \' v: N/ o) T4 S
194. 
     ; Z0 X' d, _- U2 z* g& @# T" D
195.     /* HCLK = SYSCLK */
     
196.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     
197. 
     1 ?' E6 A0 @) {- j3 R8 M
198.     /* PCLK2 = HCLK */
     
199.     RCC_PCLK2Config(RCC_HCLK_Div1);
     % v5 F, l* m) g; V: H
200. 
     
201.     /* PCLK1 = HCLK */
     
202.     RCC_PCLK1Config(RCC_HCLK_Div1);
     
203. 
     
204.     /* Configure PLLs */
     . f' ]' |- I7 c7 s4 G/ l
205.     /* PLLCLK = HSI(8MHz) / 2 * 9 = 36MHz */
     ; \# f9 s* c9 w7 g
206.     RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_9);
     2 @* d' q/ y4 X* _
207. 
     ; \  U* z6 I4 w8 m* }
208.     /* Enable PLL */
     . P9 [. ]# d* e8 d: G" d0 P
209.     RCC_PLLCmd(ENABLE);
     ; w5 R) ]* q' E5 W/ X# e: w
210. 
     
211.     /* Wait till PLL is ready */
     , v+ F1 `/ f) O1 U" s
212.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     
213. 
     $ n9 r8 F" K+ J' K, _
214.     /* Select PLL as system clock source */
     
215.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     3 Z# T; S5 }0 H: A
216. 
     ! l3 W! j4 L3 P1 A+ Y9 s& r
217.     /* Wait till PLL is used as system clock source */
     
218.     while(RCC_GetSYSCLKSource() != 0x08);
     $ o: `7 K0 D  c3 i4 a7 u! t: W6 @
219.   }
     
220. }
     ( u( g- V& Y8 u. o
221. 
     ; H5 W* U# E, @' G
222. #ifdef USE_FULL_ASSERT
     : F# X. {& T- V9 w
223. /**
     
224.   * @brief  Reports the name of the source file and the source line number
     9 u; {- J: `2 l
225.   *         where the assert_param error has occurred.
     $ F4 }+ {$ @( l9 b' A  L! y; E( V
226.   * @param  file: pointer to the source file name.
     4 @- m" m+ F) }
227.   * @param  line: assert_param error line source number.
     
228.   * @return None.
     & v( U* m  G% @; L7 P) k* r- `
229.   */
     
230. void assert_failed(uint8_t *file, uint32_t line)
     
231. {
     4 ~  z: m( R) b0 j: d, j8 `' O' U
232.   /* User can add his own implementation to report the file name and line number,
     4 H% d5 O: W: S, ~
233.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     
234. 
     
235.   /* Infinite loop */
     
236.   while(1)
     
237.   {
     - {- s6 e! k/ }  i0 q1 \
238.   }
     
239. }
     5 ~& w! ]5 l( }3 ]: l) G
240. #endif

复制代码

8 q* t1 K+ [# g3 ]+ c) u3，注意
$ b/ t* V" E1 b4 G+ M& X0 Q
6 f9 _; B0 s' w. y! e3 c# R* GCAN 消息发送缓冲区和接收缓冲区的大小，可以根据应用的需求进行修改，缓冲区使用的是堆内存，需要根据缓冲区大小和应用程序中堆内存使用情况进行配置。



* O0 O$ h/ K1 ~1 O. p; |