What Are Digital Filters?

Digital filters are algorithms that process discrete-time signals to remove unwanted components or extract specific information. They operate on sampled data, applying mathematical operations to modify the frequency content of a signal. In Arduino-based DIY projects, digital filters are implemented entirely in software, making them a cost-effective way to clean sensor readings, remove noise, or detect events without adding external components like RC circuits or dedicated filter ICs. Whether you are building a weather station, a robotics controller, or an audio effects pedal, understanding digital filters can dramatically improve the reliability and accuracy of your measurements.

Types of Digital Filters

Filters are broadly categorized by their frequency response and application. The four most common types used in microcontroller projects are low-pass, high-pass, band-pass, and notch filters. Each serves a distinct purpose in shaping the signal.

Low-Pass Filters

A low-pass filter (LPF) allows signals below a certain cutoff frequency to pass through while attenuating higher-frequency components. This is essential for smoothing noisy sensor data such as analog readings from photoresistors, temperature sensors, or accelerometers. The simplest software LPF is the moving average, but more sophisticated IIR designs like the single-pole low-pass filter offer smoother roll-off with minimal delay.

High-Pass Filters

High-pass filters (HPF) do the opposite: they block low-frequency components and let high-frequency signals through. These are useful for detecting rapid changes, such as edge detection in a touch sensor or removing DC offset from an audio input. In Arduino, a high-pass filter can be implemented by subtracting a low-pass filtered version of the signal from the original.

Band-Pass Filters

Band-pass filters (BPF) pass a specific range of frequencies and reject those outside that range. They are common in communication systems and can help isolate a particular tone or vibration frequency in a DIY project. For example, a band-pass filter can be used to detect a specific sound frequency in a clap-activated light switch.

Notch Filters

Notch filters (or band-stop filters) remove a narrow band of frequencies while leaving the rest of the spectrum largely unchanged. A classic application is removing 50/60 Hz power line hum from sensor readings. On an Arduino, a notch filter can be implemented using a second-order IIR architecture that places zeros at the unwanted frequency.

Implementing Digital Filters on Arduino

Arduino boards, especially the Uno and Nano, have limited RAM and processing power (8-bit CPU, up to 16 MHz). Therefore, filter implementations must be efficient, often using integer arithmetic and fixed-point representations. Below are several practical filter algorithms with code examples suitable for real-time operation.

Moving Average Filter

The moving average filter is the simplest smoothing filter. It maintains a sliding window of recent samples and outputs the arithmetic mean. It works well for reducing high-frequency noise but introduces a lag equal to half the window length.

// Simple moving average for analog reading
const int WINDOW_SIZE = 10;
float buffer[WINDOW_SIZE];
int index = 0;
float sum = 0.0;
float output = 0.0;

void setup() {
  for (int i = 0; i < WINDOW_SIZE; i++) buffer[i] = 0.0;
}

void loop() {
  float newSample = analogRead(A0);
  sum -= buffer[index];
  buffer[index] = newSample;
  sum += newSample;
  index = (index + 1) % WINDOW_SIZE;
  output = sum / WINDOW_SIZE;
  // Use output for control or display
}

Exponential Moving Average (EMA)

The EMA filter requires only two variables (previous output and a smoothing factor) and no large buffer. It gives more weight to recent samples, making it more responsive than a simple moving average. The formula is output = alpha * newSample + (1 - alpha) * previousOutput.

// Exponential moving average
float EMA_alpha = 0.2;  // Smoothing factor (0 to 1, smaller = smoother)
float emaOutput = 0;

void setup() {
  emaOutput = analogRead(A0); // Initialize
}

void loop() {
  float raw = analogRead(A0);
  emaOutput = EMA_alpha * raw + (1 - EMA_alpha) * emaOutput;
}

The alpha value controls the cutoff frequency. A smaller alpha produces more smoothing but slower response. To avoid floating-point overhead, you can use fixed-point arithmetic by scaling alpha to an integer (e.g., 256) and shifting the result.

Median Filter

Median filtering is excellent for removing impulse noise (spikes) while preserving edges. It works by sorting a window of samples and taking the middle value. On Arduino, a common approach for a 3- or 5-sample median filter is to use insertion sort, which is fast for small windows.

// 5-sample median filter
int medianFilter(int newSample) {
  static int buffer[5] = {0,0,0,0,0};
  static int pos = 0;
  int temp[5];
  // Insert new sample
  buffer[pos] = newSample;
  pos = (pos + 1) % 5;
  // Copy and sort
  for (int i = 0; i < 5; i++) temp[i] = buffer[i];
  // Bubble sort (inefficient but fine for 5 elements)
  for (int i = 0; i < 5; i++) {
    for (int j = i+1; j < 5; j++) {
      if (temp[i] > temp[j]) {
        int t = temp[i];
        temp[i] = temp[j];
        temp[j] = t;
      }
    }
  }
  return temp[2]; // median
}

