1，开发环境

1，固件库：STM32F10x_StdPeriph_Lib_V3.5.0

2，编译器：ARMCC V5.06

3，IDE：Keil uVision5

4，操作系统：Windows 10 专业版


2，程序源码

RingBuffer.h 文件

1. /**
   
2.   ******************************************************************************
   
3.   * @file    RingBuffer.h
   
4.   * @author  XinLi
   
5.   * @version v1.1
   
6.   * @date    15-January-2018
   
7.   * @brief   Header file for RingBuffer.c module.
   
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    
14.   * it under the terms of the GNU General Public License as published by
    
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    
17.   *
    
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.   ******************************************************************************
    
27.   */
    
28. 
    
29. #ifndef __RINGBUFFER_H
    
30. #define __RINGBUFFER_H
    
31. 
    
32. #ifdef __cplusplus
    
33. extern "C" {
    
34. #endif
    
35. 
    
36. /* Header includes -----------------------------------------------------------*/
    
37. #include <stdint.h>
    
38. #include <stdbool.h>
    
39. #include <stdlib.h>
    
40. 
    
41. /* Macro definitions ---------------------------------------------------------*/
    
42. #define RING_BUFFER_MALLOC(size)  malloc(size)
    
43. #define RING_BUFFER_FREE(block)   free(block)
    
44. 
    
45. /* Type definitions ----------------------------------------------------------*/
    
46. typedef struct
    
47. {
    
48.   uint8_t *buffer;
    
49.   uint32_t size;
    
50.   uint32_t in;
    
51.   uint32_t out;
    
52. }RingBuffer;
    
53. 
    
54. /* Variable declarations -----------------------------------------------------*/
    
55. /* Variable definitions ------------------------------------------------------*/
    
56. /* Function declarations -----------------------------------------------------*/
    
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);
    
61. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len);
    
62. 
    
63. /* Function definitions ------------------------------------------------------*/
    
64. 
    
65. /**
    
66.   * @brief  Removes the entire FIFO contents.
    
67.   * @param  [in] fifo: The fifo to be emptied.
    
68.   * @return None.
    
69.   */
    
70. static inline void RingBuffer_Reset(RingBuffer *fifo)
    
71. {
    
72.   fifo->in = fifo->out = 0;
    
73. }
    
74. 
    
75. /**
    
76.   * @brief  Returns the size of the FIFO in bytes.
    
77.   * @param  [in] fifo: The fifo to be used.
    
78.   * @return The size of the FIFO.
    
79.   */
    
80. static inline uint32_t RingBuffer_Size(RingBuffer *fifo)
    
81. {
    
82.   return fifo->size;
    
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)
    
91. {
    
92.   return fifo->in - fifo->out;
    
93. }
    
94. 
    
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.   */
    
100. static inline uint32_t RingBuffer_Avail(RingBuffer *fifo)
     
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.
     
108.   * @retval true:      Yes.
     
109.   * @retval false:     No.
     
110.   */
     
111. static inline bool RingBuffer_IsEmpty(RingBuffer *fifo)
     
112. {
     
113.   return RingBuffer_Len(fifo) == 0;
     
114. }
     
115. 
     
116. /**
     
117.   * @brief  Is the FIFO full?
     
118.   * @param  [in] fifo: The fifo to be used.
     
119.   * @retval true:      Yes.
     
120.   * @retval false:     No.
     
121.   */
     
122. static inline bool RingBuffer_IsFull(RingBuffer *fifo)
     
123. {
     
124.   return RingBuffer_Avail(fifo) == 0;
     
125. }
     
126. 
     
127. #ifdef __cplusplus
     
128. }
     
129. #endif
     
130. 
     
131. #endif /* __RINGBUFFER_H */
     

复制代码

RingBuffer.c 文件

1. <div>/**
   
2.   ******************************************************************************
   
3.   * @file    RingBuffer.c
   
4.   * @author  XinLi
   
5.   * @version v1.1
   
6.   * @date    15-January-2018
   
7.   * @brief   Ring buffer module source file.
   
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    
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,
    
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.   ******************************************************************************
    
27.   */
    
28. 
    
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "RingBuffer.h"
    
31. #include <string.h>
    
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);
    
41. static uint32_t roundup_pow_of_two(uint32_t x);
    
42. 
    
43. /* Function definitions ------------------------------------------------------*/
    
44. 
    
45. /**
    
46.   * @brief  Allocates a new FIFO and its internal buffer.
    
47.   * @param  [in] size: The size of the internal buffer to be allocated.
    
48.   * @note   The size will be rounded-up to a power of 2.
    
49.   * @return RingBuffer pointer.
    
50.   */
    
51. RingBuffer *RingBuffer_Malloc(uint32_t size)
    
52. {
    
53.   RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer));
    
54. 
    
55.   if(fifo != NULL)
    
56.   {
    
57.     if(is_power_of_2(size) != true)
    
58.     {
    
59.       if(size > 0x80000000UL)
    
60.       {
    
61.         RING_BUFFER_FREE(fifo);
    
62.         return NULL;
    
63.       }
    
64. 
    
65.       size = roundup_pow_of_two(size);
    
66.     }
    
67. 
    
68.     fifo->buffer = RING_BUFFER_MALLOC(size);
    
69. 
    
70.     if(fifo->buffer == NULL)
    
71.     {
    
72.       RING_BUFFER_FREE(fifo);
    
73.       return NULL;
    
74.     }
    
75. 
    
76.     fifo->size = size;
    
77.     fifo->in = fifo->out = 0;
    
78.   }
    
79. 
    
80.   return fifo;
    
81. }
    
82. 
    
83. /**
    
84.   * @brief  Frees the FIFO.
    
85.   * @param  [in] fifo: The fifo to be freed.
    
86.   * @return None.
    
87.   */
    
88. void RingBuffer_Free(RingBuffer *fifo)
    
89. {
    
90.   RING_BUFFER_FREE(fifo->buffer);
    
91.   RING_BUFFER_FREE(fifo);
    
92. }
    
93. 
    
94. /**
    
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.
    
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.   */
     
104. uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len)
     
105. {
     
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. 
     
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. 
     
117.   return len;
     
118. }
     
119. 
     
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.
     
124.   * @param  [in] len:  The size of the destination buffer.
     
125.   * @return The number of copied bytes.
     
126.   * @note   This function copies at most @len bytes from the FIFO into
     
127.   *         the @out and returns the number of copied bytes.
     
128.   */
     
129. uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len)
     
130. {
     
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);
     
136. 
     
137.   /* Then get the rest (if any) from the beginning of the buffer. */
     
138.   memcpy((uint8_t *)out + l, fifo->buffer, len - l);
     
139. 
     
140.   fifo->out += len;
     
141. 
     
142.   return len;
     
143. }
     
144. 
     
145. /**
     
146.   * @brief  Determine whether some value is a power of two.
     
147.   * @param  [in] x: The number to be confirmed.
     
148.   * @retval true:   Yes.
     
149.   * @retval false:  No.
     
150.   * @note   Where zero is not considered a power of two.
     
151.   */
     
