Precision Analog Measurement

Introduction

One of my proudest engineering achievements was being involved with the ESA Plato mission. We designed the electronics and FPGAs that control the thermal base for the camera system. As you can imagine, such a system needs incredible stability and accuracy in its temperature measurements.

All of this was implemented using a simple analog ration metric approach and a lot of design analysis and component selection to ensure sources of inaccuracy were removed.

The approach used is one that I have seen used in a range of applications when it comes to measuring accurately using ADCs.

The approach is to perform a ratiometric measurement, which enables us to compensate for changes in voltage references, ADC Changes, bias currents, trace resistances, and thermocouple junctions.

This might sound like a complicated solution, however we will be able to implement the solution using the XADC, a simple DAC for the reference and precision resistors plus the temperature sensor such as a Thermistor.

Ratiometric design

If you are not familiar with ratiometirc measurement, it is a technique used to improve the accuracy and stability of analog sensor readings. We do this by removing the impacts of fluctuations in supply voltage or current. This approach also has the benefit of removing other sources of error from fluctuations such as ADC gain.

We do this by instead of taking one measurement of the voltage level. We measure two proportional signals and use the ratio between the determine the actual value. We are still measuring voltages across devices (e.g. thermistors, resistors).

However, by using the ratio of these two measurements, the measurement becomes independent of the actual value of the excitation, as any variation cancels out. This method is particularly powerful in precision systems where the excitation source may drift or where absolute calibration is difficult, such as in temperature sensing, strain measurement, or bridge circuits. When combined with differential sensing and stable component matching, ratiometric measurement enables highly accurate and repeatable resistance-based reading.

For this example, we are going to be using a thermistor, as the device we wish to measure so we can determine the temperature.

The best way to drive a ratiometric system is to use a constant current, as such I will be using a DAC and a resistor to create the current.

To do this accurately, we need to ensure the 1K resistor is a precision resistor with a small tolerance and very stable across temperature.

Using Drive A and Drive B enables me to be able to drive the measurements in both directions. Initially we can set Drive A to be positive and Drive B as the ground. The measurements of the thermistor and reference resistor can be taken.

The drive can then be reversed so the current flows in the opposite direction. The measurements can then be taken again with the current flowing in the opposite direction.

This allows the removal of noise as we can determine the average from the positive and negative current flows.

We can then use the ratiometric approach to determine the thermistor measurement.

In our project, we are going to use the PmodDA4 to provide the reference current, while two channels of the XADC are going to be used to perform the measurements.

Note that we need to use a board that enables a differential measurement, not one that is configured for unipolar measurements only.

Let’s take a little more in depth look at the analog design.

Analogue Design

This design uses a differential, ratiometric analogue front-end to measure temperature with a 10kΩ NTC thermistor and a 1kΩ precision reference resistor. A constant 0.5 V excitation is applied across a resistor network, resulting in a stable current of approximately 32.5 µA. The current flows through the thermistor and reference resistor in series, with 2.2kΩ current-limiting resistors on each side.

Voltage drops are measured using the XADC's differential inputs:

• VAUX0 measures the voltage across the thermistor
• VAUX8 measures the voltage across the reference resistor

Because both the thermistor and the reference resistor are driven by the same current, the system uses a ratiometric formula to calculate resistance:

R_therm = R_ref × (V_therm / V_ref)

This approach cancels out variations in supply voltage and current source, improving accuracy.

The design is optimized for low power, low noise, and works reliably in the 0 °C to ~100 °C range. Below 0 °C, the thermistor resistance becomes too large, and the voltage across it may exceed the 1.0 V input limit of the XADC, causing clipping. These conditions can be detected and flagged in software.

Operating Range:

• Excitation Voltage: 0.5 V
• Constant Current: ~32.5 µA
• Thermistor Type: 10kΩ NTC, B = 3950
• Reference Resistor: 1kΩ ±0.1%
• Safe Temperature Range: 0 °C to 100 °C
• Measurement Method: Differential, ratiometric via XADC
• ADC Input Range: -0.5 to 0.5V

