Arduino Nano Sensor Calibration and Signal Filtering: The Ultimate Guide

Introduction to Arduino Nano Sensor Calibration and Signal Filtering

When building embedded systems with the Arduino Nano, capturing real-world phenomena using analog or digital sensors is only half the battle. Raw data straight from an analog-to-digital converter (ADC) is rarely pristine. It is frequently plagued by electrical noise, power supply ripple, thermal drift, and inherent sensor non-linearities.

To transform raw, jittery integer streams into reliable, actionable measurements, engineers rely on two essential pillars: sensor calibration and signal filtering.

The Arduino Nano, powered by the ATmega328P microcontroller, offers an accessible yet capable platform for these tasks. Operating at 16 MHz with 2KB of SRAM and 32KB of flash memory, the Nano requires lightweight, efficient algorithms. This comprehensive guide explores how to tackle hardware noise, implement professional calibration routines, and deploy advanced digital filtering techniques directly in your embedded code.

Understanding the Arduino Nano Analog-to-Digital Converter (ADC)

Before diving into signal processing, you must understand the hardware handling your inputs. The Arduino Nano features 8 analog input pins (A0 through A7) connected to a 10-bit Successive Approximation Register (SAR) ADC.

A 10-bit ADC maps input voltages ranging from 0V to the reference voltage ($V_{REF}$) into integer values from 0 to 1023 ($2^{10} - 1$). By default, $V_{REF}$ is tied to the Nano's onboard 5V rail.

Common ADC Pitfalls on the Nano

• Voltage Fluctuations: Powering your Nano via USB or an unstable linear regulator introduces high-frequency noise directly into the $V_{REF}$ line, corrupting ADC measurements.
• Input Impedance Mismatch: Sources with high output impedance connected directly to the ADC can cause charging delays on the internal sample-and-hold capacitor, leading to cross-talk or inaccurate readings.
• Quantization Error: With a 5V reference, each step of the 10-bit ADC represents approximately $4.88 \text{ mV}$ ($5000\text{ mV} / 1024$). Any physical change smaller than this threshold goes undetected without oversampling.

To achieve precision, you must clean the incoming signal electrically, mathematically smooth it in software, and calibrate the output against known reference standards.

The Foundations of Sensor Calibration

Calibration bridges the gap between raw hardware values and true engineering units (such as degrees Celsius, Pascals, or centimeters). Without calibration, component tolerances, manufacturing defects, and environmental shifts render your measurements inaccurate.

Two-Point Calibration Method

The most common approach for linear sensors is the two-point linear calibration method. By recording raw ADC values at two known reference points (e.g., freezing point and boiling point for temperature), you establish a linear equation:

$y = mx + c$

Where:

• $y$ is the calibrated value in engineering units.
• $x$ is the raw ADC reading.
• $m$ is the slope (gain).
• $c$ is the y-intercept (offset).

Implementing Linear Calibration in Arduino Code

```cpp

const int sensorPin = A0;

// Calibration constants determined empirically

const float rawMin = 102.0; // Raw ADC at known minimum reference

const float rawMax = 921.0; // Raw ADC at known maximum reference

const float targetMin = 0.0; // True physical minimum unit

const float targetMax = 100.0;// True physical maximum unit

void setup() {

Serial.begin(9600);

}

void loop() {

int rawValue = analogRead(sensorPin);

// Apply linear mapping formula

float calibratedValue = (float)(rawValue - rawMin) * (targetMax - targetMin) / (rawMax - rawMin) + targetMin;

// Clamp values to prevent boundary overshoot

calibratedValue = constrain(calibratedValue, targetMin, targetMax);

Serial.print("Raw: ");

Serial.print(rawValue);

Serial.print("\tCalibrated: ");

Serial.println(calibratedValue);

delay(500);

}

```

Digital Signal Filtering Techniques for Microcontrollers

Even after proper calibration, raw sensor data often suffers from transient spikes, electromagnetic interference (EMI), and mechanical vibrations. Relying on raw data triggers false positives in control loops and erratic behavior on displays.

Digital signal filters process streams of discrete samples to extract the underlying true signal. Let's examine the three most practical filters for the Arduino Nano.

1. Moving Average Filter (SMA)

