【一起来玩RTOS系列】之RT-Thread 邮箱用于线程间通信

bigfanofloT

邮箱

邮箱服务是实时操作系统中一种典型的任务间通信方法，特点是开销比较低，效率较高。邮箱中的每一封邮件只能容纳固定的4字节内容（针对32位处理系统，指针的大小即为4个字节，所以一封邮件恰好能够容纳一个指针）。典型的邮箱也称作交换消息，如图所示，线程或中断服务例程把一封4字节长度的邮件发送到邮箱中。而一个或多个线程可以从邮箱中接收这些邮件进行处理。



RT-Thread操作系统采用的邮箱通信机制有点类似于传统意义上的管道，用于线程间通讯。非阻塞方式的邮件发送过程能够安全的应用于中断服务中，是线程，中断服务，定时器向线程发送消息的有效手段。通常来说，邮件收取过程可能是阻塞的，这取决于邮箱中是否有邮件，以及收取邮件时设置的超时时间。当邮箱中不存在邮件且超时时间不为0时，邮件收取过程将变成阻塞方式。所以在这类情况下，只能由线程进行邮件的收取。

RT-Thread操作系统的邮箱中可存放固定条数的邮件，邮箱容量在创建/初始化邮箱时设定，每个邮件大小为4字节。当需要在线程间传递比较大的消息时，可以把指向一个缓冲区的指针作为邮件发送到邮箱中。

在一个线程向邮箱发送邮件时，如果邮箱没满，将把邮件复制到邮箱中。如果邮箱已经满了，发送线程可以设置超时时间，选择是否等待挂起或直接返回-RT_EFULL。如果发送线程选择挂起等待，那么当邮箱中的邮件被收取而空出空间来时，等待挂起的发送线程将被唤醒继续发送的过程。

在一个线程从邮箱中接收邮件时，如果邮箱是空的，接收线程可以选择是否等待挂起直到收到新的邮件而唤醒，或设置超时时间。当达到设置的超时时间，邮箱依然未收到邮件时，这个选择超时等待的线程将被唤醒并返回-RT_ETIMEOUT。如果邮箱中存在邮件，那么接收线程将复制邮箱中的4个字节邮件到接收线程中。

邮箱控制块

1. 
   
2. struct rt_mailbox
   
3. {
   
4.     struct rt_ipc_object parent;
   
5. 
   
6.     rt_uint32_t* msg_pool;              /* 邮箱缓冲区的开始地址 */
   
7.     rt_uint16_t size;                   /* 邮箱缓冲区的大小     */
   
8. 
   
9.     rt_uint16_t entry;                  /* 邮箱中邮件的数目     */
   
10.     rt_uint16_t in_offset, out_offset;  /* 邮箱缓冲的进出指针   */
    
11.     rt_list_t suspend_sender_thread;    /* 发送线程的挂起等待队列 */
    
12. };
    
13. typedef struct rt_mailbox* rt_mailbox_t;

复制代码

rt_mailbox对象从rt_ipc_object中派生，由IPC容器管理。

邮箱相关接口

创建邮箱

创建邮箱对象可以调用如下的函数接口：

1. rt_mailbox_t rt_mb_create (const char* name, rt_size_t size, rt_uint8_t flag);

复制代码

创建邮箱对象时会先创建一个邮箱对象控制块，然后给邮箱分配一块内存空间用来存放邮件，这块内存的大小等于邮件大小（4字节）与邮箱容量的乘积，接着初始化接收邮件和发送邮件在邮箱中的偏移量。

函数参数


      参数  描述

      name  邮箱名称；

      size  邮箱容量；

      flag  邮箱标志，它可以取如下数值：

1. #define RT_IPC_FLAG_FIFO 0x00 /* IPC参数采用FIFO方式*/
   
2. #define RT_IPC_FLAG_PRIO 0x01 /* IPC参数采用优先级方式*/

复制代码

函数返回

创建成功返回邮箱对象的句柄；否则返回-RT_NULL。

删除邮箱

当邮箱不再被使用时，应该删除它来释放相应的系统资源，一旦操作完成，邮箱将被永久性的删除。删除邮箱的函数接口如下：

1. rt_err_t rt_mb_delete (rt_mailbox_t mb);

复制代码

