Belajar Firmware Engineer - TinyML Firmware

#Pendahuluan

Setelah di episode 20 firmware kita layak disertifikasi, pada episode ini kita menaruh kecerdasan buatan di dalam chip. TinyML — inferensi machine learning yang berjalan di MCU — adalah salah satu track pertumbuhan tercepat di firmware 2026 (episode 1 dan 26), dan membuka kelas produk yang sebelumnya mustahil: deteksi kata kunci, deteksi anomali motor, gesture control, semuanya tanpa cloud.

Mengapa TinyML penting? Karena mengirim semua data ke cloud itu mahal, lambat, dan sensitif. Dengan inferensi di perangkat: latensi hilang, privasi terjaga (data tidak pergi ke mana-mana), offline tetap bekerja, dan daya lebih hemat (tidak perlu selalu mengirim data). Perangkat pintar sejati memproses di tempatnya.

#Apa Itu TinyML?

TinyML = menjalankan model ML pada perangkat dengan RAM puluhan–ratusan KB dan flash 1–2 MB. Berbeda dari AI di cloud:

Contoh nyata: sensor gudang mendeteksi anomali getaran motor di perangkat, lalu hanya mengirim alert — bukan raw data sepanjang hari.

#Siklus Hidup Model

Alur dari data sampai firmware:

#Kuantisasi: Float → Int

Model float32 (4 byte/nilai) terlalu besar untuk MCU. Kuantisasi int8 memetakan rentang nilai ke 8-bit — ukuran turun ±4x dan lebih cepat di hardware MCU:

float 0.0 .. 1.0  -->  int8 0 .. 127
scale & zero-point  → disimpan di metadata model
 
Keuntungan : ukuran kecil, inferensi cepat, hemat daya
Harga     : akurasi sedikit turun (biasanya 1-3%)

Quantization-aware training (simulasi kuantisasi saat training) mengurangi penurunan akurasi secara signifikan — pilihan pertama jika target int8.

#Runtime: TensorFlow Lite Micro

Di MCU, model berjalan lewat TFLite Micro — interpreter minimalis. Konsep kuncinya:

• Tensor arena: buffer memori tunggal yang dialokasikan sekali (statis) untuk semua tensor.
• Interpreter: memuat model dari array C, menjalankan inferensi di arena.

#include "tensorflow/lite/micro/micro_interpreter.h"
#include "model_data.h"       // model ter-embed sebagai array
 
static uint8_t tensor_arena[40 * 1024];   // arena statis
 
int run_inference(const float *input, float *output) {
    static tflite::MicroInterpreter interpreter(
        model_data, resolver, tensor_arena, sizeof(tensor_arena));
 
    // 1. salin input ke input tensor
    memcpy(interpreter.input(0)->data.f, input,
           interpreter.input(0)->bytes);
    // 2. jalankan inferensi
    if (interpreter.Invoke() != kTfLiteOk) return -1;
    // 3. baca output
    memcpy(output, interpreter.output(0)->data.f,
           interpreter.output(0)->bytes);
    return 0;
}

Arena statis adalah pola episode 8 dalam aksi: tanpa malloc di jalur inferensi — buffer disiapkan sekali, deterministik dan aman untuk real-time.

#Praktik: Deteksi Sinyal Sederhana

Contoh end-to-end untuk sinyal 1-D (misal anomali motor): feed window sinyal 64 sample, output probabilitas "normal/anomali":

// setiap window 64 sample dari ADC:
float window[64];
int16_t class = -1;
float score = 0.0f;
 
while (1) {
    sample_window(&window);                  // isi 64 sample
    if (run_inference(window, &score) == 0) {
        class = (score > 0.5f) ? ANOMALY : NORMAL;
        if (class == ANOMALY) alert_server(); // kirim hanya alert
    }
}

Pola ini memakai prinsip yang sudah kalian kuasai: sampling ADC (episode 5), buffer statis (episode 8), dan real-time budget (episode 16). TinyML bukan sihir — ia model + disiplin firmware.

#Kesalahan Umum TinyML

1. Model float di MCU — ukuran dan kecepatan tidak realistis; kuantisasi int8 dulu.
2. Arena terlalu kecil — kTfLiteError saat inisialisasi; hitung kebutuhan memory.
3. Mengirim raw data terus — menyia-nyiakan keunggulan edge; inferensi di perangkat.
4. Akurasi PC ≠ akurasi MCU — test di target (kondisi nyata, noise nyata).
5. Data tidak seimbang saat training — model bias; kelas minoritas selalu salah.
6. Melupakan update model — model juga butuh jalur update (episode 13/19).

#Penutup

Inti yang harus dibawa pulang:

• TinyML = inferensi ML di MCU: latensi rendah, privasi, offline, hemat daya.
• Alur: train → convert → quantize int8 → embed C array → TFLite Micro.
• Kuantisasi int8 memangkas ukuran ±4x dengan akurasi hampir sama.
• Tensor arena statis = buffer sekali alokasi; ramah real-time.
• Ukur arena dan latensi di target sebelum desain final.

Di episode 22 selanjutnya kita memproses sinyal: DSP & Signal Processing — filter FIR/IIR, FFT, dan pemrosesan sinyal real-time di firmware. Perangkat kalian akan mendengar dan melihat lebih tajam!