This analog front-end provides an efficient and accurate method for measuring temperature using standard AMD XADC hardware.

Using a differential current drive—where current flows between two controlled drive points (such as Drive A and Drive B)—offers several advantages for precision analog sensing applications, especially when measuring resistive sensors like thermistors.

• Improved Noise RejectionDifferential drive helps minimize the impact of power supply noise and other common-mode signals. Since both sides of the analogue front-end move relative to each other rather than ground, the ADC is less sensitive to external interference and system-level noise.
• Balanced Signal PathThe current flows symmetrically through the thermistor and reference resistor. This balanced path reduces errors caused by mismatched trace resistances, voltage drops across ground planes, or connector imperfections.
• Support for Bipolar ExcitationBy alternating the direction of the current (e.g., swapping Drive A and Drive B), you can reverse the current flow through the sensors. This enables you to cancel out offsets in the ADC, amplifiers, and even thermoelectric effects by measuring both polarities and averaging.
• Cleaner Differential Voltage MeasurementWith a symmetric current path, voltage drops across both the thermistor and reference resistor naturally stay within a safe and narrow voltage range (e.g., 0–1 V), making them ideal for differential ADC inputs.
• Ratiometric AccuracySince the same current flows through both the thermistor and the reference resistor, the ratio of their voltage drops is directly proportional to their resistance ratio. This means you can accurately calculate the thermistor’s resistance without knowing the exact current value.
• Better Thermal and Layout StabilityA symmetric, differential layout reduces sensitivity to local heating and environmental changes, making the system more stable over time and temperature

Let’s get started with this by creating the AMD Vivado™ Design Tool project.

Hardware Design

Create a new project.

Name the project and location.

Select the ZedBoard.

Once the project is open, create a new block diagram.

Add a processing system to the block diagram.

Once the processing system is added, run the block automation to configure the PS for the ZedBoard.

The resultant image should be similar to the one below.

Make sure you have installed the Digilent Vivado library available here.

In block diagram, add in the Pmod bridge as the PmodDA4 is not supported in the library.

Configure the Pmod bridge to be connected to Pmod JA.

Select the top row as SPI and disable the bottom row.

Re-customize the processing system to enable the SPI0 and ensure it is routed to the EMIO.

Add in a XADC wizard and configure as below, to show the channel sequencer running from start up.

Disable all the alarms as we will not be using them in this project.

Enable the channel VAUX0 and VAUX8.

Run the connection automation.

Make VAux0 and VAux8 external.

The resultant block diagram should look as below.

Software Design

The application software running on the processing system is going to control the current direction, make the necessary measurements and calculate the end value and temperature.

This has some interesting aspects as we need to configure and control the Pmod DA4 DAC and make sure we correctly handle the conversions from the XADC when negative.

The Pmod DA4 contains an octal AD5628 which has 12-bit resolution. We can configure and control this over the SPI interface.

To use the DAC we need to do the following:

• Initialize the PS SPI into the correct mode.
• Initialize the DAC in this case we will use the internal reference and power up the DAC.
• Calculate the code which will give a 0.5V excitation voltage into the network

Within AMD Vitis™ Software Platform, we will use several different functions to do this.

