rt_thread&finsh控制臺移植STM32-有解無憂

先說一下感受吧，第一次有想搞應用系統的想法，初步看了很多嵌入式系統，俗稱RTOS，包括UC/OS/，freeRTOS,liteOS，rt_thread，雖然都不是很懂，但是有必要學習一下，最侄訓是選擇了rt_thread，說是國產的，也說是學習比較容易的，硬體要求低的，反正一大推理由，我也不知道，選了就選吧，

正題：

A. 先來說一下我的硬體：STM32F103RCXX, 開發板隨意，只要你有可以串口通信，還連接控制一顆燈即可）

軟體：WIN10, 這個應該不是很重要了吧，

　　第一隨文就節點是，我已經移植了，rt_thread_nano. 且已經基本可以點亮一顆燈，和串口，且還掛載了finsh組件，

說一下步驟吧，

1. cubeMX 生成起碼專案，啟動UART1和PA8. 這些看你們硬體，具體如下圖操作如圖：

說說這個東西吧，其實建立工程有好多種方法，我發現這個是最簡單的，但是需要cubeMX工具，如果你想從事STM32作業的，

還得多學習用庫建立的方法，那些我就不描述了，百度一下一大把，主要是HAL庫建立工程，

　2. 建立好生成工程后打開如下幾步驟，如下介紹，

  1 #include "main.h"
  2 #include <rtthread.h>
  3 
  4 
  5     #ifndef RT_USING_HEAP
  6         rt_err_t hdle1;
  7         static struct rt_thread led_thread ;
  8         static char led_stack[256] ;
  9     #else
 10         static rt_thread_t led_thread ;
 11     #endif
 12 
 13 UART_HandleTypeDef huart1;
 14 
 15 
 16 void led_entry(void *parameter)
 17 {
 18     while(1)
 19     {
 20         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_8,GPIO_PIN_RESET);
 21         rt_thread_mdelay(500);
 22         
 23         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_8,GPIO_PIN_SET);
 24         rt_thread_mdelay(500);
 25     }
 26 }
 27 
 28 
 29 
 30 /* USER CODE END PV */
 31 
 32 void SystemClock_Config(void);
 33 static void MX_GPIO_Init(void);
 34 static void MX_USART1_UART_Init(void);
 35 
 36 int main(void)
 37 {
 38   HAL_Init();
 39 
 40   SystemClock_Config();
 41   MX_GPIO_Init();
 42   MX_USART1_UART_Init();
 43   while (1)
 44   {
 45         rt_thread_mdelay(100) ;
 46   }
 47 }
 48 void SystemClock_Config(void)
 49 {
 50   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
 51   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 52 
 53   /** Initializes the RCC Oscillators according to the specified parameters
 54   * in the RCC_OscInitTypeDef structure.
 55   */
 56   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
 57   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
 58   RCC_OscInitStruct.HSICalibrationValue =https://www.cnblogs.com/zthuang/archive/2021/06/07/ RCC_HSICALIBRATION_DEFAULT;
 59   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
 60   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
 61   {
 62     Error_Handler();
 63   }
 64   /** Initializes the CPU, AHB and APB buses clocks
 65   */
 66   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
 67                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
 68   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
 69   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
 70   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
 71   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
 72 
 73   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
 74   {
 75     Error_Handler();
 76   }
 77 }
 78 
 79 
 80 static void MX_USART1_UART_Init(void)
 81 {
 82 
 83   /* USER CODE BEGIN USART1_Init 0 */
 84 
 85   /* USER CODE END USART1_Init 0 */
 86 
 87   /* USER CODE BEGIN USART1_Init 1 */
 88 
 89   /* USER CODE END USART1_Init 1 */
 90   huart1.Instance = USART1;
 91   huart1.Init.BaudRate = 115200;
 92   huart1.Init.WordLength = UART_WORDLENGTH_8B;
 93   huart1.Init.StopBits = UART_STOPBITS_1;
 94   huart1.Init.Parity = UART_PARITY_NONE;
 95   huart1.Init.Mode = UART_MODE_TX_RX;
 96   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
 97   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
 98   if (HAL_UART_Init(&huart1) != HAL_OK)
 99   {
100     Error_Handler();
101   }
102   /* USER CODE BEGIN USART1_Init 2 */
103 
104   /* USER CODE END USART1_Init 2 */
105 
106 }
107 
108 
109 static void MX_GPIO_Init(void)
110 {
111   GPIO_InitTypeDef GPIO_InitStruct = {0};
112 
113   /* GPIO Ports Clock Enable */
114   __HAL_RCC_GPIOA_CLK_ENABLE();
115 
116   /*Configure GPIO pin Output Level */
117   HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
118 
119   /*Configure GPIO pin : PA8 */
120   GPIO_InitStruct.Pin = GPIO_PIN_8;
121   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
122   GPIO_InitStruct.Pull = GPIO_NOPULL;
123   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
124   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
125 
126 }
127 
128 /* USER CODE BEGIN 4 */
129 
130 void rt_hw_console_output(const char *str)
131 {
132     rt_size_t i = 0, size = 0;
133     char a = '\r';
134 
135     __HAL_UNLOCK(&huart1);
136 
137     size = rt_strlen(str);
138     for (i = 0; i < size; i++)
139     {
140         if (*(str + i) == '\n')
141         {
142             HAL_UART_Transmit(&huart1, (uint8_t *)&a, 1, 1);
143         }
144         HAL_UART_Transmit(&huart1, (uint8_t *)(str + i), 1, 1);
145     }
146 }
147 char rt_hw_console_getchar(void)
148 {
149     int ch = -1;
150 
151     if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE) != RESET)
152     {
153         ch = huart1.Instance->DR & 0xff;
154     }
155     else
156     {
157         if(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_ORE) != RESET)
158         {
159             __HAL_UART_CLEAR_OREFLAG(&huart1);
160         }
161         rt_thread_mdelay(10);
162     }
163     return ch;
164 }
165 
166 void led_start(void)
167 {
168     #ifndef RT_USING_HEAP
169     hdle1 = rt_thread_init(&led_thread,
170                                                     "ledshine",
171                                                     led_entry,
172                                                     RT_NULL,
173                                                     &led_stack[0],
174                                                     sizeof(led_stack),
175                                                     RT_THREAD_PRIORITY_MAX-2,
176                                                     20);
177     if(hdle1 != RT_EOK)
178     {
179         rt_thread_startup(&led_thread) ;
180         
181     }
182     #else
183        if(led_thread == RT_NULL)
184          {
185             led_thread = rt_thread_create("ledshine",
186                                                                 led_entry,
187                                                                 RT_NULL,
188                                                                 128,
189                                                                 RT_THREAD_PRIORITY_MAX-2,
190                                                                 20);
191             if(led_thread != RT_NULL)
192             {
193                 rt_thread_startup(led_thread) ;
194             }
195         }
196     
197     #endif
198 
199 }
200 void led_exit(void)
201 {
202     if(led_thread != RT_NULL)  
203     {
204         #ifdef RT_USING_HEAP
205             rt_thread_delete(led_thread) ;// 
206             led_thread = RT_NULL ;
207         #endif
208     }
209 }
210 
211 INIT_BOARD_EXPORT(MX_USART1_UART_Init) ;
212 MSH_CMD_EXPORT(led_start,ledon) ;
213 MSH_CMD_EXPORT(led_exit,ledexit) ;
214 
215 /* USER CODE END 4 */
216 
217 void Error_Handler(void)
218 {
219   /* USER CODE BEGIN Error_Handler_Debug */
220   /* User can add his own implementation to report the HAL error return state */
221   __disable_irq();
222   while (1)
223   {
224   }
225   /* USER CODE END Error_Handler_Debug */
226 }
227 
228 #ifdef  USE_FULL_ASSERT
229 /**
230   * @brief  Reports the name of the source file and the source line number
231   *         where the assert_param error has occurred.
232   * @param  file: pointer to the source file name
233   * @param  line: assert_param error line source number
234   * @retval None
235   */
236 void assert_failed(uint8_t *file, uint32_t line)
237 {
238   /* USER CODE BEGIN 6 */
239   /* User can add his own implementation to report the file name and line number,
240      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
241   /* USER CODE END 6 */
242 }
243 #endif /* USE_FULL_ASSERT */
244 
245 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/