The Simple Moving Average calculates the unweighted mean of the last $N$ samples. As a new sample arrives, the oldest sample is dropped. This effectively attenuates high-frequency white noise.

• Pros: Extremely easy to implement; highly effective at smoothing steady-state signals.
• Cons: Introduces phase lag; sudden changes in the sensor value cause a sluggish response proportional to window size $N$.

2. Exponential Moving Average (EMA)

Unlike the SMA, the EMA applies recursive weighting, giving exponentially more weight to recent readings. It requires minimal RAM because it only stores the previous filtered output.

The EMA formula is:

$Y_t = \alpha \cdot X_t + (1 - \alpha) \cdot Y_{t-1}$

Where $\alpha$ is the smoothing factor ($0 < \alpha \le 1$). A smaller $\alpha$ increases smoothing but increases lag.

3. Median Filter

The median filter sorts a collection of recent samples and picks the middle value. This filter excels at removing impulsive noise, such as sudden voltage spikes or transient electromagnetic bursts, without smearing step responses.

Comparing Filtering Algorithms for Arduino Nano

Practical Implementation: Combining Calibration and Filtering

Here is a complete, production-ready Arduino sketch that integrates a median filter, an exponential moving average filter, and linear calibration for an analog sensor attached to pin A0.

```cpp

#define SENSOR_PIN A0

#define NUM_SAMPLES 5

// Calibration constants

const float RAW_MIN = 50.0;

const float RAW_MAX = 950.0;

const float UNIT_MIN = 0.0;

const float UNIT_MAX = 50.0; // e.g., 0 to 50 Amps or Celsius

// EMA smoothing factor (0.0 < ALPHA <= 1.0)

const float ALPHA = 0.2;

float filteredEMA = 0.0;

void setup() {

Serial.begin(115200);

// Initialize EMA with the first reading

filteredEMA = analogRead(SENSOR_PIN);

}

void loop() {

// Step 1: Gather samples for median filtering

int samples[NUM_SAMPLES];

for (byte i = 0; i < NUM_SAMPLES; i++) {

samples[i] = analogRead(SENSOR_PIN);

delay(2); // Short delay between samples

}

// Step 2: Sort samples to find the median

sortArray(samples, NUM_SAMPLES);

int medianRaw = samples[NUM_SAMPLES / 2];

// Step 3: Apply Exponential Moving Average (EMA) filter

filteredEMA = (ALPHA medianRaw) + ((1.0 - ALPHA) filteredEMA);

// Step 4: Apply Linear Calibration

float calibratedValue = (filteredEMA - RAW_MIN) * (UNIT_MAX - UNIT_MIN) / (RAW_MAX - RAW_MIN) + UNIT_MIN;

calibratedValue = constrain(calibratedValue, UNIT_MIN, UNIT_MAX);

// Output results for Serial Plotter

Serial.print("Raw_Median:");

Serial.print(medianRaw);

Serial.print(",");

Serial.print("Filtered_EMA:");

Serial.print(filteredEMA);

Serial.print(",");

Serial.print("Calibrated:");

Serial.println(calibratedValue);

delay(50);

}

// Helper function to sort integer arrays for the median filter

void sortArray(int arr[], byte n) {

for (byte i = 0; i < n - 1; i++) {

for (byte j = i + 1; j < n; j++) {

if (arr[i] > arr[j]) {

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

}

}

}

```

Best Practices for Hardware Noise Reduction

Software filtering is powerful, but it cannot completely cure poor hardware design. To maximize the performance of your Arduino Nano sensor setup, follow these electrical engineering guidelines:

• Use Shielded Cables: For long sensor runs, use twisted-pair or shielded cables to prevent electromagnetic pickup from AC mains or nearby motors.
• Decoupling Capacitors: Place a $0.1\,\mu\text{F}$ ceramic capacitor directly between the sensor's power and ground pins close to the sensor breakout board.
• Separate Analog and Digital Grounds: Ensure your analog ground returns share a clean, single-point star ground connection with the digital ground to minimize ground loops.
• Stable Reference: If your application demands absolute precision, consider using an external voltage reference IC (like the TL431 or REF3030) rather than relying on the noisy $5\text{V}$ USB bus.