embfilt

KO | EN

gitlite — search

#hacktoberfest #react #ai #typescript #llm #go #android #machine-learning #rust #deep-learning #docker #macos #ios #mcp

(★ 10)

Embedded Filters (embfilt) - Standalone digital filters for embedded systems.

embfilt Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Embedded Filters

[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://raw.githubusercontent.com/huunghiaspkt/embfilt/main/LICENSE)
[![C Standard](https://img.shields.io/badge/C-C99-green.svg)]()

A collection of standalone digital filters, designed for resource-constrained embedded systems and microcontrollers. Zero heap allocation, zero cross-dependencies — each filter is a single `.h`/`.c` pair you drop into your project.

## Filters at a Glance

| Filter | Cost per Sample | RAM | Strengths | Weaknesses |
|--------|----------------|-----|-----------|------------|
| [IIR Biquad](#iir-filters) | 5 mul + 4 add | 28 B | Frequency-selective, very fast | Phase distortion, needs float |
| [IIR EMA](#ema--1st-order-low-pass) | 1 mul + 1 add + 1 sub | 8 B | Smallest, cheapest IIR | -6 dB/oct rolloff, LPF only |
| [Moving Average](#moving-average) | 1 mul + 1 add + 1 sub | 4*n* + 20 B | Dead simple, O(1) | Smears transients, adds latency |
| [Median](#median-filter) | O(*n*) comparisons + shifts | 8*n* + 16 B | Kills spikes without smearing | Not frequency-aware |
| [Kalman](#kalman-filter) | 5 arithmetic ops | 20 B | Adaptive, optimal for Gaussian noise | Tuning is non-trivial |

---

## IIR Filters

**`IIR_filter/`** — Eight IIR filters: seven 2nd-order biquads (Direct Form II Transposed) plus one 1st-order EMA.

| File | Type | Order | Parameters |
|------|------|-------|------------|
| `ema_filt.h/c` | Exponential Moving Avg | 1st | freq, srate |
| `lpf_filt.h/c` | Low-Pass | 2nd | freq, srate, bandwidth |
| `hpf_filt.h/c` | High-Pass | 2nd | freq, srate, bandwidth |
| `bpf_filt.h/c` | Band-Pass (0 dB peak) | 2nd | freq, srate, bandwidth |
| `notch_filt.h/c` | Notch / Band-Reject | 2nd | freq, srate, bandwidth |
| `peq_filt.h/c` | Peaking Band EQ | 2nd | dbGain, freq, srate, bandwidth |
| `lsh_filt.h/c` | Low Shelf | 2nd | dbGain, freq, srate, bandwidth |
| `hsh_filt.h/c` | High Shelf | 2nd | dbGain, freq, srate, bandwidth |

```c
#include "lpf_filt.h"

iir_lpf_t filt;
iir_lpf_init(&filt, 50.0f, 1000.0f, 1.0f);  /* 50 Hz cutoff, 1 kHz sample rate, 1 octave BW */

for (;;) {
    float out = iir_lpf(&filt, adc_read());
}
```

### IIR Filter Responses

All seven filter types applied to a composite signal (5 + 50 + 200 Hz). Each subplot shows the input (blue) and filtered output (orange):

![IIR Filter Responses](https://raw.githubusercontent.com/huunghiaspkt/embfilt/main/docs/iir_filters.png)

| Type | Use case |
|------|----------|
| **Low-Pass** | Remove high-frequency sensor noise, smooth ADC readings |
| **High-Pass** | Remove DC offset, isolate AC component of a signal |
| **Band-Pass** | Isolate a known frequency (e.g., vibration analysis) |
| **Notch** | Reject a specific interference frequency (50/60 Hz mains hum) |
| **Peaking EQ** | Boost or cut a narrow frequency band |
| **Low/High Shelf** | Boost or cut everything below/above a threshold frequency |

</details>

<details>
<summary><b>Choosing bandwidth</b></summary>

The `bandwidth` parameter controls how sharp or gentle the filter acts around the target frequency. **Smaller values = sharper, more selective. Larger values = wider, gentler.**

| Bandwidth | Sharpness | Use when |
|-----------|-----------|----------|
| 0.1–0.3 | Very sharp | Rejecting a single interference frequency |
| 0.5–1.0 | Moderate | General-purpose filtering |
| **1.0** | **Default** | **Good starting point for most applications** |
| 1.5–3.0 | Gentle | Smooth transitions, broad noise shaping |

**Per-filter guide:**

| Filter | Start with | Sensor example |
|--------|-----------|----------------|
| **LPF / HPF** | 1.0 | Smoothing ADC readings, removing DC offset |
| **BPF** | 0.5–1.0 | Isolating motor vibration at a known RPM frequency |
| **Notch** | 0.1–0.3 | Removing 50/60 Hz mains interference from sensor lines |
| **PEQ** | 0.5–2.0 | Compensating for sensor frequency response |
| **Shelf** | 0.5–1.5 | Attenuating everything above/below a threshold |

**Tuning:** Start at 1.0. If the filter affects neighboring frequencies too much, decrease. If the transition is too abrupt or causes ringing, increase.

</details>

**Pros:** Lowest CPU cost of any frequency-selective filter. Covers low-pass, high-pass, band-pass, notch, EQ, and shelf in a unified interface. Only 2 state variables per filter instance.

**Cons:** Introduces phase distortion (not suitable where phase matters). Can go unstable with poorly chosen parameters. Requires floating-point arithmetic. Changing cutoff at runtime means recalculating coefficients.

---

## Moving Average

**`MA_filter/`** — Running-sum moving average. Constant O(1) cost per sample regardless of window size.

```c
#include "ma_filt.h"

float buf[64];
ma_t filt;
ma_init(&filt, buf, 64);  /* 64-sample window */

for (;;) {
    float out = ma(&filt, adc_read());
}
```

### Moving Average

Top: white noise reduced by MA(32). Bottom: window size comparison (8, 16, 64) on a noisy 5 Hz sine — larger windows smooth more but add latency:

![Moving Average Filter](https://raw.githubusercontent.com/huunghiaspkt/embfilt/main/docs/ma_filter.png)

**Pros:** Fastest filter in this library — one add, one subtract, one multiply per sample. Trivial to tune (just set window size). Excellent at reducing white/random noise.

**Cons:** Treats all samples equally — no frequency discrimination. Smears step changes and transients. Output lags the input by half the window size. Susceptible to accumulated floating-point rounding error over very long runs.

**Best for:** General-purpose smoothing where simplicity and speed matter more than frequency precision. Good default choice for ADC readings, battery voltage monitoring, and temperature sensing.

---

## Median Filter

**`Median_filter/`** — Sliding-window median implemented with a sorted array and circular buffer. Cache-friendly flat arrays, no pointer chasing.

```c
#include "median_filt.h"

#define WIN 7
float buf[WIN * 2];           /* requires 2x window size */
median_t filt;
median_init(&filt, buf, WIN); /* use odd window for unique median */

for (;;) {
    float out = median(&filt, adc_read());
}
```

### Median Filter

Top: impulse spike removal — the median filter (orange) cleanly rejects outlier spikes while following the underlying sine wave. Bottom: step response comparison — median preserves sharp edges that moving average smears:

![Median Filter](https://raw.githubusercontent.com/huunghiaspkt/embfilt/main/docs/median_filter.png)

**Pros:** Eliminates impulse noise and spikes completely — outliers are discarded, not averaged in. Preserves step edges that averaging filters would blur. No floating-point math needed in the processing loop.

**Cons:** O(*n*) per sample (scan + shift on each call). Uses twice the window size in memory. Not frequency-aware — cannot target specific bands. Large windows can over-smooth fast signals.

**Best for:** Signals contaminated with impulse noise — EMI spikes, sensor glitches, contact bounce. Often used as a preprocessing stage before IIR or Kalman filtering.

---

## Kalman Filter

**`Kalman_filter/`** — Scalar (1D) Kalman filter. Predict/correct cycle using pure scalar arithmetic — no matrix math.

```c
#include "kalman_filt.h"

kalman_t kf;
kalman_init(&kf,
    0.01f,          /* proc_noise: how fast the true value drifts  */
    0.1f,           /* meas_noise: how noisy the sensor is         */
    first_reading,  /* initial estimate                            */
    1.0f);          /* initial uncertainty (high = low confidence)  */

for (;;) {
    float out = kalman(&kf, adc_read());
}
```

### Kalman Filter

Top: ramp tracking — fast process noise (q=0.1) tracks better than slow (q=0.001). Bottom: tuning comparison showing the q/r tradeoff between smoothing and responsiveness:

![Kalman Filter](https://raw.githubusercontent.com/huunghiaspkt/embfilt/main/docs/kalman_filter.png)

**Pros:** Automatically balances responsiveness vs. smoothness via the Kalman gain. Produces statistically optimal estimates for linear systems with Gaussian noise. Extremely low CPU and memory cost. Adapts over time as it learns the noise characteristics.

**Cons:** Only two tuning knobs (proc_noise, meas_noise), but getting them right requires understanding your system. Assumes the underlying signal changes smoothly — sudden jumps cause transient error. This scalar implementation handles single-variable systems only.

**Tuning guide:**

| Scenario | proc_noise | meas_noise | Result |
|----------|------------|------------|--------|
| Stable signal, noisy sensor | Small | Large | Heavy smoothing, slow response |
| Fast-changing signal, clean sensor | Large | Small | Quick tracking, more noise in output |

**Best for:** Continuously varying physical quantities — temperature, pressure, distance, weight, battery voltage — where the true value doesn't jump instantaneously.

---

## How to Use

### Integration

Copy the `.h` and `.c` files for the filter(s) you need into your project. No build system or library installation required.

## Thread Safety & IRQ Usage

Each filter instance is **self-contained** — no global or shared state. Safe to use separate instances across RTOS tasks without locking.

**Rules for a single instance:**

| Context | Safe? | Notes |
|---------|-------|-------|
| One task, no ISR | Yes | Normal usage |
| ISR only (e.g., ADC complete callback) | Yes | Filter runs entirely in interrupt context |
| ISR + main sharing one instance | **No** | ISR can preempt mid-update, corrupting state |

All processing functions (`iir_lpf`, `ma`, `median`, `kalman`, etc.) are `static inline` — they compile into the calling function with no call overhead, making them suitable for tight ISR timing.

---

## References

- Microchip AN4515 — [Processing Analog Sensor Data with Digital Filtering](docs/DS00004515.pdf)
- Robert Bristow-Johnson — [Audio EQ Cookbook](https://www.w3.org/2011/audio/audio-eq-cookbook.html)

## License

This project is licensed under the MIT License — see the [LICENSE](LICENSE) file for details.

embfilt

embfilt Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

embfilt

embfilt Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Download README