删除邮箱时，如果有线程被挂起在该邮箱对象上，内核先唤醒挂起在该邮箱上的所有线程（线程获得返回值是-RT_ERROR），然后再释放邮箱使用的内存，最后删除邮箱对象。

函数参数


      参数  描述

        mb  邮箱对象的句柄。

函数返回

RT_EOK

初始化邮箱

初始化邮箱跟创建邮箱类似，只是初始化邮箱用于静态邮箱对象的初始化。其他与创建邮箱不同的是，此处静态邮箱对象所使用的内存空间是由用户线程指定的一个缓冲区空间，用户把缓冲区的指针传递给邮箱对象控制块，其余的初始化工作与创建邮箱时相同。函数接口如下：

1. rt_err_t rt_mb_init(rt_mailbox_t mb, const char* name, void* msgpool,
   
2.     rt_size_t size, rt_uint8_t flag)

复制代码

初始化邮箱时，该函数接口需要获得用户已经申请获得的邮箱对象控制块，缓冲区的指针，以及邮箱名称和邮箱容量。

函数参数


      参数  描述

        mb  邮箱对象的句柄；

      name  邮箱名称；

   msgpool  缓冲区指针；

      size  邮箱容量；

      flag  邮箱标志，它可以取如下数值：

1. #define RT_IPC_FLAG_FIFO 0x00 /* IPC参数采用FIFO方式*/
   
2. #define RT_IPC_FLAG_PRIO 0x01 /* IPC参数采用优先级方式*/

复制代码

函数返回

RT_EOK

注： 这里的size参数指定的是邮箱的容量，即如果msgpool的字节数是N，那么邮箱容量应该是N/4。
脱离邮箱

脱离邮箱将把邮箱对象从内核对象管理器中删除。脱离邮箱使用下面的接口：

1. rt_err_t rt_mb_detach(rt_mailbox_t mb);

复制代码

使用该函数接口后，内核先唤醒所有挂在该邮箱上的线程（线程获得返回值是- RT_ERROR ），然后将该邮箱对象从内核对象管理器中删除。

函数参数


      参数  描述

        mb  邮箱对象的句柄。

函数返回

RT_EOK

发送邮件

线程或者中断服务程序可以通过邮箱给其他线程发送邮件，发送邮件函数接口如下：

1. rt_err_t rt_mb_send (rt_mailbox_t mb, rt_uint32_t value);

复制代码

发送的邮件可以是32位任意格式的数据，一个整型值或者一个指向缓冲区的指针。当邮箱中的邮件已经满时，发送邮件的线程或者中断程序会收到-RT_EFULL 的返回值。

函数参数


      参数  描述

        mb  邮箱对象的句柄；

     value  邮件内容。

函数返回

发送成功返回RT_EOK；如果邮箱已经满了，返回-RT_EFULL。

等待方式发送邮件

用户也可以通过如下的函数接口向指定邮箱发送邮件：

1. rt_err_t rt_mb_send_wait (rt_mailbox_t mb, rt_uint32_t value, rt_int32_t timeout);

复制代码

rt_mb_send_wait与rt_mb_send的区别在于，如果邮箱已经满了，那么发送线程将根据设定的timeout参数等待邮箱中因为收取邮件而空出空间。如果设置的超时时间到达依然没有空出空间，这时发送线程将被唤醒返回错误码。

函数参数


      参数  描述

        mb  邮箱对象的句柄；

     value  邮件内容；

   timeout  超时时间。

函数返回

发送成功返回RT_EOK；如果设置的时间超时依然未发送成功，返回-RT_ETIMEOUT，其他情况返回-RT_ERROR。

接收邮件

只有当接收者接收的邮箱中有邮件时，接收者才能立即取到邮件并返回RT_EOK的返回值，否则接收线程会根据超时时间设置，或挂起在邮箱的等待线程队列上，或直接返回。接收邮件函数接口如下：

1. rt_err_t rt_mb_recv (rt_mailbox_t mb, rt_uint32_t* value, rt_int32_t timeout);

复制代码

接收邮件时，接收者需指定接收邮件的邮箱句柄，并指定接收到的邮件存放位置以及最多能够等待的超时时间。如果接收时设定了超时，当指定的时间内依然未收到邮件时，将返回-RT_ETIMEOUT。

函数参数


      参数  描述

        mb  邮箱对象的句柄；

     value  邮件内容；

   timeout  超时时间。

