Infinite Impulse Response (IIR) Filter

An IIR filter's output depends on both past inputs and past outputs, creating a recursive feedback loop. This is mathematically expressed by its difference equation:

y[n] = Σ (b_k * x[n-k]) - Σ (a_k * y[n-k])

Where a_k and b_k are the filter coefficients. The feedback of previous outputs (y[n-k]) allows for a much sharper frequency response with far fewer coefficients (taps) than an equivalent Finite Impulse Response (FIR) filter. This computational efficiency is critical for microcontrollers.

Because of its feedback path, an IIR filter's pole locations in the z-plane determine its stability. For a causal system to be Bounded-Input, Bounded-Output (BIBO) stable, all poles must lie inside the unit circle. This is a fundamental design constraint. Unstable filters exhibit unbounded output growth, even with a bounded input. Stability analysis is therefore a mandatory step in IIR filter design, unlike with inherently stable FIR filters.

IIR filters generally have a non-linear phase response across frequencies. This means different frequency components of a signal experience different time delays as they pass through the filter, potentially causing phase distortion. This is undesirable in applications where the signal's shape must be preserved, such as in digital communications or precise audio processing. For applications requiring linear phase (constant group delay), an FIR filter is typically chosen despite its higher computational cost.

IIR filters are often designed by transforming classic, well-understood analog filter prototypes (e.g., Butterworth, Chebyshev, Elliptic) into the digital domain using methods like the bilinear transform. This provides direct access to established filter characteristics:

• Butterworth: Maximally flat passband.
• Chebyshev: Steeper roll-off with passband ripple.
• Elliptic (Cauer): Sharpest transition band with ripple in both passband and stopband. This heritage allows engineers to leverage analog design intuition for digital implementations.

This is the primary advantage for TinyML. To achieve a given frequency selectivity (e.g., a sharp cutoff), an IIR filter requires significantly fewer coefficients and arithmetic operations per output sample than an FIR filter. This translates directly to:

• Lower CPU cycles on the microcontroller.
• Reduced memory for storing coefficients and delay line states.
• Lower power consumption, a critical metric for battery-operated sensor nodes. This efficiency makes IIR filters the default choice for many real-time filtering tasks on MCUs.

When implemented on fixed-point microcontrollers, IIR filter coefficients must be quantized to a limited bit-width. This quantization can subtly shift the pole and zero locations in the z-plane, potentially leading to:

• Frequency response deviation from the designed ideal.
• Limit cycle oscillations (small, persistent output variations with zero input).
• In severe cases, movement of poles outside the unit circle, causing instability. This necessitates careful fixed-point design and scaling during implementation to maintain performance and stability.

While powerful, IIR filters require careful design on resource-limited hardware.

• Fixed-Point Arithmetic: Coefficients and state variables must use Q-format fixed-point math to avoid floating-point overhead, risking overflow and coefficient quantization issues.
• Stability: Pole locations must remain inside the unit circle. Coefficient quantization can push an otherwise stable filter into instability.
• Limit Cycles: Low-bit-width implementations can cause small oscillations in the output even with zero input.
• Tooling: Libraries like ARM CMSIS-DSP provide optimized fixed-point IIR functions (arm_biquad_cascade_df1_f32) that are essential for performant TinyML deployment.

A Finite Impulse Response (FIR) filter is a digital filter whose output depends only on a finite number of past and present input samples. Unlike IIR filters, FIR filters have no feedback loop, making them inherently stable and providing a linear phase response, which preserves the shape of a signal. This comes at the cost of computational efficiency, often requiring many more coefficients than an IIR filter to achieve a comparable frequency selectivity.

• Key Contrast with IIR: FIR filters are always stable and have a linear phase, while IIR filters are more computationally efficient but can be unstable and have a non-linear phase.
• Use Case: FIR filters are preferred in applications where signal shape integrity is critical, such as in communications or audio crossover networks, despite their higher computational load.

Digital Signal Processing (DSP) is the overarching discipline of manipulating discrete-time signals using mathematical algorithms. IIR filters are a fundamental tool within the DSP toolkit, used for operations like filtering, noise reduction, and feature extraction on digitized sensor data. The core challenge in TinyML is executing these DSP algorithms—including IIR filters—within the severe memory and compute constraints of microcontrollers.

• Core Operations: Includes filtering (IIR/FIR), transforms (FFT, DCT), convolution, and correlation.
• TinyML Context: Efficient DSP is the preprocessing backbone for on-device machine learning, turning raw sensor streams into clean, informative features for model inference.

Sensor fusion is the process of combining data from multiple, often heterogeneous, sensors to produce a more accurate, complete, and reliable estimate of the environment or system state than is possible with a single sensor. IIR filters are frequently employed at the front end of fusion pipelines to condition individual sensor streams (e.g., smoothing accelerometer data) before they are fused using algorithms like the Kalman filter.

• Role of IIR: Acts as a pre-filter to reduce high-frequency noise and artifacts from individual sensors like IMUs or microphones.
• Example: In a drone, an IIR low-pass filter might smooth raw gyroscope data before it is fused with accelerometer and magnetometer data in a complementary filter to estimate orientation.

A Kalman filter is a recursive, optimal estimation algorithm that uses a series of measurements observed over time, containing statistical noise, to produce estimates of unknown variables. While both are recursive, the Kalman filter is a state-space model that optimally fuses predictions with measurements, whereas an IIR filter is a simpler, fixed-coefficient filter for shaping frequency response. They are often used in sequence: IIR for initial signal conditioning, Kalman for dynamic state estimation.

• Contrast: Kalman filters dynamically adjust their internal model based on uncertainty; IIR filters apply a static transfer function.
• Complementary Use: A lightweight, fixed-gain Kalman filter (e.g., for tilt estimation) may follow an IIR pre-filter stage on a microcontroller.

A moving average filter is a specific, simple type of Finite Impulse Response (FIR) filter where each output point is the average of a window of previous input points. It is a common baseline for smoothing. Compared to an IIR filter like a single-pole low-pass, a moving average requires more memory (to store the window) and computation per sample for similar smoothing effects but guarantees stability and a linear phase.

• Efficiency Trade-off: An exponential moving average (EMA), which is an IIR formulation, can approximate a moving average with constant memory and computation, making it preferable for TinyML.
• Typical Use: Quick, simple smoothing of sensor readings (e.g., temperature) where computational simplicity is valued over precise frequency control.

ADC Sampling is the process of converting a continuous analog sensor signal into discrete digital values. Aliasing is a critical distortion that occurs when a signal contains frequencies higher than half the sampling rate (the Nyquist frequency). IIR filters are crucial as anti-aliasing filters applied in the digital domain after oversampling, or their analog equivalents are used before the ADC to bandlimit the signal.

• Nyquist Rate: The minimum sampling frequency (twice the highest signal frequency) to avoid aliasing.
• IIR's Role: A sharp digital IIR low-pass filter can be used in a decimation filter chain to reduce the sample rate of an oversampled signal while aggressively removing high-frequency content to prevent aliasing.