Analogue inputs: ADCs, sensors and signal conditioning

Many robot sensors produce analogue voltages: potentiometers on joints, current-sense amplifiers in motor drivers, battery voltage dividers, force-sensitive resistors in grippers, infrared distance sensors, thermistors on motors and analogue microphones. The microcontroller's analogue-to-digital converter (ADC) turns these voltages into numbers. Getting a trustworthy number requires understanding what the ADC actually measures, how its resolution and reference set the smallest change it can see, how sampling works and what goes wrong when it is done carelessly, and how to condition the signal with dividers, amplifiers and filters so it arrives at the ADC in a form it can measure accurately.

What an ADC does

An ADC compares an input voltage with a reference voltage and outputs a number proportional to their ratio. An N-bit ADC divides the reference range into 2^N steps. Microcontroller ADCs are commonly 10 or 12 bits, and some reach 16; dedicated external converters offer 16 to 24 bits for precise measurements such as load cells. The size of one step, the least significant bit (LSB), is the smallest change the ADC can distinguish:

A 12-bit ADC with a 3.3 V reference has 4,096 codes and an LSB of about 0.81 mV. Resolution is not accuracy. Real converters add offset error, gain error, non-linearity and noise, so the last bit or two of a microcontroller ADC reading usually flicker, and the effective number of bits, ENOB, may be 9 to 11 rather than 12. The reference itself sets the accuracy ceiling: if the 3.3 V supply used as the reference is really 3.25 V, every reading is 1.5 % off. Precise designs use a dedicated reference chip, or measure ratiometrically, powering a sensor such as a potentiometer from the same voltage that serves as the ADC reference, so supply variations cancel.

def adc_code(vin, vref=3.3, bits=12):
    code = int(vin / vref * 2**bits)
    return max(0, min(code, 2**bits - 1))

def adc_volts(code, vref=3.3, bits=12):
    return code / 2**bits * vref

for bits in (8, 10, 12, 16):
    print(f"{bits:2d}-bit: LSB = {3.3 / 2**bits * 1000:7.3f} mV")

v = 1.2345
c = adc_code(v)
print(f"{v} V -> code {c} -> {adc_volts(c):.4f} V (error {abs(adc_volts(c)-v)*1000:.2f} mV)")
print(f"same code read with a 3.25 V true reference: {adc_volts(c, vref=3.25):.4f} V")

 8-bit: LSB =  12.891 mV
10-bit: LSB =   3.223 mV
12-bit: LSB =   0.806 mV
16-bit: LSB =   0.050 mV
1.2345 V -> code 1532 -> 1.2343 V (error 0.22 mV)
same code read with a 3.25 V true reference: 1.2156 V

Sampling and aliasing

An ADC measures the input at discrete moments, the sampling rate. To represent a signal faithfully, the sampling rate must exceed twice the highest frequency present, the Nyquist criterion. Frequencies above half the sampling rate do not disappear: they fold back and appear as false, lower frequencies in the data, an effect called aliasing. A current-sense signal with 20 kHz PWM ripple sampled at 1 kHz, for example, shows a slow wobble that is not really there, and no amount of software filtering afterwards can tell the alias from a real signal.

The defence is an anti-aliasing filter, a low-pass filter before the ADC that removes content above half the sampling rate. In robots, a simple resistor-capacitor filter is often enough. For motor current, there is a cleverer solution: trigger the ADC from the PWM timer so it samples at the same point in every PWM cycle, typically the middle of the on-time, where the current equals its average. This synchronized sampling is standard in motor controllers and lesson 11 returns to it.

Resistive sensors and dividers

Many sensors change resistance: potentiometers, thermistors, force-sensitive resistors, light-dependent resistors and strain gauges. Placing the sensor in a voltage divider, as in lesson 1, converts resistance to a voltage. A potentiometer used as a joint sensor is already a divider: with its ends across the reference voltage, the wiper voltage is proportional to the angle. For a thermistor, whose resistance falls steeply with temperature, the divider produces a non-linear voltage that software converts with the manufacturer's Beta value or the Steinhart-Hart equation. Choose the fixed resistor near the sensor's resistance in the middle of the range of interest to get the greatest sensitivity there.

import math
R_FIXED, R0, T0, BETA = 10_000, 10_000, 298.15, 3950   # 10k NTC, B = 3950 K