152. static bool is_power_of_2(uint32_t x)
     
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.
     
160.   * @return The power of two.
     
161.   */
     
162. static uint32_t roundup_pow_of_two(uint32_t x)
     
163. {
     
164.   uint32_t b = 0;
     
165. 
     
166.   for(int i = 0; i < 32; i++)
     
167.   {
     
168.     b = 1UL << i;
     
169. 
     
170.     if(x <= b)
     
171.     {
     
172.       break;
     
173.     }
     
174.   }
     
175. 
     
176.   return b;
     
177. }</div><div></div>

复制代码

CAN.h 文件

1. /**
   
2.   ******************************************************************************
   
3.   * @file    CAN.h
   
4.   * @author  XinLi
   
5.   * @version v1.0
   
6.   * @date    24-June-2018
   
7.   * @brief   Header file for CAN.c module.
   
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    
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,
    
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.   ******************************************************************************
    
27.   */
    
28. 
    
29. #ifndef __CAN_H
    
30. #define __CAN_H
    
31. 
    
32. #ifdef __cplusplus
    
33. extern "C" {
    
34. #endif
    
35. 
    
36. /* Header includes -----------------------------------------------------------*/
    
37. #include "stm32f10x.h"
    
38. #include <stdbool.h>
    
39. 
    
40. /* Macro definitions ---------------------------------------------------------*/
    
41. 
    
42. /******************************* CAN1 Configure *******************************/
    
43. #define CAN1_TX_BUFFER_SIZE        (16)
    
44. #define CAN1_RX_BUFFER_SIZE        (16)
    
45. 
    
46. #define CAN1_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
47. #define CAN1_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
48. 
    
49. #define CAN1_TX_GPIO_PORT          GPIOB
    
50. #define CAN1_RX_GPIO_PORT          GPIOB
    
51. 
    
52. #define CAN1_TX_GPIO_PIN           GPIO_Pin_9
    
53. #define CAN1_RX_GPIO_PIN           GPIO_Pin_8
    
54. 
    
55. #define CAN1_IRQ_PREEMPT_PRIORITY  (0)
    
56. #define CAN1_IRQ_SUB_PRIORITY      (0)
    
57. 
    
58. #define CAN1_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap1_CAN1 , ENABLE)
    
59. /******************************************************************************/
    
60. 
    
61. #ifdef STM32F10X_CL
    
62. /******************************* CAN2 Configure *******************************/
    
63. #define CAN2_TX_BUFFER_SIZE        (16)
    
64. #define CAN2_RX_BUFFER_SIZE        (16)
    
65. 
    
66. #define CAN2_TX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
67. #define CAN2_RX_GPIO_CLOCK         RCC_APB2Periph_GPIOB
    
68. 
    
69. #define CAN2_TX_GPIO_PORT          GPIOB
    
70. #define CAN2_RX_GPIO_PORT          GPIOB
    
71. 
    
72. #define CAN2_TX_GPIO_PIN           GPIO_Pin_13
    
73. #define CAN2_RX_GPIO_PIN           GPIO_Pin_12
    
74. 
    
75. #define CAN2_IRQ_PREEMPT_PRIORITY  (0)
    
76. #define CAN2_IRQ_SUB_PRIORITY      (0)
    
77. 
    
78. #define CAN2_PORT_REMAP()          GPIO_PinRemapConfig(GPIO_Remap_CAN2 , DISABLE)
    
79. /******************************************************************************/
    
80. #endif /* STM32F10X_CL */
    
81. 
    
82. /* Type definitions ----------------------------------------------------------*/
    
83. typedef enum
    
84. {
    
85.   CAN_WorkModeNormal   = CAN_Mode_Normal,
    
86.   CAN_WorkModeLoopBack = CAN_Mode_LoopBack
    
87. }CAN_WorkMode;
    
88. 
    
89. typedef enum
    
90. {
    
91.   CAN_BaudRate1000K = 6,
    
92.   CAN_BaudRate500K  = 12,
    
93.   CAN_BaudRate250K  = 24,
    
94.   CAN_BaudRate125K  = 48,
    
95.   CAN_BaudRate100K  = 60,
    
96.   CAN_BaudRate50K   = 120,
    
97.   CAN_BaudRate20K   = 300,
    
98.   CAN_BaudRate10K   = 600
    
99. }CAN_BaudRate;
    
100. 
     
101. /* Variable declarations -----------------------------------------------------*/
     
102. /* Variable definitions ------------------------------------------------------*/
     
103. /* Function declarations -----------------------------------------------------*/
     
104. void CAN_Configure(CAN_TypeDef *CANx, CAN_WorkMode WorkMode, CAN_BaudRate BaudRate, uint32_t StdId, uint32_t ExtId);
     
105. void CAN_Unconfigure(CAN_TypeDef *CANx);
     
106. 
     
107. void CAN_SetTransmitFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     
108. void CAN_SetReceiveFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void));
     
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);
     
112. 
     
113. uint32_t CAN_GetUsedTransmitBufferSize(CAN_TypeDef *CANx);
     
114. uint32_t CAN_GetUsedReceiveBufferSize(CAN_TypeDef *CANx);
     
115. uint32_t CAN_GetUnusedTransmitBufferSize(CAN_TypeDef *CANx);
     
116. uint32_t CAN_GetUnusedReceiveBufferSize(CAN_TypeDef *CANx);
     
117. 
     
118. bool CAN_IsTransmitBufferEmpty(CAN_TypeDef *CANx);
     
119. bool CAN_IsReceiveBufferEmpty(CAN_TypeDef *CANx);
     
120. bool CAN_IsTransmitBufferFull(CAN_TypeDef *CANx);
     
121. bool CAN_IsReceiveBufferFull(CAN_TypeDef *CANx);
     
122. 
     
123. void CAN_ClearTransmitBuffer(CAN_TypeDef *CANx);
     
124. void CAN_ClearReceiveBuffer(CAN_TypeDef *CANx);
     
125. 
     
126. bool CAN_IsTransmitMessage(CAN_TypeDef *CANx);
     
127. 
     
128. /* Function definitions ------------------------------------------------------*/
     
129. 
     
130. #ifdef __cplusplus
     
131. }
     
132. #endif
     
133. 
     
134. #endif /* __CAN_H */
     

复制代码

CAN.c 文件

1. /**
   
2.   ******************************************************************************
   
3.   * @file    CAN.c
   
4.   * @author  XinLi
   
5.   * @version v1.0
   
6.   * @date    24-June-2018
   
7.   * @brief   CAN module driver.
   
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    
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,
    
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.   ******************************************************************************
    
27.   */
    
28. 
    
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "CAN.h"
    
31. #include "RingBuffer.h"
    
32. 
    
33. /* Macro definitions ---------------------------------------------------------*/
    
34. /* Type definitions ----------------------------------------------------------*/
    
35. /* Variable declarations -----------------------------------------------------*/
    
36. static volatile bool can1InitFlag     = false;
    
