Belajar Embedded Engineer - DSP & Signal Processing

#Pendahuluan

Banyak firmware tidak berurusan dengan "data" abstrak, melainkan dengan sinyal: audio dari mikrofon, getaran dari IMU, tegangan dari sensor medis. Sebelum sinyal itu bisa dipahami atau dijadikan input AI (episode 21), ia harus dibersihkan dan dianalisis — dan itulah pekerjaan DSP (Digital Signal Processing).

DSP adalah matematika yang berjalan dalam real-time: filter membuang noise, FFT mengungkap frekuensi yang terkandung, dan semua itu harus selesai sebelum sampel berikutnya tiba. Episode ini membangun fondasi DSP praktis untuk embedded: sampling, filter digital, FFT, dan desain pipeline real-time yang tidak putus di tengah aliran data.

#Sampling: Mengubah Dunia Nyata Jadi Angka

Perangkat membaca dunia nyata lewat ADC dengan kecepatan tertentu — itulah sampling rate. Dua aturan yang menentukan segalanya:

1. Nyquist theorem — untuk menangkap sinyal sampai frekuensi F, kalian harus sampling minimal 2×F. Mikrofon untuk suara manusia (0-4 kHz) butuh sampling ≥ 8 kHz.
2. Anti-aliasing — sinyal di atas setengah sampling rate akan "menipu" menjadi frekuensi lain (alias). Filter analog sebelum ADC, atau filter digital, harus membuangnya.

Suara manusia : sampling 16 kHz, filter low-pass 8 kHz
Audio musik   : sampling 44,1 kHz, filter 20 kHz
Getaran motor : sampling 1 kHz, filter 500 Hz
IMU gesture   : sampling 100-500 Hz

Kesalahan sampling adalah biang kegagalan DSP paling umum: sampling terlalu rendah → data "alias" → analisis frekuensi salah → kesimpulan salah. Selalu tentukan bandwidth sinyal kalian sebelum memilih sampling rate.

#Filter Digital: Membuang Noise

Filter digital menerima deret sampel dan mengeluarkan deret yang telah diubah. Dua keluarga utama:

FIR filter menghitung output sebagai penjumlahan bobot sampel masa lalu. Untuk 16 tap:

/* FIR filter 16 tap, order simetris (linear phase) */
static const float h[16] = { 0.001f, 0.013f, 0.045f, 0.100f,
                             0.160f, 0.210f, 0.230f, 0.240f,
                             0.240f, 0.230f, 0.210f, 0.160f,
                             0.100f, 0.045f, 0.013f, 0.001f };
 
float fir_process(float x) {
    static float buf[16];          /* ring buffer sampel (pola episode 3) */
    static uint8_t idx = 0;
 
    buf[idx] = x;                  /* simpan sampel terbaru */
    uint8_t i = idx;
    float y = 0.0f;
    for (uint8_t k = 0; k < 16; k++) {
        y += h[k] * buf[i];        /* bobot * sampel, urut mundur */
        i = (i == 0) ? 15 : (uint8_t)(i - 1);
    }
    idx = (uint8_t)((idx + 1) % 16);
    return y;
}

Perhatikan pola yang familiar: ring buffer dari episode 3 adalah infrastruktur DSP juga. Koefisien h[] tidak dihitung tangan — mereka dihasilkan oleh tool desain filter (SciPy, Octave) lalu ditanam sebagai tabel.

IIR filter jauh lebih ringkas (beberapa koefisien, memori kecil) — contoh biquad adalah blok bangunan standar:

/* IIR biquad (2 pole, 2 zero) — contoh struktur */
typedef struct {
    float b0, b1, b2, a1, a2;   /* koefisien dari tool desain */
    float z1, z2;               /* state */
} biquad_t;
 
float biquad_process(biquad_t *f, float x) {
    float y = f->b0 * x + f->z1;
    f->z1 = f->b1 * x - f->a1 * y + f->z2;
    f->z2 = f->b2 * x - f->a2 * y;
    return y;
}