def thermistor_temp(code, bits=12):
    """Thermistor on the bottom of a divider, fixed resistor to Vref."""
    ratio = code / (2**bits - 1)
    r = R_FIXED * ratio / (1 - ratio)
    inv_t = 1 / T0 + math.log(r / R0) / BETA
    return 1 / inv_t - 273.15, r

for code in (3000, 2048, 1200, 700):
    t, r = thermistor_temp(code)
    print(f"code {code:4d}: R = {r/1000:6.2f} kOhm, T = {t:5.1f} C")

code 3000: R =  27.40 kOhm, T =   3.9 C
code 2048: R =  10.00 kOhm, T =  25.0 C
code 1200: R =   4.15 kOhm, T =  46.2 C
code  700: R =   2.06 kOhm, T =  65.3 C

Strain gauges, used in load cells for force and weight, change resistance by only a fraction of a per cent. They are wired in a Wheatstone bridge, two dividers side by side, so the output is the small difference between two voltages, measured by an instrumentation amplifier or a dedicated bridge ADC chip such as the 24-bit converters common on load-cell boards.

Amplifiers and op-amps

Some signals are too small for the ADC to resolve, and some are too large or centred in the wrong place. Operational amplifiers (op-amps) scale and shift them. An op-amp has very high gain and, with feedback resistors, forms amplifiers whose gain is set by the resistor ratio. A non-inverting amplifier has gain 1 + Rf/Rg; a voltage follower, with gain 1, buffers a high-impedance source such as a divider so the ADC's input does not load it. Op-amps for single-supply robot circuits should be rail-to-rail types, whose inputs and outputs can swing close to 0 V and the supply.

Motor current is commonly measured with a small sense resistor, a shunt of a few milliohms, in the current path. The voltage across it is tiny, so a current-sense amplifier, an op-amp circuit integrated with precise gain, amplifies it. Some sense the low side between the load and ground; others, the high side, can measure in the supply line and often both directions. Hall-effect current sensors measure the magnetic field around a conductor instead, giving isolation and no power loss in a resistor, at somewhat lower accuracy.

Filtering

A first-order RC low-pass filter, a series resistor followed by a capacitor to ground, passes slow changes and attenuates fast ones. Its cut-off frequency, where the output has fallen to about 71 % (−3 dB) of the input, is:

Above \( f_c \), the output falls by a factor of ten for each tenfold increase in frequency, 20 dB per decade, which is gentle; steep anti-aliasing needs higher-order active filters, but for robot sensors a single RC stage plus software filtering usually works. The capacitor also helps the ADC directly: many microcontroller ADCs charge a small internal sampling capacitor from the input during a short acquisition time, and a source with high resistance cannot charge it in time, giving low readings. A capacitor of a few nanofarads at the ADC pin, or a buffer amplifier, supplies that charge. Check the datasheet's maximum source impedance for your chosen sampling time.

Software adds further filtering. A moving average of the last N samples reduces random noise by a factor of about the square root of N. An exponential filter, y = y + α(x − y), needs only one stored value and is common in firmware. Oversampling, taking many samples and averaging, can even increase effective resolution when enough noise is present to dither the readings. But every filter adds delay, and delay in a feedback loop reduces stability, so control engineers filter as little as necessary and account for the lag, as ROB-300 explains.

import math, random
random.seed(1)
def rc_cutoff(r, c): return 1 / (2 * math.pi * r * c)
print(f"1 kOhm and 10 nF: fc = {rc_cutoff(1e3, 10e-9)/1000:.1f} kHz")
print(f"10 kOhm and 100 nF: fc = {rc_cutoff(1e4, 100e-9):.0f} Hz")

true_v = 2.000
samples = [true_v + random.gauss(0, 0.010) for _ in range(256)]
alpha, y = 0.1, samples[0]
for x in samples:
    y += alpha * (x - y)
spread = max(samples) - min(samples)
avg16 = sum(samples[-16:]) / 16
print(f"raw spread: {spread*1000:.1f} mV")
print(f"average of 16: {avg16:.4f} V, exponential filter: {y:.4f} V")

1 kOhm and 10 nF: fc = 15.9 kHz
10 kOhm and 100 nF: fc = 159 Hz
raw spread: 55.7 mV
average of 16: 2.0003 V, exponential filter: 2.0023 V