基于STM32 NUCLEO板設計彩色LED照明燈（純cubeMX開發）

1. /* Includes ------------------------------------------------------------------*/
   
2. #include "stm32f0xx_hal.h"
   
3. #include "stdbool.h"
   
4. #include "string.h"
   
5. 
   
6. /* USER CODE BEGIN Includes */
   
7. 
   
8. /* USER CODE END Includes */
   
9. 
   
10. /* Private variables ---------------------------------------------------------*/
    
11. TIM_HandleTypeDef htim2;
    
12. 
    
13. UART_HandleTypeDef huart2;
    
14. 
    
15. /* USER CODE BEGIN PV */
    
16. 
    
17. /* USER CODE END PV */
    
18. 
    
19. /* Private function prototypes -----------------------------------------------*/
    
20. void SystemClock_Config(void);
    
21. static void MX_GPIO_Init(void);
    
22. static void MX_TIM2_Init(void);
    
23. static void MX_USART2_UART_Init(void);
    
24. 
    
25. /* USER CODE BEGIN PFP */
    
26. void scheduler( void );
    
27. bool serial2_in(uint8_t *pchByte);
    
28. bool serial2_out(uint8_t chByte) ;
    
29. 
    
30. /* USER CODE END PFP */
    
31. 
    
32. /* USER CODE BEGIN 0 */
    
33. 
    
34. /* USER CODE END 0 */
    
35. 
    
36. int main(void)
    
37. {
    
38. 
    
39.   /* USER CODE BEGIN 1 */
    
40. 
    
41.   /* USER CODE END 1 */
    
42. 
    
43.   /* MCU Configuration----------------------------------------------------------*/
    
44. 
    
45.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
46.   HAL_Init();
    
47. 
    
48.   /* Configure the system clock */
    
49.   SystemClock_Config();
    
50. 
    
51.   /* Initialize all configured peripherals */
    
52.   MX_GPIO_Init();
    
53.   MX_TIM2_Init();
    
54.   MX_USART2_UART_Init();
    
55. 
    
56.   /* USER CODE BEGIN 2 */
    
57.     HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_1);
    
58.         HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_2);
    
59.         HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3);
    
60.   /* USER CODE END 2 */
    
61. 
    
62.   /* USER CODE BEGIN 3 */
    
63.   /* Infinite loop */
    
64.   while (1)
    
65.   {
    
66.         scheduler();
    
67.   }
    
68.   /* USER CODE END 3 */
    
69. 
    
70. }
    
71. 
    
72. /** System Clock Configuration
    
73. */
    
74. void SystemClock_Config(void)
    
75. {
    
76. 
    
77.   RCC_OscInitTypeDef RCC_OscInitStruct;
    
78.   RCC_ClkInitTypeDef RCC_ClkInitStruct;
    
79.   RCC_PeriphCLKInitTypeDef PeriphClkInit;
    
80. 
    
81.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
    
82.   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
    
83.   RCC_OscInitStruct.HSICalibrationValue = 16;
    
84.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    
85.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
    
86.   RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL12;
    
87.   RCC_OscInitStruct.PLL.PREDIV = RCC_PREDIV_DIV2;
    
88.   HAL_RCC_OscConfig(&RCC_OscInitStruct);
    
89. 
    
90.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK;
    
91.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    
92.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    
93.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
    
94.   HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1);
    
95. 
    
96.   PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2;
    
97.   PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_HSI;
    
98.   HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit);
    
99. 
    
100.   __SYSCFG_CLK_ENABLE();
     
101. 
     
102. }
     
103. 
     
104. /* TIM2 init function */
     
105. void MX_TIM2_Init(void)
     
106. {
     
107. 
     
108.   TIM_MasterConfigTypeDef sMasterConfig;
     
109.   TIM_OC_InitTypeDef sConfigOC;
     
110. 
     
111.   htim2.Instance = TIM2;
     
112.   htim2.Init.Prescaler = 1875;
     
113.   htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
     
114.   htim2.Init.Period = 256;
     
115.   htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
     
116.   HAL_TIM_PWM_Init(&htim2);
     
117. 
     
118.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
     
119.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
     
120.   HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig);
     
121. 
     
122.   sConfigOC.OCMode = TIM_OCMODE_PWM1;
     
123.   sConfigOC.Pulse = 80;
     
124.   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
     
125.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
     
126.   HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1);
     
127. 
     
128.   sConfigOC.Pulse = 160;
     
129.   HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_2);
     
130. 
     
131.   sConfigOC.Pulse = 240;
     
132.   HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_3);
     
133.   
     
134. }
     
135. 
     
136. /* USART2 init function */
     
137. void MX_USART2_UART_Init(void)
     