37. static volatile bool can1TransmitFlag = false;
    
38. 
    
39. static volatile void (*can1TransmitFinishCallback)(void) = 0;
    
40. static volatile void (*can1ReceiveFinishCallback)(void)  = 0;
    
41. 
    
42. static RingBuffer *can1TxBuffer = 0;
    
43. static RingBuffer *can1RxBuffer = 0;
    
44. 
    
45. #ifdef STM32F10X_CL
    
46. static volatile bool can2InitFlag     = false;
    
47. static volatile bool can2TransmitFlag = false;
    
48. 
    
49. static volatile void (*can2TransmitFinishCallback)(void) = 0;
    
50. static volatile void (*can2ReceiveFinishCallback)(void)  = 0;
    
51. 
    
52. static RingBuffer *can2TxBuffer = 0;
    
53. static RingBuffer *can2RxBuffer = 0;
    
54. #endif /* STM32F10X_CL */
    
55. 
    
56. /* Variable definitions ------------------------------------------------------*/
    
57. /* Function declarations -----------------------------------------------------*/
    
58. /* Function definitions ------------------------------------------------------*/
    
59. 
    
60. /**
    
61.   * @brief  CAN configure.
    
62.   * @param  [in] CANx:     Where x can be 1 or 2 to select the CAN peripheral.
    
63.   * @param  [in] WorkMode: Work mode.
    
64.   * @param  [in] BaudRate: Communication baud rate.
    
65.   * @param  [in] StdId:    Filter standard frame ID.
    
66.   * @param  [in] ExtId:    Filter extended frame ID.
    
67.   * @return None.
    
68.   */
    
69. void CAN_Configure(CAN_TypeDef *CANx, CAN_WorkMode WorkMode, CAN_BaudRate BaudRate, uint32_t StdId, uint32_t ExtId)
    
70. {
    
71.   GPIO_InitTypeDef      GPIO_InitStructure      = {0};
    
72.   CAN_InitTypeDef       CAN_InitStructure       = {0};
    
73.   CAN_FilterInitTypeDef CAN_FilterInitStructure = {0};
    
74.   NVIC_InitTypeDef      NVIC_InitStructure      = {0};
    
75. 
    
76.   if(CANx == CAN1)
    
77.   {
    
78.     if(can1InitFlag == false)
    
79.     {
    
80.       can1InitFlag = true;
    
81. 
    
82.       can1TransmitFlag = false;
    
83. 
    
84.       can1TransmitFinishCallback = 0;
    
85.       can1ReceiveFinishCallback  = 0;
    
86. 
    
87.       can1TxBuffer = RingBuffer_Malloc(sizeof(CanTxMsg) * CAN1_TX_BUFFER_SIZE);
    
88.       can1RxBuffer = RingBuffer_Malloc(sizeof(CanRxMsg) * CAN1_RX_BUFFER_SIZE);
    
89. 
    
90. #ifdef STM32F10X_CL
    
91.       if(can2InitFlag == false)
    
92. #endif /* STM32F10X_CL */
    
93.       {
    
94.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    
95.       }
    
96. 
    
97.       RCC_APB2PeriphClockCmd(CAN1_TX_GPIO_CLOCK | CAN1_RX_GPIO_CLOCK | RCC_APB2Periph_AFIO, ENABLE);
    
98. 
    
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);
     
103. 
     
104.       GPIO_InitStructure.GPIO_Pin   = CAN1_RX_GPIO_PIN;
     
105.       GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IPU;
     
106.       GPIO_Init(CAN1_RX_GPIO_PORT, &GPIO_InitStructure);
     
107. 
     
108.       CAN1_PORT_REMAP();
     
109. 
     
110.       CAN_InitStructure.CAN_Prescaler = BaudRate;
     
111.       CAN_InitStructure.CAN_Mode      = WorkMode;
     
112.       CAN_InitStructure.CAN_SJW       = CAN_SJW_1tq;
     
113.       CAN_InitStructure.CAN_BS1       = CAN_BS1_3tq;
     
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;
     
119.       CAN_InitStructure.CAN_RFLM      = DISABLE;
     
120.       CAN_InitStructure.CAN_TXFP      = ENABLE;
     
121. 
     
122.       CAN_DeInit(CAN1);
     
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);
     
127.       CAN_FilterInitStructure.CAN_FilterMaskIdHigh     = (~((uint16_t)((((StdId<<18)|ExtId)<<3)>>16)))&0xFFFF;
     
128.       CAN_FilterInitStructure.CAN_FilterMaskIdLow      = (~((uint16_t)(((StdId<<18)|ExtId)<<3)))&0xFFF8;
     
129.       CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_Filter_FIFO0;
     
130.       CAN_FilterInitStructure.CAN_FilterNumber         = 0;
     
131.       CAN_FilterInitStructure.CAN_FilterMode           = CAN_FilterMode_IdMask;
     
132.       CAN_FilterInitStructure.CAN_FilterScale          = CAN_FilterScale_32bit;
     
133.       CAN_FilterInitStructure.CAN_FilterActivation     = ENABLE;
     
134.       CAN_FilterInit(&CAN_FilterInitStructure);
     
135. 
     
136.       CAN_ITConfig(CAN1, CAN_IT_TME | CAN_IT_FMP0 |CAN_IT_FF0 | CAN_IT_FOV0 | CAN_IT_FMP1 | CAN_IT_FF1 | CAN_IT_FOV1 |
     
137.                          CAN_IT_WKU | CAN_IT_SLK  |CAN_IT_EWG | CAN_IT_EPV  | CAN_IT_BOF  | CAN_IT_LEC | CAN_IT_ERR, DISABLE);
     
138.       CAN_ITConfig(CAN1, CAN_IT_TME | CAN_IT_FMP0, ENABLE);
     
139. 
     
140. #ifdef STM32F10X_CL
     
141.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN1_TX_IRQn;
     
142. #else
     
143.       NVIC_InitStructure.NVIC_IRQChannel                   = USB_HP_CAN1_TX_IRQn;
     
144. #endif /* STM32F10X_CL */
     
145. 
     
146.       NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = CAN1_IRQ_PREEMPT_PRIORITY;
     
147.       NVIC_InitStructure.NVIC_IRQChannelSubPriority        = CAN1_IRQ_SUB_PRIORITY;
     
148.       NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
     
149.       NVIC_Init(&NVIC_InitStructure);
     
150. 
     
151. #ifdef STM32F10X_CL
     
152.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN1_RX0_IRQn;
     
153. #else
     
154.       NVIC_InitStructure.NVIC_IRQChannel                   = USB_LP_CAN1_RX0_IRQn;
     
155. #endif /* STM32F10X_CL */
     
156. 
     
157.       NVIC_Init(&NVIC_InitStructure);
     
158.     }
     
159.   }
     
160. 
     
161. #ifdef STM32F10X_CL
     
162.   if(CANx == CAN2)
     
