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
// Wait end of conversion and get value
if (HAL_ADC_PollForConversion(&AdcHandle, 10) == HAL_OK) {
return (HAL_ADC_GetValue(&AdcHandle));
} else {
return 0;
}
}
int main(void)
{
/* MCU Configuration----------------------------------------------------------*/
HAL_Init(); /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
SystemClock_Config(); /* Configure the system clock */
ADC1_Config(); /* configure ADC1 */
Display_GPIO_Config(); /* Configure 7-Segment Displays */
Alarm_GPIO_Config(); /* Configure alarm pins */
initLCD(); /* configure LCD */
/* print temperature on the first line of the LCD */
returnHome(); /* just makes sure that start writing at the right place */
LCD_WriteString(" Temperature"); /* The 2 initial space are for centering */
adcState = malloc(sizeof(kalmanState)); /* Init Kalman Filter */
kalmanInit(adcState, INIT_q, INIT_r, INIT_x, INIT_p, INIT_k);
/* main program to run in this infinite loop */
while (1) {
if (adcTimer >= ADC_PERIOD) { /* 100Hz */
adcTimer = 0;
HAL_ADC_Start(&ADC1_Handle); /* start ADC conversion */
/* wait for the conversion to be done and get data */
if (HAL_ADC_PollForConversion(&ADC1_Handle, 1000000) == HAL_OK) {
adc_val = HAL_ADC_GetValue(&ADC1_Handle); /* get the value */
kalmanUpdate(adcState, adc_val); /* filter the data and update the filter parameters */
/* DON'T DELETE printf for matlab script */
//printf("%f,%f,%f,%f,%f,%f\n",adc_val, adcState->q,adcState->r, adcState->x, adcState->p, adcState->k);
temp = convertTemp(adcState->x); /* convert the filterd value of the ADC into temperature */
/* Alarm triggering */
if (temp > THRESHHOLD_TEMP) {
if ( filterAlarmCounter > 5 ){ /* 5 consecutive to avoid false positive */
trigger_alarm();
}
else {
filterAlarmCounter++;
}
}
else {
shutoff_alarm();
filterAlarmCounter = 0;
}
/* Update Measurement to Display at 2Hz */
if (updateMeasureForDisplayTimer >= UPDATE_MEASURE_PERIOD) {
updateMeasureForDisplayTimer = 0; /* reset the displayTimer tick */
displayTemp = temp;
displayTemp = floor(10 * displayTemp) / 10; /* truncate to 1 decimal without rounding */
/* LCD DISPLAY */
SetAdress(64); /* go to line 2 of LCD */
sprintf(tempToLCD, " %.1f", displayTemp); /* convert the float to a string and formats it */
LCD_WriteString(tempToLCD); /* print value to the LCD display */
/* LCD DISPLAY END */
}
}
}
/* here display runs at DISPLAY_7_SEGMENT_PERIOD speed, but displayTemp gets updated at 2Hz */
if(display7segTimer >= DISPLAY_7_SEGMENT_PERIOD) {
display7segTimer = 0;
display(displayTemp); /* display on 7-segment display */
}
}
}
/* USER CODE BEGIN 4 */
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{
ConvertedValue = HAL_ADC_GetValue(&hadc_bsp1);
trace_printf("%04d\n\r",ConvertedValue);
HAL_Delay(500);
}
uint16_t adc_read(analogin_t *obj)
{
ADC_ChannelConfTypeDef sConfig = {0};
// Configure ADC channel
switch (obj->channel) {
case 0:
sConfig.Channel = ADC_CHANNEL_0;
break;
case 1:
sConfig.Channel = ADC_CHANNEL_1;
break;
case 2:
sConfig.Channel = ADC_CHANNEL_2;
break;
case 3:
sConfig.Channel = ADC_CHANNEL_3;
break;
case 4:
sConfig.Channel = ADC_CHANNEL_4;
break;
case 5:
sConfig.Channel = ADC_CHANNEL_5;
break;
case 6:
sConfig.Channel = ADC_CHANNEL_6;
break;
case 7:
sConfig.Channel = ADC_CHANNEL_7;
break;
case 8:
sConfig.Channel = ADC_CHANNEL_8;
break;
case 9:
sConfig.Channel = ADC_CHANNEL_9;
break;
case 10:
sConfig.Channel = ADC_CHANNEL_10;
break;
case 11:
sConfig.Channel = ADC_CHANNEL_11;
break;
case 12:
sConfig.Channel = ADC_CHANNEL_12;
break;
case 13:
sConfig.Channel = ADC_CHANNEL_13;
break;
case 14:
sConfig.Channel = ADC_CHANNEL_14;
break;
case 15:
sConfig.Channel = ADC_CHANNEL_15;
break;
case 16:
sConfig.Channel = ADC_CHANNEL_TEMPSENSOR;
break;
case 17:
sConfig.Channel = ADC_CHANNEL_VREFINT;
break;
case 18:
sConfig.Channel = ADC_CHANNEL_18;
break;
case 19:
sConfig.Channel = ADC_CHANNEL_19;
break;
case 20:
sConfig.Channel = ADC_CHANNEL_20;
break;
case 21:
sConfig.Channel = ADC_CHANNEL_21;
break;
case 22:
sConfig.Channel = ADC_CHANNEL_22;
break;
case 23:
sConfig.Channel = ADC_CHANNEL_23;
break;
case 24:
sConfig.Channel = ADC_CHANNEL_24;
break;
case 25:
sConfig.Channel = ADC_CHANNEL_25;
break;
case 26:
sConfig.Channel = ADC_CHANNEL_26;
break;
#ifdef ADC_CHANNEL_27
case 27:
sConfig.Channel = ADC_CHANNEL_27;
break;
#endif
#ifdef ADC_CHANNEL_28
case 28:
sConfig.Channel = ADC_CHANNEL_28;
break;
#endif
#ifdef ADC_CHANNEL_29
case 29:
sConfig.Channel = ADC_CHANNEL_29;
break;
#endif
#ifdef ADC_CHANNEL_30
case 30:
sConfig.Channel = ADC_CHANNEL_30;
break;
#endif
#ifdef ADC_CHANNEL_31
case 31:
sConfig.Channel = ADC_CHANNEL_31;
break;
#endif
default:
return 0;
}
sConfig.Rank = ADC_REGULAR_RANK_1;
sConfig.SamplingTime = ADC_SAMPLETIME_16CYCLES;
HAL_ADC_ConfigChannel(&obj->handle, &sConfig);
HAL_ADC_Start(&obj->handle); // Start conversion
// Wait end of conversion and get value
if (HAL_ADC_PollForConversion(&obj->handle, 10) == HAL_OK) {
return (uint16_t)HAL_ADC_GetValue(&obj->handle);
} else {
return 0;
}
}
uint16_t adc_read(analogin_t *obj)
{
ADC_ChannelConfTypeDef sConfig = {0};
// Configure ADC channel
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_15CYCLES;
sConfig.Offset = 0;
switch (obj->channel) {
case 0:
sConfig.Channel = ADC_CHANNEL_0;
break;
case 1:
sConfig.Channel = ADC_CHANNEL_1;
break;
case 2:
sConfig.Channel = ADC_CHANNEL_2;
break;
case 3:
sConfig.Channel = ADC_CHANNEL_3;
break;
case 4:
sConfig.Channel = ADC_CHANNEL_4;
break;
case 5:
sConfig.Channel = ADC_CHANNEL_5;
break;
case 6:
sConfig.Channel = ADC_CHANNEL_6;
break;
case 7:
sConfig.Channel = ADC_CHANNEL_7;
break;
case 8:
sConfig.Channel = ADC_CHANNEL_8;
break;
case 9:
sConfig.Channel = ADC_CHANNEL_9;
break;
case 10:
sConfig.Channel = ADC_CHANNEL_10;
break;
case 11:
sConfig.Channel = ADC_CHANNEL_11;
break;
case 12:
sConfig.Channel = ADC_CHANNEL_12;
break;
case 13:
sConfig.Channel = ADC_CHANNEL_13;
break;
case 14:
sConfig.Channel = ADC_CHANNEL_14;
break;
case 15:
sConfig.Channel = ADC_CHANNEL_15;
break;
case 16:
sConfig.Channel = ADC_CHANNEL_TEMPSENSOR;
break;
case 17:
sConfig.Channel = ADC_CHANNEL_VREFINT;
/* From experiment, measurement needs max sampling time to be valid */
sConfig.SamplingTime = ADC_SAMPLETIME_480CYCLES;
break;
case 18:
sConfig.Channel = ADC_CHANNEL_VBAT;
/* From experiment, measurement needs max sampling time to be valid */
sConfig.SamplingTime = ADC_SAMPLETIME_480CYCLES;
break;
default:
return 0;
}
// Measuring VBAT sets the ADC_CCR_VBATE bit in ADC->CCR, and there is not
// possibility with the ST HAL driver to clear it. If it isn't cleared,
// VBAT remains connected to the ADC channel in preference to temperature,
// so VBAT readings are returned in place of temperature.
ADC->CCR &= ~(ADC_CCR_VBATE | ADC_CCR_TSVREFE);
HAL_ADC_ConfigChannel(&obj->handle, &sConfig);
HAL_ADC_Start(&obj->handle); // Start conversion
// Wait end of conversion and get value
if (HAL_ADC_PollForConversion(&obj->handle, 10) == HAL_OK) {
return (uint16_t)HAL_ADC_GetValue(&obj->handle);
} else {
return 0;
}
}
uint16_t BSP_ADC_GetValue(void){
HAL_ADC_Start(&ADC_HandleStruct);
return HAL_ADC_GetValue(&ADC_HandleStruct);
}
/**
* @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 Conversion complete callback in non blocking mode
* @param hadc : hadc handle
* @note This example shows a simple way to report end of conversion, and
* you can add your own implementation.
* @retval None
*/
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc)
{
aADCDualConversionDone = 1;
aADCDualConversionValue = HAL_ADC_GetValue(hadc);
}
/**
* @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);
}
}
}
uint16_t adc_read(analogin_t *obj)
{
ADC_ChannelConfTypeDef sConfig = {0};
// Configure ADC channel
sConfig.Rank = ADC_RANK_CHANNEL_NUMBER;
switch (obj->channel) {
case 0:
sConfig.Channel = ADC_CHANNEL_0;
break;
case 1:
sConfig.Channel = ADC_CHANNEL_1;
break;
case 2:
sConfig.Channel = ADC_CHANNEL_2;
break;
case 3:
sConfig.Channel = ADC_CHANNEL_3;
break;
case 4:
sConfig.Channel = ADC_CHANNEL_4;
break;
case 5:
sConfig.Channel = ADC_CHANNEL_5;
break;
case 6:
sConfig.Channel = ADC_CHANNEL_6;
break;
case 7:
sConfig.Channel = ADC_CHANNEL_7;
break;
case 8:
sConfig.Channel = ADC_CHANNEL_8;
break;
case 9:
sConfig.Channel = ADC_CHANNEL_9;
break;
case 10:
sConfig.Channel = ADC_CHANNEL_10;
break;
case 11:
sConfig.Channel = ADC_CHANNEL_11;
break;
case 12:
sConfig.Channel = ADC_CHANNEL_12;
break;
case 13:
sConfig.Channel = ADC_CHANNEL_13;
break;
case 14:
sConfig.Channel = ADC_CHANNEL_14;
break;
case 15:
sConfig.Channel = ADC_CHANNEL_15;
break;
#ifdef ADC_CHANNEL_VLCD
case 16:
sConfig.Channel = ADC_CHANNEL_VLCD;
break;
#endif
case 17:
sConfig.Channel = ADC_CHANNEL_VREFINT;
break;
case 18:
sConfig.Channel = ADC_CHANNEL_TEMPSENSOR;
break;
default:
return 0;
}
/* Reset ADC channel selection register */
ADC1->CHSELR = 0;
HAL_ADC_ConfigChannel(&obj->handle, &sConfig);
HAL_ADC_Start(&obj->handle); // Start conversion
// Wait end of conversion and get value
if (HAL_ADC_PollForConversion(&obj->handle, 10) == HAL_OK) {
return (uint16_t)HAL_ADC_GetValue(&obj->handle);
} else {
return 0;
}
}
uint32_t Syringe_Size(void)
{
uint32_t adc_value;
uint32_t adc_valuetest=0;
ADC_Config();
if (HAL_ADCEx_Calibration_Start(&AdcHandle) != HAL_OK)
{
/* Calibration Error */
Error_Handler();
}
#if defined(ADC_TRIGGER_FROM_TIMER)
/* Configure the TIM peripheral */
TIM_Config();
#endif /* ADC_TRIGGER_FROM_TIMER */
/*## Enable peripherals ####################################################*/
#if defined(ADC_TRIGGER_FROM_TIMER)
/* Timer enable */
if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
{
/* Counter Enable Error */
Error_Handler();
}
#endif /* ADC_TRIGGER_FROM_TIMER */
/* Note: This example, on some other STM32 boards, is performing */
/* DAC signal generation here. */
/* On STM32F103RB-Nucleo, the device has no DAC available, */
/* therefore analog signal must be supplied externally. */
/*## Start ADC conversions #################################################*/
/* Start ADC conversion on regular group with transfer by DMA */
// if (HAL_ADC_Start_DMA(&AdcHandle,
// (uint32_t *)aADCxConvertedValues,
// ADCCONVERTEDVALUES_BUFFER_SIZE
// ) != HAL_OK)
// {
// /* Start Error */
// Error_Handler();
// }
if (HAL_ADC_Start(&AdcHandle) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
if (HAL_ADC_PollForConversion(&AdcHandle,10) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
adc_value= HAL_ADC_GetValue(&AdcHandle);
if(adc_value<=0x400) return(10);
else if(adc_value>0x400 && adc_value<=0x800) return(20);
else if(adc_value>0x800 && adc_value<=0xc00) return(30);
else if(adc_value>0xc00)
return(50);
}
int main(void)
{
uint32_t v_sense;
float tempinvolts, temperature;
int counter = 0;
HAL_StatusTypeDef rc;
KalmanState kstate = {0.01, 0.3, 0.0, 0.1, 0.0};
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize the ADC and GPIO and LCD display */
initialize_ADC();
initialize_GPIO();
initialize_LCD();
/* then call start */
if (HAL_ADC_Start(&ADC1_handle) != HAL_OK)
Error_Handler(ADC_INIT_FAIL);
while (1) {
if (SYSTICK_READ_TEMP_FLAG == 1) {
if ((rc = HAL_ADC_PollForConversion(&ADC1_handle, 10000)) != HAL_OK)
printf("Error: %d\n", rc);
v_sense = HAL_ADC_GetValue(&ADC1_handle); /* Read register from the ADC */
tempinvolts = v_sense * (V_REF / 4096); /* Scale the reading into V (resolution is 12bits with VREF+ = 3.3V) */
temperature = (tempinvolts - V_25) / AVG_SLOPE + TEMP_REF + FUDGE_FACTOR; /* Formula for temperature from doc_05 p.230 */
/* Grind through the Kalman filter */
if (Kalmanfilter_asm(&temperature, &filtered_temp, 1, &kstate) != 0)
printf("Overflow error\n");
unfiltered_temp = temperature;
// printf("%d %f\n", counter, filtered_temp);
/* Display only once out of this many times the 7-segment display */
if (counter % SEGMENT_DISPLAY_PERIOD == 0) {
displayed_segment_value = filtered_temp;
display_LCD_num(filtered_temp);
}
if (ALARM_TRIGGERED_FLAG == 1) {
/* Avoid spurious noise by waiting for a lower threshold before turning off alarm */
if (filtered_temp < LOWER_THRESHOLD_TEMP) {
ALARM_TRIGGERED_FLAG = 0;
turn_off_LEDs();
}
} else {
if (filtered_temp > THRESHOLD_TEMP)
ALARM_TRIGGERED_FLAG = 1;
}
if (ALARM_TRIGGERED_FLAG == 1) {
if (counter % ALARM_LED_TOGGLE_PERIOD == 0)
toggle_LEDs();
}
printf("%f, %f\n", unfiltered_temp, filtered_temp);
++counter;
SYSTICK_READ_TEMP_FLAG = 0; /* Reset the flag */
}
/* Systick_Handler triggers the flag once every 50ms */
if (SYSTICK_DISPLAY_SEGMENT_FLAG == 1) {
display_segment_val();
SYSTICK_DISPLAY_SEGMENT_FLAG = 0;
}
}
}
/**
* @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 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)
{
}
}
/**
* The on chip temperature.
*
* This is horrible as TEMPERATURE_external() must be called first
*/
int16_t TEMPERATURE_cpu() {
HAL_ADC_PollForConversion(&hadc, 100);
uint32_t val = HAL_ADC_GetValue(&hadc);
return ComputeTemperature(val);
}
/**
* @brief Conversion complete callback in non blocking mode
* @param AdcHandle : AdcHandle handle
* @note This example shows a simple way to report end of conversion, and
* you can add your own implementation.
* @retval None
*/
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* AdcHandle)
{
/* Get the converted value of regular channel */
uhADCxConvertedRegValue = HAL_ADC_GetValue(AdcHandle);
}
uint16_t adc_read(analogin_t *obj)
{
ADC_ChannelConfTypeDef sConfig = {0};
// Configure ADC channel
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_15CYCLES;
sConfig.Offset = 0;
switch (obj->channel) {
case 0:
sConfig.Channel = ADC_CHANNEL_0;
break;
case 1:
sConfig.Channel = ADC_CHANNEL_1;
break;
case 2:
sConfig.Channel = ADC_CHANNEL_2;
break;
case 3:
sConfig.Channel = ADC_CHANNEL_3;
break;
case 4:
sConfig.Channel = ADC_CHANNEL_4;
break;
case 5:
sConfig.Channel = ADC_CHANNEL_5;
break;
case 6:
sConfig.Channel = ADC_CHANNEL_6;
break;
case 7:
sConfig.Channel = ADC_CHANNEL_7;
break;
case 8:
sConfig.Channel = ADC_CHANNEL_8;
break;
case 9:
sConfig.Channel = ADC_CHANNEL_9;
break;
case 10:
sConfig.Channel = ADC_CHANNEL_10;
break;
case 11:
sConfig.Channel = ADC_CHANNEL_11;
break;
case 12:
sConfig.Channel = ADC_CHANNEL_12;
break;
case 13:
sConfig.Channel = ADC_CHANNEL_13;
break;
case 14:
sConfig.Channel = ADC_CHANNEL_14;
break;
case 15:
sConfig.Channel = ADC_CHANNEL_15;
break;
case 16:
sConfig.Channel = ADC_CHANNEL_TEMPSENSOR;
break;
case 17:
sConfig.Channel = ADC_CHANNEL_VREFINT;
break;
case 18:
sConfig.Channel = ADC_CHANNEL_VBAT;
break;
default:
return 0;
}
HAL_ADC_ConfigChannel(&obj->handle, &sConfig);
HAL_ADC_Start(&obj->handle); // Start conversion
// Wait end of conversion and get value
if (HAL_ADC_PollForConversion(&obj->handle, 10) == HAL_OK) {
return (uint16_t)HAL_ADC_GetValue(&obj->handle);
} 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;
}
