Making Accurate Thermocouple Measurements with the ITS-90 Standard

Making Accurate Thermocouple Measurements with the ITS-90 Standard

Thermocouples are workhorse sensors for measuring temperature across extreme ranges—from cryogenic cold to red-hot metal. But getting accurate readings from thermocouple sensors can be challenging since their output voltage ranges from milli volts down to sub micro volts. In this tutorial, we’ll discuss how to make accurate thermocouple measurements using the ITS-90 standard and go step by step on how to implement the standard in embedded code.

Overview on what we will cover:

  • The Seebeck effect and how thermocouples generate voltage
  • Why thermocouple signals are tricky: down to sub microvolts, noise, and bipolar voltage level
  • How the ITS-90 standard ensures globally consistent results
  • How to apply Cold Junction Compensation (CJC)
  • How to measure a K-type thermocouple using Arduino + High Resolution ADC

Thermocouples 101: The Seebeck Effect

When two dissimilar metals are joined, they generate a small EMF or voltage proportional to the temperature between the junction—this is the Seebeck effect. The resulting EMF is small (sub microvolts to tens of millivolts) but predictable, which makes thermocouples excellent for wide-range temperature sensing.

Type Typical Range (°C) Notes
T-Type −200 to +400 Good at low temperatures
J-Type −210 to +1200 General-purpose legacy type
K-Type −200 to +1372 Most common; used in this tutorial
S-Type −50 to +1768 Lab-grade, noble metal

*This chart is based on ranges from NIST's ITS-90 Thermocouple Database - SRD 60

Pros: huge temperature range, rugged, inexpensive.
Cons: modest absolute accuracy (often ±1–2 °C), noise pickup, and the need for cold junction compensation.

ITS-90: A Universal Temperature Scale

ITS-90 (International Temperature Scale of 1990) defines traceable relationships that convert thermocouple voltage to temperature. National labs (such as NIST in the US) provide datasets and polynomial coefficients so thermocouple temperature measurements are consistent worldwide. The ITS-90 provides two different methods for converting thermocouple output voltages to temperature readings:

  1. Lookup Tables — direct EMF-to-temperature lookup values for whole integer degrees. Simple but memory-heavy; interpolation required for fractions.
  2. Polynomials — based on polynomial calculations and defined coefficients per range. This method requires less memory and is great for microcontroller based designs

In this tutorial we will look at an example using the Polynomials approach.

Accuracy note: The ITS-90 polynomial method itself contributes roughly ≤0.2% intrinsic error. Your total error budget must also include the probe’s tolerance, ADC circuit accuracy/noise, wiring, and cold junction sensor error (covered later).

Why Thermocouples Are Tricky to Measure

  • Tiny signals: sub microvolts to millivolts require high-resolution, low-noise measurement.
    • Requires high resolution ADC (18 bit or higher) with high gain precision amplifier, like an instrumentation amplifier.
    • Select an amplifier IC with a built-in gain or programmable gain to avoid hard to quantify error caused by external resistor gain networks
    • For better accuracy calibrate the ADC + amplifier measurement to eliminate offset and gain error. Click here to access Anabit's tutorial on doing a two point calibration on an ADC circuit. 
  • Bipolar voltage: readings can be positive or negative depending on the reference junction temperature.
    • Requires a positive and negative supply to your ADC circuit to handle negative voltage thermocouple measurements
    • Another approach would be to add DC bias to ensure signal is positive, but bias voltage adds additional error factor to your measurement
  • Noise pickup: long thermocouple sensor leads act like antennas; leading to RF interference. Also be aware of 50/60 Hz ripple from AC / DC power supplies as well as noise from DC to DC converters. 
    • Use hardware and digital filtering tuned to the noise sources internal and external to your thermocouple measurement circuit.
  • Extra junctions: metal terminals/solder joints where the thermocouple sensors connect introduce unintended thermoelectric voltages via the Seebeck effect.
    • Requires cold junction compensation (covered next)

Cold Junction Compensation (CJC)

The thermocouple’s “cold junction” is where the probe wires meet your board’s connection point, which is some type of metal, leading to additional unwanted Seebeck effect voltage in your measurement. Historically, labs fixed this junction at 0 °C in an ice bath. This created a known temperature condition at the unwanted (but unavoidable) additional metal junction. In thermocouple measurement circuits, we use an additional temperature sensor to measure the board temperature at or near the connector and use ITS-90 polynomials to convert that temperature to an equivalent voltage, then combine it with the thermocouple voltage to get the true hot-junction temperature. This is demonstrated in the step by step thermocouple measurement process covered next in this tutorial. For this additional temperature sensor it is critical that its measurement is not skewed by circuits causing local heating around the sensor, such as a linear regulator circuit. The temperature reading from the sensor needs to represent the exact temperature at the point where the thermocouple sensor connects to the board for accurate thermocouple readings. 

Implementing the ITS-90 Standard in Embedded Code

As mentioned earlier, this tutorial will cover how to use the ITS-90 standard in embedded code using the polynomial method. We will use the K-Type Thermocouple polynomials and constants from NIST's ITS-90 Thermocouple Database for our example. We will implement the polynomials using the Arduino programming environment which is based on the C and C++ languages. There are links at the end of this tutorial to the NIST database and to this example code on Github.

Here is the NIST polynomials implemented in code using Horner's Method which is a microcontroller friendly way to compute polynomials (for more information on Horner's Method see link at the end). This function can be used to convert EMF to temperature and temperature to EMF (needed for cold junction compensation). 

