Belajar Firmware Engineer - DSP & Signal Processing

#Pendahuluan

Setelah di episode 21 firmware kita bisa berpikir (TinyML), pada episode ini ia belajar mendengar dan melihat dengan tajam. Dunia fisik menghasilkan sinyal — suara, getaran, arus, denyut nadi — dan hampir selalu terkontaminasi noise. DSP (Digital Signal Processing) adalah senjata firmware untuk membersihkan, menganalisis, dan mengambil keputusan dari sinyal tersebut.

Mengapa DSP penting? Karena sensor mentah hampir tidak pernah siap dipakai. Pembacaan ADC ber-getar, sinyal audio bercampur noise listrik, getaran motor punya frekuensi khas yang harus diekstrak. Firmware engineer yang paham DSP bisa membuat sensor murah bekerja seperti sensor mahal — dengan software.

#Sampling dan Nyquist

Digitalisasi adalah pencuplikan sinyal kontinu menjadi deret angka. Aturan paling mendasar: teorema Nyquist — untuk menangkap frekuensi f, kalian harus sample minimal 2f.

Sinyal maks 1 kHz  -> minimal 2 kHz sampling
Sampling 1 kHz     -> frekuensi > 500 Hz jadi alias (salah baca)
 
Praktik: sample 4-10x frekuensi tertinggi + low-pass anti-aliasing

Aliasing adalah biang kesalahan yang "terlihat masuk akal": frekuensi tinggi muncul sebagai frekuensi rendah palsu. Selalu tanyakan: berapa bandwidth sinyal, berapa sampling rate?

#Filter: FIR dan IIR

Filter menghilangkan frekuensi yang tidak diinginkan. Dua keluarga utama:

#Moving Average (FIR sederhana)

Filter paling sederhana untuk sensor: rata-rata N sampel terakhir.

#define WINDOW 8
static uint16_t buf[WINDOW];
static uint32_t sum = 0;
static uint8_t idx = 0;
 
uint16_t filter(uint16_t sample) {
    sum -= buf[idx];        // buang sampel tertua
    buf[idx] = sample;
    sum += sample;
    idx = (idx + 1) % WINDOW;
    return (uint16_t)(sum / WINDOW);
}

Makin besar WINDOW, makin halus hasilnya — tapi makin lambat merespons perubahan (lag). Trade-off antara smoothness dan responsiveness ini keputusan desain, bukan angka ajaib.

#IIR Low-Pass (order 1)

Lebih hemat dan responsif daripada moving average:

static float y = 0.0f;
#define ALPHA 0.1f               // 0..1: kecil = lebih halus
 
float lowpass(float x) {
    y += ALPHA * (x - y);        // y = y + a*(x-y)
    return y;
}

IIR makin halus dengan ALPHA kecil, tapi tambah lag. Untuk MCU tanpa FPU, konversi ke fixed-point (di bawah) sering diperlukan.

#FFT: Melihat Frekuensi

FFT (Fast Fourier Transform) mengubah sinyal domain waktu menjadi domain frekuensi — untuk mendeteksi getaran khas, frekuensi mains (50 Hz), atau komponen harmonik. Implementasi embedded paling umum: CMSIS-DSP (ARM) — optimal untuk Cortex-M:

#include "arm_math.h"
 
static float32_t input[256];      // window sampel
static float32_t fft_out[256];    // kompleks: real+imag berselang
static float32_t mag[128];
 
arm_rfft_fast_instance_f32 fft;
arm_rfft_fast_init_f32(&fft, 256);
 
void analyze(void) {
    arm_rfft_fast_f32(&fft, input, fft_out, 0);   // forward FFT
    arm_cmplx_mag_f32(fft_out, mag, 128);          // magnitudo
    // mag[k] mewakili bin frekuensi k * (Fs/N)
}

Fs = 1000 Hz, N = 256  ->  resolusi = 1000/256 ≈ 3.9 Hz/bin
Puncak di bin 13       ->  frekuensi dominan ≈ 50 Hz

#Fixed-Point: DSP Tanpa FPU

Banyak MCU kecil tidak punya FPU — operasi float lambat. Solusinya fixed-point: representasikan nilai sebagai integer dengan skala tetap.

1.0  ->  32767
0.5  ->  16384
skala dikenal semua orang: konversi di awal, kalkulasi integer, skala kembali
 
CMSIS-DSP menyediakan versi q15/q31 dari semua filter & FFT

Aturan: kalau arsitektur target punya FPU (Cortex-M4F/M7) dan budget timing cukup, float32 lebih sederhana. Kalau tidak, fixed-point adalah jawabannya — CMSIS-DSP sudah menyediakannya.

#Praktik: DSP Pipeline

Alur khas firmware DSP — filter + FFT untuk deteksi getaran:

while (1) {
    for (i = 0; i < 256; i++) {
        input[i] = lowpass(adc_read());   // 1. IIR bersihkan noise
        wait_sample_period();             //    sampling konsisten
    }
    analyze();                            // 2. FFT lihat frekuensi
    if (detect_peak(&mag, 128))           // 3. deteksi puncak khas
        raise_alarm();                    //    aksi di perangkat
}

Perhatikan sampling konsisten — timer (episode 5), bukan delay() — karena FFT mengasumsikan interval tetap. Satu sampel "telat" merusak seluruh spektrum.

#Kesalahan Umum DSP

1. Sampling tidak konsisten — timer wajib; jitter merusak spektrum.
2. Mengabaikan Nyquist/alias — frekuensi palsu dihasilkan sendiri.
3. Window terlalu kecil untuk FFT — resolusi frekuensi buruk; pilih N sesuai.
4. Float di MCU tanpa FPU — kinerja jeblok; gunakan fixed-point.
5. Filter ditulis manual — lebih lambat & salah; pakai CMSIS-DSP.
6. Output tidak diskalakan — overflow/misinterpretasi nilai.

#Penutup

Inti yang harus dibawa pulang:

• Nyquist: sample minimal 2x frekuensi tertinggi; perhatikan alias.
• FIR stabil (fase linear, tap banyak); IIR hemat (feedback, berhati-hati stabilitas).
• Moving average & low-pass IIR membersihkan noise sensor; trade-off smoothness vs lag.
• FFT (CMSIS-DSP) mengungkap frekuensi; bin = k * Fs/N.
• Fixed-point untuk MCU tanpa FPU; sampling harus konsisten.

Di episode 23 selanjutnya kita masuk industri otomotif: Automotive & CAN — protokol CAN bus, CAN-FD, AUTOSAR, dan praktik firmware komunikasi kendaraan. Perangkat kalian siap masuk mobil!