函数返回

成功收到返回RT_EOK，超时返回-RT_ETIMEOUT，其他返回-RT_ERROR。
使用场合

邮箱是一种简单的线程间消息传递方式，在RT-Thread操作系统的实现中能够一次传递4字节邮件，并且邮箱具备一定的存储功能，能够缓存一定数量的邮件数(邮件数由创建、初始化邮箱时指定的容量决定)。邮箱中一封邮件的最大长度是4字节，所以邮箱能够用于不超过4字节的消息传递，当传送的消息长度大于这个数目时就不能再采用邮箱的方式。 最重要的是，在32位系统上4字节的内容恰好适合放置一个指针，所以邮箱也适合那种仅传递指针的情况，例如：

1. struct msg
   
2. {
   
3.     rt_uint8_t *data_ptr;
   
4.     rt_uint32_t data_size;
   
5. };

复制代码

对于这样一个消息结构体，其中包含了指向数据的指针data_ptr和数据块长度的变量data_size。当一个线程需要把这个消息发送给另外一个线程时，可以采用如下的操作：

1. struct msg* msg_ptr;
   
2. 
   
3. msg_ptr = (struct msg*)rt_malloc(sizeof(struct msg));
   
4. msg_ptr->data_ptr = ...; /* 指向相应的数据块地址*/
   
5. msg_ptr->data_size = len; /* 数据块的长度*/
   
6. /* 发送这个消息指针给mb邮箱*/
   
7. rt_mb_send(mb, (rt_uint32_t)msg_ptr);

复制代码

而在接收线程中，因为收取过来的是指针，而msg_ptr是一个新分配出来的内存块，所以在接收线程处理完毕后，需要释放相应的内存块：

1. struct msg* msg_ptr;
   
2. if (rt_mb_recv(mb, (rt_uint32_t*)&msg_ptr) == RT_EOK)
   
3. {
   
4.     /* 在接收线程处理完毕后，需要释放相应的内存块*/
   
5.     rt_free(msg_ptr);
   
6. }

复制代码

接下来在机智云gokit智能硬件开发板上演示如何创建并使用邮箱进行线程间的通信。

注意：使用邮箱时要打开宏

1. /**
   
2.   ***********************************
   
3.   * File Name          : main.c
   
4.   * Description        : Main program body
   
5.   ***********************************
   
6.   ** This notice applies to any and all portions of this file
   
7.   * that are not between comment pairs USER CODE BEGIN and
   
8.   * USER CODE END. Other portions of this file, whether
   
9.   * inserted by the user or by software development tools
   
10.   * are owned by their respective copyright owners.
    
11.   *
    
12.   * COPYRIGHT(c) 2017 STMicroelectronics
    
13.   *
    
14.   * Redistribution and use in source and binary forms, with or without modification,
    
15.   * are permitted provided that the following conditions are met:
    
16.   *   1. Redistributions of source code must retain the above copyright notice,
    
17.   *      this list of conditions and the following disclaimer.
    
18.   *   2. Redistributions in binary form must reproduce the above copyright notice,
    
19.   *      this list of conditions and the following disclaimer in the documentation
    
20.   *      and/or other materials provided with the distribution.
    
21.   *   3. Neither the name of STMicroelectronics nor the names of its contributors
    
22.   *      may be used to endorse or promote products derived from this software
    
23.   *      without specific prior written permission.
    
24.   *
    
25.   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    
26.   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    
27.   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
    
28.   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
    
29.   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    
30.   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
    
31.   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    
32.   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
    
33.   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    
34.   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    
35.   *
    
36.   ***********************************
    
37.   */
    
38. /* Includes ------------------------------------------------------------------*/
    
39. #include "main.h"
    
40. #include "STM32f1xx_hal.h"
    
41. #include "usart.h"
    
42. #include "gpio.h"
    
43. 
    
44. /* USER CODE BEGIN Includes */
    
45. #include "rtthread.h"
    
46. #include "string.h"
    
47. /* USER CODE END Includes */
    
48. 
    
49. /* Private variables ---------------------------------------------------------*/
    
50. 
    
51. /* USER CODE BEGIN PV */
    
52. /* Private variables ---------------------------------------------------------*/
    
53. 
    
54. /* USER CODE END PV */
    