163.   {
     
164.     if(can2InitFlag == false)
     
165.     {
     
166.       can2InitFlag = true;
     
167. 
     
168.       can2TransmitFlag = false;
     
169. 
     
170.       can2TransmitFinishCallback = 0;
     
171.       can2ReceiveFinishCallback  = 0;
     
172. 
     
173.       can2TxBuffer = RingBuffer_Malloc(sizeof(CanTxMsg) * CAN2_TX_BUFFER_SIZE);
     
174.       can2RxBuffer = RingBuffer_Malloc(sizeof(CanRxMsg) * CAN2_RX_BUFFER_SIZE);
     
175. 
     
176.       if(can1InitFlag == false)
     
177.       {
     
178.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
     
179.       }
     
180. 
     
181.       RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, ENABLE);
     
182.       RCC_APB2PeriphClockCmd(CAN2_TX_GPIO_CLOCK | CAN2_RX_GPIO_CLOCK | RCC_APB2Periph_AFIO, ENABLE);
     
183. 
     
184.       GPIO_InitStructure.GPIO_Pin   = CAN2_TX_GPIO_PIN;
     
185.       GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
     
186.       GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
187.       GPIO_Init(CAN2_TX_GPIO_PORT, &GPIO_InitStructure);
     
188. 
     
189.       GPIO_InitStructure.GPIO_Pin   = CAN2_RX_GPIO_PIN;
     
190.       GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IPU;
     
191.       GPIO_Init(CAN2_RX_GPIO_PORT, &GPIO_InitStructure);
     
192. 
     
193.       CAN2_PORT_REMAP();
     
194. 
     
195.       CAN_InitStructure.CAN_Prescaler = BaudRate;
     
196.       CAN_InitStructure.CAN_Mode      = WorkMode;
     
197.       CAN_InitStructure.CAN_SJW       = CAN_SJW_1tq;
     
198.       CAN_InitStructure.CAN_BS1       = CAN_BS1_3tq;
     
199.       CAN_InitStructure.CAN_BS2       = CAN_BS2_2tq;
     
200.       CAN_InitStructure.CAN_TTCM      = DISABLE;
     
201.       CAN_InitStructure.CAN_ABOM      = ENABLE;
     
202.       CAN_InitStructure.CAN_AWUM      = DISABLE;
     
203.       CAN_InitStructure.CAN_NART      = ENABLE;
     
204.       CAN_InitStructure.CAN_RFLM      = DISABLE;
     
205.       CAN_InitStructure.CAN_TXFP      = ENABLE;
     
206. 
     
207.       CAN_DeInit(CAN2);
     
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);
     
212.       CAN_FilterInitStructure.CAN_FilterMaskIdHigh     = (~((uint16_t)((((StdId<<18)|ExtId)<<3)>>16)))&0xFFFF;
     
213.       CAN_FilterInitStructure.CAN_FilterMaskIdLow      = (~((uint16_t)(((StdId<<18)|ExtId)<<3)))&0xFFF8;
     
214.       CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_Filter_FIFO0;
     
215.       CAN_FilterInitStructure.CAN_FilterNumber         = 14;
     
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);
     
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. 
     
225.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN2_TX_IRQn;
     
226.       NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = CAN2_IRQ_PREEMPT_PRIORITY;
     
227.       NVIC_InitStructure.NVIC_IRQChannelSubPriority        = CAN2_IRQ_SUB_PRIORITY;
     
228.       NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
     
229.       NVIC_Init(&NVIC_InitStructure);
     
230. 
     
231.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN2_RX0_IRQn;
     
232.       NVIC_Init(&NVIC_InitStructure);
     
233.     }
     
234.   }
     
235. #endif /* STM32F10X_CL */
     
236. }
     
237. 
     
238. /**
     
239.   * @brief  CAN unconfigure.
     
240.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     
241.   * @return None.
     
242.   */
     
243. void CAN_Unconfigure(CAN_TypeDef *CANx)
     
244. {
     
245.   NVIC_InitTypeDef NVIC_InitStructure = {0};
     
246. 
     
247.   if(CANx == CAN1)
     
248.   {
     
249.     if(can1InitFlag == true)
     
250.     {
     
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 */
     
258. 
     
259.       NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = CAN1_IRQ_PREEMPT_PRIORITY;
     
260.       NVIC_InitStructure.NVIC_IRQChannelSubPriority        = CAN1_IRQ_SUB_PRIORITY;
     
261.       NVIC_InitStructure.NVIC_IRQChannelCmd                = DISABLE;
     
262.       NVIC_Init(&NVIC_InitStructure);
     
263. 
     
264. #ifdef STM32F10X_CL
     
265.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN1_RX0_IRQn;
     
266. #else
     
267.       NVIC_InitStructure.NVIC_IRQChannel                   = USB_LP_CAN1_RX0_IRQn;
     
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.       }
     
280. 
     
281.       can1TransmitFlag = false;
     
282. 
     
283.       can1TransmitFinishCallback = 0;
     
284.       can1ReceiveFinishCallback  = 0;
     
285. 
     
286.       RingBuffer_Free(can1TxBuffer);
     
287.       RingBuffer_Free(can1RxBuffer);
     
288.     }
     
289.   }
     
290. 
     
291. #ifdef STM32F10X_CL
     
292.   if(CANx == CAN2)
     
293.   {
     
294.     if(can2InitFlag == true)
     
295.     {
     
296.       can2InitFlag = false;
     
297. 
     
298.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN2_TX_IRQn;
     
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. 
     
304.       NVIC_InitStructure.NVIC_IRQChannel                   = CAN2_RX0_IRQn;
     
305.       NVIC_Init(&NVIC_InitStructure);
     
306. 
     
307.       CAN_DeInit(CAN2);
     
308. 
     
309.       if(can1InitFlag == false)
     
310.       {
     
311.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, DISABLE);
     
312.       }
     
313. 
     
314.       RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, DISABLE);
     
315. 
     
316.       can2TransmitFlag = false;
     
317. 
     
318.       can2TransmitFinishCallback = 0;
     
319.       can2ReceiveFinishCallback  = 0;
     
320. 
     
321.       RingBuffer_Free(can2TxBuffer);
     
322.       RingBuffer_Free(can2RxBuffer);
     
323.     }
     
324.   }
     
325. #endif /* STM32F10X_CL */
     
326. }
     
327. 
     
328. /**
     
329.   * @brief  CAN set transmit finish callback.
     
330.   * @param  [in] CANx:     Where x can be 1 or 2 to select the CAN peripheral.
     
331.   * @param  [in] Callback: Callback.
     
332.   * @return None.
     
333.   */
     
334. void CAN_SetTransmitFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void))
     
335. {
     
336.   if(CANx == CAN1)
     
337.   {
     
338.     if(can1InitFlag == true)
     
339.     {
     
340.       can1TransmitFinishCallback = (volatile void (*)(void))Callback;
     
341.     }
     
342.   }
     
343. 
     
344. #ifdef STM32F10X_CL
     
345.   if(CANx == CAN2)
     
346.   {
     
347.     if(can2InitFlag == true)
     
348.     {
     
349.       can2TransmitFinishCallback = (volatile void (*)(void))Callback;
     
350.     }
     
351.   }
     
352. #endif /* STM32F10X_CL */
     
353. }
     
