/* Includes ------------------------------------------------------------------*/

#include "ALLinclude.h"

ADC_HandleTypeDef    AdcHandle;
DMA_HandleTypeDef    HdmaCh1;
uint32_t   gADCxConvertedData[4];


float VoltageBAT;

#define  VBATIndex  0
#define  V5VIndex   1
#define  UVIndex    2
/**
  * @brief  ADC configuration function.
  * @param  None
  * @retval None
  */
void APP_ADCConfig(void)
{
  ADC_ChannelConfTypeDef   sConfig={0};
  RCC_PeriphCLKInitTypeDef RCC_PeriphCLKInit={0};
  
  __HAL_RCC_ADC1_CLK_ENABLE();
  
  RCC_PeriphCLKInit.PeriphClockSelection= RCC_PERIPHCLK_ADC;
  RCC_PeriphCLKInit.AdcClockSelection   = RCC_ADCPCLK2_DIV16;
  HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInit);
  
  AdcHandle.Instance = ADC1;
  
  AdcHandle.Init.Resolution            = ADC_RESOLUTION_12B;             /* 12-bit resolution for converted data  */
  AdcHandle.Init.DataAlign             = ADC_DATAALIGN_RIGHT;            /* Right-alignment for converted data */
  AdcHandle.Init.ScanConvMode          = ADC_SCAN_ENABLE;                /* Scan Mode Enable */
  AdcHandle.Init.ContinuousConvMode    = DISABLE;                        /* Single Conversion */
  AdcHandle.Init.NbrOfConversion       = 1;                              /* Conversion Number 3 */
  AdcHandle.Init.DiscontinuousConvMode = DISABLE;                        /* Discontinuous Mode Disable */
  AdcHandle.Init.NbrOfDiscConversion   = 1;                              /* Discontinuous Conversion Number 1 */
  AdcHandle.Init.ExternalTrigConv      = ADC_SOFTWARE_START;             /* Software Trigger */

  if (HAL_ADC_Init(&AdcHandle) != HAL_OK)
  {
    APP_ErrorHandler();
  }
  
  sConfig.Channel      = ADC_CHANNEL_1;             //PA1
  sConfig.Rank         = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_28CYCLES_5;
  
  if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
  {
    APP_ErrorHandler();
  }
  
  sConfig.Channel      = ADC_CHANNEL_2;           //PA2
  sConfig.Rank         = ADC_REGULAR_RANK_2;
  sConfig.SamplingTime = ADC_SAMPLETIME_28CYCLES_5;
  
  if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
  {
    APP_ErrorHandler();
  }
  
  sConfig.Channel      = ADC_CHANNEL_9;           //PB1
  sConfig.Rank         = ADC_REGULAR_RANK_3;
  sConfig.SamplingTime = ADC_SAMPLETIME_28CYCLES_5;
  
  if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
  {
    APP_ErrorHandler();
  }
  
}

/**
  * @brief Initialize ADC MSP.
  */