55. 
    
56. /* Private function prototypes -----------------------------------------------*/
    
57. void SystemClock_Config(void);
    
58. 
    
59. /* USER CODE BEGIN PFP */
    
60. /* Private function prototypes -----------------------------------------------*/
    
61. 
    
62. /* USER CODE END PFP */
    
63. 
    
64. /* USER CODE BEGIN 0 */
    
65. //重映射串口1到rt_kprintf
    
66. void rt_hw_console_output(const char *str)
    
67. {
    
68.     /* empty console output */
    
69.         char aa='\r';
    
70.           rt_enter_critical();
    
71. 
    
72.                 while(*str!='\0')
    
73.                 {
    
74.                         if(*str=='\n')
    
75.                         {
    
76.                                 HAL_UART_Transmit(&huart1, (uint8_t *)&aa, 1, 10);
    
77.                         }
    
78.                                 HAL_UART_Transmit(&huart1, (uint8_t *)(str++), 1, 10);
    
79.                 }
    
80.                
    
81.                 rt_exit_critical();
    
82. }
    
83. 
    
84. void rt_hw_us_delay(int us)
    
85. {
    
86.     rt_uint32_t delta;
    
87. 
    
88.     /* 获得延时经过的tick数 */
    
89.     us = us * (SysTick->LOAD/(1000000/RT_TICK_PER_SECOND));
    
90. 
    
91.     /* 获得当前时间 */
    
92.     delta = SysTick->VAL;
    
93. 
    
94.     /* 循环获得当前时间，直到达到指定的时间后退出循环 */
    
95.     while (delta - SysTick->VAL< us);
    
96. }
    
97. 
    
98. void rt_hw_ms_delay(int ms)
    
99. {
    
100.         int i=0,j=0;
     
101.         for(j=0;j<ms;j++)
     
102.         {
     
103.                 for (i=0;i<2;i++)
     
104.                 rt_hw_us_delay(500);
     
105.         }
     
106. }
     
107. uint32_t rt_hw_delay_Init(void)
     
108. {
     
109. #if !defined(STM32F0xx)
     
110.         uint32_t c;
     
111.         
     
112.     /* Enable TRC */
     
113.     CoreDebug->DEMCR &= ~0x01000000;
     
114.     CoreDebug->DEMCR |=  0x01000000;
     
115.         
     
116.     /* Enable counter */
     
117.     DWT->CTRL &= ~0x00000001;
     
118.     DWT->CTRL |=  0x00000001;
     
119.         
     
120.     /* Reset counter */
     
121.     DWT->CYCCNT = 0;
     
122.         
     
123.         /* Check if DWT has started */
     
124.         c = DWT->CYCCNT;
     
125.         
     
126.         /* 2 dummys */
     
127.         __ASM volatile ("NOP");
     
128.         __ASM volatile ("NOP");
     
129.         
     
130.         /* Return difference, if result is zero, DWT has not started */
     
131.         return (DWT->CYCCNT - c);
     
132. #else
     
133.         /* Return OK */
     
134.         return 1;
     
135. #endif
     
136. }
     
137. void rt_hw_delay_us(__IO uint32_t micros)
     
138. {
     
139. #if !defined(STM32F0xx)
     
140.         uint32_t start = DWT->CYCCNT;
     
141.         
     
142.         /* Go to number of cycles for system */
     
143.         micros *= (HAL_RCC_GetHCLKFreq() / 1000000);
     
144.         
     
145.         /* Delay till end */
     
146.         while ((DWT->CYCCNT - start) < micros);
     
147. #else
     
148.         /* Go to clock cycles */
     
149.         micros *= (SystemCoreClock / 1000000) / 5;
     
150.         
     
151.         /* Wait till done */
     
152.         while (micros--);
     
153. #endif
     
154. }
     
155. void rt_hw_delay_ms(__IO uint32_t mills)
     
156. {
     
157.         rt_hw_delay_us(1000*mills);
     
158. }
     
159. 
     
160. /*
     
161. * 程序清单：邮箱例程
     
162. *
     
163. * 这个程序会创建2个动态线程，一个静态的邮箱对象，其中一个线程往邮箱中发送邮件，
     
164. * 一个线程从邮箱中收取邮件。
     
165. */
     
166. 
     
167. /* 指向线程控制块的指针 */
     