Perhatikan: karena feedback (state z1, z2), IIR bisa tidak stabil jika koefisien salah. Inilah mengapa FIR lebih disukai untuk presisi — tapi IIR menang untuk hemat resource.

#FFT: Membaca Frekuensi dalam Sinyal

FFT (Fast Fourier Transform) mengubah sinyal dari domain waktu ke domain frekuensi — menjawab pertanyaan "frekuensi apa yang ada di sinyal ini?" Ini dasar dari deteksi nada, analisis getaran, dan banyak fitur audio.

Cara kerjanya: kumpulkan window sampel (biasanya 256/512/1024, pangkat dua), jalankan FFT, dan setiap bin output mewakili pita frekuensi:

sampling 16 kHz, window 512 sampel
-> 256 bin frekuensi, resolusi 16.000/512 = 31,25 Hz per bin
 
Bin 0  = 0 Hz (DC)
Bin 10 = 312,5 Hz
Bin 90 = 2.812,5 Hz (nada sekitar di sini jika ada)

Implementasi FFT di embedded biasanya memakai library matang (CMSIS-DSP, KissFFT, ARM's DSP) — jangan menulis FFT sendiri. Tapi memahami outputnya wajib: membaca bin, memilih window (Hamming/Hanning) untuk mengurangi kebocoran spektrum, dan menafsirkan magnitudo.

Aplikasi nyata yang sering muncul: deteksi anomali getaran — hitung FFT getaran motor sehat vs rusak; kerusakan bearing muncul sebagai puncak frekuensi khas. Ini dipakai di predictive maintenance industri (dan menjadi input TinyML di episode 21).

#Pipeline DSP Real-Time

DSP yang baik berjalan dalam pipeline yang deterministik — setiap sampel diproses dalam tenggat yang tetap:

Tiga aturan pipeline DSP embedded:

1. Sampling di ISR/DMA, pemrosesan di task — pola episode 8: jangan proses di ISR.
2. Proses per blok, bukan per sampel — kumpulkan window (misal 256 sampel), baru proses; lebih efisien dan sesuai pola FFT.
3. Deterministik — tanpa malloc, tanpa blocking I/O di path pemrosesan (episode 14).

#Praktik: Aplikasi DSP Pertama

1. Bangun FIR filter low-pass dengan koefisien dari SciPy (scipy.signal.firwin), tanam sebagai tabel.
2. Suntikkan sinyal uji: sinus 1 kHz + noise 5 kHz → pastikan noise hilang setelah filter.
3. Terapkan FFT (CMSIS-DSP atau KissFFT) pada window sinyal bersih dan bandingkan spektrum.
4. Bangun detektor nada: deteksi puncak bin frekuensi tertentu → LED menyala saat nada terdeteksi.
5. Ukur waktu pemrosesan per window dengan timer — pastikan jauh di bawah interval window.

#Common Pitfalls

1. Sampling tanpa anti-aliasing — frekuensi alias merusak analisis.
2. Integer overflow di filter/FFT — hasil terlihat seperti noise acak.
3. Memproses di ISR — pipeline jitter dan deadline terlewat.
4. Menulis FFT sendiri — gunakan library teruji; fokus pada interpretasi.
5. Tidak menguji dengan sinyal known-answer — bug matematika baru kelihatan di lapangan.

#Penutup

Inti yang harus dibawa pulang:

• Sampling ≥ 2× bandwidth (Nyquist); anti-aliasing wajib.
• FIR stabil dan presisi; IIR hemat resource tapi bisa tidak stabil.
• FFT mengungkap frekuensi — baca bin dengan benar, pakai library matang.
• Pipeline DSP: sampling di ISR/DMA, proses per blok, deterministik.
• Selalu uji dengan sinyal known-answer dan jaga tipe data dari overflow.

Di episode 23 selanjutnya kita masuk ke dunia industri yang paling menuntut: automotive & industrial embedded — CAN, AUTOSAR, dan protokol industri, dengan praktik menyiapkan komunikasi CAN pertama. Inilah dunia di mana ASIL dari episode 20 menjadi nyata setiap hari. Sampai jumpa di episode 23!