354. 
     
355. /**
     
356.   * @brief  CAN set receive finish callback.
     
357.   * @param  [in] CANx:     Where x can be 1 or 2 to select the CAN peripheral.
     
358.   * @param  [in] Callback: Callback.
     
359.   * @return None.
     
360.   */
     
361. void CAN_SetReceiveFinishCallback(CAN_TypeDef *CANx, void (*Callback)(void))
     
362. {
     
363.   if(CANx == CAN1)
     
364.   {
     
365.     if(can1InitFlag == true)
     
366.     {
     
367.       can1ReceiveFinishCallback = (volatile void (*)(void))Callback;
     
368.     }
     
369.   }
     
370. 
     
371. #ifdef STM32F10X_CL
     
372.   if(CANx == CAN2)
     
373.   {
     
374.     if(can2InitFlag == true)
     
375.     {
     
376.       can2ReceiveFinishCallback = (volatile void (*)(void))Callback;
     
377.     }
     
378.   }
     
379. #endif /* STM32F10X_CL */
     
380. }
     
381. 
     
382. /**
     
383.   * @brief  CAN set transmit message.
     
384.   * @param  [in] CANx:    Where x can be 1 or 2 to select the CAN peripheral.
     
385.   * @param  [in] Message: The address of the message to be transmit.
     
386.   * @param  [in] Number:  The number of the message to be transmit.
     
387.   * @return The number of message transmit.
     
388.   */
     
389. uint32_t CAN_SetTransmitMessage(CAN_TypeDef *CANx, CanTxMsg *Message, uint32_t Number)
     
390. {
     
391.   if(CANx == CAN1)
     
392.   {
     
393.     if(can1InitFlag == true)
     
394.     {
     
395.       uint32_t available = RingBuffer_Avail(can1TxBuffer) / sizeof(CanTxMsg);
     
396. 
     
397.       if(available > Number)
     
398.       {
     
399.         Number = RingBuffer_In(can1TxBuffer, Message, sizeof(CanTxMsg) * Number) / sizeof(CanTxMsg);
     
400.       }
     
401.       else
     
402.       {
     
403.         Number = RingBuffer_In(can1TxBuffer, Message, sizeof(CanTxMsg) * available) / sizeof(CanTxMsg);
     
404.       }
     
405. 
     
406.       if(Number > 0)
     
407.       {
     
408.         if(can1TransmitFlag == false)
     
409.         {
     
410.           can1TransmitFlag = true;
     
411. 
     
412.           CanTxMsg canTxMsg = {0};
     
413.           RingBuffer_Out(can1TxBuffer, &canTxMsg, sizeof(canTxMsg));
     
414.           CAN_Transmit(CAN1, &canTxMsg);
     
415.         }
     
416.       }
     
417. 
     
418.       return Number;
     
419.     }
     
420.   }
     
421. 
     
422. #ifdef STM32F10X_CL
     
423.   if(CANx == CAN2)
     
424.   {
     
425.     if(can2InitFlag == true)
     
426.     {
     
427.       uint32_t available = RingBuffer_Avail(can2TxBuffer) / sizeof(CanTxMsg);
     
428. 
     
429.       if(available > Number)
     
430.       {
     
431.         Number = RingBuffer_In(can2TxBuffer, Message, sizeof(CanTxMsg) * Number) / sizeof(CanTxMsg);
     
432.       }
     
433.       else
     
434.       {
     
435.         Number = RingBuffer_In(can2TxBuffer, Message, sizeof(CanTxMsg) * available) / sizeof(CanTxMsg);
     
436.       }
     
437. 
     
438.       if(Number > 0)
     
439.       {
     
440.         if(can2TransmitFlag == false)
     
441.         {
     
442.           can2TransmitFlag = true;
     
443. 
     
444.           CanTxMsg canTxMsg = {0};
     
445.           RingBuffer_Out(can2TxBuffer, &canTxMsg, sizeof(canTxMsg));
     
446.           CAN_Transmit(CAN2, &canTxMsg);
     
447.         }
     
448.       }
     
449. 
     
450.       return Number;
     
451.     }
     
452.   }
     
453. #endif /* STM32F10X_CL */
     
454. 
     
455.   return 0;
     
456. }
     
457. 
     
458. /**
     
459.   * @brief  CAN get receive message.
     
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.
     
464.   */
     
465. uint32_t CAN_GetReceiveMessage(CAN_TypeDef *CANx, CanRxMsg *Message, uint32_t Number)
     
466. {
     
467.   if(CANx == CAN1)
     
468.   {
     
469.     if(can1InitFlag == true)
     
470.     {
     
471.       return RingBuffer_Out(can1RxBuffer, Message, sizeof(CanRxMsg) * Number) / sizeof(CanRxMsg);
     
472.     }
     
473.   }
     
474. 
     
475. #ifdef STM32F10X_CL
     
476.   if(CANx == CAN2)
     
477.   {
     
478.     if(can2InitFlag == true)
     
479.     {
     
480.       return RingBuffer_Out(can2RxBuffer, Message, sizeof(CanRxMsg) * Number) / sizeof(CanRxMsg);
     
481.     }
     
482.   }
     
483. #endif /* STM32F10X_CL */
     
484. 
     
485.   return 0;
     
486. }
     
487. 
     
488. /**
     
489.   * @brief  Get the size of the CAN transmit buffer used.
     
490.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     
491.   * @return Used the size of the transmit buffer.
     
492.   */
     
493. uint32_t CAN_GetUsedTransmitBufferSize(CAN_TypeDef *CANx)
     
494. {
     
495.   if(CANx == CAN1)
     
496.   {
     
497.     if(can1InitFlag == true)
     
498.     {
     
499.       return RingBuffer_Len(can1TxBuffer) / sizeof(CanTxMsg);
     
500.     }
     
501.   }
     
502. 
     
503. #ifdef STM32F10X_CL
     
504.   if(CANx == CAN2)
     
505.   {
     
506.     if(can2InitFlag == true)
     
507.     {
     
508.       return RingBuffer_Len(can2TxBuffer) / sizeof(CanTxMsg);
     
509.     }
     
510.   }
     
511. #endif /* STM32F10X_CL */
     
512. 
     
513.   return 0;
     
514. }
     
515. 
     
516. /**
     
517.   * @brief  Get the size of the CAN receive buffer used.
     
518.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     
519.   * @return Used the size of the receive buffer.
     
520.   */
     
521. uint32_t CAN_GetUsedReceiveBufferSize(CAN_TypeDef *CANx)
     
