//------------------------------------------------------
uint8_t read_batt()
{ uint32_t temp[3];
//HAL_ADC_Start_IT(&hadc1);
for(uint8_t i=0;i<3;i++)
{
HAL_ADC_Start(&hadc1);
if (HAL_ADC_PollForConversion(&hadc1, 100) != HAL_OK)
return 0;
if ((HAL_ADC_GetState(&hadc1) & HAL_ADC_STATE_EOC_REG) == HAL_ADC_STATE_EOC_REG)
{
temp[i] = HAL_ADC_GetValue(&hadc1);
if(temp[i]<batt_min)
temp[i]=batt_min;
if(temp[i]>batt_max)
temp[i]=batt_max;
}
HAL_ADC_Stop(&hadc1);
}
temp[0]=(temp[0]+temp[1]+temp[2])/3;
batt_status=(temp[0]-batt_min)*100/(batt_max-batt_min);
SEGGER_RTT_printf(0,"power:%d\r\n",batt_status);
return 1;
}
/**
* @brief Initializes ADC HAL.
* @param None
* @retval None
*/
static void ADCx_Init(void)
{
if(HAL_ADC_GetState(&hnucleo_Adc) == HAL_ADC_STATE_RESET)
{
/* ADC Config */
hnucleo_Adc.Instance = NUCLEO_ADCx;
hnucleo_Adc.Init.OversamplingMode = DISABLE;
hnucleo_Adc.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2; /* (must not exceed 16MHz) */
hnucleo_Adc.Init.LowPowerAutoPowerOff = DISABLE;
hnucleo_Adc.Init.LowPowerFrequencyMode = ENABLE;
hnucleo_Adc.Init.LowPowerAutoWait = ENABLE;
hnucleo_Adc.Init.Resolution = ADC_RESOLUTION_12B;
hnucleo_Adc.Init.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
hnucleo_Adc.Init.ScanConvMode = ADC_SCAN_DIRECTION_FORWARD;
hnucleo_Adc.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hnucleo_Adc.Init.ContinuousConvMode = DISABLE;
hnucleo_Adc.Init.DiscontinuousConvMode = DISABLE;
hnucleo_Adc.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
hnucleo_Adc.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
hnucleo_Adc.Init.DMAContinuousRequests = DISABLE;
ADCx_MspInit(&hnucleo_Adc);
HAL_ADC_Init(&hnucleo_Adc);
}
}
void adcGetConversion()
{
HAL_ADC_PollForConversion(&AdcHandle1, 10);
HAL_ADC_PollForConversion(&AdcHandle2, 10);
HAL_ADC_PollForConversion(&AdcHandle3, 10);
/* Check if the continous conversion of regular channel is finished */
if(HAL_ADC_GetState(&AdcHandle1) == HAL_ADC_STATE_EOC_REG
&& HAL_ADC_GetState(&AdcHandle2) == HAL_ADC_STATE_EOC_REG
&& HAL_ADC_GetState(&AdcHandle3) == HAL_ADC_STATE_EOC_REG)
{
/*##-5- Get the converted value of regular channel ########################*/
uhADCxConvertedValue1 = HAL_ADC_GetValue(&AdcHandle1);
uhADCxConvertedValue2 = HAL_ADC_GetValue(&AdcHandle2);
uhADCxConvertedValue3 = HAL_ADC_GetValue(&AdcHandle3);
}
}
void js_analogRead(CScriptVar *v, void *userdata){
int type = v->getParameter("type")->getInt();
int pin = v->getParameter("pin")->getInt();
if(Types[type] == 0 || Pins[pin] ==0){
v->getReturnVar()->setInt(0);
return;
}
if(AdcHandle.Instance != ADC3){
AdcHandle.Instance = ADC3;
AdcHandle.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV2;
AdcHandle.Init.Resolution = ADC_RESOLUTION12b;
AdcHandle.Init.ScanConvMode = DISABLE;
AdcHandle.Init.ContinuousConvMode = DISABLE;
AdcHandle.Init.DiscontinuousConvMode = DISABLE;
AdcHandle.Init.NbrOfDiscConversion = 0;
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
AdcHandle.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1;
AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle.Init.NbrOfConversion = 1;
AdcHandle.Init.DMAContinuousRequests = DISABLE;
AdcHandle.Init.EOCSelection = DISABLE;
if (HAL_ADC_Init(&AdcHandle) != HAL_OK)
{
v->getReturnVar()->setInt(0);
return;
}
}
ADC_ChannelConfTypeDef sConfig;
sConfig.Channel = Pins[pin];
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
sConfig.Offset = 0;
if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
{
v->getReturnVar()->setInt(0);
return;
}
if (HAL_ADC_Start(&AdcHandle) != HAL_OK)
{
v->getReturnVar()->setInt(0);
return;
}
HAL_ADC_PollForConversion(&AdcHandle, 10);
if (HAL_ADC_GetState(&AdcHandle) == HAL_ADC_STATE_EOC_REG)
{
uhADCxConvertedValue = HAL_ADC_GetValue(&AdcHandle);
}
v->getReturnVar()->setInt(uhADCxConvertedValue);
return;
}
STATIC uint32_t adc_read_channel(ADC_HandleTypeDef *adcHandle) {
uint32_t rawValue = 0;
HAL_ADC_Start(adcHandle);
if (HAL_ADC_PollForConversion(adcHandle, 10) == HAL_OK && HAL_ADC_GetState(adcHandle) == HAL_ADC_STATE_EOC_REG) {
rawValue = HAL_ADC_GetValue(adcHandle);
}
HAL_ADC_Stop(adcHandle);
return rawValue;
}
/**
* @brief Returns the Joystick key pressed.
* @note To know which Joystick key is pressed we need to detect the voltage
* level on each key output
* - None : 3.3 V / 4095
* - SEL : 1.055 V / 1308
* - DOWN : 0.71 V / 88
* - LEFT : 3.0 V / 3720
* - RIGHT : 0.595 V / 737
* - UP : 1.65 V / 2046
* @retval JOYState_TypeDef: Code of the Joystick key pressed.
*/
JOYState_TypeDef BSP_JOY_GetState(void)
{
JOYState_TypeDef state;
uint16_t keyconvertedvalue = 0;
/* Start the conversion process */
HAL_ADC_Start(&hnucleo_Adc);
/* Wait for the end of conversion */
HAL_ADC_PollForConversion(&hnucleo_Adc, 10);
/* Check if the continuous conversion of regular channel is finished */
if(HAL_ADC_GetState(&hnucleo_Adc) == HAL_ADC_STATE_EOC_REG)
{
/* Get the converted value of regular channel */
keyconvertedvalue = HAL_ADC_GetValue(&hnucleo_Adc);
}
if((keyconvertedvalue > 2010) && (keyconvertedvalue < 2090))
{
state = JOY_UP;
}
else if((keyconvertedvalue > 680) && (keyconvertedvalue < 780))
{
state = JOY_RIGHT;
}
else if((keyconvertedvalue > 1270) && (keyconvertedvalue < 1350))
{
state = JOY_SEL;
}
else if((keyconvertedvalue > 50) && (keyconvertedvalue < 130))
{
state = JOY_DOWN;
}
else if((keyconvertedvalue > 3680) && (keyconvertedvalue < 3760))
{
state = JOY_LEFT;
}
else
{
state = JOY_NONE;
}
/* Loop while a key is pressed */
if(state != JOY_NONE)
{
keyconvertedvalue = HAL_ADC_GetValue(&hnucleo_Adc);
}
/* Return the code of the Joystick key pressed */
return state;
}
/**
* @brief ADC_Handler : SSI handler for ADC page
*/
u16_t ADC_Handler(int iIndex, char *pcInsert, int iInsertLen)
{
/* We have only one SSI handler iIndex = 0 */
if (iIndex ==0)
{
char Digit1=0, Digit2=0, Digit3=0, Digit4=0;
uint32_t ADCVal = 0;
/* configure ADC if not yet configured */
if (ADC_not_configured ==1)
{
// BSP_ADC_Init(&hadc_bsp1,ADC_IN1,1,Indepenent_Mode);
HAL_ADC_Start(&hadc_bsp1);
ADC_not_configured=0;
}
HAL_ADC_PollForConversion(&hadc_bsp1, 10); // check the port pin
/* Check if the continuous conversion of regular channel is finished */
if(HAL_ADC_GetState(&hadc_bsp1) == HAL_ADC_STATE_EOC_REG)
{
/* get ADC conversion value */
ADCVal = HAL_ADC_GetValue(&hadc_bsp1);
}
// HAL_ADC_PollForConversion(&hadc_bsp1, 10);
/* get ADC conversion value */
// ADCVal = HAL_ADC_GetValue(&hadc_bsp1);
/* convert to Voltage, step = 0.8 mV */
ADCVal = (uint32_t)(ADCVal * 0.8);
/* get digits to display */
Digit1= ADCVal/1000;
Digit2= (ADCVal-(Digit1*1000))/100;
Digit3= (ADCVal-((Digit1*1000)+(Digit2*100)))/10;
Digit4= ADCVal -((Digit1*1000)+(Digit2*100)+ (Digit3*10));
/* prepare data to be inserted in html */
*pcInsert = (char)(Digit1+0x30);
*(pcInsert + 1) = (char)(Digit2+0x30);
*(pcInsert + 2) = (char)(Digit3+0x30);
*(pcInsert + 3) = (char)(Digit4+0x30);
/* 4 characters need to be inserted in html*/
return 4;
}
return 0;
}
void Get_Adc(void){
/*##-- Start the conversion process #######################################*/
if(HAL_ADC_Start(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/*##- Wait for the end of conversion #####################################*/
HAL_ADC_PollForConversion(&AdcHandle, 10);
/* Check if the continuous conversion of regular channel is finished */
if((HAL_ADC_GetState(&AdcHandle) & HAL_ADC_STATE_EOC_REG) == HAL_ADC_STATE_EOC_REG)
{
/*##-5- Get the converted value of regular channel ######################*/
uhADCxConvertedValue = HAL_ADC_GetValue(&AdcHandle);
}
}
/**
* @brief Returns the Joystick key pressed.
* @note To know which Joystick key is pressed we need to detect the voltage
* level on each key output
* - None : 3.3 V / 4095
* - SEL : 1.055 V / 1308
* - DOWN : 0.71 V / 88
* - LEFT : 3.0 V / 3720
* - RIGHT : 0.595 V / 737
* - UP : 1.65 V / 2046
* @retval JOYState_TypeDef: Code of the Joystick key pressed.
*/
JOYState_TypeDef BSP_JOY_GetState(void)
{
JOYState_TypeDef state = JOY_NONE;
uint16_t keyconvertedvalue = 0;
/* Start the conversion process */
HAL_ADC_Start(&hnucleo_Adc);
/* Wait for the end of conversion */
HAL_ADC_PollForConversion(&hnucleo_Adc, 10);
/* Check if the continous conversion of regular channel is finished */
if(HAL_ADC_GetState(&hnucleo_Adc) & HAL_ADC_STATE_REG_EOC)
{
/* Get the converted value of regular channel */
keyconvertedvalue = HAL_ADC_GetValue(&hnucleo_Adc);
}
if((keyconvertedvalue > 1980) && (keyconvertedvalue < 2120))
{
state = JOY_UP;
}
else if((keyconvertedvalue > 630) && (keyconvertedvalue < 830))
{
state = JOY_RIGHT;
}
else if((keyconvertedvalue > 1210) && (keyconvertedvalue < 1410))
{
state = JOY_SEL;
}
else if((keyconvertedvalue > 20) && (keyconvertedvalue < 160))
{
state = JOY_DOWN;
}
else if((keyconvertedvalue > 3620) && (keyconvertedvalue < 3820))
{
state = JOY_LEFT;
}
else
{
state = JOY_NONE;
}
/* Return the code of the Joystick key pressed*/
return state;
}
uint16_t TM_ADC_Read(ADC_TypeDef* ADCx, TM_ADC_Channel_t channel) {
ADC_ChannelConfTypeDef sConfig;
/* Configure ADC regular channel */
sConfig.Channel = (uint8_t) channel;
sConfig.Rank = 1;
#if defined(STM32F0xx) || defined(STM32F1xx)
sConfig.SamplingTime = ADC_SAMPLETIME_13CYCLES_5;
#else
sConfig.SamplingTime = ADC_SAMPLETIME_15CYCLES;
sConfig.Offset = 0;
#endif
/* Set handle */
AdcHandle.Instance = ADCx;
/* Return zero */
if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK) {
return 0;
}
/* Start conversion */
if (HAL_ADC_Start(&AdcHandle) != HAL_OK) {
return 0;
}
#if defined(STM32F0xx)
/* Poll for end */
if (HAL_ADC_PollForConversion(&AdcHandle, 10) == HAL_OK) {
/* Get the converted value of regular channel */
return HAL_ADC_GetValue(&AdcHandle);
}
#else
/* Poll for end */
HAL_ADC_PollForConversion(&AdcHandle, 10);
/* Check if the continous conversion of regular channel is finished */
if (HAL_ADC_GetState(&AdcHandle) == HAL_ADC_STATE_EOC_REG) {
/* Get the converted value of regular channel */
return HAL_ADC_GetValue(&AdcHandle);
}
#endif
/* Return zero */
return 0;
}
float STM32AdcChannel::GetVoltage ()
{
float result = 0;
HAL_ADC_ConfigChannel (adc.adcHandle, &channelConfig);
HAL_Delay (1);
HAL_ADC_Start (adc.adcHandle);
HAL_ADC_PollForConversion (adc.adcHandle, 10);
if (HAL_ADC_GetState (adc.adcHandle) == HAL_ADC_STATE_EOC_REG)
{
result = HAL_ADC_GetValue (adc.adcHandle) * scaleFactor;
}
return result;
}
/**
* @brief Initializes ADC HAL.
* @retval None
*/
static void ADCx_Init(void)
{
if(HAL_ADC_GetState(&hnucleo_Adc) == HAL_ADC_STATE_RESET)
{
/* ADC Config */
hnucleo_Adc.Instance = NUCLEO_ADCx;
hnucleo_Adc.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hnucleo_Adc.Init.ScanConvMode = ADC_SCAN_DISABLE;
hnucleo_Adc.Init.ContinuousConvMode = DISABLE;
hnucleo_Adc.Init.NbrOfConversion = 1;
hnucleo_Adc.Init.DiscontinuousConvMode = DISABLE;
hnucleo_Adc.Init.NbrOfDiscConversion = 1;
hnucleo_Adc.Init.ExternalTrigConv = ADC_SOFTWARE_START;
ADCx_MspInit(&hnucleo_Adc);
HAL_ADC_Init(&hnucleo_Adc);
}
}
/**
* @brief Initializes ADC HAL.
* @param None
* @retval None
*/
static void ADCx_Init(void)
{
if(HAL_ADC_GetState(&hnucleo_Adc) == HAL_ADC_STATE_RESET)
{
/* ADC Config */
hnucleo_Adc.Instance = NUCLEO_ADCx;
hnucleo_Adc.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV4; /* (must not exceed 36MHz) */
hnucleo_Adc.Init.Resolution = ADC_RESOLUTION12b;
hnucleo_Adc.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hnucleo_Adc.Init.ContinuousConvMode = DISABLE;
hnucleo_Adc.Init.DiscontinuousConvMode = DISABLE;
hnucleo_Adc.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
hnucleo_Adc.Init.EOCSelection = EOC_SINGLE_CONV;
hnucleo_Adc.Init.NbrOfConversion = 1;
hnucleo_Adc.Init.DMAContinuousRequests = DISABLE;
ADCx_MspInit(&hnucleo_Adc);
HAL_ADC_Init(&hnucleo_Adc);
}
}
/**
* @brief Initializes ADC HAL.
* @retval None
*/
static HAL_StatusTypeDef ADCx_Init(void)
{
/* Set ADC instance */
hnucleo_Adc.Instance = NUCLEO_ADCx;
if(HAL_ADC_GetState(&hnucleo_Adc) == HAL_ADC_STATE_RESET)
{
/* ADC Config */
hnucleo_Adc.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4; /* ADC clock of STM32F0 must not exceed 14MHz */
hnucleo_Adc.Init.Resolution = ADC_RESOLUTION_12B;
hnucleo_Adc.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hnucleo_Adc.Init.ScanConvMode = ADC_SCAN_DIRECTION_FORWARD; /* Sequencer will convert the number of channels configured below, successively from the lowest to the highest channel number */
hnucleo_Adc.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
hnucleo_Adc.Init.LowPowerAutoWait = DISABLE;
hnucleo_Adc.Init.LowPowerAutoPowerOff = DISABLE;
hnucleo_Adc.Init.ContinuousConvMode = DISABLE; /* Continuous mode disabled to have only 1 conversion at each conversion trig */
hnucleo_Adc.Init.DiscontinuousConvMode = DISABLE; /* Parameter discarded because sequencer is disabled */
hnucleo_Adc.Init.ExternalTrigConv = ADC_SOFTWARE_START; /* Software start to trig the 1st conversion manually, without external event */
hnucleo_Adc.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; /* Parameter discarded because trig by software start */
hnucleo_Adc.Init.DMAContinuousRequests = DISABLE;
hnucleo_Adc.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
hnucleo_Adc.Init.SamplingTimeCommon = ADC_SAMPLETIME_41CYCLES_5;
/* Initialize MSP related to ADC */
ADCx_MspInit(&hnucleo_Adc);
/* Initialize ADC */
if (HAL_ADC_Init(&hnucleo_Adc) != HAL_OK)
{
return HAL_ERROR;
}
/* Run ADC calibration */
if (HAL_ADCEx_Calibration_Start(&hnucleo_Adc) != HAL_OK)
{
return HAL_ERROR;
}
}
return HAL_OK;
}
/**
* @brief Initializes ADC HAL.
* @retval None
*/
static void ADCx_Init(void)
{
if(HAL_ADC_GetState(&hnucleo_Adc) == HAL_ADC_STATE_RESET)
{
/* ADC Config */
hnucleo_Adc.Instance = NUCLEO_ADCx;
hnucleo_Adc.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV2; /* (must not exceed 16MHz) */
hnucleo_Adc.Init.LowPowerAutoPowerOff = ADC_AUTOPOWEROFF_DISABLE;
hnucleo_Adc.Init.LowPowerAutoWait = ADC_AUTOWAIT_UNTIL_DATA_READ;
hnucleo_Adc.Init.Resolution = ADC_RESOLUTION12b;
hnucleo_Adc.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hnucleo_Adc.Init.ContinuousConvMode = DISABLE;
hnucleo_Adc.Init.ScanConvMode = DISABLE;
hnucleo_Adc.Init.ExternalTrigConv = ADC_SOFTWARE_START;
hnucleo_Adc.Init.EOCSelection = EOC_SINGLE_CONV;
hnucleo_Adc.Init.DMAContinuousRequests = DISABLE;
ADCx_MspInit(&hnucleo_Adc);
HAL_ADC_Init(&hnucleo_Adc);
}
}
/**
* @brief Initializes ADC HAL.
* @param None
* @retval None
*/
static void ADCx_Init(void)
{
if(HAL_ADC_GetState(&hnucleo_Adc) == HAL_ADC_STATE_RESET)
{
/* ADC Config */
hnucleo_Adc.Instance = NUCLEO_ADCx;
hnucleo_Adc.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4; /* (must not exceed 16MHz) */
hnucleo_Adc.Init.Resolution = ADC_RESOLUTION12b;
hnucleo_Adc.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hnucleo_Adc.Init.ScanConvMode = DISABLE; /* Sequencer disabled (ADC conversion on only 1 channel: channel set on rank 1) */
hnucleo_Adc.Init.EOCSelection = EOC_SINGLE_CONV;
hnucleo_Adc.Init.LowPowerAutoWait = ENABLE;
hnucleo_Adc.Init.ContinuousConvMode = DISABLE; /* Continuous mode disabled to have only 1 conversion at each conversion trig */
hnucleo_Adc.Init.DiscontinuousConvMode = DISABLE; /* Parameter discarded because sequencer is disabled */
hnucleo_Adc.Init.ExternalTrigConv = ADC_SOFTWARE_START; /* Software start to trig the 1st conversion manually, without external event */
hnucleo_Adc.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
hnucleo_Adc.Init.DMAContinuousRequests = DISABLE;
hnucleo_Adc.Init.Overrun = OVR_DATA_OVERWRITTEN;
ADCx_MspInit(&hnucleo_Adc);
HAL_ADC_Init(&hnucleo_Adc);
}
}
/**
* @brief Initializes ADC HAL.
* @retval None
*/
static HAL_StatusTypeDef ADCx_Init(void)
{
if(HAL_ADC_GetState(&hnucleo_Adc) == HAL_ADC_STATE_RESET)
{
/* ADC Config */
hnucleo_Adc.Instance = NUCLEO_ADCx;
hnucleo_Adc.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV8; /* (must not exceed 16MHz) */
hnucleo_Adc.Init.Resolution = ADC_RESOLUTION_12B;
hnucleo_Adc.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hnucleo_Adc.Init.ScanConvMode = DISABLE;
hnucleo_Adc.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
hnucleo_Adc.Init.LowPowerAutoWait = ENABLE;
hnucleo_Adc.Init.ContinuousConvMode = DISABLE;
hnucleo_Adc.Init.NbrOfConversion = 1;
hnucleo_Adc.Init.DiscontinuousConvMode = DISABLE;
hnucleo_Adc.Init.NbrOfDiscConversion = 1;
hnucleo_Adc.Init.ExternalTrigConv = ADC_SOFTWARE_START;
hnucleo_Adc.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
hnucleo_Adc.Init.DMAContinuousRequests = DISABLE;
hnucleo_Adc.Init.Overrun = ADC_OVR_DATA_PRESERVED;
hnucleo_Adc.Init.OversamplingMode = DISABLE;
ADCx_MspInit(&hnucleo_Adc);
if (HAL_ADC_Init(&hnucleo_Adc) != HAL_OK)
{
return HAL_ERROR;
}
if (HAL_ADCEx_Calibration_Start(&hnucleo_Adc,ADC_SINGLE_ENDED) != HAL_OK)
{
return HAL_ERROR;
}
}
return HAL_OK;
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* This sample code shows how to convert an analog input and read the converted
data using Polling mode.
To proceed, 5 steps are required: */
/* STM32L0xx HAL library initialization:
- Configure the Flash prefetch
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 2 MHz */
SystemClock_Config();
/* ### - 1 - Initialize ADC peripheral #################################### */
/*
* Instance = ADC1.
* OversamplingMode = Disabled
* ClockPrescaler = PCLK clock with no division.
* LowPowerAutoPowerOff = Disabled (For this exemple continuous mode is enabled with software start)
* LowPowerFrequencyMode = Enabled (To be enabled only if ADC clock is lower than 2.8MHz)
* LowPowerAutoWait = Disabled (New conversion starts only when the previous conversion is completed)
* Resolution = 12 bit (increased to 16 bit with oversampler)
* SamplingTime = 7.5 cycles od ADC clock.
* ScanConvMode = Forward
* DataAlign = Right
* ContinuousConvMode = Enabled
* DiscontinuousConvMode = Disabled
* ExternalTrigConvEdge = None (Software start)
* EOCSelection = End Of Conversion event
* DMAContinuousRequests = DISABLE
*/
AdcHandle.Instance = ADC1;
AdcHandle.Init.OversamplingMode = DISABLE;
AdcHandle.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV1;
AdcHandle.Init.LowPowerAutoPowerOff = DISABLE;
AdcHandle.Init.LowPowerFrequencyMode = ENABLE;
AdcHandle.Init.LowPowerAutoWait = DISABLE;
AdcHandle.Init.Resolution = ADC_RESOLUTION_12B;
AdcHandle.Init.SamplingTime = ADC_SAMPLETIME_7CYCLES_5;
AdcHandle.Init.ScanConvMode = ADC_SCAN_DIRECTION_FORWARD;
AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle.Init.ContinuousConvMode = ENABLE;
AdcHandle.Init.DiscontinuousConvMode = DISABLE;
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
AdcHandle.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
AdcHandle.Init.DMAContinuousRequests = DISABLE;
/* Initialize ADC peripheral according to the passed parameters */
if (HAL_ADC_Init(&AdcHandle) != HAL_OK)
{
Error_Handler();
}
/* ### - 2 - Start calibration ############################################ */
if (HAL_ADCEx_Calibration_Start(&AdcHandle, ADC_SINGLE_ENDED) != HAL_OK)
{
Error_Handler();
}
/* ### - 3 - Channel configuration ######################################## */
/* Select Channel 0 to be converted */
sConfig.Channel = ADC_CHANNEL_0;
if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
{
Error_Handler();
}
/*##- 4- Start the conversion process #######################################*/
if (HAL_ADC_Start(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
/*##- 5- Wait for the end of conversion #####################################*/
/* Before starting a new conversion, you need to check the current state of
the peripheral; if it’s busy you need to wait for the end of current
conversion before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
conversion, but application may perform other tasks while conversion
operation is ongoing. */
HAL_ADC_PollForConversion(&AdcHandle, 10);
/* Check if the continous conversion of regular channel is finished */
if ((HAL_ADC_GetState(&AdcHandle) & HAL_ADC_STATE_REG_EOC) == HAL_ADC_STATE_REG_EOC)
{
/*##-6- Get the converted value of regular channel ########################*/
uwADCxConvertedValue = HAL_ADC_GetValue(&AdcHandle);
}
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
ADC_ChannelConfTypeDef sConfig;
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization: global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 180 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- Configure the ADC peripheral #######################################*/
AdcHandle.Instance = ADCx;
if (HAL_ADC_DeInit(&AdcHandle) != HAL_OK)
{
/* ADC de-initialization Error */
Error_Handler();
}
AdcHandle.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV4; /* Asynchronous clock mode, input ADC clock not divided */
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 = DISABLE; /* Sequencer disabled (ADC conversion on only 1 channel: channel set on rank 1) */
AdcHandle.Init.EOCSelection = DISABLE; /* EOC flag picked-up to indicate conversion end */
AdcHandle.Init.ContinuousConvMode = DISABLE; /* Continuous mode disabled to have only 1 conversion at each conversion trig */
AdcHandle.Init.NbrOfConversion = 1; /* Parameter discarded because sequencer is disabled */
AdcHandle.Init.DiscontinuousConvMode = DISABLE; /* Parameter discarded because sequencer is disabled */
AdcHandle.Init.NbrOfDiscConversion = 0; /* Parameter discarded because sequencer is disabled */
AdcHandle.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1; /* Software start to trig the 1st conversion manually, without external event */
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; /* Parameter discarded because software trigger chosen */
AdcHandle.Init.DMAContinuousRequests = DISABLE; /* DMA one-shot mode selected (not applied to this example) */
if (HAL_ADC_Init(&AdcHandle) != HAL_OK)
{
/* ADC initialization Error */
Error_Handler();
}
/*##-2- Configure ADC regular channel ######################################*/
sConfig.Channel = ADCx_CHANNEL; /* Sampled channel number */
sConfig.Rank = 1; /* Rank of sampled channel number ADCx_CHANNEL */
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES; /* Sampling time (number of clock cycles unit) */
sConfig.Offset = 0; /* Parameter discarded because offset correction is disabled */
if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
{
/* Channel Configuration Error */
Error_Handler();
}
/*##-3- Start the conversion process #######################################*/
if (HAL_ADC_Start(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/*##-4- Wait for the end of conversion #####################################*/
/* Before starting a new conversion, you need to check the current state of
the peripheral; if it’s busy you need to wait for the end of current
conversion before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
conversion, but application may perform other tasks while conversion
operation is ongoing. */
if (HAL_ADC_PollForConversion(&AdcHandle, 10) != HAL_OK)
{
/* End Of Conversion flag not set on time */
Error_Handler();
}
/* Check if the continuous conversion of regular channel is finished */
if ((HAL_ADC_GetState(&AdcHandle) & HAL_ADC_STATE_EOC_REG) == HAL_ADC_STATE_EOC_REG)
{
/*##-5- Get the converted value of regular channel ########################*/
uhADCxConvertedValue = HAL_ADC_GetValue(&AdcHandle);
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
ADC_ChannelConfTypeDef sConfig;
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 144 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- Configure the ADC peripheral #######################################*/
AdcHandle.Instance = ADCx;
AdcHandle.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV2;
AdcHandle.Init.Resolution = ADC_RESOLUTION_12B;
AdcHandle.Init.ScanConvMode = DISABLE;
AdcHandle.Init.ContinuousConvMode = DISABLE;
AdcHandle.Init.DiscontinuousConvMode = DISABLE;
AdcHandle.Init.NbrOfDiscConversion = 0;
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
AdcHandle.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1;
AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle.Init.NbrOfConversion = 1;
AdcHandle.Init.DMAContinuousRequests = DISABLE;
AdcHandle.Init.EOCSelection = DISABLE;
if(HAL_ADC_Init(&AdcHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure ADC regular channel ######################################*/
sConfig.Channel = ADCx_CHANNEL;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
sConfig.Offset = 0;
if(HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
{
/* Channel Configuration Error */
Error_Handler();
}
/*##-3- Start the conversion process #######################################*/
if(HAL_ADC_Start(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/*##-4- Wait for the end of conversion #####################################*/
/* Before starting a new conversion, you need to check the current state of
the peripheral; if it’s busy you need to wait for the end of current
conversion before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
conversion, but application may perform other tasks while conversion
operation is ongoing. */
HAL_ADC_PollForConversion(&AdcHandle, 10);
/* Check if the continous conversion of regular channel is finished */
if(HAL_ADC_GetState(&AdcHandle) == HAL_ADC_STATE_EOC_REG)
{
/*##-5- Get the converted value of regular channel ######################*/
uhADCxConvertedValue = HAL_ADC_GetValue(&AdcHandle);
}
/* Infinite loop */
while(1)
{
}
}
static inline uint16_t adc_read(analogin_t *obj) {
ADC_ChannelConfTypeDef sConfig;
AdcHandle.Instance = (ADC_TypeDef *)(obj->adc);
// Configure ADC channel
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
sConfig.Offset = 0;
switch (obj->pin) {
case PA_0:
sConfig.Channel = ADC_CHANNEL_0;
break;
case PA_1:
sConfig.Channel = ADC_CHANNEL_1;
break;
case PA_2:
sConfig.Channel = ADC_CHANNEL_2;
break;
case PA_3:
sConfig.Channel = ADC_CHANNEL_3;
break;
case PA_4:
sConfig.Channel = ADC_CHANNEL_4;
break;
case PA_5:
sConfig.Channel = ADC_CHANNEL_5;
break;
case PA_6:
sConfig.Channel = ADC_CHANNEL_6;
break;
case PA_7:
sConfig.Channel = ADC_CHANNEL_7;
break;
case PB_0:
sConfig.Channel = ADC_CHANNEL_8;
break;
case PB_1:
sConfig.Channel = ADC_CHANNEL_9;
break;
case PC_0:
sConfig.Channel = ADC_CHANNEL_10;
break;
case PC_1:
sConfig.Channel = ADC_CHANNEL_11;
break;
case PC_2:
sConfig.Channel = ADC_CHANNEL_12;
break;
case PC_3:
sConfig.Channel = ADC_CHANNEL_13;
break;
case PC_4:
sConfig.Channel = ADC_CHANNEL_14;
break;
case PC_5:
sConfig.Channel = ADC_CHANNEL_15;
break;
default:
return 0;
}
HAL_ADC_ConfigChannel(&AdcHandle, &sConfig);
HAL_ADC_Start(&AdcHandle); // Start conversion
HAL_ADC_PollForConversion(&AdcHandle, 10); // Wait end of conversion
if (HAL_ADC_GetState(&AdcHandle) == HAL_ADC_STATE_EOC_REG)
{
return(HAL_ADC_GetValue(&AdcHandle)); // Get conversion value
}
else
{
return 0;
}
}
/**
* @brief This function will set the ADC to the required value
* @param pin : the pin to use
* @retval the value of the adc
*/
uint16_t adc_read_value(PinName pin)
{
ADC_HandleTypeDef AdcHandle = {};
ADC_ChannelConfTypeDef AdcChannelConf = {};
__IO uint16_t uhADCxConvertedValue = 0;
AdcHandle.Instance = pinmap_peripheral(pin, PinMap_ADC);
if (AdcHandle.Instance == NP) return 0;
#ifndef STM32F1xx
AdcHandle.Init.ClockPrescaler = ADC_CLOCK_DIV; /* Asynchronous clock mode, input ADC clock divided */
AdcHandle.Init.Resolution = ADC_RESOLUTION_12B; /* 12-bit resolution for converted data */
AdcHandle.Init.EOCSelection = ADC_EOC_SINGLE_CONV; /* EOC flag picked-up to indicate conversion end */
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; /* Parameter discarded because software trigger chosen */
AdcHandle.Init.DMAContinuousRequests = DISABLE; /* DMA one-shot mode selected (not applied to this example) */
#endif
AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT; /* Right-alignment for converted data */
AdcHandle.Init.ScanConvMode = DISABLE; /* Sequencer disabled (ADC conversion on only 1 channel: channel set on rank 1) */
AdcHandle.Init.ContinuousConvMode = DISABLE; /* Continuous mode disabled to have only 1 conversion at each conversion trig */
AdcHandle.Init.DiscontinuousConvMode = DISABLE; /* Parameter discarded because sequencer is disabled */
AdcHandle.Init.ExternalTrigConv = ADC_SOFTWARE_START; /* Software start to trig the 1st conversion manually, without external event */
AdcHandle.State = HAL_ADC_STATE_RESET;
#if defined (STM32F0xx) || defined (STM32L0xx)
AdcHandle.Init.LowPowerAutoWait = DISABLE; /* Auto-delayed conversion feature disabled */
AdcHandle.Init.LowPowerAutoPowerOff = DISABLE; /* ADC automatically powers-off after a conversion and automatically wakes-up when a new conversion is triggered */
AdcHandle.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN; /* DR register is overwritten with the last conversion result in case of overrun */
#ifdef STM32F0xx
AdcHandle.Init.SamplingTimeCommon = SAMPLINGTIME;
#else // STM32L0
//LowPowerFrequencyMode to enable if clk freq < 2.8Mhz
AdcHandle.Init.SamplingTime = SAMPLINGTIME;
#endif
#else
#ifdef STM32F3xx
AdcHandle.Init.LowPowerAutoWait = DISABLE; /* Auto-delayed conversion feature disabled */
#endif
AdcHandle.Init.NbrOfConversion = 1; /* Specifies the number of ranks that will be converted within the regular group sequencer. */
AdcHandle.Init.NbrOfDiscConversion = 0; /* Parameter discarded because sequencer is disabled */
#endif
g_current_pin = pin; /* Needed for HAL_ADC_MspInit*/
if (HAL_ADC_Init(&AdcHandle) != HAL_OK) {
return 0;
}
AdcChannelConf.Channel = get_adc_channel(pin); /* Specifies the channel to configure into ADC */
#ifdef STM32L4xx
if (!IS_ADC_CHANNEL(&AdcHandle, AdcChannelConf.Channel)) return 0;
#else
if (!IS_ADC_CHANNEL(AdcChannelConf.Channel)) return 0;
#endif
AdcChannelConf.Rank = ADC_REGULAR_RANK_1; /* Specifies the rank in the regular group sequencer */
#ifndef STM32L0xx
AdcChannelConf.SamplingTime = SAMPLINGTIME; /* Sampling time value to be set for the selected channel */
#endif
#if defined (STM32F3xx) || defined (STM32L4xx)
AdcChannelConf.SingleDiff = ADC_SINGLE_ENDED; /* Single-ended input channel */
AdcChannelConf.OffsetNumber = ADC_OFFSET_NONE; /* No offset subtraction */
AdcChannelConf.Offset = 0; /* Parameter discarded because offset correction is disabled */
#endif
/*##-2- Configure ADC regular channel ######################################*/
if (HAL_ADC_ConfigChannel(&AdcHandle, &AdcChannelConf) != HAL_OK)
{
/* Channel Configuration Error */
return 0;
}
#if defined (STM32F0xx) || defined (STM32F1xx) || defined (STM32F3xx) || defined (STM32L0xx) || defined (STM32L4xx)
/*##-2.1- Calibrate ADC then Start the conversion process ####################*/
#if defined (STM32F0xx) || defined (STM32F1xx)
if (HAL_ADCEx_Calibration_Start(&AdcHandle) != HAL_OK)
#else
if (HAL_ADCEx_Calibration_Start(&AdcHandle, ADC_SINGLE_ENDED) != HAL_OK)
#endif
{
/* ADC Calibration Error */
return 0;
}
#endif
/*##-3- Start the conversion process ####################*/
if (HAL_ADC_Start(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
return 0;
}
/*##-4- Wait for the end of conversion #####################################*/
/* For simplicity reasons, this example is just waiting till the end of the
conversion, but application may perform other tasks while conversion
operation is ongoing. */
if (HAL_ADC_PollForConversion(&AdcHandle, 10) != HAL_OK)
{
/* End Of Conversion flag not set on time */
return 0;
}
/* Check if the continous conversion of regular channel is finished */
if ((HAL_ADC_GetState(&AdcHandle) & HAL_ADC_STATE_REG_EOC) == HAL_ADC_STATE_REG_EOC)
{
/*##-5- Get the converted value of regular channel ########################*/
uhADCxConvertedValue = HAL_ADC_GetValue(&AdcHandle);
}
if (HAL_ADC_Stop(&AdcHandle) != HAL_OK)
{
/* Stop Conversation Error */
return 0;
}
if(HAL_ADC_DeInit(&AdcHandle) != HAL_OK) {
return 0;
}
return uhADCxConvertedValue;
}