void HAL_ADC_MspInit(ADC_HandleTypeDef *hadc)
{
  GPIO_InitTypeDef GPIO_InitStruct={0};
  __HAL_RCC_SYSCFG_CLK_ENABLE();                              /* Enable SYSCFG clock */
  __HAL_RCC_DMA1_CLK_ENABLE();                                /* Enable DMA clock */
  __HAL_RCC_GPIOA_CLK_ENABLE();                               /* Enable GPIOA clock */
  // __HAL_RCC_GPIOB_CLK_ENABLE();                               /* Enable GPIOB clock */

  GPIO_InitStruct.Pin = GPIO_PIN_1 | GPIO_PIN_2 ;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  
 #if 0 
  GPIO_InitStruct.Pin = GPIO_PIN_1 ;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  #endif

 #if 0 
  HdmaCh1.Instance                 = DMA1_Channel2;           /* DMA1 Channel1 */
  HdmaCh1.Init.Direction           = DMA_PERIPH_TO_MEMORY;    /* Transfer mode Periph to Memory */
  HdmaCh1.Init.PeriphInc           = DMA_PINC_DISABLE;        /* Peripheral increment mode Disable */
  HdmaCh1.Init.MemInc              = DMA_MINC_ENABLE;         /* Memory increment mode Enable */
  HdmaCh1.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;     /* Peripheral data alignment : Word  */
  HdmaCh1.Init.MemDataAlignment    = DMA_MDATAALIGN_WORD;     /* Memory data alignment : Word  */
  HdmaCh1.Init.Mode                = DMA_CIRCULAR;            /* Circular DMA mode */
  HdmaCh1.Init.Priority            = DMA_PRIORITY_MEDIUM;  /* Priority level : high  */

  HAL_DMA_DeInit(&HdmaCh1);                                   /* DMA1CH1 Deinitialize */
  HAL_DMA_Init(&HdmaCh1);                                     /* DMA1CH1 Initialize */
  
  HAL_DMA_ChannelMap(&HdmaCh1,DMA_CHANNEL_MAP_ADC1);          /* DMA Channel Remap */
  __HAL_LINKDMA(hadc, DMA_Handle, HdmaCh1);    
#endif              
}

//function:calculate battery voltage
//input: none
//Output:voltage V
float FunctionCalculateBATVoltage(uint32_t *ADCIN)
{
  // uint16_t ret;
  float DataMath;
  uint32_t ADBattery = 0;
  static uint32_t ADCin[BAT_TRANSLATE_TIME] = {0};

  for(int i = 0; i < BAT_TRANSLATE_TIME-1;i++)
  {
    ADCin[i]  = ADCin[i+1];
  }
  ADCin[BAT_TRANSLATE_TIME - 1] = *ADCIN;
  if(ADCin[0])
  {
    ADBattery = 0;
    for(int i =0;i<BAT_TRANSLATE_TIME;i++)
    {
      ADBattery +=ADCin[i];
    }

    ADBattery = ADBattery>>3;
    DataMath   =  (float)ADBattery;
    DataMath  *=3.0;//REF Voltage = VDD = 3.0V
    DataMath  *=2;  //200k 200k   1/2
    DataMath  /=4096;//12Bit ADC

    return DataMath;
  }
 return 0;

}

//function:calculate battery voltage
//input: none
//Output:voltage V
typedefEnumBATStatus FunctionjudgeBATStatus(float *Voltage)
{
  typedefEnumBATStatus ret;
  float VoltageBAT;
  static uint8_t TimerLowVoltage;
  VoltageBAT  = *Voltage;
  if(VoltageBAT < 3.3)//暂定3.3V
  {
    if(TimerLowVoltage<0xFF)TimerLowVoltage++;
    if(TimerLowVoltage  > 10)
    {
      ret = BATLowVoltage;
    }
  }
  else
  {
    TimerLowVoltage = 0;
    ret = BATNormal;
  }

  return ret;

}

//function:calculate battery voltage
//input: none
//Output:voltage V
typedefEnumMarkUSB FunctionJudgUSBIn(uint32_t *ADCIN)
{
   typedefEnumMarkUSB ret = USB_NotIn;
  static uint8_t TimerJitter;
  uint32_t AD5V = *ADCIN;
  if(AD5V>3000)
  {
    if(TimerJitter  < 0xFF)TimerJitter++;
    if(TimerJitter>10)
    {
      ret = USB_In;
    }
  }
  else
  {
    TimerJitter = 0;
    ret = USB_NotIn;
  }

  return ret;

}