138. {
     
139. 
     
140.   huart2.Instance = USART2;
     
141.   huart2.Init.BaudRate = 9600;//38400;
     
142.   huart2.Init.WordLength = UART_WORDLENGTH_8B;
     
143.   huart2.Init.StopBits = UART_STOPBITS_1;
     
144.   huart2.Init.Parity = UART_PARITY_NONE;
     
145.   huart2.Init.Mode = UART_MODE_TX_RX;
     
146.   huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
     
147.   huart2.Init.OverSampling = UART_OVERSAMPLING_16;
     
148.   huart2.Init.OneBitSampling = UART_ONEBIT_SAMPLING_DISABLED ;
     
149.   huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
     
150.   HAL_UART_Init(&huart2);
     
151. 
     
152. }
     
153. 
     
154. /** Configure pins as
     
155.         * Analog
     
156.         * Input
     
157.         * Output
     
158.         * EVENT_OUT
     
159.         * EXTI
     
160. */
     
161. void MX_GPIO_Init(void)
     
162. {
     
163. 
     
164.   GPIO_InitTypeDef GPIO_InitStruct;
     
165. 
     
166.   /* GPIO Ports Clock Enable */
     
167.   __GPIOC_CLK_ENABLE();
     
168.   __GPIOF_CLK_ENABLE();
     
169.   __GPIOA_CLK_ENABLE();
     
170.   __GPIOB_CLK_ENABLE();
     
171. 
     
172.   /*Configure GPIO pin : PC13 */
     
173.   GPIO_InitStruct.Pin = GPIO_PIN_13;
     
174.   GPIO_InitStruct.Mode = GPIO_MODE_EVT_RISING;
     
175.   GPIO_InitStruct.Pull = GPIO_NOPULL;
     
176.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
     
177. 
     
178.   /*Configure GPIO pin : PA5 */
     
179.   GPIO_InitStruct.Pin = GPIO_PIN_5;
     
180.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
     
181.   GPIO_InitStruct.Pull = GPIO_NOPULL;
     
182.   GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
     
183.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
     
184. }
     
185. 
     
186. /* USER CODE BEGIN 4 */
     
187. 
     
188. //! \name finit state machine state
     
189. //! @{
     
190. typedef enum {
     
191.     fsm_rt_err          = -1,    //!< fsm error, error code can be get from other interface
     
192.     fsm_rt_cpl          = 0,     //!< fsm complete
     
193.     fsm_rt_on_going     = 1,     //!< fsm on-going
     
194. } fsm_rt_t;
     
195. //! @}
     
196. 
     
197. static uint8_t analysis_val(uint8_t chValH, uint8_t chValL);
     
198. static void adjust(void);
     
199. static fsm_rt_t task_receive(void);
     
200. static fsm_rt_t task_adjust(void);
     
201. static fsm_rt_t task_delay(void);
     
202. static fsm_rt_t delay(void);
     
203. static bool s_bFlag = false;
     
204. static bool s_bRgbUpdataFlag = false;
     
205. 
     
206. static uint8_t s_chRVal = 0;
     
207. static uint8_t s_chGVal = 0;
     
208. static uint8_t s_chBVal = 0;
     
209. /****************************************************************************/
     
210. /**
     
211. * Function Name: void scheduler( void )
     
212. * Description: none
     
213. *
     
214. * Param:   none
     
215. * Return:  none
     
216. * Author:  
     
217. ****************************************************************************/
     
218. void scheduler( void )
     
219. {
     
220.         uint8_t chByte;
     
221.     while(!serial2_out('S'));
     
222.     while(!serial2_out('m'));
     
223.     while(!serial2_out('a'));
     
224.     while(!serial2_out('r'));
     
225.     while(!serial2_out('t'));
     
226.     while(!serial2_out('L'));
     
227.         while(!serial2_out('E'));
     
228.         while(!serial2_out('D'));
     
229.     while(!serial2_out('\r'));
     
230.     while(!serial2_out('\n'));
     
231.    
     
232.     /* loop here forever */
     
233.         while(1){   
     
234.         //        if (serial2_in(&chByte)) {
     
235.     //       serial2_out(chByte);
     
236.     //    }
     
237.         task_receive();  
     
238.                 task_adjust();                
     
239.         //task_delay();     
     
240.         }
     
241.                
     
242. }
     
243. 
     
244. #define TASK_RECEIVE_RESET_FSM()        \
     
245.         do{        \
     
246.                 s_tState = START;\
     
247.         }while(0)       
     
248. static fsm_rt_t task_receive(void)
     
