Nuke treeset

filters/Makefile

@@ -0,0 +1,12 @@
+CC ?= gcc
+CFLAGS ?= -Wall -O2
+
+TARGET = main.elf
+SRC = message.c main_demo.c
+
+$(TARGET): $(SRC)
+	@echo CC $@
+	@$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+clean:
+	rm -f $(TARGET)

filters/filters.c

@@ -0,0 +1,71 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define N 8
+
+uint16_t buffer[N];
+uint8_t  idx = 0;
+
+/*
+ * Pros: Simple and smooths well.
+ * Cons: Lag, slow to respond to real changes.
+ */
+uint16_t moving_average(uint16_t new_sample) {
+    buffer[idx++] = new_sample;
+    if (idx >= N)
+        idx = 0;
+
+    uint32_t sum = 0;
+    for (int i = 0; i < N; i++) sum += buffer[i];
+    return sum / N;
+}
+
+float alpha = 0.1f; // Between 0 (more smoothing) and 1 (less)
+float filtered = 0;
+
+/*
+ * Pros: Very lightweight, tunable.
+ * Cons: Might not remove all burst noise
+ */
+uint16_t low_pass_filter(uint16_t new_sample) {
+    filtered = alpha * new_sample + (1 - alpha) * filtered;
+    return (uint16_t)filtered;
+}
+
+int compare_uint16(const void *a, const void *b) {
+    return (*(uint16_t *)a - *(uint16_t *)b);
+}
+
+uint16_t median_filter(uint16_t new_sample) {
+    static uint16_t window[N];
+    static uint8_t  index = 0;
+    window[index++] = new_sample;
+    if (index >= N)
+        index = 0;
+
+    // Copy and sort
+    uint16_t sorted[N];
+    memcpy(sorted, window, sizeof(sorted));
+    qsort(sorted, N, sizeof(uint16_t), compare_uint16);
+    return sorted[N / 2];
+}
+
+#undef N
+#define N 5
+float coeffs[N] = {0.1, 0.15, 0.5, 0.15, 0.1};  // Symmetric LPF
+float buffer[N] = {0};
+int index = 0;
+
+float fir_filter(float sample) {
+    buffer[index] = sample;
+    float result = 0;
+    int i, j = index;
+    for (i = 0; i < N; i++) {
+        result += coeffs[i] * buffer[j];
+        j = (j - 1 + N) % N;
+    }
+    index = (index + 1) % N;
+    return result;
+}
+