API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 20th, 2020
736
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 33.15 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) 2020 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.  
  23. /* Private includes ----------------------------------------------------------*/
  24. /* USER CODE BEGIN Includes */
  25. #include "FlashMemory_F3/ReadWrite.h"
  26. /* USER CODE END Includes */
  27.  
  28. /* Private typedef -----------------------------------------------------------*/
  29. /* USER CODE BEGIN PTD */
  30.  
  31. /* USER CODE END PTD */
  32.  
  33. /* Private define ------------------------------------------------------------*/
  34. /* USER CODE BEGIN PD */
  35. /* USER CODE END PD */
  36.  
  37. /* Private macro -------------------------------------------------------------*/
  38. /* USER CODE BEGIN PM */
  39.  
  40. /* USER CODE END PM */
  41.  
  42. /* Private variables ---------------------------------------------------------*/
  43. ADC_HandleTypeDef hadc1;
  44. DMA_HandleTypeDef hdma_adc1;
  45.  
  46. DAC_HandleTypeDef hdac1;
  47. DAC_HandleTypeDef hdac2;
  48.  
  49. SDADC_HandleTypeDef hsdadc1;
  50. SDADC_HandleTypeDef hsdadc3;
  51. DMA_HandleTypeDef hdma_sdadc1;
  52. DMA_HandleTypeDef hdma_sdadc3;
  53.  
  54. TIM_HandleTypeDef htim2;
  55. TIM_HandleTypeDef htim3;
  56. TIM_HandleTypeDef htim4;
  57. TIM_HandleTypeDef htim5;
  58. TIM_HandleTypeDef htim6;
  59. TIM_HandleTypeDef htim19;
  60.  
  61. UART_HandleTypeDef huart1;
  62. DMA_HandleTypeDef hdma_usart1_rx;
  63.  
  64. /* USER CODE BEGIN PV */
  65. uint8_t RX_DATA[1 + 9*2 + 3*2] = {0}; // Choice + PWM + DAC
  66. uint8_t TX_DATA[4*2 + 2*2 + 3*2 + 6] = {0}; // ADC + SDADC + DSDADC + DI
  67. uint16_t PWM_PERIOD[9] = {0};
  68. uint16_t DAC_OUTPUT[3] = {0};
  69. uint16_t ADC_VALUES[4] = {0};
  70. volatile uint16_t SD_ADC1_VALUES[3] = {0};
  71. volatile uint16_t SD_ADC3_VALUES[2] = {0};
  72. uint16_t DI_VALUES[6] = {0};
  73. uint16_t TIM_PRESCALES[4] = {0}; // TIM2, TIM3, TIM4, TIM5
  74. /* USER CODE END PV */
  75.  
  76. /* Private function prototypes -----------------------------------------------*/
  77. void SystemClock_Config(void);
  78. static void MX_GPIO_Init(void);
  79. static void MX_DMA_Init(void);
  80. static void MX_ADC1_Init(void);
  81. static void MX_DAC1_Init(void);
  82. static void MX_DAC2_Init(void);
  83. static void MX_SDADC1_Init(void);
  84. static void MX_SDADC3_Init(void);
  85. static void MX_TIM2_Init(void);
  86. static void MX_TIM3_Init(void);
  87. static void MX_TIM4_Init(void);
  88. static void MX_TIM5_Init(void);
  89. static void MX_USART1_UART_Init(void);
  90. static void MX_TIM19_Init(void);
  91. static void MX_TIM6_Init(void);
  92. /* USER CODE BEGIN PFP */
  93. void fill_uint16_array(uint8_t array8[], uint16_t array16[], uint8_t elements_that_has_been_written, uint8_t size);
  94. void fill_TX_DATA_16(uint8_t array8[], uint16_t array16[], uint8_t elements_that_has_been_written, uint8_t size);
  95. void fill_TX_DATA_8(uint8_t array8[], uint16_t array16[], uint8_t elements_that_has_been_written, uint8_t size);
  96. void read_PWM_TIM_prescalers_from_memory();
  97. void write_PWM_TIM_prescalers_to_memory();
  98. void read_PWM_DAC_periods_send_measurement_back();
  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_DMA_Init();
  135.   MX_ADC1_Init();
  136.   MX_DAC1_Init();
  137.   MX_DAC2_Init();
  138.   MX_SDADC1_Init();
  139.   MX_SDADC3_Init();
  140.   MX_TIM2_Init();
  141.   MX_TIM3_Init();
  142.   MX_TIM4_Init();
  143.   MX_TIM5_Init();
  144.   MX_USART1_UART_Init();
  145.   MX_TIM19_Init();
  146.   MX_TIM6_Init();
  147.   /* USER CODE BEGIN 2 */
  148.  
  149.   // DMA UART
  150.   uint8_t RX_DATA_element_size = sizeof(RX_DATA);
  151.   HAL_UART_Receive_DMA(&huart1, RX_DATA, RX_DATA_element_size);
  152.  
  153.   // TIM Trig
  154.   HAL_TIM_Base_Start(&htim6); // For DAC
  155.   HAL_TIM_Base_Start(&htim19); // For ADC
  156.  
  157.   // DMA ADC
  158.   uint8_t ADC_element_size = sizeof(ADC_VALUES)/sizeof(ADC_VALUES[0]);
  159.   HAL_ADC_Start_DMA(&hadc1, (uint32_t *) ADC_VALUES, ADC_element_size);
  160.  
  161.   // DMA SD ADC
  162.   uint8_t SD_ADC1_element_size = sizeof(SD_ADC1_VALUES)/sizeof(SD_ADC1_VALUES[0]);
  163.   uint8_t SD_ADC3_element_size = sizeof(SD_ADC3_VALUES)/sizeof(SD_ADC3_VALUES[0]);
  164.   HAL_SDADC_Start_DMA(&hsdadc1, (uint32_t *) SD_ADC1_VALUES, SD_ADC1_element_size);
  165.   HAL_SDADC_Start_DMA(&hsdadc3, (uint32_t *) SD_ADC3_VALUES, SD_ADC3_element_size);
  166.  
  167.   // DAC
  168.   HAL_DAC_Start(&hdac1, DAC1_CHANNEL_1);
  169.   HAL_DAC_Start(&hdac1, DAC1_CHANNEL_2);
  170.   HAL_DAC_Start(&hdac2, DAC1_CHANNEL_1);
  171.  
  172.   // PWM
  173.   HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
  174.   HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
  175.   HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_2);
  176.   HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_1);
  177.   HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_2);
  178.   HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_4);
  179.   HAL_TIM_PWM_Start(&htim5, TIM_CHANNEL_1);
  180.   HAL_TIM_PWM_Start(&htim5, TIM_CHANNEL_2);
  181.   HAL_TIM_PWM_Start(&htim5, TIM_CHANNEL_3);
  182.  
  183.   // Set the PWM timers
  184.   FlashSetAddrs(0x0803F800);
  185.   read_PWM_TIM_prescalers_from_memory();
  186.  
  187.  
  188.   /* USER CODE END 2 */
  189.  
  190.   /* Infinite loop */
  191.   /* USER CODE BEGIN WHILE */
  192.   while (1)
  193.   {
  194.     /* USER CODE END WHILE */
  195.  
  196.     /* USER CODE BEGIN 3 */
  197.       // TIM 2
  198.       htim2.Instance->CCR1 = PWM_PERIOD[0]; // P0
  199.       // TIM 3
  200.       htim3.Instance->CCR1 = PWM_PERIOD[1]; // P1
  201.       htim3.Instance->CCR2 = PWM_PERIOD[2]; // P2
  202.       // TIM 4
  203.       htim4.Instance->CCR1 = PWM_PERIOD[3]; // P3
  204.       htim4.Instance->CCR2 = PWM_PERIOD[4]; // P4
  205.       htim4.Instance->CCR4 = PWM_PERIOD[5]; // P5
  206.       // TIM 5
  207.       htim5.Instance->CCR1 = PWM_PERIOD[6]; // P6
  208.       htim5.Instance->CCR2 = PWM_PERIOD[7]; // P7
  209.       htim5.Instance->CCR3 = PWM_PERIOD[8]; // P8
  210.       // DAC 1
  211.       HAL_DAC_SetValue(&hdac1, DAC1_CHANNEL_1, DAC_ALIGN_12B_R, DAC_OUTPUT[2]); // D2
  212.       HAL_DAC_SetValue(&hdac1, DAC1_CHANNEL_2, DAC_ALIGN_12B_R, DAC_OUTPUT[1]); // D1
  213.       // DAC 2
  214.       HAL_DAC_SetValue(&hdac2, DAC1_CHANNEL_1, DAC_ALIGN_12B_R, DAC_OUTPUT[0]); // D0
  215.       // DI
  216.       DI_VALUES[0] = HAL_GPIO_ReadPin(INPUT_0_GPIO_Port, INPUT_0_Pin); // I0
  217.       DI_VALUES[1] = HAL_GPIO_ReadPin(INPUT_1_GPIO_Port, INPUT_1_Pin); // I1
  218.       DI_VALUES[2] = HAL_GPIO_ReadPin(INPUT_2_GPIO_Port, INPUT_2_Pin); // I2
  219.       DI_VALUES[3] = HAL_GPIO_ReadPin(INPUT_3_GPIO_Port, INPUT_3_Pin); // I3
  220.       DI_VALUES[4] = HAL_GPIO_ReadPin(INPUT_4_GPIO_Port, INPUT_4_Pin); // I4
  221.       DI_VALUES[5] = HAL_GPIO_ReadPin(INPUT_5_GPIO_Port, INPUT_5_Pin); // I5
  222.   }
  223.   /* USER CODE END 3 */
  224. }
  225.  
  226. /**
  227.   * @brief System Clock Configuration
  228.   * @retval None
  229.   */
  230. void SystemClock_Config(void)
  231. {
  232.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  233.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  234.   RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
  235.  
  236.   /** Initializes the RCC Oscillators according to the specified parameters
  237.   * in the RCC_OscInitTypeDef structure.
  238.   */
  239.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  240.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  241.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  242.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  243.   {
  244.     Error_Handler();
  245.   }
  246.   /** Initializes the CPU, AHB and APB buses clocks
  247.   */
  248.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
  249.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  250.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSE;
  251.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  252.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV16;
  253.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  254.  
  255.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  256.   {
  257.     Error_Handler();
  258.   }
  259.   PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_ADC1
  260.                               |RCC_PERIPHCLK_SDADC;
  261.   PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK2;
  262.   PeriphClkInit.SdadcClockSelection = RCC_SDADCSYSCLK_DIV4;
  263.   PeriphClkInit.Adc1ClockSelection = RCC_ADC1PCLK2_DIV2;
  264.  
  265.   if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  266.   {
  267.     Error_Handler();
  268.   }
  269.   HAL_PWREx_EnableSDADC(PWR_SDADC_ANALOG1);
  270.   HAL_PWREx_EnableSDADC(PWR_SDADC_ANALOG3);
  271. }
  272.  
  273. /**
  274.   * @brief ADC1 Initialization Function
  275.   * @param None
  276.   * @retval None
  277.   */
  278. static void MX_ADC1_Init(void)
  279. {
  280.  
  281.   /* USER CODE BEGIN ADC1_Init 0 */
  282.  
  283.   /* USER CODE END ADC1_Init 0 */
  284.  
  285.   ADC_ChannelConfTypeDef sConfig = {0};
  286.  
  287.   /* USER CODE BEGIN ADC1_Init 1 */
  288.  
  289.   /* USER CODE END ADC1_Init 1 */
  290.   /** Common config
  291.   */
  292.   hadc1.Instance = ADC1;
  293.   hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
  294.   hadc1.Init.ContinuousConvMode = ENABLE;
  295.   hadc1.Init.DiscontinuousConvMode = DISABLE;
  296.   hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T19_TRGO;
  297.   hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  298.   hadc1.Init.NbrOfConversion = 4;
  299.   if (HAL_ADC_Init(&hadc1) != HAL_OK)
  300.   {
  301.     Error_Handler();
  302.   }
  303.   /** Configure Regular Channel
  304.   */
  305.   sConfig.Channel = ADC_CHANNEL_0;
  306.   sConfig.Rank = ADC_REGULAR_RANK_1;
  307.   sConfig.SamplingTime = ADC_SAMPLETIME_239CYCLES_5;
  308.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  309.   {
  310.     Error_Handler();
  311.   }
  312.   /** Configure Regular Channel
  313.   */
  314.   sConfig.Channel = ADC_CHANNEL_1;
  315.   sConfig.Rank = ADC_REGULAR_RANK_2;
  316.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  317.   {
  318.     Error_Handler();
  319.   }
  320.   /** Configure Regular Channel
  321.   */
  322.   sConfig.Channel = ADC_CHANNEL_2;
  323.   sConfig.Rank = ADC_REGULAR_RANK_3;
  324.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  325.   {
  326.     Error_Handler();
  327.   }
  328.   /** Configure Regular Channel
  329.   */
  330.   sConfig.Channel = ADC_CHANNEL_3;
  331.   sConfig.Rank = ADC_REGULAR_RANK_4;
  332.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  333.   {
  334.     Error_Handler();
  335.   }
  336.   /* USER CODE BEGIN ADC1_Init 2 */
  337.  
  338.   /* USER CODE END ADC1_Init 2 */
  339.  
  340. }
  341.  
  342. /**
  343.   * @brief DAC1 Initialization Function
  344.   * @param None
  345.   * @retval None
  346.   */
  347. static void MX_DAC1_Init(void)
  348. {
  349.  
  350.   /* USER CODE BEGIN DAC1_Init 0 */
  351.  
  352.   /* USER CODE END DAC1_Init 0 */
  353.  
  354.   DAC_ChannelConfTypeDef sConfig = {0};
  355.  
  356.   /* USER CODE BEGIN DAC1_Init 1 */
  357.  
  358.   /* USER CODE END DAC1_Init 1 */
  359.   /** DAC Initialization
  360.   */
  361.   hdac1.Instance = DAC1;
  362.   if (HAL_DAC_Init(&hdac1) != HAL_OK)
  363.   {
  364.     Error_Handler();
  365.   }
  366.   /** DAC channel OUT1 config
  367.   */
  368.   sConfig.DAC_Trigger = DAC_TRIGGER_T6_TRGO;
  369.   sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
  370.   if (HAL_DAC_ConfigChannel(&hdac1, &sConfig, DAC_CHANNEL_1) != HAL_OK)
  371.   {
  372.     Error_Handler();
  373.   }
  374.   /** DAC channel OUT2 config
  375.   */
  376.   if (HAL_DAC_ConfigChannel(&hdac1, &sConfig, DAC_CHANNEL_2) != HAL_OK)
  377.   {
  378.     Error_Handler();
  379.   }
  380.   /* USER CODE BEGIN DAC1_Init 2 */
  381.  
  382.   /* USER CODE END DAC1_Init 2 */
  383.  
  384. }
  385.  
  386. /**
  387.   * @brief DAC2 Initialization Function
  388.   * @param None
  389.   * @retval None
  390.   */
  391. static void MX_DAC2_Init(void)
  392. {
  393.  
  394.   /* USER CODE BEGIN DAC2_Init 0 */
  395.  
  396.   /* USER CODE END DAC2_Init 0 */
  397.  
  398.   DAC_ChannelConfTypeDef sConfig = {0};
  399.  
  400.   /* USER CODE BEGIN DAC2_Init 1 */
  401.  
  402.   /* USER CODE END DAC2_Init 1 */
  403.   /** DAC Initialization
  404.   */
  405.   hdac2.Instance = DAC2;
  406.   if (HAL_DAC_Init(&hdac2) != HAL_OK)
  407.   {
  408.     Error_Handler();
  409.   }
  410.   /** DAC channel OUT1 config
  411.   */
  412.   sConfig.DAC_Trigger = DAC_TRIGGER_T6_TRGO;
  413.   sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
  414.   if (HAL_DAC_ConfigChannel(&hdac2, &sConfig, DAC_CHANNEL_1) != HAL_OK)
  415.   {
  416.     Error_Handler();
  417.   }
  418.   /* USER CODE BEGIN DAC2_Init 2 */
  419.  
  420.   /* USER CODE END DAC2_Init 2 */
  421.  
  422. }
  423.  
  424. /**
  425.   * @brief SDADC1 Initialization Function
  426.   * @param None
  427.   * @retval None
  428.   */
  429. static void MX_SDADC1_Init(void)
  430. {
  431.  
  432.   /* USER CODE BEGIN SDADC1_Init 0 */
  433.  
  434.   /* USER CODE END SDADC1_Init 0 */
  435.  
  436.   SDADC_ConfParamTypeDef ConfParamStruct = {0};
  437.  
  438.   /* USER CODE BEGIN SDADC1_Init 1 */
  439.  
  440.   /* USER CODE END SDADC1_Init 1 */
  441.   /** Configure the SDADC low power mode, fast conversion mode,
  442.   slow clock mode and SDADC1 reference voltage
  443.   */
  444.   hsdadc1.Instance = SDADC1;
  445.   hsdadc1.Init.IdleLowPowerMode = SDADC_LOWPOWER_NONE;
  446.   hsdadc1.Init.FastConversionMode = SDADC_FAST_CONV_DISABLE;
  447.   hsdadc1.Init.SlowClockMode = SDADC_SLOW_CLOCK_DISABLE;
  448.   hsdadc1.Init.ReferenceVoltage = SDADC_VREF_EXT;
  449.   hsdadc1.InjectedTrigger = SDADC_SOFTWARE_TRIGGER;
  450.   if (HAL_SDADC_Init(&hsdadc1) != HAL_OK)
  451.   {
  452.     Error_Handler();
  453.   }
  454.   /** Configure the Injected Mode
  455.   */
  456.   if (HAL_SDADC_SelectInjectedDelay(&hsdadc1, SDADC_INJECTED_DELAY_NONE) != HAL_OK)
  457.   {
  458.     Error_Handler();
  459.   }
  460.   if (HAL_SDADC_SelectInjectedTrigger(&hsdadc1, SDADC_SOFTWARE_TRIGGER) != HAL_OK)
  461.   {
  462.     Error_Handler();
  463.   }
  464.   if (HAL_SDADC_InjectedConfigChannel(&hsdadc1, SDADC_CHANNEL_4|SDADC_CHANNEL_8
  465.                               |SDADC_CHANNEL_6, SDADC_CONTINUOUS_CONV_ON) != HAL_OK)
  466.   {
  467.     Error_Handler();
  468.   }
  469.   /** Set parameters for SDADC configuration 0 Register
  470.   */
  471.   ConfParamStruct.InputMode = SDADC_INPUT_MODE_SE_ZERO_REFERENCE;
  472.   ConfParamStruct.Gain = SDADC_GAIN_1;
  473.   ConfParamStruct.CommonMode = SDADC_COMMON_MODE_VSSA;
  474.   ConfParamStruct.Offset = 0;
  475.   if (HAL_SDADC_PrepareChannelConfig(&hsdadc1, SDADC_CONF_INDEX_0, &ConfParamStruct) != HAL_OK)
  476.   {
  477.     Error_Handler();
  478.   }
  479.   /** Set parameters for SDADC configuration 1 Register
  480.   */
  481.   ConfParamStruct.InputMode = SDADC_INPUT_MODE_DIFF;
  482.   if (HAL_SDADC_PrepareChannelConfig(&hsdadc1, SDADC_CONF_INDEX_1, &ConfParamStruct) != HAL_OK)
  483.   {
  484.     Error_Handler();
  485.   }
  486.   /** Configure the Injected Channel
  487.   */
  488.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc1, SDADC_CHANNEL_4, SDADC_CONF_INDEX_0) != HAL_OK)
  489.   {
  490.     Error_Handler();
  491.   }
  492.   /** Configure the Injected Channel
  493.   */
  494.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc1, SDADC_CHANNEL_8, SDADC_CONF_INDEX_1) != HAL_OK)
  495.   {
  496.     Error_Handler();
  497.   }
  498.   /** Configure the Injected Channel
  499.   */
  500.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc1, SDADC_CHANNEL_6, SDADC_CONF_INDEX_1) != HAL_OK)
  501.   {
  502.     Error_Handler();
  503.   }
  504.   /* USER CODE BEGIN SDADC1_Init 2 */
  505.  
  506.   /* USER CODE END SDADC1_Init 2 */
  507.  
  508. }
  509.  
  510. /**
  511.   * @brief SDADC3 Initialization Function
  512.   * @param None
  513.   * @retval None
  514.   */
  515. static void MX_SDADC3_Init(void)
  516. {
  517.  
  518.   /* USER CODE BEGIN SDADC3_Init 0 */
  519.  
  520.   /* USER CODE END SDADC3_Init 0 */
  521.  
  522.   SDADC_ConfParamTypeDef ConfParamStruct = {0};
  523.  
  524.   /* USER CODE BEGIN SDADC3_Init 1 */
  525.  
  526.   /* USER CODE END SDADC3_Init 1 */
  527.   /** Configure the SDADC low power mode, fast conversion mode,
  528.   slow clock mode and SDADC1 reference voltage
  529.   */
  530.   hsdadc3.Instance = SDADC3;
  531.   hsdadc3.Init.IdleLowPowerMode = SDADC_LOWPOWER_NONE;
  532.   hsdadc3.Init.FastConversionMode = SDADC_FAST_CONV_DISABLE;
  533.   hsdadc3.Init.SlowClockMode = SDADC_SLOW_CLOCK_DISABLE;
  534.   hsdadc3.Init.ReferenceVoltage = SDADC_VREF_EXT;
  535.   hsdadc3.InjectedTrigger = SDADC_SOFTWARE_TRIGGER;
  536.   if (HAL_SDADC_Init(&hsdadc3) != HAL_OK)
  537.   {
  538.     Error_Handler();
  539.   }
  540.   /** Configure the Injected Mode
  541.   */
  542.   if (HAL_SDADC_SelectInjectedDelay(&hsdadc3, SDADC_INJECTED_DELAY_NONE) != HAL_OK)
  543.   {
  544.     Error_Handler();
  545.   }
  546.   if (HAL_SDADC_SelectInjectedTrigger(&hsdadc3, SDADC_SOFTWARE_TRIGGER) != HAL_OK)
  547.   {
  548.     Error_Handler();
  549.   }
  550.   if (HAL_SDADC_InjectedConfigChannel(&hsdadc3, SDADC_CHANNEL_6|SDADC_CHANNEL_8, SDADC_CONTINUOUS_CONV_ON) != HAL_OK)
  551.   {
  552.     Error_Handler();
  553.   }
  554.   /** Set parameters for SDADC configuration 0 Register
  555.   */
  556.   ConfParamStruct.InputMode = SDADC_INPUT_MODE_SE_ZERO_REFERENCE;
  557.   ConfParamStruct.Gain = SDADC_GAIN_1;
  558.   ConfParamStruct.CommonMode = SDADC_COMMON_MODE_VSSA;
  559.   ConfParamStruct.Offset = 0;
  560.   if (HAL_SDADC_PrepareChannelConfig(&hsdadc3, SDADC_CONF_INDEX_0, &ConfParamStruct) != HAL_OK)
  561.   {
  562.     Error_Handler();
  563.   }
  564.   /** Set parameters for SDADC configuration 1 Register
  565.   */
  566.   ConfParamStruct.InputMode = SDADC_INPUT_MODE_DIFF;
  567.   if (HAL_SDADC_PrepareChannelConfig(&hsdadc3, SDADC_CONF_INDEX_1, &ConfParamStruct) != HAL_OK)
  568.   {
  569.     Error_Handler();
  570.   }
  571.   /** Configure the Injected Channel
  572.   */
  573.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc3, SDADC_CHANNEL_6, SDADC_CONF_INDEX_0) != HAL_OK)
  574.   {
  575.     Error_Handler();
  576.   }
  577.   /** Configure the Injected Channel
  578.   */
  579.   if (HAL_SDADC_AssociateChannelConfig(&hsdadc3, SDADC_CHANNEL_8, SDADC_CONF_INDEX_1) != HAL_OK)
  580.   {
  581.     Error_Handler();
  582.   }
  583.   /* USER CODE BEGIN SDADC3_Init 2 */
  584.  
  585.   /* USER CODE END SDADC3_Init 2 */
  586.  
  587. }
  588.  
  589. /**
  590.   * @brief TIM2 Initialization Function
  591.   * @param None
  592.   * @retval None
  593.   */
  594. static void MX_TIM2_Init(void)
  595. {
  596.  
  597.   /* USER CODE BEGIN TIM2_Init 0 */
  598.  
  599.   /* USER CODE END TIM2_Init 0 */
  600.  
  601.   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  602.   TIM_MasterConfigTypeDef sMasterConfig = {0};
  603.   TIM_OC_InitTypeDef sConfigOC = {0};
  604.  
  605.   /* USER CODE BEGIN TIM2_Init 1 */
  606.  
  607.   /* USER CODE END TIM2_Init 1 */
  608.   htim2.Instance = TIM2;
  609.   htim2.Init.Prescaler = 0;
  610.   htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  611.   htim2.Init.Period = 4095;
  612.   htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  613.   htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  614.   if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  615.   {
  616.     Error_Handler();
  617.   }
  618.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  619.   if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  620.   {
  621.     Error_Handler();
  622.   }
  623.   if (HAL_TIM_PWM_Init(&htim2) != HAL_OK)
  624.   {
  625.     Error_Handler();
  626.   }
  627.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  628.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  629.   if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  630.   {
  631.     Error_Handler();
  632.   }
  633.   sConfigOC.OCMode = TIM_OCMODE_PWM1;
  634.   sConfigOC.Pulse = 0;
  635.   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  636.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  637.   if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  638.   {
  639.     Error_Handler();
  640.   }
  641.   /* USER CODE BEGIN TIM2_Init 2 */
  642.  
  643.   /* USER CODE END TIM2_Init 2 */
  644.   HAL_TIM_MspPostInit(&htim2);
  645.  
  646. }
  647.  
  648. /**
  649.   * @brief TIM3 Initialization Function
  650.   * @param None
  651.   * @retval None
  652.   */
  653. static void MX_TIM3_Init(void)
  654. {
  655.  
  656.   /* USER CODE BEGIN TIM3_Init 0 */
  657.  
  658.   /* USER CODE END TIM3_Init 0 */
  659.  
  660.   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  661.   TIM_MasterConfigTypeDef sMasterConfig = {0};
  662.   TIM_OC_InitTypeDef sConfigOC = {0};
  663.  
  664.   /* USER CODE BEGIN TIM3_Init 1 */
  665.  
  666.   /* USER CODE END TIM3_Init 1 */
  667.   htim3.Instance = TIM3;
  668.   htim3.Init.Prescaler = 0;
  669.   htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  670.   htim3.Init.Period = 4095;
  671.   htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  672.   htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  673.   if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  674.   {
  675.     Error_Handler();
  676.   }
  677.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  678.   if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
  679.   {
  680.     Error_Handler();
  681.   }
  682.   if (HAL_TIM_PWM_Init(&htim3) != HAL_OK)
  683.   {
  684.     Error_Handler();
  685.   }
  686.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  687.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  688.   if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  689.   {
  690.     Error_Handler();
  691.   }
  692.   sConfigOC.OCMode = TIM_OCMODE_PWM1;
  693.   sConfigOC.Pulse = 0;
  694.   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  695.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  696.   if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  697.   {
  698.     Error_Handler();
  699.   }
  700.   if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  701.   {
  702.     Error_Handler();
  703.   }
  704.   /* USER CODE BEGIN TIM3_Init 2 */
  705.  
  706.   /* USER CODE END TIM3_Init 2 */
  707.   HAL_TIM_MspPostInit(&htim3);
  708.  
  709. }
  710.  
  711. /**
  712.   * @brief TIM4 Initialization Function
  713.   * @param None
  714.   * @retval None
  715.   */
  716. static void MX_TIM4_Init(void)
  717. {
  718.  
  719.   /* USER CODE BEGIN TIM4_Init 0 */
  720.  
  721.   /* USER CODE END TIM4_Init 0 */
  722.  
  723.   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  724.   TIM_MasterConfigTypeDef sMasterConfig = {0};
  725.   TIM_OC_InitTypeDef sConfigOC = {0};
  726.  
  727.   /* USER CODE BEGIN TIM4_Init 1 */
  728.  
  729.   /* USER CODE END TIM4_Init 1 */
  730.   htim4.Instance = TIM4;
  731.   htim4.Init.Prescaler = 0;
  732.   htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
  733.   htim4.Init.Period = 4095;
  734.   htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  735.   htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  736.   if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
  737.   {
  738.     Error_Handler();
  739.   }
  740.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  741.   if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
  742.   {
  743.     Error_Handler();
  744.   }
  745.   if (HAL_TIM_PWM_Init(&htim4) != HAL_OK)
  746.   {
  747.     Error_Handler();
  748.   }
  749.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  750.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  751.   if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
  752.   {
  753.     Error_Handler();
  754.   }
  755.   sConfigOC.OCMode = TIM_OCMODE_PWM1;
  756.   sConfigOC.Pulse = 0;
  757.   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  758.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  759.   if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  760.   {
  761.     Error_Handler();
  762.   }
  763.   if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  764.   {
  765.     Error_Handler();
  766.   }
  767.   if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
  768.   {
  769.     Error_Handler();
  770.   }
  771.   /* USER CODE BEGIN TIM4_Init 2 */
  772.  
  773.   /* USER CODE END TIM4_Init 2 */
  774.   HAL_TIM_MspPostInit(&htim4);
  775.  
  776. }
  777.  
  778. /**
  779.   * @brief TIM5 Initialization Function
  780.   * @param None
  781.   * @retval None
  782.   */
  783. static void MX_TIM5_Init(void)
  784. {
  785.  
  786.   /* USER CODE BEGIN TIM5_Init 0 */
  787.  
  788.   /* USER CODE END TIM5_Init 0 */
  789.  
  790.   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  791.   TIM_MasterConfigTypeDef sMasterConfig = {0};
  792.   TIM_OC_InitTypeDef sConfigOC = {0};
  793.  
  794.   /* USER CODE BEGIN TIM5_Init 1 */
  795.  
  796.   /* USER CODE END TIM5_Init 1 */
  797.   htim5.Instance = TIM5;
  798.   htim5.Init.Prescaler = 0;
  799.   htim5.Init.CounterMode = TIM_COUNTERMODE_UP;
  800.   htim5.Init.Period = 4095;
  801.   htim5.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  802.   htim5.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  803.   if (HAL_TIM_Base_Init(&htim5) != HAL_OK)
  804.   {
  805.     Error_Handler();
  806.   }
  807.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  808.   if (HAL_TIM_ConfigClockSource(&htim5, &sClockSourceConfig) != HAL_OK)
  809.   {
  810.     Error_Handler();
  811.   }
  812.   if (HAL_TIM_PWM_Init(&htim5) != HAL_OK)
  813.   {
  814.     Error_Handler();
  815.   }
  816.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  817.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  818.   if (HAL_TIMEx_MasterConfigSynchronization(&htim5, &sMasterConfig) != HAL_OK)
  819.   {
  820.     Error_Handler();
  821.   }
  822.   sConfigOC.OCMode = TIM_OCMODE_PWM1;
  823.   sConfigOC.Pulse = 0;
  824.   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  825.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  826.   if (HAL_TIM_PWM_ConfigChannel(&htim5, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  827.   {
  828.     Error_Handler();
  829.   }
  830.   if (HAL_TIM_PWM_ConfigChannel(&htim5, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  831.   {
  832.     Error_Handler();
  833.   }
  834.   if (HAL_TIM_PWM_ConfigChannel(&htim5, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
  835.   {
  836.     Error_Handler();
  837.   }
  838.   /* USER CODE BEGIN TIM5_Init 2 */
  839.  
  840.   /* USER CODE END TIM5_Init 2 */
  841.   HAL_TIM_MspPostInit(&htim5);
  842.  
  843. }
  844.  
  845. /**
  846.   * @brief TIM6 Initialization Function
  847.   * @param None
  848.   * @retval None
  849.   */
  850. static void MX_TIM6_Init(void)
  851. {
  852.  
  853.   /* USER CODE BEGIN TIM6_Init 0 */
  854.  
  855.   /* USER CODE END TIM6_Init 0 */
  856.  
  857.   TIM_MasterConfigTypeDef sMasterConfig = {0};
  858.  
  859.   /* USER CODE BEGIN TIM6_Init 1 */
  860.  
  861.   /* USER CODE END TIM6_Init 1 */
  862.   htim6.Instance = TIM6;
  863.   htim6.Init.Prescaler = 0;
  864.   htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
  865.   htim6.Init.Period = 65535;
  866.   htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  867.   if (HAL_TIM_Base_Init(&htim6) != HAL_OK)
  868.   {
  869.     Error_Handler();
  870.   }
  871.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
  872.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  873.   if (HAL_TIMEx_MasterConfigSynchronization(&htim6, &sMasterConfig) != HAL_OK)
  874.   {
  875.     Error_Handler();
  876.   }
  877.   /* USER CODE BEGIN TIM6_Init 2 */
  878.  
  879.   /* USER CODE END TIM6_Init 2 */
  880.  
  881. }
  882.  
  883. /**
  884.   * @brief TIM19 Initialization Function
  885.   * @param None
  886.   * @retval None
  887.   */
  888. static void MX_TIM19_Init(void)
  889. {
  890.  
  891.   /* USER CODE BEGIN TIM19_Init 0 */
  892.  
  893.   /* USER CODE END TIM19_Init 0 */
  894.  
  895.   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  896.   TIM_MasterConfigTypeDef sMasterConfig = {0};
  897.  
  898.   /* USER CODE BEGIN TIM19_Init 1 */
  899.  
  900.   /* USER CODE END TIM19_Init 1 */
  901.   htim19.Instance = TIM19;
  902.   htim19.Init.Prescaler = 0;
  903.   htim19.Init.CounterMode = TIM_COUNTERMODE_UP;
  904.   htim19.Init.Period = 65535;
  905.   htim19.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  906.   htim19.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  907.   if (HAL_TIM_Base_Init(&htim19) != HAL_OK)
  908.   {
  909.     Error_Handler();
  910.   }
  911.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  912.   if (HAL_TIM_ConfigClockSource(&htim19, &sClockSourceConfig) != HAL_OK)
  913.   {
  914.     Error_Handler();
  915.   }
  916.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
  917.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  918.   if (HAL_TIMEx_MasterConfigSynchronization(&htim19, &sMasterConfig) != HAL_OK)
  919.   {
  920.     Error_Handler();
  921.   }
  922.   /* USER CODE BEGIN TIM19_Init 2 */
  923.  
  924.   /* USER CODE END TIM19_Init 2 */
  925.  
  926. }
  927.  
  928. /**
  929.   * @brief USART1 Initialization Function
  930.   * @param None
  931.   * @retval None
  932.   */
  933. static void MX_USART1_UART_Init(void)
  934. {
  935.  
  936.   /* USER CODE BEGIN USART1_Init 0 */
  937.  
  938.   /* USER CODE END USART1_Init 0 */
  939.  
  940.   /* USER CODE BEGIN USART1_Init 1 */
  941.  
  942.   /* USER CODE END USART1_Init 1 */
  943.   huart1.Instance = USART1;
  944.   huart1.Init.BaudRate = 115200;
  945.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
  946.   huart1.Init.StopBits = UART_STOPBITS_1;
  947.   huart1.Init.Parity = UART_PARITY_NONE;
  948.   huart1.Init.Mode = UART_MODE_TX_RX;
  949.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  950.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  951.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  952.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  953.   if (HAL_UART_Init(&huart1) != HAL_OK)
  954.   {
  955.     Error_Handler();
  956.   }
  957.   /* USER CODE BEGIN USART1_Init 2 */
  958.  
  959.   /* USER CODE END USART1_Init 2 */
  960.  
  961. }
  962.  
  963. /**
  964.   * Enable DMA controller clock
  965.   */
  966. static void MX_DMA_Init(void)
  967. {
  968.  
  969.   /* DMA controller clock enable */
  970.   __HAL_RCC_DMA1_CLK_ENABLE();
  971.   __HAL_RCC_DMA2_CLK_ENABLE();
  972.  
  973.   /* DMA interrupt init */
  974.   /* DMA1_Channel1_IRQn interrupt configuration */
  975.   HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);
  976.   HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
  977.   /* DMA1_Channel5_IRQn interrupt configuration */
  978.   HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 0, 0);
  979.   HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
  980.   /* DMA2_Channel3_IRQn interrupt configuration */
  981.   HAL_NVIC_SetPriority(DMA2_Channel3_IRQn, 0, 0);
  982.   HAL_NVIC_EnableIRQ(DMA2_Channel3_IRQn);
  983.   /* DMA2_Channel5_IRQn interrupt configuration */
  984.   HAL_NVIC_SetPriority(DMA2_Channel5_IRQn, 0, 0);
  985.   HAL_NVIC_EnableIRQ(DMA2_Channel5_IRQn);
  986.  
  987. }
  988.  
  989. /**
  990.   * @brief GPIO Initialization Function
  991.   * @param None
  992.   * @retval None
  993.   */
  994. static void MX_GPIO_Init(void)
  995. {
  996.   GPIO_InitTypeDef GPIO_InitStruct = {0};
  997.  
  998.   /* GPIO Ports Clock Enable */
  999.   __HAL_RCC_GPIOC_CLK_ENABLE();
  1000.   __HAL_RCC_GPIOF_CLK_ENABLE();
  1001.   __HAL_RCC_GPIOA_CLK_ENABLE();
  1002.   __HAL_RCC_GPIOB_CLK_ENABLE();
  1003.   __HAL_RCC_GPIOE_CLK_ENABLE();
  1004.   __HAL_RCC_GPIOD_CLK_ENABLE();
  1005.  
  1006.   /*Configure GPIO pins : INPUT_2_Pin INPUT_1_Pin INPUT_0_Pin */
  1007.   GPIO_InitStruct.Pin = INPUT_2_Pin|INPUT_1_Pin|INPUT_0_Pin;
  1008.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  1009.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  1010.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
  1011.  
  1012.   /*Configure GPIO pin : INPUT_5_Pin */
  1013.   GPIO_InitStruct.Pin = INPUT_5_Pin;
  1014.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  1015.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  1016.   HAL_GPIO_Init(INPUT_5_GPIO_Port, &GPIO_InitStruct);
  1017.  
  1018.   /*Configure GPIO pins : INPUT_4_Pin INPUT_3_Pin */
  1019.   GPIO_InitStruct.Pin = INPUT_4_Pin|INPUT_3_Pin;
  1020.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  1021.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  1022.   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  1023.  
  1024. }
  1025.  
  1026. /* USER CODE BEGIN 4 */
  1027. // When we got a complete RX message - This function runs
  1028. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){
  1029.   /* Prevent unused argument(s) compilation warning */
  1030.   UNUSED(huart);
  1031.  
  1032.   /* NOTE : This function should not be modified, when the callback is needed,
  1033.             the HAL_UART_RxCpltCallback can be implemented in the user file.
  1034.    */
  1035.  
  1036.   uint8_t choice = RX_DATA[0];
  1037.   switch(choice){
  1038.   case 49: // "1"
  1039.       read_PWM_DAC_periods_send_measurement_back();
  1040.       break;
  1041.   case 50: // "2"
  1042.       write_PWM_TIM_prescalers_to_memory();
  1043.       break;
  1044.   }
  1045.  
  1046. }
  1047.  
  1048. void read_PWM_DAC_periods_send_measurement_back(){
  1049.       // Get the PWM and DAC values
  1050.       uint8_t PWM_element_size = sizeof(PWM_PERIOD)/sizeof(PWM_PERIOD[0]);
  1051.       uint8_t DAC_element_size = sizeof(DAC_OUTPUT)/sizeof(DAC_OUTPUT[0]);
  1052.       fill_uint16_array(RX_DATA, PWM_PERIOD, 1, PWM_element_size); // 1 because the first element is the choice above
  1053.       fill_uint16_array(RX_DATA, DAC_OUTPUT, PWM_element_size*2 + 1, DAC_element_size);
  1054.  
  1055.       // Copy
  1056.       //uint16_t SD_ADC_VALUES[2] = {SD_ADC1_VALUES[0], SD_ADC3_VALUES[0]};
  1057.       //uint16_t D_SD_ADC_VALUES[3] = {SD_ADC1_VALUES[1], SD_ADC1_VALUES[2], SD_ADC3_VALUES[1]};
  1058.       uint16_t SD_ADC_VALUES[2] = {0, 0};
  1059.       uint16_t D_SD_ADC_VALUES[3] = {0, 0, 0};
  1060.       // Send the ADC, SDADC, DSDADC and DI values
  1061.       uint8_t ADC_element_size = sizeof(ADC_VALUES)/sizeof(ADC_VALUES[0]);
  1062.       uint8_t SD_ADC_element_size = sizeof(SD_ADC_VALUES)/sizeof(SD_ADC_VALUES[0]);
  1063.       uint8_t D_SD_ADC_element_size = sizeof(D_SD_ADC_VALUES)/sizeof(D_SD_ADC_VALUES[0]);
  1064.       uint8_t DI_element_size = sizeof(DI_VALUES)/sizeof(DI_VALUES[0]);
  1065.       uint8_t TX_DATA_element_size = sizeof(TX_DATA)/sizeof(TX_DATA[0]);
  1066.       fill_TX_DATA_16(TX_DATA, ADC_VALUES, 0, ADC_element_size);
  1067.       fill_TX_DATA_16(TX_DATA, SD_ADC_VALUES, ADC_element_size*2, SD_ADC_element_size);
  1068.       fill_TX_DATA_16(TX_DATA, D_SD_ADC_VALUES, (ADC_element_size + SD_ADC_element_size)*2, D_SD_ADC_element_size);
  1069.       fill_TX_DATA_8(TX_DATA, DI_VALUES, (ADC_element_size + SD_ADC_element_size + D_SD_ADC_element_size)*2, DI_element_size);
  1070.       HAL_UART_Transmit(&huart1, TX_DATA, TX_DATA_element_size, 10);
  1071. }
  1072.  
  1073. void fill_uint16_array(uint8_t array8[], uint16_t array16[], uint8_t elements_that_has_been_written, uint8_t size) {
  1074.     for (uint8_t i = 0; i < size; i++) {
  1075.         array16[i] = (array8[i + i + elements_that_has_been_written] << 8) | (array8[i + i + 1 + elements_that_has_been_written] & 0xFF);
  1076.     }
  1077. }
  1078.  
  1079. void fill_TX_DATA_16(uint8_t array8[], uint16_t array16[], uint8_t elements_that_has_been_written, uint8_t size) {
  1080.     for (uint8_t i = 0; i < size; i++) {
  1081.         array8[i + i + elements_that_has_been_written] = array16[i] >> 8;
  1082.         array8[i + i + 1 + elements_that_has_been_written] = array16[i];
  1083.     }
  1084. }
  1085.  
  1086. void fill_TX_DATA_8(uint8_t array8[], uint16_t array16[], uint8_t elements_that_has_been_written, uint8_t size) {
  1087.     for (uint8_t i = 0; i < size; i++) {
  1088.         array8[i + elements_that_has_been_written] = array16[i];
  1089.     }
  1090. }
  1091.  
  1092. void read_PWM_TIM_prescalers_from_memory(){
  1093.     uint32_t Nsize = sizeof(TIM_PRESCALES)/sizeof(TIM_PRESCALES[0]);
  1094.     FlashReadN(0, TIM_PRESCALES, Nsize, DATA_TYPE_U16);
  1095.     htim2.Init.Prescaler = TIM_PRESCALES[0];
  1096.     htim3.Init.Prescaler = TIM_PRESCALES[1];
  1097.     htim4.Init.Prescaler = TIM_PRESCALES[2];
  1098.     htim5.Init.Prescaler = TIM_PRESCALES[3];
  1099. }
  1100.  
  1101. void write_PWM_TIM_prescalers_to_memory(){
  1102.     uint32_t Nsize = sizeof(TIM_PRESCALES)/sizeof(TIM_PRESCALES[0]);
  1103.     uint16_t wrBuf[Nsize];
  1104.     fill_uint16_array(RX_DATA, wrBuf, 1, Nsize); // 1 because choice is first element
  1105.     FlashWriteN(0, wrBuf, Nsize, DATA_TYPE_U16);
  1106.     read_PWM_TIM_prescalers_from_memory();
  1107. }
  1108.  
  1109.  
  1110. /* USER CODE END 4 */
  1111.  
  1112. /**
  1113.   * @brief  This function is executed in case of error occurrence.
  1114.   * @retval None
  1115.   */
  1116. void Error_Handler(void)
  1117. {
  1118.   /* USER CODE BEGIN Error_Handler_Debug */
  1119.   /* User can add his own implementation to report the HAL error return state */
  1120.   __disable_irq();
  1121.   while (1)
  1122.   {
  1123.   }
  1124.   /* USER CODE END Error_Handler_Debug */
  1125. }
  1126.  
  1127. #ifdef  USE_FULL_ASSERT
  1128. /**
  1129.   * @brief  Reports the name of the source file and the source line number
  1130.   *         where the assert_param error has occurred.
  1131.   * @param  file: pointer to the source file name
  1132.   * @param  line: assert_param error line source number
  1133.   * @retval None
  1134.   */
  1135. void assert_failed(uint8_t *file, uint32_t line)
  1136. {
  1137.   /* USER CODE BEGIN 6 */
  1138.   /* User can add his own implementation to report the file name and line number,
  1139.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  1140.   /* USER CODE END 6 */
  1141. }
  1142. #endif /* USE_FULL_ASSERT */
  1143.  
  1144. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  1145.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!