API tools faq
paste
Guest User

Untitled

a guest
Jul 8th, 2019
187
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 22.56 KB | None | 0 0
raw download clone embed print report
  1. #include "main.h"
  2.  
  3.  
  4. I2C_HandleTypeDef hi2c1;
  5.  
  6. RTC_HandleTypeDef hrtc;
  7.  
  8. TIM_HandleTypeDef htim2;
  9. TIM_HandleTypeDef htim3;
  10. TIM_HandleTypeDef htim9;
  11.  
  12. UART_HandleTypeDef huart2;
  13.  
  14.  
  15. /* Private function prototypes -----------------------------------------------*/
  16. void SystemClock_Config(void);
  17. static void MX_GPIO_Init(void);
  18. static void MX_TIM2_Init(void);
  19. static void MX_USART2_UART_Init(void);
  20. static void MX_I2C1_Init(void);
  21. static void MX_RTC_Init(void);
  22. static void MX_TIM3_Init(void);
  23. static void MX_TIM9_Init(void);
  24. static void MEMS_Init(void);
  25. static void associateNumber(uint8_t number);
  26. static void resetPin(void);
  27.  
  28.  
  29.  
  30.  
  31. typedef enum state {idle, wakeUp} State;
  32.  
  33. struct time
  34.     {
  35.        uint8_t  secondsU;
  36.        uint8_t  secondsD;
  37.        uint8_t  minutesU;
  38.        uint8_t  minutesD;
  39.        uint8_t  hoursU;
  40.        uint8_t  hoursD;
  41.     } actualTime;
  42. struct time actualTimeASCII;
  43. volatile State machine = idle;
  44. State machineOld = idle;
  45.  
  46. struct time getTime(void);
  47. struct time getTimeASCII(void);
  48. void displayNumber(struct time input);
  49.  
  50. int main(void)
  51. {
  52.  
  53.     HAL_Init();
  54.  
  55.     SystemClock_Config();
  56.  
  57.     /* Initialize all configured peripherals */
  58.     MX_GPIO_Init();
  59.     MX_TIM2_Init();
  60.     MX_USART2_UART_Init();
  61.     MX_I2C1_Init();
  62.     MX_RTC_Init();
  63.     MX_TIM3_Init();
  64.     MX_TIM9_Init();
  65.     MEMS_Init();
  66.  
  67.  
  68.  
  69.     while (1)
  70.     {
  71.  
  72.         switch (machine)
  73.         {
  74.         case idle:
  75.             //HAL_UART_Transmit(&huart2, (uint8_t*)"idle\n", 7, 30);
  76.             //HAL_Delay(1000);
  77.         break;
  78.  
  79.         case wakeUp:
  80.             actualTime = getTime();
  81.             actualTimeASCII = getTimeASCII();
  82.             HAL_UART_Transmit(&huart2, (uint8_t*)"wakeUp\n", 8, 30);
  83.             HAL_UART_Transmit(&huart2, &actualTimeASCII.hoursD, 1, 30);
  84.             HAL_UART_Transmit(&huart2, &actualTimeASCII.hoursU, 1, 30);
  85.             HAL_UART_Transmit(&huart2, (uint8_t*)":", 1, 30);
  86.             HAL_UART_Transmit(&huart2, &actualTimeASCII.minutesD, 1, 30);
  87.             HAL_UART_Transmit(&huart2, &actualTimeASCII.minutesU, 1, 30);
  88.             HAL_UART_Transmit(&huart2, (uint8_t*)":", 1, 30);
  89.             HAL_UART_Transmit(&huart2, &actualTimeASCII.secondsD, 1, 30);
  90.             HAL_UART_Transmit(&huart2, &actualTimeASCII.secondsU, 1, 30);
  91.             HAL_UART_Transmit(&huart2, (uint8_t*)"\n", 3, 30);
  92.  
  93.             HAL_TIM_PWM_Start(&htim9, TIM_CHANNEL_1);
  94.             htim9.Instance->CCR1 = 1;
  95.             displayNumber(actualTime);
  96.             htim9.Instance->CCR1 = 0;
  97.             HAL_TIM_PWM_Stop(&htim9, TIM_CHANNEL_1);
  98.  
  99.  
  100.             //HAL_Delay(1000);
  101.             machine=idle;
  102.         break;
  103.         }
  104.     }
  105. }
  106.  
  107. void MEMS_Init(void)
  108. {
  109.     uint8_t MAddr=0x68;
  110.     uint8_t maskPWR_MGMT_1[2] = {0x6b, 0x01};//6b
  111.     uint8_t maskPWR_MGMT_2[2] = {0x6c, 0x07};//6c
  112.     uint8_t maskACCEL_CONFIG_2[2] ={0x1d, 0x05};//1d
  113.     uint8_t maskINT_ENABLE[2] = {0x38, 0x40};//38
  114.     uint8_t maskMOT_DETECT_CTRL[2] = {0x69, 0xc0};//69
  115.     uint8_t maskWOM_THR[2]={0x1f, 0x04};//1f SOGLIA RISVEGLIO
  116.     uint8_t maskLP_ACCEL_ODR[2] = {0x1e, 0x07};//1e OUTPUT DATA RATE
  117.     uint8_t maskPWR_MGMT_1_new[2] = {0x6b, 0x20};//6b
  118.     uint8_t maskINT_PIN_CFG[2] = {0x37, 0b10};//3a
  119.  
  120.     if(HAL_I2C_IsDeviceReady(&hi2c1, MAddr<<1, 2, 10) == HAL_OK)
  121.     {
  122.         HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_6);
  123.         HAL_UART_Transmit(&huart2, (uint8_t*)"DEVICE READY!\n", 16, 30);
  124.         HAL_Delay(1000);
  125.         HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_6);
  126.         HAL_Delay(5);
  127.  
  128.         HAL_I2C_Master_Transmit(&hi2c1, MAddr<<1, maskPWR_MGMT_1, 2, 30);
  129.         HAL_Delay(5);
  130.         HAL_I2C_Master_Transmit(&hi2c1, MAddr<<1, maskPWR_MGMT_2, 2, 30);
  131.         HAL_Delay(5);
  132.         HAL_I2C_Master_Transmit(&hi2c1, MAddr<<1, maskACCEL_CONFIG_2, 2, 30);
  133.         HAL_Delay(5);
  134.         HAL_I2C_Master_Transmit(&hi2c1, MAddr<<1, maskINT_ENABLE, 2, 30);
  135.         HAL_Delay(5);
  136.         HAL_I2C_Master_Transmit(&hi2c1, MAddr<<1, maskINT_PIN_CFG, 2, 30);
  137.         HAL_Delay(5);
  138.         HAL_I2C_Master_Transmit(&hi2c1, MAddr<<1, maskMOT_DETECT_CTRL, 2, 30);
  139.         HAL_Delay(5);
  140.         HAL_I2C_Master_Transmit(&hi2c1, MAddr<<1, maskWOM_THR, 2, 30);
  141.         HAL_Delay(5);
  142.         HAL_I2C_Master_Transmit(&hi2c1, MAddr<<1, maskLP_ACCEL_ODR, 2, 30);
  143.         HAL_Delay(5);
  144.         HAL_I2C_Master_Transmit(&hi2c1, MAddr<<1, maskPWR_MGMT_1_new, 2, 30);
  145.         HAL_Delay(5);
  146.     }
  147. }
  148.  
  149. struct time getTime(void)
  150. {
  151.     struct time tempTime;
  152.  
  153.     RTC_TimeTypeDef time;
  154.     RTC_DateTypeDef date;
  155.  
  156.     HAL_RTC_GetTime(&hrtc, &time, RTC_FORMAT_BCD);
  157.     HAL_RTC_GetDate(&hrtc, &date, RTC_FORMAT_BCD);
  158.  
  159.     tempTime.secondsU=(time.Seconds%16);
  160.     tempTime.secondsD=(time.Seconds/16);
  161.     tempTime.minutesU=(time.Minutes%16);
  162.     tempTime.minutesD=(time.Minutes/16);
  163.     tempTime.hoursU=(time.Hours%16);
  164.     tempTime.hoursD=(time.Hours/16);
  165.  
  166.     return tempTime;
  167. }
  168.  
  169. struct time getTimeASCII(void)
  170. {
  171.     struct time tempTime;
  172.  
  173.     RTC_TimeTypeDef time;
  174.     RTC_DateTypeDef date;
  175.  
  176.     HAL_RTC_GetTime(&hrtc, &time, RTC_FORMAT_BCD);
  177.     HAL_RTC_GetDate(&hrtc, &date, RTC_FORMAT_BCD);
  178.  
  179.     tempTime.secondsU=(time.Seconds%16)+48;
  180.     tempTime.secondsD=(time.Seconds/16)+48;
  181.     tempTime.minutesU=(time.Minutes%16)+48;
  182.     tempTime.minutesD=(time.Minutes/16)+48;
  183.     tempTime.hoursU=(time.Hours%16)+48;
  184.     tempTime.hoursD=(time.Hours/16)+48;
  185.  
  186.     return tempTime;
  187. }
  188.  
  189. static void resetPin (void)
  190. {
  191.     HAL_GPIO_WritePin(GPIOC, MUX_DOT_Pin, GPIO_PIN_RESET);
  192.     HAL_GPIO_WritePin(GPIOC, MUX_9_Pin, GPIO_PIN_RESET);
  193.     HAL_GPIO_WritePin(GPIOC, MUX_8_Pin, GPIO_PIN_RESET);
  194.     HAL_GPIO_WritePin(GPIOA, MUX_7_Pin, GPIO_PIN_RESET);
  195.     HAL_GPIO_WritePin(GPIOA, MUX_6_Pin, GPIO_PIN_RESET);
  196.     HAL_GPIO_WritePin(GPIOA, MUX_5_Pin, GPIO_PIN_RESET);
  197.     HAL_GPIO_WritePin(GPIOA, MUX_4_Pin, GPIO_PIN_RESET);
  198.     HAL_GPIO_WritePin(GPIOA, MUX_3_Pin, GPIO_PIN_RESET);
  199.     HAL_GPIO_WritePin(GPIOA, MUX_2_Pin, GPIO_PIN_RESET);
  200.     HAL_GPIO_WritePin(GPIOA, MUX_1_Pin, GPIO_PIN_RESET);
  201.     HAL_GPIO_WritePin(GPIOA, MUX_0_Pin, GPIO_PIN_RESET);
  202. }
  203.  
  204. static void associateNumber(uint8_t number)
  205. {
  206.     switch(number)
  207.     {
  208.         case 0:
  209.             HAL_GPIO_WritePin(GPIOA, MUX_0_Pin, GPIO_PIN_SET);
  210.         break;
  211.  
  212.         case 1:
  213.             HAL_GPIO_WritePin(GPIOA, MUX_1_Pin, GPIO_PIN_SET);
  214.         break;
  215.  
  216.         case 2:
  217.             HAL_GPIO_WritePin(GPIOA, MUX_2_Pin, GPIO_PIN_SET);
  218.         break;
  219.  
  220.         case 3:
  221.             HAL_GPIO_WritePin(GPIOA, MUX_3_Pin, GPIO_PIN_SET);
  222.         break;
  223.  
  224.         case 4:
  225.             HAL_GPIO_WritePin(GPIOA, MUX_4_Pin, GPIO_PIN_SET);
  226.         break;
  227.  
  228.         case 5:
  229.             HAL_GPIO_WritePin(GPIOA, MUX_5_Pin, GPIO_PIN_SET);
  230.         break;
  231.  
  232.         case 6:
  233.             HAL_GPIO_WritePin(GPIOA, MUX_6_Pin, GPIO_PIN_SET);
  234.         break;
  235.  
  236.         case 7:
  237.             HAL_GPIO_WritePin(GPIOA, MUX_7_Pin, GPIO_PIN_SET);
  238.         break;
  239.  
  240.         case 8:
  241.             HAL_GPIO_WritePin(GPIOC, MUX_8_Pin, GPIO_PIN_SET);
  242.         break;
  243.  
  244.         case 9:
  245.             HAL_GPIO_WritePin(GPIOC, MUX_9_Pin, GPIO_PIN_SET);
  246.         break;
  247.  
  248.         case 10:
  249.             HAL_GPIO_WritePin(GPIOC, MUX_DOT_Pin, GPIO_PIN_SET);
  250.         break;
  251.     }
  252. }
  253.  
  254. volatile uint16_t intTimer=0;
  255.  
  256. void displayNumber(struct time input)
  257. {
  258.     volatile uint16_t intTimerOld=0;
  259.     uint8_t cnt=0;
  260.     htim2.Instance->CCR1 = 100;
  261.     htim2.Instance->CCR2 = 100;
  262.     htim2.Instance->CCR3 = 100;
  263.     htim2.Instance->CCR4 = 100;
  264.  
  265.     HAL_TIM_Base_Start_IT(&htim3);
  266.  
  267.     while(intTimer < 6500)
  268.     {
  269.         if(intTimerOld != intTimer)
  270.         {
  271.             switch(cnt)
  272.             {
  273.                 case 0:
  274.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_1);
  275.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_2);
  276.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_3);
  277.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_4);
  278.                     resetPin();
  279.                     associateNumber(input.minutesD);
  280.                     HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
  281.                     cnt++;
  282.                 break;
  283.  
  284.                 case 1:
  285.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_1);
  286.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_2);
  287.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_3);
  288.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_4);
  289.                     resetPin();
  290.                     associateNumber(input.minutesU);
  291.                     HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
  292.                     cnt++;
  293.                 break;
  294.                 case 2:
  295.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_1);
  296.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_2);
  297.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_3);
  298.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_4);
  299.                     resetPin();
  300.                     associateNumber(input.secondsD);
  301.                     HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_3);
  302.                     cnt++;
  303.                 break;
  304.  
  305.                 case 3:
  306.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_1);
  307.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_2);
  308.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_3);
  309.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_4);
  310.                     resetPin();
  311.                     associateNumber(input.secondsU);
  312.                     HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_4);
  313.                     cnt++;
  314.                 break;
  315.  
  316.                 case 4:
  317.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_1);
  318.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_2);
  319.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_3);
  320.                     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_4);
  321.                     resetPin();
  322.                     associateNumber(10);
  323.                     HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);
  324.                     cnt=0;
  325.                 break;
  326.             }
  327.             intTimerOld = intTimer;
  328.         }
  329.     }
  330.     resetPin();
  331.     htim2.Instance->CCR1 = 0;
  332.     htim2.Instance->CCR2 = 0;
  333.     htim2.Instance->CCR3 = 0;
  334.     htim2.Instance->CCR4 = 0;
  335.     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_1);
  336.     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_2);
  337.     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_3);
  338.     HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_4);
  339.     HAL_TIM_Base_Stop_IT(&htim3);
  340.     intTimerOld=0;
  341.     intTimer=0;
  342. }
  343. /**
  344.   * @brief System Clock Configuration
  345.   * @retval None
  346.   */
  347. void SystemClock_Config(void)
  348. {
  349.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  350.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  351.   RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
  352.  
  353.   /** Configure the main internal regulator output voltage
  354.   */
  355.   __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  356.  
  357.   /** Initializes the CPU, AHB and APB busses clocks
  358.   */
  359.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI|RCC_OSCILLATORTYPE_LSE;
  360.   RCC_OscInitStruct.LSEState = RCC_LSE_ON;
  361.   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  362.   RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  363.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  364.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  365.   RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL6;
  366.   RCC_OscInitStruct.PLL.PLLDIV = RCC_PLL_DIV3;
  367.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  368.   {
  369.     Error_Handler();
  370.   }
  371.   /** Initializes the CPU, AHB and APB busses clocks
  372.   */
  373.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
  374.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  375.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  376.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  377.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  378.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  379.  
  380.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  381.   {
  382.     Error_Handler();
  383.   }
  384.   PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_RTC;
  385.   PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
  386.   if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  387.   {
  388.     Error_Handler();
  389.   }
  390. }
  391.  
  392. /**
  393.   * @brief I2C1 Initialization Function
  394.   * @param None
  395.   * @retval None
  396.   */
  397. static void MX_I2C1_Init(void)
  398. {
  399.  
  400.   /* USER CODE BEGIN I2C1_Init 0 */
  401.  
  402.   /* USER CODE END I2C1_Init 0 */
  403.  
  404.   /* USER CODE BEGIN I2C1_Init 1 */
  405.  
  406.   /* USER CODE END I2C1_Init 1 */
  407.   hi2c1.Instance = I2C1;
  408.   hi2c1.Init.ClockSpeed = 100000;
  409.   hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
  410.   hi2c1.Init.OwnAddress1 = 0;
  411.   hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  412.   hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  413.   hi2c1.Init.OwnAddress2 = 0;
  414.   hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  415.   hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  416.   if (HAL_I2C_Init(&hi2c1) != HAL_OK)
  417.   {
  418.     Error_Handler();
  419.   }
  420.   /* USER CODE BEGIN I2C1_Init 2 */
  421.  
  422.   /* USER CODE END I2C1_Init 2 */
  423.  
  424. }
  425.  
  426. /**
  427.   * @brief RTC Initialization Function
  428.   * @param None
  429.   * @retval None
  430.   */
  431. static void MX_RTC_Init(void)
  432. {
  433.  
  434.   /* USER CODE BEGIN RTC_Init 0 */
  435.  
  436.   /* USER CODE END RTC_Init 0 */
  437.  
  438.   RTC_TimeTypeDef sTime = {0};
  439.   RTC_DateTypeDef sDate = {0};
  440.   RTC_AlarmTypeDef sAlarm = {0};
  441.  
  442.   /* USER CODE BEGIN RTC_Init 1 */
  443.  
  444.   /* USER CODE END RTC_Init 1 */
  445.   /** Initialize RTC Only
  446.   */
  447.   hrtc.Instance = RTC;
  448.   hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
  449.   hrtc.Init.AsynchPrediv = 127;
  450.   hrtc.Init.SynchPrediv = 255;
  451.   hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
  452.   hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
  453.   hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
  454.   if (HAL_RTC_Init(&hrtc) != HAL_OK)
  455.   {
  456.     Error_Handler();
  457.   }
  458.  
  459.   /* USER CODE BEGIN Check_RTC_BKUP */
  460.    
  461.   /* USER CODE END Check_RTC_BKUP */
  462.  
  463.   /** Initialize RTC and set the Time and Date
  464.   */
  465.   sTime.Hours = 0x0;
  466.   sTime.Minutes = 0x0;
  467.   sTime.Seconds = 0x0;
  468.   sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
  469.   sTime.StoreOperation = RTC_STOREOPERATION_RESET;
  470.   if (HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BCD) != HAL_OK)
  471.   {
  472.     Error_Handler();
  473.   }
  474.   sDate.WeekDay = RTC_WEEKDAY_MONDAY;
  475.   sDate.Month = RTC_MONTH_JANUARY;
  476.   sDate.Date = 0x1;
  477.   sDate.Year = 0x0;
  478.  
  479.   if (HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BCD) != HAL_OK)
  480.   {
  481.     Error_Handler();
  482.   }
  483.   /** Enable the Alarm A
  484.   */
  485.   sAlarm.AlarmTime.Hours = 0x0;
  486.   sAlarm.AlarmTime.Minutes = 0x0;
  487.   sAlarm.AlarmTime.Seconds = 0x0;
  488.   sAlarm.AlarmTime.SubSeconds = 0x0;
  489.   sAlarm.AlarmTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
  490.   sAlarm.AlarmTime.StoreOperation = RTC_STOREOPERATION_RESET;
  491.   sAlarm.AlarmMask = RTC_ALARMMASK_NONE;
  492.   sAlarm.AlarmSubSecondMask = RTC_ALARMSUBSECONDMASK_ALL;
  493.   sAlarm.AlarmDateWeekDaySel = RTC_ALARMDATEWEEKDAYSEL_DATE;
  494.   sAlarm.AlarmDateWeekDay = 0x1;
  495.   sAlarm.Alarm = RTC_ALARM_A;
  496.   if (HAL_RTC_SetAlarm_IT(&hrtc, &sAlarm, RTC_FORMAT_BCD) != HAL_OK)
  497.   {
  498.     Error_Handler();
  499.   }
  500.   /** Enable the Alarm B
  501.   */
  502.   sAlarm.AlarmDateWeekDay = 0x1;
  503.   sAlarm.Alarm = RTC_ALARM_B;
  504.   if (HAL_RTC_SetAlarm_IT(&hrtc, &sAlarm, RTC_FORMAT_BCD) != HAL_OK)
  505.   {
  506.     Error_Handler();
  507.   }
  508.   /** Enable the WakeUp
  509.   */
  510.   if (HAL_RTCEx_SetWakeUpTimer_IT(&hrtc, 0, RTC_WAKEUPCLOCK_RTCCLK_DIV16) != HAL_OK)
  511.   {
  512.     Error_Handler();
  513.   }
  514.   /* USER CODE BEGIN RTC_Init 2 */
  515.  
  516.   /* USER CODE END RTC_Init 2 */
  517.  
  518. }
  519.  
  520. /**
  521.   * @brief TIM2 Initialization Function
  522.   * @param None
  523.   * @retval None
  524.   */
  525. static void MX_TIM2_Init(void)
  526. {
  527.  
  528.   /* USER CODE BEGIN TIM2_Init 0 */
  529.  
  530.   /* USER CODE END TIM2_Init 0 */
  531.  
  532.   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  533.   TIM_MasterConfigTypeDef sMasterConfig = {0};
  534.   TIM_OC_InitTypeDef sConfigOC = {0};
  535.  
  536.   /* USER CODE BEGIN TIM2_Init 1 */
  537.  
  538.   /* USER CODE END TIM2_Init 1 */
  539.   htim2.Instance = TIM2;
  540.   htim2.Init.Prescaler = 32000;
  541.   htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  542.   htim2.Init.Period = 1;
  543.   htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  544.   htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  545.   if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  546.   {
  547.     Error_Handler();
  548.   }
  549.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  550.   if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  551.   {
  552.     Error_Handler();
  553.   }
  554.   if (HAL_TIM_PWM_Init(&htim2) != HAL_OK)
  555.   {
  556.     Error_Handler();
  557.   }
  558.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  559.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  560.   if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  561.   {
  562.     Error_Handler();
  563.   }
  564.   sConfigOC.OCMode = TIM_OCMODE_PWM1;
  565.   sConfigOC.Pulse = 0;
  566.   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  567.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  568.   if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  569.   {
  570.     Error_Handler();
  571.   }
  572.   if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  573.   {
  574.     Error_Handler();
  575.   }
  576.   if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
  577.   {
  578.     Error_Handler();
  579.   }
  580.   if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
  581.   {
  582.     Error_Handler();
  583.   }
  584.   /* USER CODE BEGIN TIM2_Init 2 */
  585.  
  586.   /* USER CODE END TIM2_Init 2 */
  587.   HAL_TIM_MspPostInit(&htim2);
  588.  
  589. }
  590.  
  591. /**
  592.   * @brief TIM3 Initialization Function
  593.   * @param None
  594.   * @retval None
  595.   */
  596. static void MX_TIM3_Init(void)
  597. {
  598.  
  599.   /* USER CODE BEGIN TIM3_Init 0 */
  600.  
  601.   /* USER CODE END TIM3_Init 0 */
  602.  
  603.   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  604.   TIM_MasterConfigTypeDef sMasterConfig = {0};
  605.  
  606.   /* USER CODE BEGIN TIM3_Init 1 */
  607.  
  608.   /* USER CODE END TIM3_Init 1 */
  609.   htim3.Instance = TIM3;
  610.   htim3.Init.Prescaler = 32000;
  611.   htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  612.   htim3.Init.Period = 1;
  613.   htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  614.   htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  615.   if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  616.   {
  617.     Error_Handler();
  618.   }
  619.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  620.   if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
  621.   {
  622.     Error_Handler();
  623.   }
  624.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  625.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  626.   if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  627.   {
  628.     Error_Handler();
  629.   }
  630.   /* USER CODE BEGIN TIM3_Init 2 */
  631.  
  632.   /* USER CODE END TIM3_Init 2 */
  633.  
  634. }
  635.  
  636. /**
  637.   * @brief TIM9 Initialization Function
  638.   * @param None
  639.   * @retval None
  640.   */
  641. static void MX_TIM9_Init(void)
  642. {
  643.  
  644.   /* USER CODE BEGIN TIM9_Init 0 */
  645.  
  646.   /* USER CODE END TIM9_Init 0 */
  647.  
  648.   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  649.   TIM_MasterConfigTypeDef sMasterConfig = {0};
  650.   TIM_OC_InitTypeDef sConfigOC = {0};
  651.  
  652.   /* USER CODE BEGIN TIM9_Init 1 */
  653.  
  654.   /* USER CODE END TIM9_Init 1 */
  655.   htim9.Instance = TIM9;
  656.   htim9.Init.Prescaler = 64000;
  657.   htim9.Init.CounterMode = TIM_COUNTERMODE_UP;
  658.   htim9.Init.Period = 2;
  659.   htim9.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  660.   htim9.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  661.   if (HAL_TIM_Base_Init(&htim9) != HAL_OK)
  662.   {
  663.     Error_Handler();
  664.   }
  665.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  666.   if (HAL_TIM_ConfigClockSource(&htim9, &sClockSourceConfig) != HAL_OK)
  667.   {
  668.     Error_Handler();
  669.   }
  670.   if (HAL_TIM_PWM_Init(&htim9) != HAL_OK)
  671.   {
  672.     Error_Handler();
  673.   }
  674.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  675.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  676.   if (HAL_TIMEx_MasterConfigSynchronization(&htim9, &sMasterConfig) != HAL_OK)
  677.   {
  678.     Error_Handler();
  679.   }
  680.   sConfigOC.OCMode = TIM_OCMODE_PWM1;
  681.   sConfigOC.Pulse = 0;
  682.   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  683.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  684.   if (HAL_TIM_PWM_ConfigChannel(&htim9, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  685.   {
  686.     Error_Handler();
  687.   }
  688.   /* USER CODE BEGIN TIM9_Init 2 */
  689.  
  690.   /* USER CODE END TIM9_Init 2 */
  691.   HAL_TIM_MspPostInit(&htim9);
  692.  
  693. }
  694.  
  695. /**
  696.   * @brief USART2 Initialization Function
  697.   * @param None
  698.   * @retval None
  699.   */
  700. static void MX_USART2_UART_Init(void)
  701. {
  702.  
  703.   /* USER CODE BEGIN USART2_Init 0 */
  704.  
  705.   /* USER CODE END USART2_Init 0 */
  706.  
  707.   /* USER CODE BEGIN USART2_Init 1 */
  708.  
  709.   /* USER CODE END USART2_Init 1 */
  710.   huart2.Instance = USART2;
  711.   huart2.Init.BaudRate = 115200;
  712.   huart2.Init.WordLength = UART_WORDLENGTH_8B;
  713.   huart2.Init.StopBits = UART_STOPBITS_1;
  714.   huart2.Init.Parity = UART_PARITY_NONE;
  715.   huart2.Init.Mode = UART_MODE_TX_RX;
  716.   huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  717.   huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  718.   if (HAL_UART_Init(&huart2) != HAL_OK)
  719.   {
  720.     Error_Handler();
  721.   }
  722.   /* USER CODE BEGIN USART2_Init 2 */
  723.  
  724.   /* USER CODE END USART2_Init 2 */
  725.  
  726. }
  727.  
  728. /**
  729.   * @brief GPIO Initialization Function
  730.   * @param None
  731.   * @retval None
  732.   */
  733. static void MX_GPIO_Init(void)
  734. {
  735.   GPIO_InitTypeDef GPIO_InitStruct = {0};
  736.  
  737.   /* GPIO Ports Clock Enable */
  738.   __HAL_RCC_GPIOC_CLK_ENABLE();
  739.   __HAL_RCC_GPIOA_CLK_ENABLE();
  740.   __HAL_RCC_GPIOB_CLK_ENABLE();
  741.  
  742.   /*Configure GPIO pin Output Level */
  743.   HAL_GPIO_WritePin(GPIOA, MUX_0_Pin|MUX_1_Pin|MUX_2_Pin|MUX_3_Pin
  744.                           |MUX_4_Pin|MUX_5_Pin|MUX_6_Pin|MUX_7_Pin, GPIO_PIN_RESET);
  745.  
  746.   /*Configure GPIO pin Output Level */
  747.   HAL_GPIO_WritePin(GPIOC, MUX_8_Pin|MUX_9_Pin|MUX_DOT_Pin, GPIO_PIN_RESET);
  748.  
  749.   /*Configure GPIO pin Output Level */
  750.   HAL_GPIO_WritePin(GPIOB, BLUE_LED_Pin|GREEN_LED_Pin, GPIO_PIN_RESET);
  751.  
  752.   /*Configure GPIO pins : BTN_UP_Pin BTN_MD_Pin BTN_DW_Pin */
  753.   GPIO_InitStruct.Pin = BTN_UP_Pin|BTN_MD_Pin|BTN_DW_Pin;
  754.   GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  755.   GPIO_InitStruct.Pull = GPIO_PULLUP;
  756.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
  757.  
  758.   /*Configure GPIO pins : MUX_0_Pin MUX_1_Pin MUX_2_Pin MUX_3_Pin
  759.                            MUX_4_Pin MUX_5_Pin MUX_6_Pin MUX_7_Pin */
  760.   GPIO_InitStruct.Pin = MUX_0_Pin|MUX_1_Pin|MUX_2_Pin|MUX_3_Pin
  761.                           |MUX_4_Pin|MUX_5_Pin|MUX_6_Pin|MUX_7_Pin;
  762.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  763.   GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  764.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  765.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  766.  
  767.   /*Configure GPIO pins : MUX_8_Pin MUX_9_Pin MUX_DOT_Pin */
  768.   GPIO_InitStruct.Pin = MUX_8_Pin|MUX_9_Pin|MUX_DOT_Pin;
  769.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  770.   GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  771.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  772.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
  773.  
  774.   /*Configure GPIO pin : INT_MEMS_Pin */
  775.   GPIO_InitStruct.Pin = INT_MEMS_Pin;
  776.   GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  777.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  778.   HAL_GPIO_Init(INT_MEMS_GPIO_Port, &GPIO_InitStruct);
  779.  
  780.   /*Configure GPIO pins : BLUE_LED_Pin GREEN_LED_Pin */
  781.   GPIO_InitStruct.Pin = BLUE_LED_Pin|GREEN_LED_Pin;
  782.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  783.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  784.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  785.   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  786.  
  787.   /* EXTI interrupt init*/
  788.   HAL_NVIC_SetPriority(EXTI1_IRQn, 0, 0);
  789.   HAL_NVIC_EnableIRQ(EXTI1_IRQn);
  790.  
  791.   HAL_NVIC_SetPriority(EXTI2_IRQn, 0, 0);
  792.   HAL_NVIC_EnableIRQ(EXTI2_IRQn);
  793.  
  794.   HAL_NVIC_SetPriority(EXTI3_IRQn, 0, 0);
  795.   HAL_NVIC_EnableIRQ(EXTI3_IRQn);
  796.  
  797.   HAL_NVIC_SetPriority(EXTI9_5_IRQn, 0, 0);
  798.   HAL_NVIC_EnableIRQ(EXTI9_5_IRQn);
  799.  
  800. }
  801.  
  802. /* USER CODE BEGIN 4 */
  803.  
  804. /* USER CODE END 4 */
  805.  
  806. /**
  807.   * @brief  This function is executed in case of error occurrence.
  808.   * @retval None
  809.   */
  810. void Error_Handler(void)
  811. {
  812.   /* USER CODE BEGIN Error_Handler_Debug */
  813.   /* User can add his own implementation to report the HAL error return state */
  814.  
  815.   /* USER CODE END Error_Handler_Debug */
  816. }
  817.  
  818. #ifdef  USE_FULL_ASSERT
  819. /**
  820.   * @brief  Reports the name of the source file and the source line number
  821.   *         where the assert_param error has occurred.
  822.   * @param  file: pointer to the source file name
  823.   * @param  line: assert_param error line source number
  824.   * @retval None
  825.   */
  826. void assert_failed(uint8_t *file, uint32_t line)
  827. {
  828.   /* USER CODE BEGIN 6 */
  829.   /* User can add his own implementation to report the file name and line number,
  830.      tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  831.   /* USER CODE END 6 */
  832. }
  833. #endif /* USE_FULL_ASSERT */
  834.  
  835. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!