STM32L4's Temperature Calculation Equation shows improper results

Question

While using STM32L4's ADC to measure its internal temperature sensor data, I am facing an issue.

The equation provided in STM32L4's reference manual, seems to showing improper results.

The equation is:

*Temperature = ((110-30) * (TS_DATA - TS_CAL_1) / (TS_CAL_2 - TS_CAL_1)) + 30*

where, TS_DATA = 945 (raw ADC data for temperature), TS_CAL_1 = 1035 (calibration point read from predefined memory address), TS_CAL_2 = 1373 (calibration point read from predefined memory address)

This results in 'Temperature = 8.69' at room temperature (about 26 Celsius), which is clearly incorrect.

My Code for the same is:

#define TS30    ((uint16_t*)((uint32_t)0x1FFF75A8))
#define TS110   ((uint16_t*)((uint32_t)0x1FFF75CA))
uint32_t ADC_Value;
double temperature;
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc){
   ADC_Value = HAL_ADC_GetValue(&hadc1);
   temperature = (double)ADC_Value - (uint32_t)*TS30;
   temperature *= (double)((uint32_t)110 - (uint32_t)30);
   temperature /= (double)(int32_t)((uint32_t)*TS110 - (uint32_t)*TS30);
   temperature += 30;
}
int main(){           /**Main Loop**/
 MX_ADC1_Init();
   HAL_ADCEx_Calibration_Start(&hadc1, ADC_SINGLE_ENDED);
   HAL_ADC_Start_IT(&hadc1);

   while(1) {
     HAL_Delay(400);
     HAL_ADC_Start_IT(&hadc1);
   }
}
static void MX_ADC1_Init(void)
{
  ADC_ChannelConfTypeDef sConfig;
  hadc1.Instance = ADC1;
  hadc1.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
  hadc1.Init.Resolution = ADC_RESOLUTION_12B;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  hadc1.Init.LowPowerAutoWait = DISABLE;
  hadc1.Init.ContinuousConvMode = DISABLE;
  hadc1.Init.NbrOfConversion = 1;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.NbrOfDiscConversion = 1;
  hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  hadc1.Init.DMAContinuousRequests = DISABLE;
  hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED;
  hadc1.Init.OversamplingMode = DISABLE;
  if (HAL_ADC_Init(&hadc1) != HAL_OK){
    _Error_Handler(__FILE__, __LINE__);
  }

  /**Configure Regular Channel**/
  sConfig.Channel = ADC_CHANNEL_TEMPSENSOR;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_640CYCLES_5;
  sConfig.SingleDiff = ADC_SINGLE_ENDED;
  sConfig.OffsetNumber = ADC_OFFSET_NONE;
  sConfig.Offset = 0;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK){
   _Error_Handler(__FILE__, __LINE__);
  }
}

Please review the code and help me.

Answer 1

Please review the code and help me.

Will do; less focus on code style than I'd usually do; more focus on the tech side of things, since we're on a EE platform, not on programmers.stackexchange.com:

$$ {\frac{\text{TS_CAL2_TEMP} – \text{TS_CAL1_TEMP}}{\text{TS_CAL2} – \text{TS_CAL1}}}(\text{TS_DATA} – \text{TS_CAL1})+30\,^°\text{C} $$

Floating Point math

void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc){
   ADC_Value = HAL_ADC_GetValue(&hadc1);
   temperature = (double)ADC_Value - (uint32_t)*TS30;
   temperature *= (double)((uint32_t)110 - (uint32_t)30);
   temperature /= (double)(int32_t)((uint32_t)*TS110 - (uint32_t)*TS30);
   temperature += 30;
}

Oh!

So, first of all: double is totally over the top here. Your processor has a floating point unit, but only for single precision floating point numbers, and you gain absolutely nothing if you calculate this in double precision. It's not like you get 16 significant digits anywhere in this formula.

Anyway, unless you know very well what you're doing, don't use the FPU in an interrupt routine! There's a simple reason to that: FPU status registers usually aren't saved / restored on switching contexts on most platforms (and AFAIK, this applies especially to ARM). So, you're mixing things up. Also, the FPU itself can raise exceptions (e.g. when doing an illegal mathematical operation), and you really don't want nested exceptions here.

Do this in fixed point. There's absolutely no reason to use floating point here.

Don't do the math in the ISR

Then, almost none of this calculation needs to be done in the interrupt routine. Precalculate the factor \$f\$ (i.e. the fraction from the reference manual, p.446) and the added value \$s\$:

\begin{align} T&= \underbrace{\frac{\text{TS_CAL2_TEMP} – \text{TS_CAL1_TEMP}}{\text{TS_CAL2} – \text{TS_CAL1}}}_f(\text{TS_DATA} – \text{TS_CAL1})+30\,^°\text{C}\\ &=f\cdot\text{TS_DATA}+\underbrace{(-f\cdot\text{TS_CAL1} + 30)}_s\\ &=f\cdot\text{TS_DATA}+s \end{align}

So that you only need to do one multiplication and one addition in the ISR.

Doing it in fixed point

Note that your \$f\$ might not be properly representable as integer; but always remember that the choice of measuring temperature in °C is arbitrary; you could just as well multiply \$f\$ and \$s\$ with 1000 and have a value in °mC, which you can convert to °C whenever you actually need to – without losing any accuracy, because your ADC nor your sensor nor the natural noise would nor the observed phenomenon even have about 10 bits of information.

Misc

Also, didn't you forget to register your ADC conversion complete callback?

Answer 2

You need to apply a scaling because your reference voltage is different from the reference voltage when the parts where calibrated.

They use a 3 V reference during calibration, you use a 3.3 V reference.

So the absolute value of the temperature sensor will not change, so the ADC value you get will be smaller than the one they got during calibration.

So your ADC value has to be scaled by a factor of 3.3 V / 3.0 V or 1.1.

If you enter that into the formula (and use the correct calibration temperatures of 130 and 30 °C) you end up with 31 °C. Still a bit off of your 26 °C, but that could be because your electronic is actually warmer, and even with the calibrated values we measured up to 6 K deviation in our tests, so I'd consider that as okayish.

(similar answer with a small code snippet, but there it was 110 and 30 °C)