IIR and FIR Filters

For more advanced filtering, you can implement Infinite Impulse Response (IIR) or Finite Impulse Response (FIR) filters. IIR filters are recursive and require fewer coefficients for a given sharpness, making them efficient on Arduino. However, they can become unstable if not designed carefully (keep poles inside the unit circle). FIR filters are non-recursive, always stable, and can have linear phase, but need many taps for sharp cutoffs, which consumes RAM and CPU cycles.

A practical single-pole IIR low-pass filter (the EMA is actually a special case) can be written as:

// Single-pole IIR low-pass filter
float iirOutput = 0;
float iirAlpha = 0.1; // 0 < alpha < 1

void loop() {
  float raw = analogRead(A0);
  iirOutput = iirAlpha * raw + (1 - iirAlpha) * iirOutput;
}

For high-pass, the formula becomes output = (1 - alpha) * (output + raw - prevRaw). For a notch filter, a biquad implementation (second-order IIR) is recommended. The Arduino Filter library by Elco Jacobs provides efficient biquad filters that can be used for LPF, HPF, BPF, and notch.

Practical Considerations for Arduino

When implementing digital filters on an 8-bit microcontroller, trade-offs between precision, speed, and memory are critical. Here are key factors to consider:

Sample Rate and Aliasing

The Nyquist criterion requires that the sampling rate be at least twice the highest frequency of interest. For typical analog sensors (e.g., thermistors, light sensors), a sample rate of 10–100 Hz is sufficient. However, for audio applications you need 8–44 kHz. Always ensure your filter coefficients are designed for the actual sample rate. Using delay() or a timer interrupt can provide consistent sampling.

Fixed-Point vs Floating-Point

Arduino Uno’s float operations are emulated in software and are much slower than integer arithmetic. For simple filters, use integer arithmetic with scaling. For example, set alpha to an integer between 0 and 256 and divide by 256 at the end (bit shift). This avoids expensive floating-point math.

Memory Usage

Each float takes 4 bytes, and an int takes 2. A 10-sample moving average buffer using floats uses 40 bytes (out of 2048 total RAM on Uno). For FIR filters with many taps, memory quickly becomes the limiting factor. Consider using smaller data types like uint16_t and pack coefficient arrays in PROGMEM if they are constant.

Quantization Noise

The Arduino’s ADC has 10-bit resolution (0–1023). Digital filter operations can introduce rounding errors, especially with integer arithmetic. Use rounding instead of truncation to preserve accuracy. For example, compute (total + WINDOW_SIZE/2) / WINDOW_SIZE for a rounded average.

Applications in DIY Projects

Digital filters enable many real-world applications on Arduino. Here are a few:

  • Sensor Smoothing: Clean noisy analog readings from potentiometers, flex sensors, or ultrasonic rangefinders. A moving average or EMA can stabilize values that would otherwise jitter.
  • Audio Processing: Build a simple equalizer or noise gate for a microphone input. Use IIR biquad filters coded in the tone() library or via direct PWM output.
  • Vibration Analysis: Use an accelerometer with a high-pass filter to detect taps or gestures, and a low-pass filter to measure static tilt.
  • Power Line Hum Rejection: Implement a 50/60 Hz notch filter on a mains-powered sensor to remove interference. This is common in DIY energy monitors.
  • Motion Control: Filter encoder readings for motor speed control. A low-pass filter on the velocity estimate prevents oscillations in PID controllers.

Choosing the Right Filter

Selecting a filter depends on your signal characteristics and system constraints. For fast, noisy signals with occasional spikes, a median filter is best. For slowly varying signals, an EMA or moving average is sufficient. If you need a sharp cutoff and have enough RAM, an FIR filter may be worthwhile. Always test with real data using the Serial Plotter to visualize the effect of different parameters. For further reading, refer to Wikipedia’s article on digital filters or Analog Devices’ filter design tutorials.

Conclusion

Digital filtering is a powerful and accessible technique for improving the quality of sensor data in Arduino DIY projects. From a simple moving average to advanced IIR/FIR designs, you can implement noise reduction, frequency selection, and signal conditioning entirely in software. By understanding the trade-offs between response time, computational cost, and memory usage, you can choose the right filter for your application. Experiment with different algorithms, tune the parameters, and watch your measurements become more stable and reliable. Start with the code examples provided, adapt them to your sensor, and take your Arduino projects to the next level.

External resources: Arduino Official Documentation on Filters, SparkFun Digital Filters Tutorial, All About Circuits: Digital Filter Design Basics.