522. {
     
523.   if(CANx == CAN1)
     
524.   {
     
525.     if(can1InitFlag == true)
     
526.     {
     
527.       return RingBuffer_Len(can1RxBuffer) / sizeof(CanRxMsg);
     
528.     }
     
529.   }
     
530. 
     
531. #ifdef STM32F10X_CL
     
532.   if(CANx == CAN2)
     
533.   {
     
534.     if(can2InitFlag == true)
     
535.     {
     
536.       return RingBuffer_Len(can2RxBuffer) / sizeof(CanRxMsg);
     
537.     }
     
538.   }
     
539. #endif /* STM32F10X_CL */
     
540. 
     
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.
     
547.   * @return Unused the size of the transmit buffer.
     
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.   }
     
558. 
     
559. #ifdef STM32F10X_CL
     
560.   if(CANx == CAN2)
     
561.   {
     
562.     if(can2InitFlag == true)
     
563.     {
     
564.       return RingBuffer_Avail(can2TxBuffer) / sizeof(CanTxMsg);
     
565.     }
     
566.   }
     
567. #endif /* STM32F10X_CL */
     
568. 
     
569.   return 0;
     
570. }
     
571. 
     
572. /**
     
573.   * @brief  Get the size of the CAN receive buffer unused.
     
574.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     
575.   * @return Unused the size of the receive buffer.
     
576.   */
     
577. uint32_t CAN_GetUnusedReceiveBufferSize(CAN_TypeDef *CANx)
     
578. {
     
579.   if(CANx == CAN1)
     
580.   {
     
581.     if(can1InitFlag == true)
     
582.     {
     
583.       return RingBuffer_Avail(can1RxBuffer) / sizeof(CanRxMsg);
     
584.     }
     
585.   }
     
586. 
     
587. #ifdef STM32F10X_CL
     
588.   if(CANx == CAN2)
     
589.   {
     
590.     if(can2InitFlag == true)
     
591.     {
     
592.       return RingBuffer_Avail(can2RxBuffer) / sizeof(CanRxMsg);
     
593.     }
     
594.   }
     
595. #endif /* STM32F10X_CL */
     
596. 
     
597.   return 0;
     
598. }
     
599. 
     
600. /**
     
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)
     
607. {
     
608.   if(CANx == CAN1)
     
609.   {
     
610.     if(can1InitFlag == true)
     
611.     {
     
612.       return !(RingBuffer_Len(can1TxBuffer) / sizeof(CanTxMsg));
     
613.     }
     
614.   }
     
615. 
     
616. #ifdef STM32F10X_CL
     
617.   if(CANx == CAN2)
     
618.   {
     
619.     if(can2InitFlag == true)
     
620.     {
     
621.       return !(RingBuffer_Len(can2TxBuffer) / sizeof(CanTxMsg));
     
622.     }
     
623.   }
     
624. #endif /* STM32F10X_CL */
     
625. 
     
626.   return false;
     
627. }
     
628. 
     
629. /**
     
630.   * @brief  Is the CAN receive buffer empty?
     
631.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     
632.   * @retval true:      The receive buffer is empty.
     
633.   * @retval false:     The receive buffer is not empty.
     
634.   */
     
635. bool CAN_IsReceiveBufferEmpty(CAN_TypeDef *CANx)
     
636. {
     
637.   if(CANx == CAN1)
     
638.   {
     
639.     if(can1InitFlag == true)
     
640.     {
     
641.       return !(RingBuffer_Len(can1RxBuffer) / sizeof(CanRxMsg));
     
642.     }
     
643.   }
     
644. 
     
645. #ifdef STM32F10X_CL
     
646.   if(CANx == CAN2)
     
647.   {
     
648.     if(can2InitFlag == true)
     
649.     {
     
650.       return !(RingBuffer_Len(can2RxBuffer) / sizeof(CanRxMsg));
     
651.     }
     
652.   }
     
653. #endif /* STM32F10X_CL */
     
654. 
     
655.   return false;
     
656. }
     
657. 
     
658. /**
     
659.   * @brief  Is the CAN transmit buffer full?
     
660.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     
661.   * @retval true:      The transmit buffer is full.
     
662.   * @retval false:     The transmit buffer is not full.
     
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));
     
671.     }
     
672.   }
     
673. 
     
674. #ifdef STM32F10X_CL
     
675.   if(CANx == CAN2)
     
676.   {
     
677.     if(can2InitFlag == true)
     
678.     {
     
679.       return !(RingBuffer_Avail(can2TxBuffer) / sizeof(CanTxMsg));
     
680.     }
     
681.   }
     
682. #endif /* STM32F10X_CL */
     
683. 
     
684.   return false;
     
685. }
     
686. 
     
687. /**
     
688.   * @brief  Is the CAN receive buffer full?
     
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.   */
     
693. bool CAN_IsReceiveBufferFull(CAN_TypeDef *CANx)
     
694. {
     
695.   if(CANx == CAN1)
     
696.   {
     
697.     if(can1InitFlag == true)
     
698.     {
     
699.       return !(RingBuffer_Avail(can1RxBuffer) / sizeof(CanRxMsg));
     
700.     }
     
701.   }
     
702. 
     
703. #ifdef STM32F10X_CL
     
704.   if(CANx == CAN2)
     
705.   {
     
706.     if(can2InitFlag == true)
     
707.     {
     
708.       return !(RingBuffer_Avail(can2RxBuffer) / sizeof(CanRxMsg));
     
709.     }
     
710.   }
     
711. #endif /* STM32F10X_CL */
     
712. 
     
713.   return false;
     
714. }
     
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.
     
719.   * @return None.
     
720.   */
     
721. void CAN_ClearTransmitBuffer(CAN_TypeDef *CANx)
     
