Design Digital Low-Pass Filters on Arduino

FIR filters are always stable while IIR filters may be unstable due to feedback. FIR filters have only zeros (no poles except at z=0), while IIR filters have both poles and zeros. For equivalent frequency specifications, FIR filters generally require higher order than IIR filters. IIR filters achieve the same selectivity with lower order but risk instability. An IIR filter may be unstable because it contains feedback. Both causal and non-causal filters can be stable. Group delay is constant only for FIR filters with linear phase. For high-fidelity audio processing, linear phase FIR filters are most appropriate to preserve waveform shape.

FIR and IIR filters have distinct characteristics: (1) Computational Speed - IIR filters are typically faster and require lower order filters to achieve similar responses due to feedback mechanisms; (2) Stability - FIR filters are always stable while IIR filters can become unstable if not carefully designed, as feedback can cause outputs to blow up; (3) Phase Response - FIR filters have constant phase delay across all frequencies, whereas IIR filters have varying phase response depending on frequency. For sharp filtering responses, IIR filters are often preferred despite potential stability concerns.

FIR (Finite Impulse Response) filters have a finite-length impulse response with only zeros in their transfer function, making them inherently stable and implemented through convolution; IIR (Infinite Impulse Response) filters have an infinite-length impulse response that can contain both poles and zeros or only poles, requiring careful pole placement for stability and implemented through difference equations with feedback.

A digital filter is classified as FIR (Finite Impulse Response) if its output depends only on present and past inputs. It is classified as IIR (Infinite Impulse Response) if its output depends on present and past inputs AND past outputs. For the system described by Y(n) = 2X(n) + X(n-1) + 2Y(n-1), since the output depends on past output Y(n-1), it is an IIR filter. To determine stability, we find the transfer function H(z) = (2 + z⁻¹)/(1 - 2z⁻¹). The pole is at z = 2. Since the pole lies outside the unit circle (|z| > 1), the system is unstable.

FIR (Finite Impulse Response) filters have only numerator terms in their transfer function, making them inherently stable with no poles, while IIR (Infinite Impulse Response) filters include both numerator and denominator terms, requiring feedback and potentially introducing instability depending on pole positions; FIR filters implement moving average functions through feedforward structures without feedback, whereas IIR filters require both feedforward and feedback paths for realization.

The firdes function in MATLAB enables the design of arbitrary FIR filters by allowing users to define a custom frequency-magnitude specification template, where users provide vectors containing frequencies of interest and corresponding desired magnitudes (with 1 indicating no change, values above 1 indicating amplification, and values below 1 indicating attenuation), and the function performs inverse FFT interpolation to generate the filter coefficients; this approach is particularly useful for creating specialized filters like custom equalizers, and the choice of window function significantly affects the filter's frequency response characteristics, with rectangular windows offering the fastest roll-off but highest side lobes, while Hamming and Hanning windows provide better side lobe suppression at the cost of slightly slower transitions.

This comprehensive workflow covers designing FIR filters using MATLAB's online Filter Designer tool. The process includes: (1) Selecting filter type (low-pass, high-pass, or band-pass) based on application needs; (2) Specifying critical parameters such as sampling frequency, pass band edge frequency, stop band edge frequency, and stop band attenuation; (3) Observing the resulting frequency response and impulse response to verify specifications; (4) Understanding the relationship between filter order and coefficient count (order = coefficients - 1); (5) Recognizing the trade-off between transition bandwidth and filter quality - narrower transitions require more coefficients but provide better frequency selectivity; (6) Exporting coefficients as ASCII text files for further processing; and (7) Manually creating custom C header files by copying coefficient values into appropriate data structures for embedded implementation.

MATLAB's Signal Processing Toolbox provides a comprehensive Filter Designer tool for FIR and IIR filter design. The tool enables graphical specification of filter type (low-pass, high-pass, band-pass, band-stop, differentiator, Hilbert transformer), frequency edges, ripple/attenuation in dB, sampling rate, and design method. Supported methods include Window (Kaiser), Optimal (equiripple), Butterworth, Chebyshev, and Elliptic designs. The tool automatically calculates coefficients and displays multiple analyses: magnitude response, phase response, group delay (verifying linear phase with constant value equal to M/2), pole-zero plot showing conjugate reciprocal symmetries, and impulse response. Users can export coefficients to workspace for implementation. The tool facilitates iterative design exploration, allowing comparison of different approaches to meet specifications efficiently.

To use a designed filter in MATLAB code, export the filter structure to the workspace using the Export function. The exported structure contains the transfer function, numerator coefficients (Num), and denominator coefficients (Den). Access coefficients using 'filt1.Num' for numerator and 'filt1.Den' for denominator. The transfer function is accessed via 'filt1.TF'. These coefficients are the numerical values that will be used in the filtering operation, typically displayed with four decimal places of precision.