/*
 *  _poly  —  Evaluate a polynomial using Horner’s rule
 *
 *  @param c  Pointer to coefficient array (c[0] is the constant term)
 *  @param n  Number of coefficients in the array
 *  @param x  Argument value
 *  @return   Polynomial value  Σ c[i]·xⁱ  for i = 0 … n−1
 */
double KTypeTC::_poly(const double *c, size_t n, double x)
{
    double y = c[n - 1];
    for (int i = static_cast<int>(n) - 2; i >= 0; --i)
        y = y * x + c[i];
    return y;
}

The function's "x" argument is for the measured voltage or temperature and "c" is from a table of constants provided by the NIST database that is saved in the code as constant arrays. Below is a screen shot of the NIST constants for the temperature range of 0 C to 270 C:

Once we have the polynomial function and the constants stored as arrays in our code we need functions to convert voltage to temperature (thermocouple sensor) and to convert temperature to voltage (cold junction compensation sensor):

/*
 *  _emfToTemp  —  Convert thermoelectric EMF (mV) ➜ temperature (°C)
 *                 Using inverse ITS-90 polynomials (piecewise)
 *
 *  Valid range:  −5.891 mV … +54.886 mV  (≈ −200 °C … +1372 °C)
 *  @return  NAN if input is outside the range.
 */
double KTypeTC::_emfToTemp(double mv)
{
    if (mv < -5.891 || mv > 54.886)
        return NAN;

    if (mv < 0.0)
        return _poly(E2T_A, sizeof(E2T_A) / sizeof(double), mv);

    if (mv <= 20.644)
        return _poly(E2T_B, sizeof(E2T_B) / sizeof(double), mv);

    return _poly(E2T_C, sizeof(E2T_C) / sizeof(double), mv);
}

/*
 *  _tempToEmf  —  Convert temperature (°C) ➜ thermoelectric EMF (mV)
 *                 Using forward ITS-90 polynomials (piecewise)
 *
 *  Valid range:  −270 °C … +1372 °C
 *  @return  NAN if input is outside the range.
 */
double KTypeTC::_tempToEmf(double t)
{
    if (t < -270.0 || t > 1372.0)
        return NAN;

    if (t < 0.0)
        return _poly(T2E_NEG, sizeof(T2E_NEG) / sizeof(double), t);

    return _poly(T2E_POS, sizeof(T2E_POS) / sizeof(double), t);
}



For the first function the input argument is the ADC measured voltage and the function returns the temperature. The second function's input argument comes from the temperature sensor at the junction where the K-Type thermocouple connects to the measurement circuit for cold junction compensation. The function then returns the corresponding voltage. The array variables you see in these functions, such as E2T_A and T2E_POS, are the constant value arrays storing values defined in the NIST database.


The next function ties all the steps to the thermocouple sensor measurement using ITS-90 together. 


    

  1. Concurrently, measure the cold junction reference temperature sensor and the output voltage of the thermocouple sensor
    2. 

  2. Using the _tempToEmf(double t) function, convert the cold junction temperature reading to a K-Type voltage

    3. 

  3. Combine the calculated cold junction temperature voltage with the measured thermocouple voltage
    4. 

  4. Using the _emfToTemp(double mv) function, calculate the temperature measured by the thermocouple sensor
    5. 








/*


 *  temperature  —  Public API


 *                  Calculate hot-junction temperature from:


 *                    • tc_mV      – measured thermocouple voltage (mV)


 *                    • ref_temp_C – reference-junction temperature (°C)


 *  Algorithm:


 *      1. Convert reference temperature to its equivalent EMF.


 *      2. Add that EMF to the measured EMF (cold-junction compensation).


 *      3. Convert the compensated EMF back to temperature.


 *  @return  Hot-junction temperature (°C) or NAN if any input is invalid.


 */



double KTypeTC::temperature(double tc_mV, double ref_temp_C)



{



    const double cj_mV = _tempToEmf(ref_temp_C);   // step 1




    if (isnan(cj_mV))




        return NAN;






    const double total_mV = tc_mV + cj_mV;         // step 2




    return _emfToTemp(total_mV);                   // step 3



}






Seeing the ITS-90 Standard and Example Code in Action


The below video clip shows the example C++ code in action. The setup for the video clip is as follows


    

  • Anabit's open source Precision Logger reference design is used to make the K-Type thermocouple measurement and the junction compensation measurement. It consists of a 32-bit ADC, differential inputs, programmable gain amp, and onboard temperature sensor for CJC
    • 

  • The code is running on an Arduino Nano Every but any Arduino with hardware SPI will work
    • 

  • K-type thermocouple sensor
    • 

  • Reference J-type thermocouple measurement using an off the shelf high accuracy data acquisition unit
    • 

  • Heating source (e.g., a small toaster oven) for a stable rising temperature profile
    • 



First off we want to apologize for the terrible video work, we will do better in the future. When you look at the K-Type thermocouple temperature data printing out to the serial monitor keep in mind that the temperature of the toaster oven (Anabit's reflow oven) is slowly rising. 








Using the ITS-90 standard with a high resolution ADC + amplifier with proper analog design concepts can deliver an accurate temperature measurement with worldwide consistency. Even though the ITS-90 polynomial method itself provides good accuracy, to understand the total accuracy of your measurement be sure to consider all factors, including: probe tolerance, ADC measurement circuit accuracy, and CJC measurement accuracy. If you have any questions or comments from this tutorial be sure to use the Anabit Forum.






Downloads & Resources







        

    
      
        

      
      Back to blog