722. {
     
723.   if(CANx == CAN1)
     
724.   {
     
725.     if(can1InitFlag == true)
     
726.     {
     
727.       RingBuffer_Reset(can1TxBuffer);
     
728.     }
     
729.   }
     
730. 
     
731. #ifdef STM32F10X_CL
     
732.   if(CANx == CAN2)
     
733.   {
     
734.     if(can2InitFlag == true)
     
735.     {
     
736.       RingBuffer_Reset(can2TxBuffer);
     
737.     }
     
738.   }
     
739. #endif /* STM32F10X_CL */
     
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.
     
745.   * @return None.
     
746.   */
     
747. void CAN_ClearReceiveBuffer(CAN_TypeDef *CANx)
     
748. {
     
749.   if(CANx == CAN1)
     
750.   {
     
751.     if(can1InitFlag == true)
     
752.     {
     
753.       RingBuffer_Reset(can1RxBuffer);
     
754.     }
     
755.   }
     
756. 
     
757. #ifdef STM32F10X_CL
     
758.   if(CANx == CAN2)
     
759.   {
     
760.     if(can2InitFlag == true)
     
761.     {
     
762.       RingBuffer_Reset(can2RxBuffer);
     
763.     }
     
764.   }
     
765. #endif /* STM32F10X_CL */
     
766. }
     
767. 
     
768. /**
     
769.   * @brief  Is the CAN transmit a message?
     
770.   * @param  [in] CANx: Where x can be 1 or 2 to select the CAN peripheral.
     
771.   * @retval true:      Is transmit a message.
     
772.   * @retval false:     Not transmit a message.
     
773.   */
     
774. bool CAN_IsTransmitMessage(CAN_TypeDef *CANx)
     
775. {
     
776.   if(CANx == CAN1)
     
777.   {
     
778.     if(can1InitFlag == true)
     
779.     {
     
780.       return can1TransmitFlag;
     
781.     }
     
782.   }
     
783. 
     
784. #ifdef STM32F10X_CL
     
785.   if(CANx == CAN2)
     
786.   {
     
787.     if(can2InitFlag == true)
     
788.     {
     
789.       return can2TransmitFlag;
     
790.     }
     
791.   }
     
792. #endif /* STM32F10X_CL */
     
793. 
     
794.   return false;
     
795. }
     
796. 
     
797. /**
     
798.   * @brief  This function handles CAN1 TX Handler.
     
799.   * @param  None.
     
800.   * @return None.
     
801.   */
     
802. #ifdef STM32F10X_CL
     
803. void CAN1_TX_IRQHandler(void)
     
804. #else
     
805. void USB_HP_CAN1_TX_IRQHandler(void)
     
806. #endif /* STM32F10X_CL */
     
807. {
     
808.   if(CAN_GetITStatus(CAN1, CAN_IT_TME) != RESET)
     
809.   {
     
810.     CAN_ClearITPendingBit(CAN1, CAN_IT_TME);
     
811. 
     
812.     CanTxMsg canTxMsg = {0};
     
813.     uint8_t  number   = RingBuffer_Out(can1TxBuffer, &canTxMsg, sizeof(canTxMsg)) / sizeof(canTxMsg);
     
814. 
     
815.     if(number > 0)
     
816.     {
     
817.       CAN_Transmit(CAN1, &canTxMsg);
     
818.     }
     
819.     else
     
820.     {
     
821.       can1TransmitFlag = false;
     
822. 
     
823.       if(can1TransmitFinishCallback != 0)
     
824.       {
     
825.         can1TransmitFinishCallback();
     
826.       }
     
827.     }
     
828.   }
     
829. }
     
830. 
     
831. /**
     
832.   * @brief  This function handles CAN1 RX0 Handler.
     
833.   * @param  None.
     
834.   * @return None.
     
835.   */
     
836. #ifdef STM32F10X_CL
     
837. void CAN1_RX0_IRQHandler(void)
     
838. #else
     
839. void USB_LP_CAN1_RX0_IRQHandler(void)
     
840. #endif /* STM32F10X_CL */
     
841. {
     
842.   if(CAN_GetITStatus(CAN1, CAN_IT_FMP0) != RESET)
     
843.   {
     
844.     CAN_ClearITPendingBit(CAN1, CAN_IT_FMP0);
     
845. 
     
846.     CanRxMsg canRxMsg = {0};
     
847.     CAN_Receive(CAN1, CAN_FIFO0, &canRxMsg);
     
848. 
     
849.     if(RingBuffer_Avail(can1RxBuffer) / sizeof(CanRxMsg) > 0)
     
850.     {
     
851.       RingBuffer_In(can1RxBuffer, &canRxMsg, sizeof(canRxMsg));
     
852.     }
     
853. 
     
854.     if(can1ReceiveFinishCallback != 0)
     
855.     {
     
856.       can1ReceiveFinishCallback();
     
857.     }
     
858.   }
     
859. }
     
860. 
     
861. #ifdef STM32F10X_CL
     
862. /**
     
863.   * @brief  This function handles CAN2 TX Handler.
     
864.   * @param  None.
     
865.   * @return None.
     
866.   */
     
867. void CAN2_TX_IRQHandler(void)
     
868. {
     
869.   if(CAN_GetITStatus(CAN2, CAN_IT_TME) != RESET)
     
870.   {
     
871.     CAN_ClearITPendingBit(CAN2, CAN_IT_TME);
     
872. 
     
873.     CanTxMsg canTxMsg = {0};
     
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
     
881.     {
     
882.       can2TransmitFlag = false;
     
883. 
     
884.       if(can2TransmitFinishCallback != 0)
     
885.       {
     
886.         can2TransmitFinishCallback();
     
887.       }
     
888.     }
     
889.   }
     
890. }
     
891. 
     
892. /**
     
893.   * @brief  This function handles CAN2 RX0 Handler.
     
894.   * @param  None.
     
895.   * @return None.
     
896.   */
     
897. void CAN2_RX0_IRQHandler(void)
     
898. {
     
899.   if(CAN_GetITStatus(CAN2, CAN_IT_FMP0) != RESET)
     
900.   {
     
901.     CAN_ClearITPendingBit(CAN2, CAN_IT_FMP0);
     
902. 
     
903.     CanRxMsg canRxMsg = {0};
     
904.     CAN_Receive(CAN2, CAN_FIFO0, &canRxMsg);
     
905. 
     
906.     if(RingBuffer_Avail(can2RxBuffer) / sizeof(CanRxMsg) > 0)
     
907.     {
     
908.       RingBuffer_In(can2RxBuffer, &canRxMsg, sizeof(canRxMsg));
     
909.     }
     
910. 
     
911.     if(can2ReceiveFinishCallback != 0)
     
912.     {
     
913.       can2ReceiveFinishCallback();
     
914.     }
     
915.   }
     
916. }
     
917. #endif /* STM32F10X_CL */
     

复制代码

main.h 文件

1. /**
   
2.   ******************************************************************************
   
3.   * @file    main.h
   
4.   * @author  XinLi
   
5.   * @version v1.0
   
6.   * @date    24-June-2018
   
7.   * @brief   Header file for main.c module.
   
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    
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,
    
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.   ******************************************************************************
    
27.   */
    
28. 
    
29. #ifndef __MAIN_H
    
30. #define __MAIN_H
    
31. 
    
32. #ifdef __cplusplus
    
33. extern "C" {
    
34. #endif
    
35. 
    
36. /* Header includes -----------------------------------------------------------*/
    
37. #include "stm32f10x.h"
    
38. 
    
39. /* Macro definitions ---------------------------------------------------------*/
    
40. /* Type definitions ----------------------------------------------------------*/
    
41. /* Variable declarations -----------------------------------------------------*/
    
42. /* Variable definitions ------------------------------------------------------*/
    
43. /* Function declarations -----------------------------------------------------*/
    
44. /* Function definitions ------------------------------------------------------*/
    
45. 
    
46. #ifdef __cplusplus
    
47. }
    
48. #endif
    
49. 
    
50. #endif /* __MAIN_H */

复制代码

main.c 文件

1. /**
   
2.   ******************************************************************************
   
3.   * @file    main.c
   
4.   * @author  XinLi
   
5.   * @version v1.0
   
6.   * @date    24-June-2018
   
7.   * @brief   Main program body.
   
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    
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,
    
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.   ******************************************************************************
    
27.   */
    
28. 
    
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "main.h"
    
31. #include "CAN.h"
    
32. 
    
33. #ifdef _RTE_
    
34. #include "RTE_Components.h"
    
35. #endif
    
36. 
    
37. #ifdef RTE_CMSIS_RTOS2
    
38. #include "cmsis_os2.h"
    
39. #endif
    
40. 
    
41. /* Macro definitions ---------------------------------------------------------*/
    
42. /* Type definitions ----------------------------------------------------------*/
    
43. /* Variable declarations -----------------------------------------------------*/
    
44. /* Variable definitions ------------------------------------------------------*/
    
45. static CanTxMsg canTxMsg = {0};
    
46. static CanRxMsg canRxMsg = {0};
    
47. 
    
48. /* Function declarations -----------------------------------------------------*/
    
49. static void SystemClock_Config(void);
    
50. 
    
51. /* Function definitions ------------------------------------------------------*/
    
52. 
    
53. /**
    
54.   * @brief  Main program.
    
55.   * @param  None.
    
56.   * @return None.
    
57.   */
    
58. int main(void)
    
59. {
    
60.   /* Configure the system clock to 72 MHz */
    
61.   SystemClock_Config();
    
62.   SystemCoreClockUpdate();
    
63. 
    
64.   /* Add your application code here */
    
65.   CAN_Configure(CAN1, CAN_WorkModeLoopBack, CAN_BaudRate250K, 0xAA55, 0x55AA);
    
66. 
    
67. #ifdef RTE_CMSIS_RTOS2
    
68.   /* Initialize CMSIS-RTOS2 */
    
69.   osKernelInitialize();
    
70. 
    
71.   /* Create thread functions that start executing,
    
72.   Example: osThreadNew(app_main, NULL, NULL); */
    
73. 
    
74.   /* Start thread execution */
    
75.   osKernelStart();
    
76. #endif
    
77. 
    
78.   /* Infinite loop */
    
79.   while(1)
    
80.   {
    
81.     canTxMsg.StdId = 0xAA55;
    
82.     canTxMsg.ExtId = 0x55AA;
    
83.     canTxMsg.IDE   = CAN_ID_STD;
    
84.     canTxMsg.RTR   = CAN_RTR_DATA;
    
85.     canTxMsg.DLC   = 8;
    
86. 
    
87.     canTxMsg.Data[0]++;
    
88.     canTxMsg.Data[1]++;
    
89.     canTxMsg.Data[2]++;
    
90.     canTxMsg.Data[3]++;
    
91.     canTxMsg.Data[4]++;
    
92.     canTxMsg.Data[5]++;
    
93.     canTxMsg.Data[6]++;
    
94.     canTxMsg.Data[7]++;
    
95. 
    
96.     CAN_SetTransmitMessage(CAN1, &canTxMsg, 1);
    
97. 
    
98.     while(CAN_IsReceiveBufferEmpty(CAN1) == true);
    
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)
     
108.   *            SYSCLK(Hz)                     = 72000000
     
109.   *            HCLK(Hz)                       = 72000000
     
110.   *            AHB Prescaler                  = 1
     
111.   *            APB1 Prescaler                 = 2
     
112.   *            APB2 Prescaler                 = 1
     
113.   *            HSE Frequency(Hz)              = 8000000
     
114.   *            HSE PREDIV1                    = 1
     
115.   *            PLLMUL                         = 9
     
116.   *            Flash Latency(WS)              = 2
     
117.   * @param  None.
     
118.   * @return None.
     
119.   */
     
120. static void SystemClock_Config(void)
     
121. {
     
122.   /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration */
     
123.   /* RCC system reset */
     
124.   RCC_DeInit();
     
125. 
     
126.   /* Enable HSE */
     
127.   RCC_HSEConfig(RCC_HSE_ON);
     
128. 
     
129.   /* Wait till HSE is ready */
     
130.   ErrorStatus HSEStartUpStatus = RCC_WaitForHSEStartUp();
     
131. 
     
132.   if(HSEStartUpStatus == SUCCESS)
     
133.   {
     
134.     /* Enable Prefetch Buffer */
     
135.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     
136. 
     
137.     /* Flash 2 wait state */
     
138.     FLASH_SetLatency(FLASH_Latency_2);
     
139. 
     
140.     /* HCLK = SYSCLK */
     
141.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     
142. 
     
143.     /* PCLK2 = HCLK */
     
144.     RCC_PCLK2Config(RCC_HCLK_Div1);
     
145. 
     
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. 
     
155.     /* Enable PLL2 */
     
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);
     
163.     RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_9);
     
164. #else
     
165.     /* PLLCLK = HSE(8MHz) * 9 = 72MHz */
     
166.     RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
     
167. #endif
     
168. 
     
169.     /* Enable PLL */
     
170.     RCC_PLLCmd(ENABLE);
     
171. 
     
172.     /* Wait till PLL is ready */
     
173.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     
174. 
     
175.     /* Select PLL as system clock source */
     
176.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     
177. 
     
178.     /* Wait till PLL is used as system clock source */
     
179.     while(RCC_GetSYSCLKSource() != 0x08);
     
180.   }
     
181.   else
     
182.   {
     
183.     /* Disable HSE */
     
184.     RCC_HSEConfig(RCC_HSE_OFF);
     
185. 
     
186.     /* Enable HSI */
     
187.     RCC_HSICmd(ENABLE);
     
188. 
     
189.     /* Enable Prefetch Buffer */
     
190.     FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     
191. 
     
192.     /* Flash 1 wait state */
     
193.     FLASH_SetLatency(FLASH_Latency_1);
     
194. 
     
195.     /* HCLK = SYSCLK */
     
196.     RCC_HCLKConfig(RCC_SYSCLK_Div1);
     
197. 
     
198.     /* PCLK2 = HCLK */
     
199.     RCC_PCLK2Config(RCC_HCLK_Div1);
     
200. 
     
201.     /* PCLK1 = HCLK */
     
202.     RCC_PCLK1Config(RCC_HCLK_Div1);
     
203. 
     
204.     /* Configure PLLs */
     
205.     /* PLLCLK = HSI(8MHz) / 2 * 9 = 36MHz */
     
206.     RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_9);
     
207. 
     
208.     /* Enable PLL */
     
209.     RCC_PLLCmd(ENABLE);
     
210. 
     
211.     /* Wait till PLL is ready */
     
212.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     
213. 
     
214.     /* Select PLL as system clock source */
     
215.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     
216. 
     
217.     /* Wait till PLL is used as system clock source */
     
218.     while(RCC_GetSYSCLKSource() != 0x08);
     
219.   }
     
220. }
     
221. 
     
222. #ifdef USE_FULL_ASSERT
     
223. /**
     
224.   * @brief  Reports the name of the source file and the source line number
     
225.   *         where the assert_param error has occurred.
     
226.   * @param  file: pointer to the source file name.
     
227.   * @param  line: assert_param error line source number.
     
228.   * @return None.
     
229.   */
     
230. void assert_failed(uint8_t *file, uint32_t line)
     
231. {
     
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. 
     
235.   /* Infinite loop */
     
236.   while(1)
     
237.   {
     
238.   }
     
239. }
     
240. #endif

复制代码

3，注意

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