168. static rt_thread_t tid1 = RT_NULL;
     
169. static rt_thread_t tid2 = RT_NULL;
     
170. 
     
171. /* 邮箱控制块 */
     
172. static struct rt_mailbox mb;
     
173. /* 用于放邮件的内存池 */
     
174. static char mb_pool[128];
     
175. 
     
176. static char mb_str1[] = "I'm a mail!";
     
177. static char mb_str2[] = "this is another mail!";
     
178. 
     
179. /* 线程1入口 */
     
180. static void thread1_entry(void* parameter)
     
181. {
     
182.     unsigned char* str;
     
183. 
     
184.     while (1)
     
185.     {
     
186.         rt_kprintf("thread1: try to recv a mail\n");
     
187. 
     
188.         /* 从邮箱中收取邮件 */
     
189.         if (rt_mb_recv(&mb, (rt_uint32_t*)&str, RT_WAITING_FOREVER)
     
190.                 == RT_EOK)
     
191.         {
     
192.             /* 显示邮箱内容 */
     
193.             rt_kprintf("thread1: get a mail, the content:%s\n", str);
     
194. 
     
195.             /* 延时10个OS Tick */
     
196.             rt_thread_delay(10);
     
197.         }
     
198.     }
     
199. }
     
200. 
     
201. /* 线程2入口 */
     
202. static void thread2_entry(void* parameter)
     
203. {
     
204.     rt_uint8_t count;
     
205. 
     
206.     count = 0;
     
207.     while (1)
     
208.     {
     
209.         count ++;
     
210.         if (count & 0x1)
     
211.         {
     
212.             /* 发送mb_str1地址到邮箱中 */
     
213.             rt_mb_send(&mb, (rt_uint32_t)&mb_str1[0]);
     
214.         }
     
215.         else
     
216.         {
     
217.             /* 发送mb_str2地址到邮箱中 */
     
218.             rt_mb_send(&mb, (rt_uint32_t)&mb_str2[0]);
     
219.         }
     
220. 
     
221.         /* 延时20个OS Tick */
     
222.         rt_thread_delay(20);
     
223.     }
     
224. }
     
225. 
     
226. 
     
227. /* USER CODE END 0 */
     
228. 
     
229. int main(void)
     
230. {
     
231. 
     
232.   /* USER CODE BEGIN 1 */
     
233. 
     
234.   /* USER CODE END 1 */
     
235. 
     
236.   /* MCU Configuration----------------------------------------------------------*/
     
237. 
     
238. //  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
     
239. //  HAL_Init();
     
240. 
     
241. //  /* USER CODE BEGIN Init */
     
242. 
     
243. //  /* USER CODE END Init */
     
244. 
     
245. //  /* Configure the system clock */
     
246. //  SystemClock_Config();
     
247. 
     
248. //  /* USER CODE BEGIN SysInit */
     
249. 
     
250. //  /* USER CODE END SysInit */
     
251. 
     
252. //  /* Initialize all configured peripherals */
     
253. //  MX_GPIO_Init();
     
254. //  MX_USART1_UART_Init();
     
255. 
     
256.   /* USER CODE BEGIN 2 */
     
257.         
     
258.     /* 初始化一个mailbox */
     
259.     rt_mb_init(&mb,
     
260.         "mbt",             /* 名称是mbt */
     
261.         &mb_pool[0],       /* 邮箱用到的内存池是mb_pool */
     
262.         sizeof(mb_pool)/4, /* 大小是mb_pool/4，因为每封邮件的大小是4字节 */
     
263.         RT_IPC_FLAG_FIFO); /* 采用FIFO方式进行线程等待 */
     
264. 
     
265.     /* 创建线程1 */
     
266.     tid1 = rt_thread_create("t1",
     
267.         thread1_entry,    /* 线程入口是thread1_entry */
     
268.         RT_NULL,         /* 入口参数是RT_NULL */
     
269.         512,
     
270.                                 2,
     
271.                                 20);
     
272.     if (tid1 != RT_NULL)
     
273.         rt_thread_startup(tid1);
     
274. 
     
275. 
     
276.     /* 创建线程2 */
     
277.     tid2 = rt_thread_create("t2",
     
278.         thread2_entry,     /* 线程入口是thread2_entry */
     
279.         RT_NULL,         /* 入口参数是RT_NULL */
     
280.         512,
     
281.                                 2,
     
282.                           20);
     
283.     if (tid2 != RT_NULL)
     
284.         rt_thread_startup(tid2);
     
285.         
     
286.                 rt_hw_delay_Init();
     
287.                         
     
288.                 printf("\r\n机智云  只为智能硬件而生\r\n");
     
289.                 printf("Gizwits Smart Cloud for Smart Products\r\n");
     
290.                 printf("链接|增值|开放|中立|安全|自有|自由|生态\r\n");
     
291.                 printf("www.gizwits.com\r\n");
     
292.                 printf("\r\nGokit RT-Thread Demo\r\n\r\n");
     
293.                
     
294.                 return 0;
     
295.         
     
296.   /* USER CODE END 2 */
     
297. 
     
298.   /* Infinite loop */
     
299.   /* USER CODE BEGIN WHILE */
     
300. //  while (1)
     
301. //  {
     
302.   /* USER CODE END WHILE */
     
303. 
     
304.   /* USER CODE BEGIN 3 */
     
305. //               
     
306. //  }
     
307.   /* USER CODE END 3 */
     
308. 
     
309. }
     