void TaskADCFunction(void *pvParamters)
{
  ADC_ChannelConfTypeDef   sConfig={0};
  for(;;)
  {
    #if 0
    HAL_ADC_Start_DMA(&AdcHandle,gADCxConvertedData,3);

    while(!__HAL_DMA_GET_FLAG(&HdmaCh1, DMA_ISR_TCIF1));                               
    
    /* Clear DMA Complete Flag */
    __HAL_DMA_CLEAR_FLAG(&HdmaCh1, DMA_IFCR_CTCIF1);   
    #endif
#if 1
		ADC1->CR2 &= ~ADC_CR2_ADON;
		sConfig.Channel      = ADC_CHANNEL_9;           //PB1
		sConfig.Rank         = ADC_REGULAR_RANK_1;
		sConfig.SamplingTime = ADC_SAMPLETIME_28CYCLES_5;
		if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
		{
			APP_ErrorHandler();
		}
		ADC1->CR2 |= ADC_CR2_ADON;
		HAL_ADC_Start(&AdcHandle);
		while(!__HAL_ADC_GET_FLAG(&AdcHandle, ADC_FLAG_EOC))
    {
		}
		gADCxConvertedData[0]=HAL_ADC_GetValue(&AdcHandle);
		__HAL_ADC_CLEAR_FLAG(&AdcHandle, ADC_FLAG_EOC);
		
		ADC1->CR2 &= ~ADC_CR2_ADON;
		sConfig.Channel      = ADC_CHANNEL_2;           //PB1
		sConfig.Rank         = ADC_REGULAR_RANK_1;
		sConfig.SamplingTime = ADC_SAMPLETIME_28CYCLES_5;
		if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
		{
			APP_ErrorHandler();
		}
		ADC1->CR2 |= ADC_CR2_ADON;
		HAL_ADC_Start(&AdcHandle);
		while(!__HAL_ADC_GET_FLAG(&AdcHandle, ADC_FLAG_EOC))
    {
		}
		gADCxConvertedData[1]=HAL_ADC_GetValue(&AdcHandle);
		__HAL_ADC_CLEAR_FLAG(&AdcHandle, ADC_FLAG_EOC);
		
		ADC1->CR2 &= ~ADC_CR2_ADON;
		sConfig.Channel      = ADC_CHANNEL_1;           //PB1
		sConfig.Rank         = ADC_REGULAR_RANK_1;
		sConfig.SamplingTime = ADC_SAMPLETIME_28CYCLES_5;
		if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
		{
			APP_ErrorHandler();
		}
		ADC1->CR2 |= ADC_CR2_ADON;
		HAL_ADC_Start(&AdcHandle);
		while(!__HAL_ADC_GET_FLAG(&AdcHandle, ADC_FLAG_EOC))
    {
			
		}
		gADCxConvertedData[2]=HAL_ADC_GetValue(&AdcHandle);
		__HAL_ADC_CLEAR_FLAG(&AdcHandle, ADC_FLAG_EOC);
//    for(int i =0; i<3;i++)
//    {
//      while(!__HAL_ADC_GET_FLAG(&AdcHandle, ADC_FLAG_EOC))
//      {
//      }
//      gADCxConvertedData[i]=HAL_ADC_GetValue(&AdcHandle);
//      __HAL_ADC_CLEAR_FLAG(&AdcHandle, ADC_FLAG_EOC);
//    }
//		
//    HAL_ADC_Stop(&AdcHandle);
#endif
    // printf("Channel: %u \r\n",(unsigned int)gADCxConvertedData[0]);
    // printf("Channe2: %u \r\n",(unsigned int)gADCxConvertedData[1]);
    // printf("Channe9: %u \r\n",(unsigned int)gADCxConvertedData[2]);

    VoltageBAT  = FunctionCalculateBATVoltage(&gADCxConvertedData[VBATIndex]);
    //printf("BATVoltage: %f \r\n",VoltageBAT);
    typedefEnumMarkUSB USBState = FunctionJudgUSBIn(&gADCxConvertedData[V5VIndex]);
    //printf("USB State: %u \r\n",USBState);


    vTaskDelay(100);
  }
}

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