You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
296 lines
8.5 KiB
C
296 lines
8.5 KiB
C
|
|
|
|
/* 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******************/
|
|
|