This video tutorial demonstrates how to design FIR and IIR filters in MATLAB using the Filter Designer tool (formerly FDA tool). The process involves selecting the response type (low pass, high pass, band pass, band stop, or differentiator), choosing the design method (FIR or IIR with prototypes like Butterworth, Chebyshev, or Elliptic), specifying filter order (minimum order or custom), and defining frequency and magnitude specifications. After designing the filter, users can visualize various responses including magnitude, phase, group delay, impulse response, and pole-zero plot. The designed filter can be exported as MATLAB code or as filter objects for implementation, and applied to data using the filter() function.

Complementary filtering combines gyroscope (smooth but biased) and accelerometer (noisy but correct) measurements. The filter uses a single parameter alpha to balance sensor weighting. The equation: fused_angle = alpha × (previous_fused_angle + gyro × delta_t) + (1 - alpha) × accelerometer_angle. Since alpha < 1, the filter converges toward accelerometer measurements, preventing bias accumulation. This simple technique provides smooth, accurate angle estimates suitable for most applications, solving approximately 90% of sensor fusion problems.

Sensor fusion combines data from multiple sensors (gyroscope and accelerometer) to achieve more accurate and reliable measurements than either sensor could provide alone; the complementary filter achieves this by taking a weighted average of the gyroscope's smooth but drifting angle measurements and the accelerometer's noisy but stable angle measurements, with an optimal gain value around 0.91-0.96 that balances noise reduction and drift minimization for stable drone flight.

The Kalman filter combines gyroscope and accelerometer readings to produce accurate tilt angle measurements by weighing sensor certainty. Gyroscopes provide smooth but drifting estimates, while accelerometers give accurate but noisy readings. The filter mathematically fuses these inputs, producing a smooth, reliable estimate suitable for real-time robot control applications.

A Kalman filter is a recursive algorithm that optimally combines noisy sensor measurements (such as accelerometer and gyroscope data from an MPU6050) to produce an accurate estimate of a system's state, such as pitch angle; in this demonstration, the steady-state Kalman filter is implemented on an ESP32 microcontroller using Arduino software, where the filter matrices are precomputed in MATLAB and then applied in closed-loop form to fuse the sensor data in real-time, producing a smoother angle estimate compared to raw sensor readings.

The complementary filter is a computationally efficient sensor fusion technique that combines accelerometer and gyroscope data to estimate roll and pitch angles by exploiting their complementary strengths: accelerometers provide stable long-term estimates when the system is at rest (measuring gravity), while gyroscopes offer accurate short-term angular rate measurements without drift; the filter merges these estimates using a weighted combination where the weighting factor alpha (typically 0.02-0.05) determines how much trust is placed in each sensor, with lower values favoring gyroscope estimates and higher values favoring accelerometer estimates.

Microcontroller filter implementation faces constraints: SMA requires significant memory (one word per period) but uses fast integer arithmetic, while EMA requires less memory but needs floating-point arithmetic. For PIC microcontrollers, EMA uses fixed-point arithmetic by multiplying values by 1000 to simulate decimal places. The alpha coefficient and intermediate values are stored as long integers. One virtual decimal place is preserved during calculations to maintain precision, with conversion to output only at the final step. This prevents EMA from never reaching input values due to precision loss. The main loop continuously reads analog inputs and calls filter subroutines.

Fixed point arithmetic is a computational technique that enables efficient fractional calculations on microcontrollers by representing numbers with an imaginary decimal point within a standard integer data type, allowing for faster operations than floating point while sacrificing some range for increased resolution; key operations include: addition/subtraction work directly, multiplication requires casting to 64-bit integers, shifting to remove overflow/underflow, and casting back to 32-bit fixed point, while conversions between integers and fixed point use bit shifts and between floating point and fixed point use multiplication/division by 2^fractional_bits (e.g., 32768 for 15 fractional bits).

Efficient audio processing on microcontrollers requires fixed-point arithmetic optimization. Use 16-bit integers with an implicit binary point between bits 7 and 8 (8.8 fixed-point format). Instead of performing full 32-bit multiplies and shifts, approximate multiplication by shifting each operand right by 8 bits first. This trades some precision for speed, which is acceptable since final output uses only 8 bits. The approximation introduces background noise around -25 dB, which is inaudible under normal listening conditions.

Fixed-point arithmetic provides an alternative to floating-point representation for fractional numbers by using a virtual radix point within an integer type, enabling precise linear computations with exact precision within a defined range; unlike floating-point which uses logarithmic spacing and requires specialized hardware for fast computation, fixed-point operations (addition, subtraction, multiplication, division) reduce to standard integer operations, making them significantly faster on microcontrollers and embedded systems without floating-point units, though they sacrifice the wide dynamic range of floating-point numbers.

Fixed point filter implementations achieve approximately 10 times lower CPU utilization (0.19%) compared to floating point implementations (1.68%) on embedded processors, but require careful selection of fixed point format (such as 2.32) and discrete sample time (such as 1ms) to maintain acceptable filter performance with minimal steady-state error.