249. {
     
250.         static uint8_t s_chLedVal[8];
     
251.         static uint8_t s_chLedInd = 0;
     
252.         static uint32_t s_wReceiveCounter = 0x2ffff;
     
253.         static enum{
     
254.                 START=0,
     
255.                 IDLE,
     
256.                 RECEIVE,
     
257.                 ANALYSIS
     
258.         }s_tState = START;
     
259.         switch (s_tState){
     
260.                 case START:
     
261.                         s_chLedVal[0] = 0x00;
     
262.                 s_chLedVal[1] = 0x00;
     
263.                 s_chLedVal[2] = 0x00;
     
264.                 s_chLedVal[3] = 0x00;
     
265.                 s_chLedVal[4] = 0x00;
     
266.                 s_chLedVal[5] = 0x00;
     
267.                 s_chLedVal[6] = 0x00;
     
268.                 s_chLedVal[7] = 0x00;
     
269.                
     
270.                         s_chLedInd = 0;
     
271.                         s_wReceiveCounter = 0x2ffff;
     
272.                         s_tState = IDLE;
     
273.                
     
274.                 case IDLE:
     
275.                         if(serial2_in(&s_chLedVal[s_chLedInd])){
     
276.                                 if('*'==s_chLedVal[s_chLedInd]){/*'*' is start mark*/
     
277.                                         s_chLedInd++;
     
278.                                         s_tState = RECEIVE;
     
279.                                 }else{
     
280.                                         s_tState = IDLE;
     
281.                                 }
     
282.                         }
     
283.                         break;
     
284.                        
     
285.                 case RECEIVE:
     
286.                         if(serial2_in(&s_chLedVal[s_chLedInd])){                               
     
287.                                 if('#'==s_chLedVal[s_chLedInd]){/*'#' is end mark*/
     
288.                                         if(7 == s_chLedInd){/*verify length */
     
289.                                                 s_tState = ANALYSIS;
     
290.                                         }else{
     
291.                                                 s_tState = START;
     
292.                                         }                                       
     
293.                                 }
     
294.                                 s_chLedInd++;
     
295.                         }
     
296.                         /*time out*/
     
297.                         s_wReceiveCounter--;
     
298.                         if(0 == s_wReceiveCounter){
     
299.                                 TASK_RECEIVE_RESET_FSM();
     
300.                         }
     
301.                         break;
     
302.                        
     
303.                 case ANALYSIS:
     
304.                         s_chRVal = analysis_val(s_chLedVal[1],s_chLedVal[2]);
     
305.                         s_chGVal = analysis_val(s_chLedVal[3],s_chLedVal[4]);
     
306.                         s_chBVal = analysis_val(s_chLedVal[5],s_chLedVal[6]);
     
307.                         s_bRgbUpdataFlag = true;
     
308.                         TASK_RECEIVE_RESET_FSM();
     
309.                         return fsm_rt_cpl;
     
310.         }
     
311.         return fsm_rt_on_going;
     
312. }
     
313. 
     
314. static uint8_t analysis_val(uint8_t chValH, uint8_t chValL)
     
315. {
     
316.         uint8_t chVal = 0;
     
317.         if((chValH >= 48) && (chValH <= 57)){/*'0'~'9'*/
     
318.                 chVal = (chValH-48)<<4;
     
319.         }else if((chValH >= 65) && (chValH <= 70)){/*'A'~'F'*/
     
320.                 chVal = (chValH-55)<<4;
     
321.         }
     
322.        
     
323.         if((chValL >= 48) && (chValL <= 57)){/*'0'~'9'*/
     
324.                 chVal |= chValL-48;
     
325.         }else if((chValH >= 65) && (chValH <= 70)){/*'A'~'F'*/
     
326.                 chVal |= chValL-55;
     
327.         }
     
328.        
     
329.         return chVal;
     
330. }
     
331. 
     
332. #define TASK_ADJUST_RESET_FSM()        \
     
333.         do{        \
     
334.                 s_tState = START;\
     
335.         }while(0)
     
336. static fsm_rt_t task_adjust(void)
     
337. {
     
338.         static enum{
     
339.                 START=0,
     
340.                 IDLE,
     
341.                 ADJUST
     
342.         }s_tState = START;
     
343.         switch(s_tState){
     
344.                 case START:
     
345.                         s_tState = IDLE;
     
346.                
     
347.                 case IDLE:
     
348.                         if(s_bRgbUpdataFlag){
     
349.                                 s_bRgbUpdataFlag = false;
     
350.                                 s_tState = ADJUST;
     
351.                         }
     
352.                         break;
     
353.                
     
354.                 case ADJUST:
     
355.                         adjust();
     
356.                         while(!serial2_out('O'));
     
357.                         while(!serial2_out('K'));
     
358.                         while(!serial2_out('\r'));
     
359.                         while(!serial2_out('\n'));
     
360.                         TASK_ADJUST_RESET_FSM();
     
361.                         return fsm_rt_cpl;
     
362.         }
     
363.        
     
364.         return fsm_rt_on_going;
     
365. }
     
366. 
     
