/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "string.h"
#include "math.h"
#include "stdlib.h"
#include "stdio.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
ADC_HandleTypeDef hadc1;
ADC_HandleTypeDef hadc2;

DAC_HandleTypeDef hdac1;
DAC_HandleTypeDef hdac2;

UART_HandleTypeDef huart2;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);
static void MX_ADC2_Init(void);
static void MX_DAC1_Init(void);
static void MX_DAC2_Init(void);
static void MX_USART2_UART_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void w_calibration(void);
ADC_ChannelConfTypeDef sConfig= {0};
int w_uart_cr=0;
int w_uart_r_cnt=0;
char w_uart_r[100]={0};
char w_uart_r_1[2]={0};
char w_uart_t[100];
uint32_t w_adc;
double w_adc_d=0;
uint32_t w_dac;
double w_dac_d=0;
uint16_t * VREF_R;
double w_vref;
double w_vdda;
char w_dac_str[10];
double w_ch1_out=0;
double w_ch1_f=0; //DAC1-1
double w_ch1_s=0; //ADC2-2
double w_ch2_out=0;
double w_ch2_f=0; //DAC2-1
double w_ch2_s=0; //ADC2-4
double w_ch3_s=0; //ADC1-1
double w_ch4_s=0; //ADC1-2
double w_ch5_s=0; //ADC1-4
double w_ch6_s=0; //ADC1-11
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

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

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_ADC1_Init();
  MX_ADC2_Init();
  MX_DAC1_Init();
  MX_DAC2_Init();
  MX_USART2_UART_Init();
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  int i;
  VREF_R=(uint16_t *)0x1FFFF7BA; //typical 1.23V Vref Register
  w_vref=((double)*VREF_R/(double)4096.0)*3.3; //1.2238;


  /* ADC1&2 Caliblation and Polling VREF & DDA ****************************/
    HAL_Delay(500);

    w_calibration();

    sConfig.Channel = ADC_CHANNEL_1;
    HAL_ADC_ConfigChannel(&hadc1, &sConfig);

    sConfig.Channel = ADC_CHANNEL_2;
    HAL_ADC_ConfigChannel(&hadc2, &sConfig);
  /**********************************************************************/
	  HAL_DAC_SetValue(&hdac1, DAC_CHANNEL_1, DAC_ALIGN_12B_R, (uint32_t)0);
	  HAL_DAC_Start(&hdac1, DAC_CHANNEL_1);
	  HAL_DAC_SetValue(&hdac2, DAC_CHANNEL_1, DAC_ALIGN_12B_R, (uint32_t)0);
	  HAL_DAC_Start(&hdac2, DAC_CHANNEL_1);

  HAL_UART_Receive_IT(&huart2, (uint8_t*)w_uart_r_1, 1);
  while (1)
  {
      if(w_uart_cr==1){
    	  HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_3);
          HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_SET);
          HAL_Delay(20);
          w_uart_cr=0;
          w_uart_r_cnt=strlen(w_uart_r);
          //HAL_UART_Transmit(&huart2, (uint8_t*)w_uart_r, strlen(w_uart_r),100);
          //HAL_UART_Transmit(&huart2, (uint8_t*)"\r\n",2, 20);

		  if(strncmp((char*)w_uart_r,"DAC1=",5)==0){
			  if(w_uart_r_cnt==11){
				  w_dac_str[0]=w_uart_r[5];
				  w_dac_str[1]=w_uart_r[6];
				  w_dac_str[2]=w_uart_r[7];
				  w_dac_str[3]=w_uart_r[8];
				  w_dac_str[4]=w_uart_r[9];
				  w_dac_str[5]=w_uart_r[10];
				  w_dac_str[6]=0x00;
				  w_dac_d=atof(w_dac_str);
				  if(w_dac_d>=0 && w_dac_d<=3.3){
					  strcpy((char*)w_uart_t,"OK\r\n");
					  HAL_UART_Transmit(&huart2, (uint8_t*)w_uart_t, strlen((char*)w_uart_t), 100);
					  w_ch1_out=w_dac_d;
				  }
			  }
		  }
		  if(strncmp((char*)w_uart_r,"DAC2=",5)==0){
			  if(w_uart_r_cnt==11){
				  w_dac_str[0]=w_uart_r[5];
				  w_dac_str[1]=w_uart_r[6];
				  w_dac_str[2]=w_uart_r[7];
				  w_dac_str[3]=w_uart_r[8];
				  w_dac_str[4]=w_uart_r[9];
				  w_dac_str[5]=w_uart_r[10];
				  w_dac_str[6]=0x00;
				  w_dac_d=atof(w_dac_str);
				  if(w_dac_d>=0 && w_dac_d<=3.3){
					  strcpy((char*)w_uart_t,"OK\r\n");
					  HAL_UART_Transmit(&huart2, (uint8_t*)w_uart_t, strlen((char*)w_uart_t), 100);
					  w_ch2_out=w_dac_d;
				  }
			  }
		  }
		  if(w_uart_r_cnt==3){
			  if(strncmp((char*)w_uart_r,"cal",3)==0){
				  w_calibration();
			  }
			  if(strncmp((char*)w_uart_r,"ch1",3)==0){
			  	  sprintf((char*)w_uart_t,"CH1=%.4f\r\n",w_ch1_s);
				  HAL_UART_Transmit(&huart2, (uint8_t*)w_uart_t, strlen((char*)w_uart_t), 100);
			  }
			  if(strncmp((char*)w_uart_r,"ch2",3)==0){
			  	  sprintf((char*)w_uart_t,"CH2=%.4f\r\n",w_ch2_s);
				  HAL_UART_Transmit(&huart2, (uint8_t*)w_uart_t, strlen((char*)w_uart_t), 100);
			  }
			  if(strncmp((char*)w_uart_r,"ch3",3)==0){
			  	  sprintf((char*)w_uart_t,"CH3=%.4f\r\n",w_ch3_s);
				  HAL_UART_Transmit(&huart2, (uint8_t*)w_uart_t, strlen((char*)w_uart_t), 100);
			  }
			  if(strncmp((char*)w_uart_r,"ch4",3)==0){
			  	  sprintf((char*)w_uart_t,"CH4=%.4f\r\n",w_ch4_s);
				  HAL_UART_Transmit(&huart2, (uint8_t*)w_uart_t, strlen((char*)w_uart_t), 100);
			  }
			  if(strncmp((char*)w_uart_r,"ch5",3)==0){
			  	  sprintf((char*)w_uart_t,"CH5=%.4f\r\n",w_ch5_s);
				  HAL_UART_Transmit(&huart2, (uint8_t*)w_uart_t, strlen((char*)w_uart_t), 100);
			  }
			  if(strncmp((char*)w_uart_r,"ch6",3)==0){
			  	  sprintf((char*)w_uart_t,"CH6=%.4f\r\n",w_ch6_s);
				  HAL_UART_Transmit(&huart2, (uint8_t*)w_uart_t, strlen((char*)w_uart_t), 100);
			  }
		  }
          for(i=0;i<20;i++){w_uart_r[i]=0;}
          HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_RESET);
          HAL_UART_Abort_IT(&huart2);
          HAL_UART_Receive_IT(&huart2, (uint8_t*)w_uart_r_1, 1);
          w_uart_cr=0;
      }

      // ch1-f DAC1-1 output ****************************************************************
      w_ch1_f=w_ch1_f+(w_ch1_out-w_ch1_s)/2;
      if(w_ch1_f<0){w_ch1_f=0;}
      if(w_ch1_f>w_vdda){w_ch1_f=w_vdda-0.001;}
	  w_dac=(uint32_t)((double)(w_ch1_f/w_vdda)*(double)4096.0);
	  HAL_DAC_SetValue(&hdac1, DAC_CHANNEL_1, DAC_ALIGN_12B_R, w_dac);
      // ch2-f DAC2-1 output ****************************************************************
      w_ch2_f=w_ch2_f+(w_ch2_out-w_ch2_s);
      if(w_ch2_f<0){w_ch2_f=0;}
      if(w_ch2_f>w_vdda){w_ch2_f=w_vdda-0.001;}
	  w_dac=(uint32_t)((double)(w_ch2_f/w_vdda)*(double)4096.0);
	  HAL_DAC_SetValue(&hdac2, DAC_CHANNEL_1, DAC_ALIGN_12B_R, w_dac);
      // ch1-s ADC2-2 input  ****************************************************************
	  sConfig.Channel = ADC_CHANNEL_2;
	  HAL_ADC_ConfigChannel(&hadc2, &sConfig);
  	  HAL_ADC_Start(&hadc2);
  	  HAL_ADC_PollForConversion(&hadc2, 100);
  	  w_adc=HAL_ADC_GetValue(&hadc2);
  	  w_ch1_s=((double)w_adc/(double)4096.0)*w_vdda;
      // ch2-s ADC2-4 input  ****************************************************************
	  sConfig.Channel = ADC_CHANNEL_4;
	  HAL_ADC_ConfigChannel(&hadc2, &sConfig);
  	  HAL_ADC_Start(&hadc2);
  	  HAL_ADC_PollForConversion(&hadc2, 100);
  	  w_adc=HAL_ADC_GetValue(&hadc2);
  	  w_ch2_s=((double)w_adc/(double)4096.0)*w_vdda;
      // ch3-s ADC1-1 input  ****************************************************************
	  sConfig.Channel = ADC_CHANNEL_1;
	  HAL_ADC_ConfigChannel(&hadc1, &sConfig);
  	  HAL_ADC_Start(&hadc1);
  	  HAL_ADC_PollForConversion(&hadc1, 100);
  	  w_adc=HAL_ADC_GetValue(&hadc1);
  	  w_ch3_s=((double)w_adc/(double)4096.0)*w_vdda;
      // ch4-s ADC1-2 input  ****************************************************************
	  sConfig.Channel = ADC_CHANNEL_2;
	  HAL_ADC_ConfigChannel(&hadc1, &sConfig);
  	  HAL_ADC_Start(&hadc1);
  	  HAL_ADC_PollForConversion(&hadc1, 100);
  	  w_adc=HAL_ADC_GetValue(&hadc1);
  	  w_ch4_s=((double)w_adc/(double)4096.0)*w_vdda;
      // ch5-s ADC1-4 input  ****************************************************************
	  sConfig.Channel = ADC_CHANNEL_4;
	  HAL_ADC_ConfigChannel(&hadc1, &sConfig);
  	  HAL_ADC_Start(&hadc1);
  	  HAL_ADC_PollForConversion(&hadc1, 100);
  	  w_adc=HAL_ADC_GetValue(&hadc1);
  	  w_ch5_s=((double)w_adc/(double)4096.0)*w_vdda;
      // ch6-s ADC1-11 input  ****************************************************************
	  sConfig.Channel = ADC_CHANNEL_11;
	  HAL_ADC_ConfigChannel(&hadc1, &sConfig);
  	  HAL_ADC_Start(&hadc1);
  	  HAL_ADC_PollForConversion(&hadc1, 100);
  	  w_adc=HAL_ADC_GetValue(&hadc1);
  	  w_ch6_s=((double)w_adc/(double)4096.0)*w_vdda;

    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL8;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC12;
  PeriphClkInit.Adc12ClockSelection = RCC_ADC12PLLCLK_DIV1;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief ADC1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_ADC1_Init(void)
{

  /* USER CODE BEGIN ADC1_Init 0 */

  /* USER CODE END ADC1_Init 0 */

  ADC_MultiModeTypeDef multimode = {0};
  ADC_ChannelConfTypeDef sConfig = {0};

  /* USER CODE BEGIN ADC1_Init 1 */

  /* USER CODE END ADC1_Init 1 */
  /** Common config
  */
  hadc1.Instance = ADC1;
  hadc1.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
  hadc1.Init.Resolution = ADC_RESOLUTION_12B;
  hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc1.Init.ContinuousConvMode = DISABLE;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.NbrOfConversion = 1;
  hadc1.Init.DMAContinuousRequests = DISABLE;
  hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  hadc1.Init.LowPowerAutoWait = DISABLE;
  hadc1.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
  if (HAL_ADC_Init(&hadc1) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure the ADC multi-mode
  */
  multimode.Mode = ADC_MODE_INDEPENDENT;
  if (HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel
  */
  sConfig.Channel = ADC_CHANNEL_1;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SingleDiff = ADC_SINGLE_ENDED;
  sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
  sConfig.OffsetNumber = ADC_OFFSET_NONE;
  sConfig.Offset = 0;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN ADC1_Init 2 */

  /* USER CODE END ADC1_Init 2 */

}

/**
  * @brief ADC2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_ADC2_Init(void)
{

  /* USER CODE BEGIN ADC2_Init 0 */

  /* USER CODE END ADC2_Init 0 */

  ADC_ChannelConfTypeDef sConfig = {0};

  /* USER CODE BEGIN ADC2_Init 1 */

  /* USER CODE END ADC2_Init 1 */
  /** Common config
  */
  hadc2.Instance = ADC2;
  hadc2.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
  hadc2.Init.Resolution = ADC_RESOLUTION_12B;
  hadc2.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc2.Init.ContinuousConvMode = DISABLE;
  hadc2.Init.DiscontinuousConvMode = DISABLE;
  hadc2.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  hadc2.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc2.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc2.Init.NbrOfConversion = 1;
  hadc2.Init.DMAContinuousRequests = DISABLE;
  hadc2.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  hadc2.Init.LowPowerAutoWait = DISABLE;
  hadc2.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
  if (HAL_ADC_Init(&hadc2) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel
  */
  sConfig.Channel = ADC_CHANNEL_2;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SingleDiff = ADC_SINGLE_ENDED;
  sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
  sConfig.OffsetNumber = ADC_OFFSET_NONE;
  sConfig.Offset = 0;
  if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN ADC2_Init 2 */

  /* USER CODE END ADC2_Init 2 */

}

/**
  * @brief DAC1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_DAC1_Init(void)
{

  /* USER CODE BEGIN DAC1_Init 0 */

  /* USER CODE END DAC1_Init 0 */

  DAC_ChannelConfTypeDef sConfig = {0};

  /* USER CODE BEGIN DAC1_Init 1 */

  /* USER CODE END DAC1_Init 1 */
  /** DAC Initialization
  */
  hdac1.Instance = DAC1;
  if (HAL_DAC_Init(&hdac1) != HAL_OK)
  {
    Error_Handler();
  }
  /** DAC channel OUT1 config
  */
  sConfig.DAC_Trigger = DAC_TRIGGER_NONE;
  sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_DISABLE;
  if (HAL_DAC_ConfigChannel(&hdac1, &sConfig, DAC_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN DAC1_Init 2 */

  /* USER CODE END DAC1_Init 2 */

}

/**
  * @brief DAC2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_DAC2_Init(void)
{

  /* USER CODE BEGIN DAC2_Init 0 */

  /* USER CODE END DAC2_Init 0 */

  DAC_ChannelConfTypeDef sConfig = {0};

  /* USER CODE BEGIN DAC2_Init 1 */

  /* USER CODE END DAC2_Init 1 */
  /** DAC Initialization
  */
  hdac2.Instance = DAC2;
  if (HAL_DAC_Init(&hdac2) != HAL_OK)
  {
    Error_Handler();
  }
  /** DAC channel OUT1 config
  */
  sConfig.DAC_Trigger = DAC_TRIGGER_NONE;
  sConfig.DAC_OutputSwitch = DAC_OUTPUTSWITCH_ENABLE;
  if (HAL_DAC_ConfigChannel(&hdac2, &sConfig, DAC_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN DAC2_Init 2 */

  /* USER CODE END DAC2_Init 2 */

}

/**
  * @brief USART2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART2_UART_Init(void)
{

  /* USER CODE BEGIN USART2_Init 0 */

  /* USER CODE END USART2_Init 0 */

  /* USER CODE BEGIN USART2_Init 1 */

  /* USER CODE END USART2_Init 1 */
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 38400;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */

  /* USER CODE END USART2_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3|GPIO_PIN_4, GPIO_PIN_RESET);

  /*Configure GPIO pins : PB3 PB4 */
  GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){
	if(w_uart_r_1[0] == 0x0d || w_uart_r_1[0] == 0x0a){
		w_uart_cr=1;
	}else{
		strcat(w_uart_r,w_uart_r_1);
	}
	HAL_UART_Receive_IT(&huart2, (uint8_t*)w_uart_r_1, 1);
}
void w_calibration(void){

    HAL_ADCEx_Calibration_Start(&hadc1, ADC_SINGLE_ENDED);
    HAL_ADCEx_Calibration_Start(&hadc2, ADC_SINGLE_ENDED);

    //sConfig.Channel = ADC_CHANNEL_1;
    sConfig.Channel = ADC_CHANNEL_VREFINT;
    sConfig.Rank = ADC_REGULAR_RANK_1;
    sConfig.SingleDiff = ADC_SINGLE_ENDED;
    sConfig.SamplingTime = ADC_SAMPLETIME_61CYCLES_5;
    sConfig.OffsetNumber = ADC_OFFSET_NONE;
    sConfig.Offset = 0;
    HAL_ADC_ConfigChannel(&hadc1, &sConfig);

    HAL_ADC_Start(&hadc1);
    HAL_ADC_PollForConversion(&hadc1, 100);
    w_adc=HAL_ADC_GetValue(&hadc1);
    HAL_ADC_Stop(&hadc1);

    w_vdda=(double)((double)4096.0/(double)w_adc)*w_vref;
    sprintf(w_uart_t,"STM32F303 2020.10.12 V04.3 384KBPS VDDA= %.4fV VREF= %.4fV\r\n",w_vdda,w_vref);
    HAL_UART_Transmit(&huart2, (uint8_t*)w_uart_t, strlen((char*)w_uart_t), 100);

    HAL_UART_AbortReceive_IT(&huart2);
	HAL_UART_Receive_IT(&huart2, (uint8_t*)w_uart_r_1, 1);

}
/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */

  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/