void DemoInitialize()
{
XSpiPs_Config *SpiConfig_MIO;
int Status;
SpiConfig_MIO = XSpiPs_LookupConfig(SPI_MIO);
Status = XSpiPs_CfgInitialize(&SpiInstance_MIO, SpiConfig_MIO,SpiConfig_MIO->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
XSpiPs_SetOptions(&SpiInstance_MIO, XSPIPS_MASTER_OPTION | XSPIPS_CLK_PHASE_1_OPTION);
XSpiPs_SetClkPrescaler(&SpiInstance_MIO, XSPIPS_CLK_PRESCALE_128);
//internal reference
op_buff[0] = 0x10;
op_buff[1] = 0x00;
op_buff[2] = 0x00;
op_buff[3] = 0x01;
XSpiPs_PolledTransfer(&SpiInstance_MIO, op_buff, NULL,4);
//power up
op_buff[0] = 0x08;
op_buff[1] = 0x00;
op_buff[2] = 0x00;
op_buff[3] = 0xff;
XSpiPs_PolledTransfer(&SpiInstance_MIO, op_buff, NULL,4);
}

The application will use DACA and DACH as the outputs, alternating them between 0.5V and 0V.

void Posdirection()
{
//u16 an[4],
u16 conv;
u8 buf[2] = {0,0};
double val;
u16 count;
op_buff[0] = 0x03; //write to and update register n - in this case DAC A
op_buff[3] = 0x00;
count = (1638/2);
op_buff[1] = 0xff & count >>8;
op_buff[1] = 0x00 | op_buff[1]; //dac a address
op_buff[2] = (u8) count;
XSpiPs_PolledTransfer(&SpiInstance_MIO, op_buff, NULL,4);
op_buff[0] = 0x03; //write to and update register n - in this case DAC H
op_buff[3] = 0x00;
count = (0);
op_buff[1] = 0xff & count >>8;
op_buff[1] = 0x70 | op_buff[1]; //write to and update register n - in this case DAC H
op_buff[2] = (u8) count;
XSpiPs_PolledTransfer(&SpiInstance_MIO, op_buff, NULL,4);
}

While the neg direction flips them around, I could have written a combine function but wanted to keep them separate for clarity.

void negdirection()
{
//u16 an[4],
u16 conv;
u8 buf[2] = {0,0};
double val;
u16 count;
op_buff[0] = 0x03; //write to and update register n - in this case DAC A
op_buff[3] = 0x00;
count = (0);
op_buff[1] = 0xff & count >>8;
op_buff[1] = 0x00 | op_buff[1]; //dac a address
op_buff[2] = (u8) count;
XSpiPs_PolledTransfer(&SpiInstance_MIO, op_buff, NULL,4);
op_buff[0] = 0x03; //write to and update register n - in this case DAC H
op_buff[3] = 0x00;
count = (1638/2);
op_buff[1] = 0xff & count >>8;
op_buff[1] = 0x70 | op_buff[1]; //write to and update register n - in this case DAC H
op_buff[2] = (u8) count;
XSpiPs_PolledTransfer(&SpiInstance_MIO, op_buff, NULL,4);
}

The next step is to be able to make sure the negative raw values are handled correctly as the bipolar inputs on the XADC have a range of -0.5 to 0.5v.

float ConvertXADC_BipolarVoltage(u16 raw)
{
// Treat raw as signed 16-bit value (it's already aligned)
s16 signed_raw = (s16)raw;
// Convert to ±0.5V range (2048 codes for ±0.5V, scaled left by 4 bits)
return ((float)signed_raw / 16384.0f) * 0.5f;
}

The next element is to read the XADC values back from the XADC, this can read channels Vaux 0 and 8.

float ReadXADC_VAUX(unsigned int channel)
{
u16 raw;
float voltage;
// Wait for ADC to settle (optional, but recommended)
for (int i = 0; i < 10; i++) {
raw = XSysMon_GetAdcData(&SysMonInst, channel);
}
voltage = ConvertXADC_BipolarVoltage(raw);//XSysMon_RawToVoltage(raw);
return voltage;
}

There are then two functions to convert the readings into a Resistance and Temperature.

float CalculateThermistorResistance(float v_therm, float v_ref, float r_ref)
{
if (v_ref <= 0.001f)  // Avoid divide-by-zero
{
return -1.0f;  // Error flag or out-of-range
}
return r_ref * (v_therm / v_ref);
}
float ThermistorResistanceToTemperature(float r_therm)
{
// Thermistor parameters (customize if needed)
const float R0 = 10000.0f;     // Resistance at T0 (25°C)
const float B  = 3950.0f;      // Beta constant
const float T0 = 298.15f;      // T0 = 25°C in Kelvin
if (r_therm <= 0.0f) {
return -273.15f;  // Invalid resistance → absolute zero as error code
}
// Apply the Beta equation
float inv_T = (1.0f / T0) + (1.0f / B) * logf(r_therm / R0);
float T_kelvin = 1.0f / inv_T;
float T_celsius = T_kelvin - 273.15f;
return T_celsius;
}

The final element is the main process which sequences the testing performs some of the calculations.

int main()
{
init_platform();
print("Hello World\n\r");
print("Successfully ran Hello World application");
int status;
// Initialize the XADC
status = XSysMon_CfgInitialize(&SysMonInst,
XSysMon_LookupConfig(XPAR_XADC_WIZ_0_BASEADDR),
XPAR_XADC_WIZ_0_BASEADDR);
if (status != XST_SUCCESS) {
printf("XADC initialization failed!\n");
return -1;
}
// Enable sequencer for just VAUX0 and VAUX8
XSysMon_SetSequencerMode(&SysMonInst, XSM_SEQ_MODE_SAFE);
XSysMon_SetSeqChEnables(&SysMonInst, XSM_SEQ_CH_AUX00 | XSM_SEQ_CH_AUX08);
XSysMon_SetSequencerMode(&SysMonInst, XSM_SEQ_MODE_CONTINPASS);
DemoInitialize();
Posdirection();
while (1)
{
Posdirection();
usleep(1000000);
float v_therm_p = ReadXADC_VAUX(XSM_CH_AUX_MIN + 8);  // VAUX0
float v_ref_p   = ReadXADC_VAUX(XSM_CH_AUX_MIN + 0);  // VAUX8
// printf("Thermistor Voltage Pos (VAUX0): %.3f V\n", v_therm_p);
// printf("Reference Voltage Pos  (VAUX8): %.3f V\n", v_ref_p);
usleep(1000000);
negdirection();
usleep(1000000);
float v_therm_n = ReadXADC_VAUX(XSM_CH_AUX_MIN + 8);  // VAUX0
float v_ref_n   = ReadXADC_VAUX(XSM_CH_AUX_MIN + 0);  // VAUX8
float vref = (v_ref_p - v_ref_n) / 2;
float vtherm = (v_therm_p - v_therm_n) / 2;
// printf("Thermistor Voltage Neg (VAUX0): %.3f V\n", v_therm_n);
// printf("Reference Voltage Neg (VAUX8): %.3f V\n", v_ref_n);
//printf("Thermistor Voltage Avg (VAUX0): %.3f V\n", vtherm);
// printf("Reference Voltage  Avg (VAUX8): %.3f V\n", vref);
float Rtherm = CalculateThermistorResistance(vtherm,vref, r_ref);
//printf("RTherm: %.3f Ohms\n", Rtherm);
float temp_c = ThermistorResistanceToTemperature(Rtherm);
printf("Temperature: %.2f C\n", temp_c);
usleep(1000000);
}
cleanup_platform();
return 0;
}

Testing

To test this, I lashed up a simple breadboard and connected the thermistor to a large metal heat sink to provide something thermally stable. Sadly, I did not have matched resistors or precision reference resistors in the lab. However, the results were encouraging. I will develop a Pmod which has the correct analogue layout.

However, while the set up was not the best with lots of flying leads, sources of noise, etc., the design worked pretty well and I am sure with a nice custom Pmod design with the correct components its performance would be much better.

The first test was to measure the reference and thermistor voltages.

Once I had the voltages recorded correctly, I needed to then check that the negative voltages were properly reported.

The final stage was to run the experiment and record the temperatures from the thermistor using the ration metric approach.

Wrap Up

This project shows how we are able to develop precision analog solutions using the XADC within the AMD Zynq™ 7000 SoC. We can implement this within any AMD FPGA or SoC which has a XADC or Sysmon.

Future additions would be to implement the algorithm within a logic using RTL or model-based design, for example, as demonstrated in this project.

AMD, and the AMD Arrow logo, Vitis, Vivado, Zynq and combinations thereof are trademarks of Advanced Micro Devices, Inc. Other product names used in this publication are for identification purposes only and may be trademarks of their respective companies.