367. static void adjust(void)
     
368. {
     
369.         TIM_OC_InitTypeDef sConfigOC;
     
370.        
     
371.         sConfigOC.OCMode = TIM_OCMODE_PWM1;
     
372.     sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
     
373.     sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
     
374. 
     
375.         sConfigOC.Pulse = s_chRVal;
     
376.         HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1);
     
377. 
     
378.         sConfigOC.Pulse = s_chGVal;
     
379.         HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_2);
     
380. 
     
381.         sConfigOC.Pulse = s_chBVal;
     
382.         HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_3);
     
383.        
     
384.         HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_1);
     
385.         HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_2);
     
386.         HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3);
     
387. }
     
388. 
     
389. #define TASK_DELAY_RESET_FSM()        \
     
390.         do{        \
     
391.                 s_tTaskDelayState = TASK_DELAY_START;        \
     
392.         }while(0)       
     
393. static  fsm_rt_t task_delay(void)
     
394. {
     
395.         static enum{
     
396.                 TASK_DELAY_START=0,
     
397.                 TASK_DELAY_ING
     
398.         }s_tTaskDelayState = TASK_DELAY_START;
     
399.         switch(s_tTaskDelayState){
     
400.                 case TASK_DELAY_START:
     
401.                         s_bFlag = false;
     
402.                
     
403.                 case TASK_DELAY_ING:
     
404.                         if(fsm_rt_cpl == delay()){
     
405.                                 s_bFlag = true;
     
406.                                 TASK_DELAY_RESET_FSM();
     
407.                                 return fsm_rt_on_going;
     
408.                         }
     
409.         }
     
410.         return fsm_rt_on_going;
     
411. }
     
412. 
     
413. #define DELAY_RESET_FSM()        \
     
414.         do{        \
     
415.                 s_tDelaytState = DELAY_START;        \
     
416.         }while(0)
     
417. #define DEALY_TIME (0xff)
     
418.        
     
419. static fsm_rt_t delay(void)
     
420. {
     
421.         static enum{
     
422.                 DELAY_START = 0,
     
423.                 DELAY
     
424.         }s_tDelaytState = DELAY_START;
     
425.         static uint32_t s_wDelayCounter = 0;
     
426.         switch(s_tDelaytState){
     
427.                 case DELAY_START:
     
428.                         s_wDelayCounter = 0;
     
429.                         s_tDelaytState = DELAY;
     
430. 
     
431.                 case DELAY:
     
432.                         s_wDelayCounter ++;
     
433.                         if(s_wDelayCounter > DEALY_TIME){       
     
434.                                 s_wDelayCounter = 0;                               
     
435.                                 DELAY_RESET_FSM();
     
436.                                 return fsm_rt_cpl;
     
437.                         }
     
438.                         break;
     
439.         }                       
     
440.         return fsm_rt_on_going;
     
441. }
     
442. 
     
443. bool serial2_out(uint8_t chByte)
     
444. {
     
445.     bool bUartState;
     
446.         if(HAL_UART_Transmit(&huart2,&chByte,1,10) == HAL_OK){
     
447.                 bUartState = true;
     
448.         }else{
     
449.                 bUartState = false;
     
450.         }
     
451.     return bUartState;
     
452. }
     
453. 
     
454. bool serial2_in(uint8_t *pchByte)
     
455. {
     
456.     bool bUartState;
     
457.     if(0 == pchByte){
     
458.          bUartState = false;
     
459.     }else{
     
460.         if(HAL_UART_Receive(&huart2,pchByte,1,0x1fffff) == HAL_OK){
     
461.                         bUartState = true;
     
462.                 }else{
     
463.                         bUartState = false;
     
464.                 }
     
465.         }
     
466.     return bUartState;
     
467. }
     
468. /* USER CODE END 4 */
     
469. 
     
470. #ifdef USE_FULL_ASSERT
     
471. 
     
472. /**
     
473.    * @brief Reports the name of the source file and the source line number
     
474.    * where the assert_param error has occurred.
     
475.    * @param file: pointer to the source file name
     
476.    * @param line: assert_param error line source number
     
477.    * @retval None
     
478.    */
     
479. void assert_failed(uint8_t* file, uint32_t line)
     
480. {
     
481.   /* USER CODE BEGIN 6 */
     
482.   /* User can add his own implementation to report the file name and line number,
     
483.     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     
484.   /* USER CODE END 6 */
     
485. 
     
486. }
     
487. 
     
488. #endif
     
489. 
     
490. /**
     
491.   * @}
     
492.   */
     
493. 
     
494. /**
     
495.   * @}
     
496. */
     
497. 
     
498. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
     

復制代碼

本帖需要重新編輯補全電路原理圖,源碼,詳細說明與圖片即可獲得100+黑幣(帖子下方有編輯按鈕)