API tools faq
paste
Guest User

Untitled

a guest
Jun 28th, 2021
739
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 43.64 KB | None | 0 0
raw download clone embed print report
  1. /* USER CODE BEGIN Header */
  2. /**
  3.   ******************************************************************************
  4.   * @file           : main.c
  5.   * @brief          : Main program body
  6.   ******************************************************************************
  7.   * @attention
  8.   *
  9.   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
  10.   * All rights reserved.</center></h2>
  11.   *
  12.   * This software component is licensed by ST under BSD 3-Clause license,
  13.   * the "License"; You may not use this file except in compliance with the
  14.   * License. You may obtain a copy of the License at:
  15.   *                        opensource.org/licenses/BSD-3-Clause
  16.   *
  17.   ******************************************************************************
  18.   */
  19. /* USER CODE END Header */
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "main.h"
  22. #include "fatfs.h"
  23. #include "usb_device.h"
  24.  
  25. /* Private includes ----------------------------------------------------------*/
  26. /* USER CODE BEGIN Includes */
  27. #include "STM32 PLC/Functions.h"
  28. /* USER CODE END Includes */
  29.  
  30. /* Private typedef -----------------------------------------------------------*/
  31. /* USER CODE BEGIN PTD */
  32.  
  33. /* USER CODE END PTD */
  34.  
  35. /* Private define ------------------------------------------------------------*/
  36. /* USER CODE BEGIN PD */
  37. /* USER CODE END PD */
  38.  
  39. /* Private macro -------------------------------------------------------------*/
  40. /* USER CODE BEGIN PM */
  41.  
  42. /* USER CODE END PM */
  43.  
  44. /* Private variables ---------------------------------------------------------*/
  45. CAN_HandleTypeDef hcan;
  46.  
  47. DAC_HandleTypeDef hdac1;
  48. DAC_HandleTypeDef hdac2;
  49.  
  50. RTC_HandleTypeDef hrtc;
  51.  
  52. SDADC_HandleTypeDef hsdadc1;
  53. SDADC_HandleTypeDef hsdadc2;
  54. SDADC_HandleTypeDef hsdadc3;
  55.  
  56. SPI_HandleTypeDef hspi1;
  57. SPI_HandleTypeDef hspi2;
  58.  
  59. TIM_HandleTypeDef htim2;
  60. TIM_HandleTypeDef htim4;
  61. TIM_HandleTypeDef htim5;
  62. TIM_HandleTypeDef htim6;
  63. TIM_HandleTypeDef htim12;
  64. TIM_HandleTypeDef htim13;
  65. TIM_HandleTypeDef htim14;
  66. TIM_HandleTypeDef htim16;
  67. TIM_HandleTypeDef htim19;
  68.  
  69. UART_HandleTypeDef huart1;
  70.  
  71. /* USER CODE BEGIN PV */
  72.  
  73. /* USER CODE END PV */
  74.  
  75. /* Private function prototypes -----------------------------------------------*/
  76. void SystemClock_Config(void);
  77. static void MX_GPIO_Init(void);
  78. static void MX_DAC1_Init(void);
  79. static void MX_DAC2_Init(void);
  80. static void MX_RTC_Init(void);
  81. static void MX_SPI2_Init(void);
  82. static void MX_TIM2_Init(void);
  83. static void MX_TIM5_Init(void);
  84. static void MX_SPI1_Init(void);
  85. static void MX_TIM4_Init(void);
  86. static void MX_SDADC1_Init(void);
  87. static void MX_SDADC2_Init(void);
  88. static void MX_SDADC3_Init(void);
  89. static void MX_TIM19_Init(void);
  90. static void MX_CAN_Init(void);
  91. static void MX_USART1_UART_Init(void);
  92. static void MX_TIM6_Init(void);
  93. static void MX_TIM12_Init(void);
  94. static void MX_TIM13_Init(void);
  95. static void MX_TIM16_Init(void);
  96. static void MX_TIM14_Init(void);
  97. /* USER CODE BEGIN PFP */
  98.  
  99. /* USER CODE END PFP */
  100.  
  101. /* Private user code ---------------------------------------------------------*/
  102. /* USER CODE BEGIN 0 */
  103.  
  104. /* USER CODE END 0 */
  105.  
  106. /**
  107.   * @brief  The application entry point.
  108.   * @retval int
  109.   */
  110. int main(void)
  111. {
  112.   /* USER CODE BEGIN 1 */
  113.  
  114.   /* USER CODE END 1 */
  115.  
  116.   /* MCU Configuration--------------------------------------------------------*/
  117.  
  118.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  119.   HAL_Init();
  120.  
  121.   /* USER CODE BEGIN Init */
  122.  
  123.   /* USER CODE END Init */
  124.  
  125.   /* Configure the system clock */
  126.   SystemClock_Config();
  127.  
  128.   /* USER CODE BEGIN SysInit */
  129.  
  130.   /* USER CODE END SysInit */
  131.  
  132.   /* Initialize all configured peripherals */
  133.   MX_GPIO_Init();
  134.   MX_DAC1_Init();
  135.   MX_DAC2_Init();
  136.   MX_RTC_Init();
  137.   MX_SPI2_Init();
  138.   MX_TIM2_Init();
  139.   MX_TIM5_Init();
  140.   MX_SPI1_Init();
  141.   MX_TIM4_Init();
  142.   MX_SDADC1_Init();
  143.   MX_SDADC2_Init();
  144.   MX_SDADC3_Init();
  145.   MX_TIM19_Init();
  146.   MX_CAN_Init();
  147.   MX_USART1_UART_Init();
  148.   MX_TIM6_Init();
  149.   MX_TIM12_Init();
  150.   MX_TIM13_Init();
  151.   MX_TIM16_Init();
  152.   MX_USB_DEVICE_Init();
  153.   MX_FATFS_Init();
  154.   MX_TIM14_Init();
  155.   /* USER CODE BEGIN 2 */
  156.  
  157.   FATFS filesystem;
  158.   FIL file; // File
  159.   uint32_t totalSpace;
  160.   uint32_t freeSpace;
  161.  
  162.   //STM32_PLC_Start_Analog_Input(&htim12, &htim13, &htim16, &hsdadc1, &hsdadc2, &hsdadc3);
  163.   STM32_PLC_Start_Analog_Output(&hdac1, &hdac2, &htim6);
  164.   //STM32_PLC_Start_Counters(&htim4, &htim19, &htim14);
  165.   //STM32_PLC_Start_PWM(&htim2, &htim5);
  166.   //STM32_PLC_Start_SD(&hspi1, SD_CS_GPIO_Port, SD_CS_Pin, &filesystem, &file);
  167.   //STM32_PLC_Start_RTC(&hrtc);
  168.  
  169.  
  170.  
  171.  
  172.   /*
  173.   FRESULT mount_result = STM32_PLC_SD_Mont_Card();
  174.   FRESULT free_result = STM32_PLC_SD_Check_Space(&totalSpace, &freeSpace);
  175.   FRESULT open_result = STM32_PLC_SD_Create_New_File_With_Read_Write("myTest44.txt");
  176.   int written_result1 = STM32_PLC_SD_Write_File("First line\n");
  177.   int written_result2 = STM32_PLC_SD_Write_File("Second line\n");
  178.   int written_result3 = STM32_PLC_SD_Write_File("third line\n");
  179.   int written_result4 = STM32_PLC_SD_Write_File("last line");
  180.   FRESULT close_result = STM32_PLC_SD_Close_File();
  181.   open_result = STM32_PLC_SD_Create_New_File_With_Read_Write("myTest60.txt");
  182.    written_result1 = STM32_PLC_SD_Write_File("First line\n");
  183.    written_result2 = STM32_PLC_SD_Write_File("Second line\n");
  184.    written_result3 = STM32_PLC_SD_Write_File("third line\n");
  185.    written_result4 = STM32_PLC_SD_Write_File("fourth line");
  186.    close_result = STM32_PLC_SD_Close_File();
  187.   //open_result = STM32_PLC_SD_Create_New_File_With_Read_Write("myTest45.txt");
  188.   //written_result = STM32_PLC_SD_Write_File("fifth line\n");
  189.   //written_result = STM32_PLC_SD_Write_File("last line");
  190.    close_result = STM32_PLC_SD_Close_File();
  191.   FRESULT umount_result = STM32_PLC_SD_Umont_Card();
  192.  
  193. */
  194.  
  195.  
  196.   STM32_PLC_Start_LCD(&hspi2, &hspi1, LCD_CS_GPIO_Port, LCD_CS_Pin, LCD_DC_GPIO_Port, LCD_DC_Pin, LCD_RST_GPIO_Port, LCD_RST_Pin, TS_CS_GPIO_Port, TS_CS_Pin);
  197.   //STM32_PLC_LCD_Show_Intro_Frame();
  198.   //STM32_PLC_LCD_Calibrate_Touch();
  199.   //float val = 34;
  200.   //STM32_PLC_LCD_Show_Num_Pad_Frame(true, true, &val, "Write values here");
  201.   //STM32_PLC_LCD_Show_Question_Dialog("STM32 Question?");
  202.   STM32_PLC_LCD_Show_Main_Frame();
  203.  
  204.   uint16_t d0 = 0, d1 = 0, d2 = 0;
  205.  
  206.  
  207.   /* USER CODE END 2 */
  208.  
  209.   /* Infinite loop */
  210.   /* USER CODE BEGIN WHILE */
  211.  
  212.   while (1)
  213.   {
  214.     /* USER CODE END WHILE */
  215.  
  216.     /* USER CODE BEGIN 3 */
  217.  
  218.       /* Enable LED lamps on the PCB */
  219.       STM32_PLC_LED0(true);
  220.       STM32_PLC_LED1(true);
  221.       STM32_PLC_LED2(true);
  222.       STM32_PLC_LED3(true);
  223.       STM32_PLC_LED4(true);
  224.  
  225.  
  226.       STM32_PLC_LCD_Show_Values();
  227.       STM32_PLC_Analog_Output_Set(0, d0);
  228.       STM32_PLC_Analog_Output_Set(1, d1);
  229.       STM32_PLC_Analog_Output_Set(2, d2);
  230.       d0 += 10;
  231.       d1 += 20;
  232.       d2 += 30;
  233.       if(d0 >= 4095)
  234.           d0 = 0;
  235.       if(d1 >= 4095)
  236.           d1 = 0;
  237.       if(d2 >= 4095)
  238.           d2 = 0;
  239.  
  240.   }
  241.   /* USER CODE END 3 */
  242. }
  243.  
  244. /**
  245.   * @brief System Clock Configuration
  246.   * @retval None
  247.   */
  248. void SystemClock_Config(void)
  249. {
  250.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  251.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  252.   RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
  253.  
  254.   /** Initializes the RCC Oscillators according to the specified parameters
  255.   * in the RCC_OscInitTypeDef structure.
  256.   */
  257.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI|RCC_OSCILLATORTYPE_HSE;
  258.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  259.   RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  260.   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  261.   RCC_OscInitStruct.LSIState = RCC_LSI_ON;
  262.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  263.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  264.   RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL6;
  265.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  266.   {
  267.     Error_Handler();
  268.   }
  269.   /** Initializes the CPU, AHB and APB buses clocks
  270.   */
  271.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
  272.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  273.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  274.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  275.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  276.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  277.  
  278.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  279.   {
  280.     Error_Handler();
  281.   }
  282.   PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USB|RCC_PERIPHCLK_USART1
  283.                               |RCC_PERIPHCLK_RTC|RCC_PERIPHCLK_SDADC;
  284.   PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK2;
  285.   PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
  286.   PeriphClkInit.USBClockSelection = RCC_USBCLKSOURCE_PLL;
  287.   PeriphClkInit.SdadcClockSelection = RCC_SDADCSYSCLK_DIV8;
  288.   if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  289.   {
  290.     Error_Handler();
  291.   }
  292.   HAL_PWREx_EnableSDADC(PWR_SDADC_ANALOG1);
  293.   HAL_PWREx_EnableSDADC(PWR_SDADC_ANALOG2);
  294.   HAL_PWREx_EnableSDADC(PWR_SDADC_ANALOG3);
  295. }
  296.  
  297. /**
  298.   * @brief CAN Initialization Function
  299.   * @param None
  300.   * @retval None
  301.   */
  302. static void MX_CAN_Init(void)
  303. {
  304.  
  305.   /* USER CODE BEGIN CAN_Init 0 */
  306.  
  307.   /* USER CODE END CAN_Init 0 */
  308.  
  309.   /* USER CODE BEGIN CAN_Init 1 */
  310.  
  311.   /* USER CODE END CAN_Init 1 */
  312.   hcan.Instance = CAN;
  313.   hcan.Init.Prescaler = 16;
  314.   hcan.Init.Mode = CAN_MODE_NORMAL;
  315.   hcan.Init.SyncJumpWidth = CAN_SJW_1TQ;
  316.   hcan.Init.TimeSeg1 = CAN_BS1_3TQ;
  317.   hcan.Init.TimeSeg2 = CAN_BS2_2TQ;
  318.   hcan.Init.TimeTriggeredMode = DISABLE;
  319.   hcan.Init.AutoBusOff = DISABLE;
  320.   hcan.Init.AutoWakeUp = DISABLE;
  321.   hcan.Init.AutoRetransmission = DISABLE;
  322.   hcan.Init.ReceiveFifoLocked = DISABLE;
  323.   hcan.Init.TransmitFifoPriority = DISABLE;
  324.   if (HAL_CAN_Init(&hcan) != HAL_OK)
  325.   {
  326.     Error_Handler();
  327.   }
  328.   /* USER CODE BEGIN CAN_Init 2 */
  329.  
  330.   /* USER CODE END CAN_Init 2 */
  331.  
  332. }
  333.  
  334. /**
  335.   * @brief DAC1 Initialization Function
  336.   * @param None
  337.   * @retval None
  338.   */
  339. static void MX_DAC1_Init(void)
  340. {
  341.  
  342.   /* USER CODE BEGIN DAC1_Init 0 */
  343.  
  344.   /* USER CODE END DAC1_Init 0 */
  345.  
  346.   DAC_ChannelConfTypeDef sConfig = {0};
  347.  
  348.   /* USER CODE BEGIN DAC1_Init 1 */
  349.  
  350.   /* USER CODE END DAC1_Init 1 */
  351.   /** DAC Initialization
  352.   */
  353.   hdac1.Instance = DAC1;
  354.   if (HAL_DAC_Init(&hdac1) != HAL_OK)
  355.   {
  356.     Error_Handler();
  357.   }
  358.   /** DAC channel OUT1 config
  359.   */
  360.   sConfig.DAC_Trigger = DAC_TRIGGER_T6_TRGO;
  361.   sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
  362.   if (HAL_DAC_ConfigChannel(&hdac1, &sConfig, DAC_CHANNEL_1) != HAL_OK)
  363.   {
  364.     Error_Handler();
  365.   }
  366.   /** DAC channel OUT2 config
  367.   */
  368.   if (HAL_DAC_ConfigChannel(&hdac1, &sConfig, DAC_CHANNEL_2) != HAL_OK)
  369.   {
  370.     Error_Handler();
  371.   }
  372.   /* USER CODE BEGIN DAC1_Init 2 */
  373.  
  374.   /* USER CODE END DAC1_Init 2 */
  375.  
  376. }
  377.  
  378. /**
  379.   * @brief DAC2 Initialization Function
  380.   * @param None
  381.   * @retval None
  382.   */
  383. static void MX_DAC2_Init(void)
  384. {
  385.  
  386.   /* USER CODE BEGIN DAC2_Init 0 */
  387.  
  388.   /* USER CODE END DAC2_Init 0 */
  389.  
  390.   DAC_ChannelConfTypeDef sConfig = {0};
  391.  
  392.   /* USER CODE BEGIN DAC2_Init 1 */
  393.  
  394.   /* USER CODE END DAC2_Init 1 */
  395.   /** DAC Initialization
  396.   */
  397.   hdac2.Instance = DAC2;
  398.   if (HAL_DAC_Init(&hdac2) != HAL_OK)
  399.   {
  400.     Error_Handler();
  401.   }
  402.   /** DAC channel OUT1 config
  403.   */
  404.   sConfig.DAC_Trigger = DAC_TRIGGER_T6_TRGO;
  405.   sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
  406.   if (HAL_DAC_ConfigChannel(&hdac2, &sConfig, DAC_CHANNEL_1) != HAL_OK)
  407.   {
  408.     Error_Handler();
  409.   }
  410.   /* USER CODE BEGIN DAC2_Init 2 */
  411.  
  412.   /* USER CODE END DAC2_Init 2 */
  413.  
  414. }
  415.  
  416. /**
  417.   * @brief RTC Initialization Function
  418.   * @param None
  419.   * @retval None
  420.   */
  421. static void MX_RTC_Init(void)
  422. {
  423.  
  424.   /* USER CODE BEGIN RTC_Init 0 */
  425.  
  426.   /* USER CODE END RTC_Init 0 */
  427.  
  428.   RTC_TimeTypeDef sTime = {0};
  429.   RTC_DateTypeDef sDate = {0};
  430.  
  431.   /* USER CODE BEGIN RTC_Init 1 */
  432.  
  433.   /* USER CODE END RTC_Init 1 */
  434.   /** Initialize RTC Only
  435.   */
  436.   hrtc.Instance = RTC;
  437.   hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
  438.   hrtc.Init.AsynchPrediv = 127;
  439.   hrtc.Init.SynchPrediv = 255;
  440.   hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
  441.   hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
  442.   hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
  443.   if (HAL_RTC_Init(&hrtc) != HAL_OK)
  444.   {
  445.     Error_Handler();
  446.   }
  447.  
  448.   /* USER CODE BEGIN Check_RTC_BKUP */
  449.  
  450.   /* USER CODE END Check_RTC_BKUP */
  451.  
  452.   /** Initialize RTC and set the Time and Date
  453.   */
  454.   sTime.Hours = 0;
  455.   sTime.Minutes = 0;
  456.   sTime.Seconds = 0;
  457.   sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
  458.   sTime.StoreOperation = RTC_STOREOPERATION_RESET;
  459.   if (HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN) != HAL_OK)
  460.   {
  461.     Error_Handler();
  462.   }
  463.   sDate.WeekDay = RTC_WEEKDAY_MONDAY;
  464.   sDate.Month = RTC_MONTH_JANUARY;
  465.   sDate.Date = 1;
  466.   sDate.Year = 0;
  467.  
  468.   if (HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BIN) != HAL_OK)
  469.   {
  470.     Error_Handler();
  471.   }
  472.   /* USER CODE BEGIN RTC_Init 2 */
  473.  
  474.   /* USER CODE END RTC_Init 2 */
  475.  
  476. }
  477.  
  478. /**
  479.   * @brief SDADC1 Initialization Function
  480.   * @param None
  481.   * @retval None
  482.   */
  483. static void MX_SDADC1_Init(void)
  484. {
  485.  
  486.   /* USER CODE BEGIN SDADC1_Init 0 */
  487.  
  488.   /* USER CODE END SDADC1_Init 0 */
  489.  
  490.   SDADC_ConfParamTypeDef ConfParamStruct = {0};
  491.  
  492.   /* USER CODE BEGIN SDADC1_Init 1 */
  493.  
  494.   /* USER CODE END SDADC1_Init 1 */
  495.   /** Configure the SDADC low power mode, fast conversion mode,
  496.   slow clock mode and SDADC1 reference voltage
  497.   */
  498.   hsdadc1.Instance = SDADC1;
  499.   hsdadc1.Init.IdleLowPowerMode = SDADC_LOWPOWER_NONE;
  500.   hsdadc1.Init.FastConversionMode = SDADC_FAST_CONV_DISABLE;
  501.   hsdadc1.Init.SlowClockMode = SDADC_SLOW_CLOCK_DISABLE;
  502.   hsdadc1.Init.ReferenceVoltage = SDADC_VREF_EXT;
  503.   hsdadc1.InjectedTrigger = SDADC_EXTERNAL_TRIGGER;
  504.   hsdadc1.ExtTriggerEdge = SDADC_EXT_TRIG_RISING_EDGE;
  505.   if (HAL_SDADC_Init(&hsdadc1) != HAL_OK)
  506.   {
  507.     Error_Handler();
  508.   }
  509.   /** Configure the Injected Mode
  510.   */
  511.   if (HAL_SDADC_SelectInjectedDelay(&hsdadc1, SDADC_INJECTED_DELAY_NONE) != HAL_OK)
  512.   {
  513.     Error_Handler();
  514.   }
  515.   if (HAL_SDADC_SelectInjectedExtTrigger(&hsdadc1, SDADC_EXT_TRIG_TIM13_CC1, SDADC_EXT_TRIG_RISING_EDGE) != HAL_OK)
  516.   {
  517.     Error_Handler();
  518.   }
  519.   if (HAL_SDADC_SelectInjectedTrigger(&hsdadc1, SDADC_EXTERNAL_TRIGGER) != HAL_OK)
  520.   {
  521.     Error_Handler();
  522.   }
  523.   if (HAL_SDADC_InjectedConfigChannel(&hsdadc1, SDADC_CHANNEL_0|SDADC_CHANNEL_1
  524.                               |SDADC_CHANNEL_2|SDADC_CHANNEL_3
  525.                               |SDADC_CHANNEL_4|SDADC_CHANNEL_5
  526.                               |SDADC_CHANNEL_6|SDADC_CHANNEL_7
  527.                               |SDADC_CHANNEL_8, SDADC_CONTINUOUS_CONV_ON) != HAL_OK)
  528.   {
  529.     Error_Handler();
  530.   }
  531.   /** Set parameters for SDADC configuration 0 Register
  532.   */
  533.   ConfParamStruct.InputMode = SDADC_INPUT_MODE_SE_ZERO_REFERENCE;
  534.   ConfParamStruct.Gain = SDADC_GAIN_1;
  535.   ConfParamStruct.CommonMode = SDADC_COMMON_MODE_VSSA;
  536.   ConfParamStruct.Offset = 0;
  537.   if (HAL_SDADC_PrepareChannelConfig(&hsdadc1, SDADC_CONF_INDEX_0, &ConfParamStruct) != HAL_OK)
  538.   {
  539.     Error_Handler();
  540.   }
  541.   /** Configure the Injected Channel
  542.   */
  543.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc1, SDADC_CHANNEL_0, SDADC_CONF_INDEX_0) != HAL_OK)
  544.   {
  545.     Error_Handler();
  546.   }
  547.   /** Configure the Injected Channel
  548.   */
  549.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc1, SDADC_CHANNEL_1, SDADC_CONF_INDEX_0) != HAL_OK)
  550.   {
  551.     Error_Handler();
  552.   }
  553.   /** Configure the Injected Channel
  554.   */
  555.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc1, SDADC_CHANNEL_2, SDADC_CONF_INDEX_0) != HAL_OK)
  556.   {
  557.     Error_Handler();
  558.   }
  559.   /** Configure the Injected Channel
  560.   */
  561.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc1, SDADC_CHANNEL_3, SDADC_CONF_INDEX_0) != HAL_OK)
  562.   {
  563.     Error_Handler();
  564.   }
  565.   /** Configure the Injected Channel
  566.   */
  567.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc1, SDADC_CHANNEL_4, SDADC_CONF_INDEX_0) != HAL_OK)
  568.   {
  569.     Error_Handler();
  570.   }
  571.   /** Configure the Injected Channel
  572.   */
  573.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc1, SDADC_CHANNEL_5, SDADC_CONF_INDEX_0) != HAL_OK)
  574.   {
  575.     Error_Handler();
  576.   }
  577.   /** Configure the Injected Channel
  578.   */
  579.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc1, SDADC_CHANNEL_6, SDADC_CONF_INDEX_0) != HAL_OK)
  580.   {
  581.     Error_Handler();
  582.   }
  583.   /** Configure the Injected Channel
  584.   */
  585.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc1, SDADC_CHANNEL_7, SDADC_CONF_INDEX_0) != HAL_OK)
  586.   {
  587.     Error_Handler();
  588.   }
  589.   /** Configure the Injected Channel
  590.   */
  591.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc1, SDADC_CHANNEL_8, SDADC_CONF_INDEX_0) != HAL_OK)
  592.   {
  593.     Error_Handler();
  594.   }
  595.   /* USER CODE BEGIN SDADC1_Init 2 */
  596.  
  597.   /* USER CODE END SDADC1_Init 2 */
  598.  
  599. }
  600.  
  601. /**
  602.   * @brief SDADC2 Initialization Function
  603.   * @param None
  604.   * @retval None
  605.   */
  606. static void MX_SDADC2_Init(void)
  607. {
  608.  
  609.   /* USER CODE BEGIN SDADC2_Init 0 */
  610.  
  611.   /* USER CODE END SDADC2_Init 0 */
  612.  
  613.   SDADC_ConfParamTypeDef ConfParamStruct = {0};
  614.  
  615.   /* USER CODE BEGIN SDADC2_Init 1 */
  616.  
  617.   /* USER CODE END SDADC2_Init 1 */
  618.   /** Configure the SDADC low power mode, fast conversion mode,
  619.   slow clock mode and SDADC1 reference voltage
  620.   */
  621.   hsdadc2.Instance = SDADC2;
  622.   hsdadc2.Init.IdleLowPowerMode = SDADC_LOWPOWER_NONE;
  623.   hsdadc2.Init.FastConversionMode = SDADC_FAST_CONV_DISABLE;
  624.   hsdadc2.Init.SlowClockMode = SDADC_SLOW_CLOCK_DISABLE;
  625.   hsdadc2.Init.ReferenceVoltage = SDADC_VREF_EXT;
  626.   hsdadc2.InjectedTrigger = SDADC_EXTERNAL_TRIGGER;
  627.   hsdadc2.ExtTriggerEdge = SDADC_EXT_TRIG_RISING_EDGE;
  628.   if (HAL_SDADC_Init(&hsdadc2) != HAL_OK)
  629.   {
  630.     Error_Handler();
  631.   }
  632.   /** Configure the Injected Mode
  633.   */
  634.   if (HAL_SDADC_SelectInjectedDelay(&hsdadc2, SDADC_INJECTED_DELAY_NONE) != HAL_OK)
  635.   {
  636.     Error_Handler();
  637.   }
  638.   if (HAL_SDADC_SelectInjectedExtTrigger(&hsdadc2, SDADC_EXT_TRIG_TIM12_CC1, SDADC_EXT_TRIG_RISING_EDGE) != HAL_OK)
  639.   {
  640.     Error_Handler();
  641.   }
  642.   if (HAL_SDADC_SelectInjectedTrigger(&hsdadc2, SDADC_EXTERNAL_TRIGGER) != HAL_OK)
  643.   {
  644.     Error_Handler();
  645.   }
  646.   if (HAL_SDADC_InjectedConfigChannel(&hsdadc2, SDADC_CHANNEL_0|SDADC_CHANNEL_1
  647.                               |SDADC_CHANNEL_2, SDADC_CONTINUOUS_CONV_ON) != HAL_OK)
  648.   {
  649.     Error_Handler();
  650.   }
  651.   /** Set parameters for SDADC configuration 0 Register
  652.   */
  653.   ConfParamStruct.InputMode = SDADC_INPUT_MODE_SE_ZERO_REFERENCE;
  654.   ConfParamStruct.Gain = SDADC_GAIN_1;
  655.   ConfParamStruct.CommonMode = SDADC_COMMON_MODE_VSSA;
  656.   ConfParamStruct.Offset = 0;
  657.   if (HAL_SDADC_PrepareChannelConfig(&hsdadc2, SDADC_CONF_INDEX_0, &ConfParamStruct) != HAL_OK)
  658.   {
  659.     Error_Handler();
  660.   }
  661.   /** Configure the Injected Channel
  662.   */
  663.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc2, SDADC_CHANNEL_0, SDADC_CONF_INDEX_0) != HAL_OK)
  664.   {
  665.     Error_Handler();
  666.   }
  667.   /** Configure the Injected Channel
  668.   */
  669.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc2, SDADC_CHANNEL_1, SDADC_CONF_INDEX_0) != HAL_OK)
  670.   {
  671.     Error_Handler();
  672.   }
  673.   /** Configure the Injected Channel
  674.   */
  675.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc2, SDADC_CHANNEL_2, SDADC_CONF_INDEX_0) != HAL_OK)
  676.   {
  677.     Error_Handler();
  678.   }
  679.   /* USER CODE BEGIN SDADC2_Init 2 */
  680.  
  681.   /* USER CODE END SDADC2_Init 2 */
  682.  
  683. }
  684.  
  685. /**
  686.   * @brief SDADC3 Initialization Function
  687.   * @param None
  688.   * @retval None
  689.   */
  690. static void MX_SDADC3_Init(void)
  691. {
  692.  
  693.   /* USER CODE BEGIN SDADC3_Init 0 */
  694.  
  695.   /* USER CODE END SDADC3_Init 0 */
  696.  
  697.   SDADC_ConfParamTypeDef ConfParamStruct = {0};
  698.  
  699.   /* USER CODE BEGIN SDADC3_Init 1 */
  700.  
  701.   /* USER CODE END SDADC3_Init 1 */
  702.   /** Configure the SDADC low power mode, fast conversion mode,
  703.   slow clock mode and SDADC1 reference voltage
  704.   */
  705.   hsdadc3.Instance = SDADC3;
  706.   hsdadc3.Init.IdleLowPowerMode = SDADC_LOWPOWER_NONE;
  707.   hsdadc3.Init.FastConversionMode = SDADC_FAST_CONV_DISABLE;
  708.   hsdadc3.Init.SlowClockMode = SDADC_SLOW_CLOCK_DISABLE;
  709.   hsdadc3.Init.ReferenceVoltage = SDADC_VREF_EXT;
  710.   hsdadc3.InjectedTrigger = SDADC_EXTERNAL_TRIGGER;
  711.   hsdadc3.ExtTriggerEdge = SDADC_EXT_TRIG_RISING_EDGE;
  712.   if (HAL_SDADC_Init(&hsdadc3) != HAL_OK)
  713.   {
  714.     Error_Handler();
  715.   }
  716.   /** Configure the Injected Mode
  717.   */
  718.   if (HAL_SDADC_SelectInjectedDelay(&hsdadc3, SDADC_INJECTED_DELAY_NONE) != HAL_OK)
  719.   {
  720.     Error_Handler();
  721.   }
  722.   if (HAL_SDADC_SelectInjectedExtTrigger(&hsdadc3, SDADC_EXT_TRIG_TIM16_CC1, SDADC_EXT_TRIG_RISING_EDGE) != HAL_OK)
  723.   {
  724.     Error_Handler();
  725.   }
  726.   if (HAL_SDADC_SelectInjectedTrigger(&hsdadc3, SDADC_EXTERNAL_TRIGGER) != HAL_OK)
  727.   {
  728.     Error_Handler();
  729.   }
  730.   if (HAL_SDADC_InjectedConfigChannel(&hsdadc3, SDADC_CHANNEL_0|SDADC_CHANNEL_2
  731.                               |SDADC_CHANNEL_4|SDADC_CHANNEL_6
  732.                               |SDADC_CHANNEL_8, SDADC_CONTINUOUS_CONV_ON) != HAL_OK)
  733.   {
  734.     Error_Handler();
  735.   }
  736.   /** Set parameters for SDADC configuration 0 Register
  737.   */
  738.   ConfParamStruct.InputMode = SDADC_INPUT_MODE_DIFF;
  739.   ConfParamStruct.Gain = SDADC_GAIN_1;
  740.   ConfParamStruct.CommonMode = SDADC_COMMON_MODE_VSSA;
  741.   ConfParamStruct.Offset = 0;
  742.   if (HAL_SDADC_PrepareChannelConfig(&hsdadc3, SDADC_CONF_INDEX_0, &ConfParamStruct) != HAL_OK)
  743.   {
  744.     Error_Handler();
  745.   }
  746.   /** Configure the Injected Channel
  747.   */
  748.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc3, SDADC_CHANNEL_0, SDADC_CONF_INDEX_0) != HAL_OK)
  749.   {
  750.     Error_Handler();
  751.   }
  752.   /** Configure the Injected Channel
  753.   */
  754.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc3, SDADC_CHANNEL_2, SDADC_CONF_INDEX_0) != HAL_OK)
  755.   {
  756.     Error_Handler();
  757.   }
  758.   /** Configure the Injected Channel
  759.   */
  760.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc3, SDADC_CHANNEL_4, SDADC_CONF_INDEX_0) != HAL_OK)
  761.   {
  762.     Error_Handler();
  763.   }
  764.   /** Configure the Injected Channel
  765.   */
  766.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc3, SDADC_CHANNEL_6, SDADC_CONF_INDEX_0) != HAL_OK)
  767.   {
  768.     Error_Handler();
  769.   }
  770.   /** Configure the Injected Channel
  771.   */
  772.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc3, SDADC_CHANNEL_8, SDADC_CONF_INDEX_0) != HAL_OK)
  773.   {
  774.     Error_Handler();
  775.   }
  776.   /* USER CODE BEGIN SDADC3_Init 2 */
  777.  
  778.   /* USER CODE END SDADC3_Init 2 */
  779.  
  780. }
  781.  
  782. /**
  783.   * @brief SPI1 Initialization Function
  784.   * @param None
  785.   * @retval None
  786.   */
  787. static void MX_SPI1_Init(void)
  788. {
  789.  
  790.   /* USER CODE BEGIN SPI1_Init 0 */
  791.  
  792.   /* USER CODE END SPI1_Init 0 */
  793.  
  794.   /* USER CODE BEGIN SPI1_Init 1 */
  795.  
  796.   /* USER CODE END SPI1_Init 1 */
  797.   /* SPI1 parameter configuration*/
  798.   hspi1.Instance = SPI1;
  799.   hspi1.Init.Mode = SPI_MODE_MASTER;
  800.   hspi1.Init.Direction = SPI_DIRECTION_2LINES;
  801.   hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
  802.   hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
  803.   hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
  804.   hspi1.Init.NSS = SPI_NSS_SOFT;
  805.   hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
  806.   hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
  807.   hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
  808.   hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  809.   hspi1.Init.CRCPolynomial = 7;
  810.   hspi1.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
  811.   hspi1.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
  812.   if (HAL_SPI_Init(&hspi1) != HAL_OK)
  813.   {
  814.     Error_Handler();
  815.   }
  816.   /* USER CODE BEGIN SPI1_Init 2 */
  817.  
  818.   /* USER CODE END SPI1_Init 2 */
  819.  
  820. }
  821.  
  822. /**
  823.   * @brief SPI2 Initialization Function
  824.   * @param None
  825.   * @retval None
  826.   */
  827. static void MX_SPI2_Init(void)
  828. {
  829.  
  830.   /* USER CODE BEGIN SPI2_Init 0 */
  831.  
  832.   /* USER CODE END SPI2_Init 0 */
  833.  
  834.   /* USER CODE BEGIN SPI2_Init 1 */
  835.  
  836.   /* USER CODE END SPI2_Init 1 */
  837.   /* SPI2 parameter configuration*/
  838.   hspi2.Instance = SPI2;
  839.   hspi2.Init.Mode = SPI_MODE_MASTER;
  840.   hspi2.Init.Direction = SPI_DIRECTION_2LINES;
  841.   hspi2.Init.DataSize = SPI_DATASIZE_8BIT;
  842.   hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;
  843.   hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
  844.   hspi2.Init.NSS = SPI_NSS_SOFT;
  845.   hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  846.   hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
  847.   hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
  848.   hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  849.   hspi2.Init.CRCPolynomial = 7;
  850.   hspi2.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
  851.   hspi2.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
  852.   if (HAL_SPI_Init(&hspi2) != HAL_OK)
  853.   {
  854.     Error_Handler();
  855.   }
  856.   /* USER CODE BEGIN SPI2_Init 2 */
  857.  
  858.   /* USER CODE END SPI2_Init 2 */
  859.  
  860. }
  861.  
  862. /**
  863.   * @brief TIM2 Initialization Function
  864.   * @param None
  865.   * @retval None
  866.   */
  867. static void MX_TIM2_Init(void)
  868. {
  869.  
  870.   /* USER CODE BEGIN TIM2_Init 0 */
  871.  
  872.   /* USER CODE END TIM2_Init 0 */
  873.  
  874.   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  875.   TIM_MasterConfigTypeDef sMasterConfig = {0};
  876.   TIM_OC_InitTypeDef sConfigOC = {0};
  877.  
  878.   /* USER CODE BEGIN TIM2_Init 1 */
  879.  
  880.   /* USER CODE END TIM2_Init 1 */
  881.   htim2.Instance = TIM2;
  882.   htim2.Init.Prescaler = 20;
  883.   htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  884.   htim2.Init.Period = 0xffff;
  885.   htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  886.   htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  887.   if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  888.   {
  889.     Error_Handler();
  890.   }
  891.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  892.   if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  893.   {
  894.     Error_Handler();
  895.   }
  896.   if (HAL_TIM_PWM_Init(&htim2) != HAL_OK)
  897.   {
  898.     Error_Handler();
  899.   }
  900.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  901.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  902.   if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  903.   {
  904.     Error_Handler();
  905.   }
  906.   sConfigOC.OCMode = TIM_OCMODE_PWM1;
  907.   sConfigOC.Pulse = 0xffff;
  908.   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  909.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  910.   if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  911.   {
  912.     Error_Handler();
  913.   }
  914.   sConfigOC.Pulse = 0;
  915.   if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  916.   {
  917.     Error_Handler();
  918.   }
  919.   if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
  920.   {
  921.     Error_Handler();
  922.   }
  923.   sConfigOC.Pulse = 0xffff;
  924.   if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
  925.   {
  926.     Error_Handler();
  927.   }
  928.   /* USER CODE BEGIN TIM2_Init 2 */
  929.  
  930.   /* USER CODE END TIM2_Init 2 */
  931.   HAL_TIM_MspPostInit(&htim2);
  932.  
  933. }
  934.  
  935. /**
  936.   * @brief TIM4 Initialization Function
  937.   * @param None
  938.   * @retval None
  939.   */
  940. static void MX_TIM4_Init(void)
  941. {
  942.  
  943.   /* USER CODE BEGIN TIM4_Init 0 */
  944.  
  945.   /* USER CODE END TIM4_Init 0 */
  946.  
  947.   TIM_Encoder_InitTypeDef sConfig = {0};
  948.   TIM_MasterConfigTypeDef sMasterConfig = {0};
  949.   TIM_IC_InitTypeDef sConfigIC = {0};
  950.  
  951.   /* USER CODE BEGIN TIM4_Init 1 */
  952.  
  953.   /* USER CODE END TIM4_Init 1 */
  954.   htim4.Instance = TIM4;
  955.   htim4.Init.Prescaler = 0;
  956.   htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
  957.   htim4.Init.Period = 0xffff;
  958.   htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  959.   htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  960.   if (HAL_TIM_IC_Init(&htim4) != HAL_OK)
  961.   {
  962.     Error_Handler();
  963.   }
  964.   sConfig.EncoderMode = TIM_ENCODERMODE_TI12;
  965.   sConfig.IC1Polarity = TIM_ICPOLARITY_RISING;
  966.   sConfig.IC1Selection = TIM_ICSELECTION_DIRECTTI;
  967.   sConfig.IC1Prescaler = TIM_ICPSC_DIV1;
  968.   sConfig.IC1Filter = 0;
  969.   sConfig.IC2Polarity = TIM_ICPOLARITY_RISING;
  970.   sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;
  971.   sConfig.IC2Prescaler = TIM_ICPSC_DIV1;
  972.   sConfig.IC2Filter = 0;
  973.   if (HAL_TIM_Encoder_Init(&htim4, &sConfig) != HAL_OK)
  974.   {
  975.     Error_Handler();
  976.   }
  977.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  978.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  979.   if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
  980.   {
  981.     Error_Handler();
  982.   }
  983.   sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
  984.   sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
  985.   sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
  986.   sConfigIC.ICFilter = 0;
  987.   if (HAL_TIM_IC_ConfigChannel(&htim4, &sConfigIC, TIM_CHANNEL_3) != HAL_OK)
  988.   {
  989.     Error_Handler();
  990.   }
  991.   if (HAL_TIM_IC_ConfigChannel(&htim4, &sConfigIC, TIM_CHANNEL_4) != HAL_OK)
  992.   {
  993.     Error_Handler();
  994.   }
  995.   /* USER CODE BEGIN TIM4_Init 2 */
  996.  
  997.   /* USER CODE END TIM4_Init 2 */
  998.  
  999. }
  1000.  
  1001. /**
  1002.   * @brief TIM5 Initialization Function
  1003.   * @param None
  1004.   * @retval None
  1005.   */
  1006. static void MX_TIM5_Init(void)
  1007. {
  1008.  
  1009.   /* USER CODE BEGIN TIM5_Init 0 */
  1010.  
  1011.   /* USER CODE END TIM5_Init 0 */
  1012.  
  1013.   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  1014.   TIM_MasterConfigTypeDef sMasterConfig = {0};
  1015.   TIM_OC_InitTypeDef sConfigOC = {0};
  1016.  
  1017.   /* USER CODE BEGIN TIM5_Init 1 */
  1018.  
  1019.   /* USER CODE END TIM5_Init 1 */
  1020.   htim5.Instance = TIM5;
  1021.   htim5.Init.Prescaler = 19;
  1022.   htim5.Init.CounterMode = TIM_COUNTERMODE_UP;
  1023.   htim5.Init.Period = 0xffff;
  1024.   htim5.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  1025.   htim5.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  1026.   if (HAL_TIM_Base_Init(&htim5) != HAL_OK)
  1027.   {
  1028.     Error_Handler();
  1029.   }
  1030.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  1031.   if (HAL_TIM_ConfigClockSource(&htim5, &sClockSourceConfig) != HAL_OK)
  1032.   {
  1033.     Error_Handler();
  1034.   }
  1035.   if (HAL_TIM_PWM_Init(&htim5) != HAL_OK)
  1036.   {
  1037.     Error_Handler();
  1038.   }
  1039.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  1040.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  1041.   if (HAL_TIMEx_MasterConfigSynchronization(&htim5, &sMasterConfig) != HAL_OK)
  1042.   {
  1043.     Error_Handler();
  1044.   }
  1045.   sConfigOC.OCMode = TIM_OCMODE_PWM1;
  1046.   sConfigOC.Pulse = 0;
  1047.   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  1048.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  1049.   if (HAL_TIM_PWM_ConfigChannel(&htim5, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  1050.   {
  1051.     Error_Handler();
  1052.   }
  1053.   if (HAL_TIM_PWM_ConfigChannel(&htim5, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  1054.   {
  1055.     Error_Handler();
  1056.   }
  1057.   if (HAL_TIM_PWM_ConfigChannel(&htim5, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
  1058.   {
  1059.     Error_Handler();
  1060.   }
  1061.   sConfigOC.Pulse = 0xffff;
  1062.   if (HAL_TIM_PWM_ConfigChannel(&htim5, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
  1063.   {
  1064.     Error_Handler();
  1065.   }
  1066.   /* USER CODE BEGIN TIM5_Init 2 */
  1067.  
  1068.   /* USER CODE END TIM5_Init 2 */
  1069.   HAL_TIM_MspPostInit(&htim5);
  1070.  
  1071. }
  1072.  
  1073. /**
  1074.   * @brief TIM6 Initialization Function
  1075.   * @param None
  1076.   * @retval None
  1077.   */
  1078. static void MX_TIM6_Init(void)
  1079. {
  1080.  
  1081.   /* USER CODE BEGIN TIM6_Init 0 */
  1082.  
  1083.   /* USER CODE END TIM6_Init 0 */
  1084.  
  1085.   TIM_MasterConfigTypeDef sMasterConfig = {0};
  1086.  
  1087.   /* USER CODE BEGIN TIM6_Init 1 */
  1088.  
  1089.   /* USER CODE END TIM6_Init 1 */
  1090.   htim6.Instance = TIM6;
  1091.   htim6.Init.Prescaler = 18;
  1092.   htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
  1093.   htim6.Init.Period = 0xffff;
  1094.   htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  1095.   if (HAL_TIM_Base_Init(&htim6) != HAL_OK)
  1096.   {
  1097.     Error_Handler();
  1098.   }
  1099.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
  1100.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  1101.   if (HAL_TIMEx_MasterConfigSynchronization(&htim6, &sMasterConfig) != HAL_OK)
  1102.   {
  1103.     Error_Handler();
  1104.   }
  1105.   /* USER CODE BEGIN TIM6_Init 2 */
  1106.  
  1107.   /* USER CODE END TIM6_Init 2 */
  1108.  
  1109. }
  1110.  
  1111. /**
  1112.   * @brief TIM12 Initialization Function
  1113.   * @param None
  1114.   * @retval None
  1115.   */
  1116. static void MX_TIM12_Init(void)
  1117. {
  1118.  
  1119.   /* USER CODE BEGIN TIM12_Init 0 */
  1120.  
  1121.   /* USER CODE END TIM12_Init 0 */
  1122.  
  1123.   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  1124.   TIM_OC_InitTypeDef sConfigOC = {0};
  1125.  
  1126.   /* USER CODE BEGIN TIM12_Init 1 */
  1127.  
  1128.   /* USER CODE END TIM12_Init 1 */
  1129.   htim12.Instance = TIM12;
  1130.   htim12.Init.Prescaler = 17;
  1131.   htim12.Init.CounterMode = TIM_COUNTERMODE_UP;
  1132.   htim12.Init.Period = 0xffff;
  1133.   htim12.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  1134.   htim12.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  1135.   if (HAL_TIM_Base_Init(&htim12) != HAL_OK)
  1136.   {
  1137.     Error_Handler();
  1138.   }
  1139.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  1140.   if (HAL_TIM_ConfigClockSource(&htim12, &sClockSourceConfig) != HAL_OK)
  1141.   {
  1142.     Error_Handler();
  1143.   }
  1144.   if (HAL_TIM_OC_Init(&htim12) != HAL_OK)
  1145.   {
  1146.     Error_Handler();
  1147.   }
  1148.   sConfigOC.OCMode = TIM_OCMODE_TOGGLE;
  1149.   sConfigOC.Pulse = 0;
  1150.   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  1151.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  1152.   if (HAL_TIM_OC_ConfigChannel(&htim12, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  1153.   {
  1154.     Error_Handler();
  1155.   }
  1156.   /* USER CODE BEGIN TIM12_Init 2 */
  1157.  
  1158.   /* USER CODE END TIM12_Init 2 */
  1159.  
  1160. }
  1161.  
  1162. /**
  1163.   * @brief TIM13 Initialization Function
  1164.   * @param None
  1165.   * @retval None
  1166.   */
  1167. static void MX_TIM13_Init(void)
  1168. {
  1169.  
  1170.   /* USER CODE BEGIN TIM13_Init 0 */
  1171.  
  1172.   /* USER CODE END TIM13_Init 0 */
  1173.  
  1174.   TIM_OC_InitTypeDef sConfigOC = {0};
  1175.  
  1176.   /* USER CODE BEGIN TIM13_Init 1 */
  1177.  
  1178.   /* USER CODE END TIM13_Init 1 */
  1179.   htim13.Instance = TIM13;
  1180.   htim13.Init.Prescaler = 16;
  1181.   htim13.Init.CounterMode = TIM_COUNTERMODE_UP;
  1182.   htim13.Init.Period = 0xffff;
  1183.   htim13.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  1184.   htim13.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  1185.   if (HAL_TIM_Base_Init(&htim13) != HAL_OK)
  1186.   {
  1187.     Error_Handler();
  1188.   }
  1189.   if (HAL_TIM_OC_Init(&htim13) != HAL_OK)
  1190.   {
  1191.     Error_Handler();
  1192.   }
  1193.   sConfigOC.OCMode = TIM_OCMODE_TOGGLE;
  1194.   sConfigOC.Pulse = 0;
  1195.   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  1196.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  1197.   if (HAL_TIM_OC_ConfigChannel(&htim13, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  1198.   {
  1199.     Error_Handler();
  1200.   }
  1201.   /* USER CODE BEGIN TIM13_Init 2 */
  1202.  
  1203.   /* USER CODE END TIM13_Init 2 */
  1204.  
  1205. }
  1206.  
  1207. /**
  1208.   * @brief TIM14 Initialization Function
  1209.   * @param None
  1210.   * @retval None
  1211.   */
  1212. static void MX_TIM14_Init(void)
  1213. {
  1214.  
  1215.   /* USER CODE BEGIN TIM14_Init 0 */
  1216.  
  1217.   /* USER CODE END TIM14_Init 0 */
  1218.  
  1219.   /* USER CODE BEGIN TIM14_Init 1 */
  1220.  
  1221.   /* USER CODE END TIM14_Init 1 */
  1222.   htim14.Instance = TIM14;
  1223.   htim14.Init.Prescaler = 15;
  1224.   htim14.Init.CounterMode = TIM_COUNTERMODE_UP;
  1225.   htim14.Init.Period = 0xffff;
  1226.   htim14.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  1227.   htim14.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  1228.   if (HAL_TIM_Base_Init(&htim14) != HAL_OK)
  1229.   {
  1230.     Error_Handler();
  1231.   }
  1232.   /* USER CODE BEGIN TIM14_Init 2 */
  1233.  
  1234.   /* USER CODE END TIM14_Init 2 */
  1235.  
  1236. }
  1237.  
  1238. /**
  1239.   * @brief TIM16 Initialization Function
  1240.   * @param None
  1241.   * @retval None
  1242.   */
  1243. static void MX_TIM16_Init(void)
  1244. {
  1245.  
  1246.   /* USER CODE BEGIN TIM16_Init 0 */
  1247.  
  1248.   /* USER CODE END TIM16_Init 0 */
  1249.  
  1250.   TIM_OC_InitTypeDef sConfigOC = {0};
  1251.   TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};
  1252.  
  1253.   /* USER CODE BEGIN TIM16_Init 1 */
  1254.  
  1255.   /* USER CODE END TIM16_Init 1 */
  1256.   htim16.Instance = TIM16;
  1257.   htim16.Init.Prescaler = 14;
  1258.   htim16.Init.CounterMode = TIM_COUNTERMODE_UP;
  1259.   htim16.Init.Period = 0xffff;
  1260.   htim16.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  1261.   htim16.Init.RepetitionCounter = 0;
  1262.   htim16.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  1263.   if (HAL_TIM_Base_Init(&htim16) != HAL_OK)
  1264.   {
  1265.     Error_Handler();
  1266.   }
  1267.   if (HAL_TIM_OC_Init(&htim16) != HAL_OK)
  1268.   {
  1269.     Error_Handler();
  1270.   }
  1271.   sConfigOC.OCMode = TIM_OCMODE_TOGGLE;
  1272.   sConfigOC.Pulse = 0;
  1273.   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  1274.   sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
  1275.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  1276.   sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
  1277.   sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  1278.   if (HAL_TIM_OC_ConfigChannel(&htim16, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  1279.   {
  1280.     Error_Handler();
  1281.   }
  1282.   sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
  1283.   sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
  1284.   sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
  1285.   sBreakDeadTimeConfig.DeadTime = 0;
  1286.   sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
  1287.   sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
  1288.   sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
  1289.   if (HAL_TIMEx_ConfigBreakDeadTime(&htim16, &sBreakDeadTimeConfig) != HAL_OK)
  1290.   {
  1291.     Error_Handler();
  1292.   }
  1293.   /* USER CODE BEGIN TIM16_Init 2 */
  1294.  
  1295.   /* USER CODE END TIM16_Init 2 */
  1296.  
  1297. }
  1298.  
  1299. /**
  1300.   * @brief TIM19 Initialization Function
  1301.   * @param None
  1302.   * @retval None
  1303.   */
  1304. static void MX_TIM19_Init(void)
  1305. {
  1306.  
  1307.   /* USER CODE BEGIN TIM19_Init 0 */
  1308.  
  1309.   /* USER CODE END TIM19_Init 0 */
  1310.  
  1311.   TIM_Encoder_InitTypeDef sConfig = {0};
  1312.   TIM_MasterConfigTypeDef sMasterConfig = {0};
  1313.   TIM_IC_InitTypeDef sConfigIC = {0};
  1314.  
  1315.   /* USER CODE BEGIN TIM19_Init 1 */
  1316.  
  1317.   /* USER CODE END TIM19_Init 1 */
  1318.   htim19.Instance = TIM19;
  1319.   htim19.Init.Prescaler = 0;
  1320.   htim19.Init.CounterMode = TIM_COUNTERMODE_UP;
  1321.   htim19.Init.Period = 0xffff;
  1322.   htim19.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  1323.   htim19.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  1324.   if (HAL_TIM_IC_Init(&htim19) != HAL_OK)
  1325.   {
  1326.     Error_Handler();
  1327.   }
  1328.   sConfig.EncoderMode = TIM_ENCODERMODE_TI12;
  1329.   sConfig.IC1Polarity = TIM_ICPOLARITY_RISING;
  1330.   sConfig.IC1Selection = TIM_ICSELECTION_DIRECTTI;
  1331.   sConfig.IC1Prescaler = TIM_ICPSC_DIV1;
  1332.   sConfig.IC1Filter = 0;
  1333.   sConfig.IC2Polarity = TIM_ICPOLARITY_RISING;
  1334.   sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;
  1335.   sConfig.IC2Prescaler = TIM_ICPSC_DIV1;
  1336.   sConfig.IC2Filter = 0;
  1337.   if (HAL_TIM_Encoder_Init(&htim19, &sConfig) != HAL_OK)
  1338.   {
  1339.     Error_Handler();
  1340.   }
  1341.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  1342.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  1343.   if (HAL_TIMEx_MasterConfigSynchronization(&htim19, &sMasterConfig) != HAL_OK)
  1344.   {
  1345.     Error_Handler();
  1346.   }
  1347.   sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
  1348.   sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
  1349.   sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
  1350.   sConfigIC.ICFilter = 0;
  1351.   if (HAL_TIM_IC_ConfigChannel(&htim19, &sConfigIC, TIM_CHANNEL_3) != HAL_OK)
  1352.   {
  1353.     Error_Handler();
  1354.   }
  1355.   /* USER CODE BEGIN TIM19_Init 2 */
  1356.  
  1357.   /* USER CODE END TIM19_Init 2 */
  1358.  
  1359. }
  1360.  
  1361. /**
  1362.   * @brief USART1 Initialization Function
  1363.   * @param None
  1364.   * @retval None
  1365.   */
  1366. static void MX_USART1_UART_Init(void)
  1367. {
  1368.  
  1369.   /* USER CODE BEGIN USART1_Init 0 */
  1370.  
  1371.   /* USER CODE END USART1_Init 0 */
  1372.  
  1373.   /* USER CODE BEGIN USART1_Init 1 */
  1374.  
  1375.   /* USER CODE END USART1_Init 1 */
  1376.   huart1.Instance = USART1;
  1377.   huart1.Init.BaudRate = 38400;
  1378.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
  1379.   huart1.Init.StopBits = UART_STOPBITS_1;
  1380.   huart1.Init.Parity = UART_PARITY_NONE;
  1381.   huart1.Init.Mode = UART_MODE_TX_RX;
  1382.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  1383.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  1384.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  1385.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  1386.   if (HAL_UART_Init(&huart1) != HAL_OK)
  1387.   {
  1388.     Error_Handler();
  1389.   }
  1390.   /* USER CODE BEGIN USART1_Init 2 */
  1391.  
  1392.   /* USER CODE END USART1_Init 2 */
  1393.  
  1394. }
  1395.  
  1396. /**
  1397.   * @brief GPIO Initialization Function
  1398.   * @param None
  1399.   * @retval None
  1400.   */
  1401. static void MX_GPIO_Init(void)
  1402. {
  1403.   GPIO_InitTypeDef GPIO_InitStruct = {0};
  1404.  
  1405.   /* GPIO Ports Clock Enable */
  1406.   __HAL_RCC_GPIOE_CLK_ENABLE();
  1407.   __HAL_RCC_GPIOC_CLK_ENABLE();
  1408.   __HAL_RCC_GPIOF_CLK_ENABLE();
  1409.   __HAL_RCC_GPIOA_CLK_ENABLE();
  1410.   __HAL_RCC_GPIOB_CLK_ENABLE();
  1411.   __HAL_RCC_GPIOD_CLK_ENABLE();
  1412.  
  1413.   /*Configure GPIO pin Output Level */
  1414.   HAL_GPIO_WritePin(CS4_GPIO_Port, CS4_Pin, GPIO_PIN_SET);
  1415.  
  1416.   /*Configure GPIO pin Output Level */
  1417.   HAL_GPIO_WritePin(GPIOF, CS3_Pin|LCD_RST_Pin, GPIO_PIN_RESET);
  1418.  
  1419.   /*Configure GPIO pin Output Level */
  1420.   HAL_GPIO_WritePin(CS0_GPIO_Port, CS0_Pin, GPIO_PIN_SET);
  1421.  
  1422.   /*Configure GPIO pin Output Level */
  1423.   HAL_GPIO_WritePin(GPIOC, CS1_Pin|CS2_Pin|LCD_CS_Pin, GPIO_PIN_SET);
  1424.  
  1425.   /*Configure GPIO pin Output Level */
  1426.   HAL_GPIO_WritePin(CS5_GPIO_Port, CS5_Pin, GPIO_PIN_SET);
  1427.  
  1428.   /*Configure GPIO pin Output Level */
  1429.   HAL_GPIO_WritePin(LCD_DC_GPIO_Port, LCD_DC_Pin, GPIO_PIN_RESET);
  1430.  
  1431.   /*Configure GPIO pin Output Level */
  1432.   HAL_GPIO_WritePin(GPIOD, TS_CS_Pin|SD_CS_Pin, GPIO_PIN_SET);
  1433.  
  1434.   /*Configure GPIO pin Output Level */
  1435.   HAL_GPIO_WritePin(GPIOD, LED0_Pin|LED1_Pin|LED2_Pin, GPIO_PIN_RESET);
  1436.  
  1437.   /*Configure GPIO pin Output Level */
  1438.   HAL_GPIO_WritePin(GPIOB, LED3_Pin|LED4_Pin, GPIO_PIN_RESET);
  1439.  
  1440.   /*Configure GPIO pins : DI0_Pin DI1_Pin DI2_Pin DI3_Pin
  1441.                            DI4_Pin */
  1442.   GPIO_InitStruct.Pin = DI0_Pin|DI1_Pin|DI2_Pin|DI3_Pin
  1443.                           |DI4_Pin;
  1444.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  1445.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  1446.   HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
  1447.  
  1448.   /*Configure GPIO pin : DI5_Pin */
  1449.   GPIO_InitStruct.Pin = DI5_Pin;
  1450.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  1451.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  1452.   HAL_GPIO_Init(DI5_GPIO_Port, &GPIO_InitStruct);
  1453.  
  1454.   /*Configure GPIO pins : DI6_Pin DI7_Pin */
  1455.   GPIO_InitStruct.Pin = DI6_Pin|DI7_Pin;
  1456.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  1457.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  1458.   HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
  1459.  
  1460.   /*Configure GPIO pin : CS4_Pin */
  1461.   GPIO_InitStruct.Pin = CS4_Pin;
  1462.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  1463.   GPIO_InitStruct.Pull = GPIO_PULLUP;
  1464.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  1465.   HAL_GPIO_Init(CS4_GPIO_Port, &GPIO_InitStruct);
  1466.  
  1467.   /*Configure GPIO pins : CS3_Pin LCD_RST_Pin */
  1468.   GPIO_InitStruct.Pin = CS3_Pin|LCD_RST_Pin;
  1469.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  1470.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  1471.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  1472.   HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
  1473.  
  1474.   /*Configure GPIO pin : CS0_Pin */
  1475.   GPIO_InitStruct.Pin = CS0_Pin;
  1476.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  1477.   GPIO_InitStruct.Pull = GPIO_PULLUP;
  1478.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  1479.   HAL_GPIO_Init(CS0_GPIO_Port, &GPIO_InitStruct);
  1480.  
  1481.   /*Configure GPIO pins : CS1_Pin CS2_Pin LCD_CS_Pin */
  1482.   GPIO_InitStruct.Pin = CS1_Pin|CS2_Pin|LCD_CS_Pin;
  1483.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  1484.   GPIO_InitStruct.Pull = GPIO_PULLUP;
  1485.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  1486.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
  1487.  
  1488.   /*Configure GPIO pin : CS5_Pin */
  1489.   GPIO_InitStruct.Pin = CS5_Pin;
  1490.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  1491.   GPIO_InitStruct.Pull = GPIO_PULLUP;
  1492.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  1493.   HAL_GPIO_Init(CS5_GPIO_Port, &GPIO_InitStruct);
  1494.  
  1495.   /*Configure GPIO pin : LCD_DC_Pin */
  1496.   GPIO_InitStruct.Pin = LCD_DC_Pin;
  1497.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  1498.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  1499.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  1500.   HAL_GPIO_Init(LCD_DC_GPIO_Port, &GPIO_InitStruct);
  1501.  
  1502.   /*Configure GPIO pins : TS_CS_Pin SD_CS_Pin */
  1503.   GPIO_InitStruct.Pin = TS_CS_Pin|SD_CS_Pin;
  1504.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  1505.   GPIO_InitStruct.Pull = GPIO_PULLUP;
  1506.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  1507.   HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
  1508.  
  1509.   /*Configure GPIO pin : TS_IRQ_Pin */
  1510.   GPIO_InitStruct.Pin = TS_IRQ_Pin;
  1511.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  1512.   GPIO_InitStruct.Pull = GPIO_PULLUP;
  1513.   HAL_GPIO_Init(TS_IRQ_GPIO_Port, &GPIO_InitStruct);
  1514.  
  1515.   /*Configure GPIO pins : LED0_Pin LED1_Pin LED2_Pin */
  1516.   GPIO_InitStruct.Pin = LED0_Pin|LED1_Pin|LED2_Pin;
  1517.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  1518.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  1519.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  1520.   HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
  1521.  
  1522.   /*Configure GPIO pins : LED3_Pin LED4_Pin */
  1523.   GPIO_InitStruct.Pin = LED3_Pin|LED4_Pin;
  1524.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  1525.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  1526.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  1527.   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  1528.  
  1529. }
  1530.  
  1531. /* USER CODE BEGIN 4 */
  1532.  
  1533. /* USER CODE END 4 */
  1534.  
  1535. /**
  1536.   * @brief  This function is executed in case of error occurrence.
  1537.   * @retval None
  1538.   */
  1539. void Error_Handler(void)
  1540. {
  1541.   /* USER CODE BEGIN Error_Handler_Debug */
  1542.   /* User can add his own implementation to report the HAL error return state */
  1543.   __disable_irq();
  1544.   while (1)
  1545.   {
  1546.   }
  1547.   /* USER CODE END Error_Handler_Debug */
  1548. }
  1549.  
  1550. #ifdef  USE_FULL_ASSERT
  1551. /**
  1552.   * @brief  Reports the name of the source file and the source line number
  1553.   *         where the assert_param error has occurred.
  1554.   * @param  file: pointer to the source file name
  1555.   * @param  line: assert_param error line source number
  1556.   * @retval None
  1557.   */
  1558. void assert_failed(uint8_t *file, uint32_t line)
  1559. {
  1560.   /* USER CODE BEGIN 6 */
  1561.   /* User can add his own implementation to report the file name and line number,
  1562.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  1563.   /* USER CODE END 6 */
  1564. }
  1565. #endif /* USE_FULL_ASSERT */
  1566.  
  1567. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  1568.  
Advertisement
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!