標題: 基于STM32 NUCLEO板設計彩色LED照明燈（純cubeMX開發(fā)） [打印本頁]
作者: stc89c52wzy    時間: 2020-4-16 22:43
標題: 基于STM32 NUCLEO板設計彩色LED照明燈（純cubeMX開發(fā)）
  1. /* Includes ------------------------------------------------------------------*/
  2. #include "stm32f0xx_hal.h"
  3. #include "stdbool.h"
  4. #include "string.h"

  6. /* USER CODE BEGIN Includes */

  8. /* USER CODE END Includes */

  10. /* Private variables ---------------------------------------------------------*/
  11. TIM_HandleTypeDef htim2;

  13. UART_HandleTypeDef huart2;

  15. /* USER CODE BEGIN PV */

  17. /* USER CODE END PV */

  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);

  25. /* USER CODE BEGIN PFP */
  26. void scheduler( void );
  27. bool serial2_in(uint8_t *pchByte);
  28. bool serial2_out(uint8_t chByte) ;

  30. /* USER CODE END PFP */

  32. /* USER CODE BEGIN 0 */

  34. /* USER CODE END 0 */

  36. int main(void)
  37. {

  39.   /* USER CODE BEGIN 1 */

  41.   /* USER CODE END 1 */

  43.   /* MCU Configuration----------------------------------------------------------*/

  45.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  46.   HAL_Init();

  48.   /* Configure the system clock */
  49.   SystemClock_Config();

  51.   /* Initialize all configured peripherals */
  52.   MX_GPIO_Init();
  53.   MX_TIM2_Init();
  54.   MX_USART2_UART_Init();

  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 */

  62.   /* USER CODE BEGIN 3 */
  63.   /* Infinite loop */
  64.   while (1)
  65.   {
  66.         scheduler();
  67.   }
  68.   /* USER CODE END 3 */

  70. }

  72. /** System Clock Configuration
  73. */
  74. void SystemClock_Config(void)
  75. {

  77.   RCC_OscInitTypeDef RCC_OscInitStruct;
  78.   RCC_ClkInitTypeDef RCC_ClkInitStruct;
  79.   RCC_PeriphCLKInitTypeDef PeriphClkInit;

  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);

  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);

  96.   PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2;
  97.   PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_HSI;
  98.   HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit);

  100.   __SYSCFG_CLK_ENABLE();

  102. }

  104. /* TIM2 init function */
  105. void MX_TIM2_Init(void)
  106. {

  108.   TIM_MasterConfigTypeDef sMasterConfig;
  109.   TIM_OC_InitTypeDef sConfigOC;

  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);

  118.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  119.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  120.   HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig);

  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);

  128.   sConfigOC.Pulse = 160;
  129.   HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_2);

  131.   sConfigOC.Pulse = 240;
  132.   HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_3);
  133.   
  134. }

  136. /* USART2 init function */
  137. void MX_USART2_UART_Init(void)
  138. {

  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);

  152. }

  154. /** Configure pins as
  155.         * Analog
  156.         * Input
  157.         * Output
  158.         * EVENT_OUT
  159.         * EXTI
  160. */
  161. void MX_GPIO_Init(void)
  162. {

  164.   GPIO_InitTypeDef GPIO_InitStruct;

  166.   /* GPIO Ports Clock Enable */
  167.   __GPIOC_CLK_ENABLE();
  168.   __GPIOF_CLK_ENABLE();
  169.   __GPIOA_CLK_ENABLE();
  170.   __GPIOB_CLK_ENABLE();

  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);

  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. }

  186. /* USER CODE BEGIN 4 */

  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. //! @}

  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;

  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. }

  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. }

  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. }

  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. }

  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;

  375.         sConfigOC.Pulse = s_chRVal;
  376.         HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1);

  378.         sConfigOC.Pulse = s_chGVal;
  379.         HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_2);

  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. }

  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. }

  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;

  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. }

  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. }

  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 */

  470. #ifdef USE_FULL_ASSERT

  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 */

  486. }

  488. #endif

  490. /**
  491.   * @}
  492.   */

  494. /**
  495.   * @}
  496. */

  498. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
復制代碼


基于STM32 NUCLEO板設計彩色LED照明燈（純cubeMX開發(fā)）.7z

4.93 MB, 下載次數(shù): 7, 下載積分: 黑幣 -5

作者: admin    時間: 2020-4-17 16:48
本帖需要重新編輯補全電路原理圖,源碼,詳細說明與圖片即可獲得100+黑幣(帖子下方有編輯按鈕)



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1