310. 
     
311. /** System Clock Configuration
     
312. */
     
313. void SystemClock_Config(void)
     
314. {
     
315. 
     
316.   RCC_OscInitTypeDef RCC_OscInitStruct;
     
317.   RCC_ClkInitTypeDef RCC_ClkInitStruct;
     
318. 
     
319.     /**Initializes the CPU, AHB and APB busses clocks
     
320.     */
     
321.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
     
322.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
     
323.   RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
     
324.   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
     
325.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
     
326.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
     
327.   RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
     
328.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     
329.   {
     
330.     _Error_Handler(__FILE__, __LINE__);
     
331.   }
     
332. 
     
333.     /**Initializes the CPU, AHB and APB busses clocks
     
334.     */
     
335.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
     
336.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
     
337.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
     
338.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     
339.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
     
340.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
     
341. 
     
342.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
     
343.   {
     
344.     _Error_Handler(__FILE__, __LINE__);
     
345.   }
     
346. 
     
347.     /**Configure the Systick interrupt time
     
348.     */
     
349.   HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
     
350. 
     
351.     /**Configure the Systick
     
352.     */
     
353.   HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
     
354. 
     
355.   /* SysTick_IRQn interrupt configuration */
     
356.   HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
     
357. }
     
358. 
     
359. /* USER CODE BEGIN 4 */
     
360. 
     
361. /* USER CODE END 4 */
     
362. 
     
363. /**
     
364.   * @brief  This function is executed in case of error occurrence.
     
365.   * @param  None
     
366.   * @retval None
     
367.   */
     
368. void _Error_Handler(char * file, int line)
     
369. {
     
370.   /* USER CODE BEGIN Error_Handler_Debug */
     
371.   /* User can add his own implementation to report the HAL error return state */
     
372.   while(1)
     
373.   {
     
374.   }
     
375.   /* USER CODE END Error_Handler_Debug */
     
376. }
     
377. 
     
378. #ifdef USE_FULL_ASSERT
     
379. 
     
380. /**
     
381.    * @brief Reports the name of the source file and the source line number
     
382.    * where the assert_param error has occurred.
     
383.    * @param file: pointer to the source file name
     
384.    * @param line: assert_param error line source number
     
385.    * @retval None
     
386.    */
     
387. void assert_failed(uint8_t* file, uint32_t line)
     
388. {
     
389.   /* USER CODE BEGIN 6 */
     
390.   /* User can add his own implementation to report the file name and line number,
     
391.     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     
392.   /* USER CODE END 6 */
     
393. 
     
394. }
     
395. 
     
396. #endif
     
397. 
     
398. /**
     
399.   * @}
     
400.   */
     
401. 
     
402. /**
     
403.   * @}
     
404. */
     
405. 
     
406. /*********** (C) COPYRIGHT STMicroelectronics ***END OF FILE**/
     

复制代码

串口信息：



源码下载：
Gokit_RT-Thread.zip (8.66 MB, 下载次数: 2, 售价: 1 金钱)

2017-12-9 22:26 上传

点击文件名下载附件
售价: 1 金钱  [记录]
下载积分: 威望 1