Membawa Kecerdasan ke Chip Kecil: Contoh Pemrograman AI di Arduino IDE untuk Pemula (TinyML)

Dulu, kecerdasan buatan (Artificial Intelligence/AI) identik dengan server raksasa dan komputer super canggih. Namun, revolusi baru sedang terjadi. Kini, AI bisa berjalan di dalam mikrokontroler kecil seharga ratusan ribu rupiah. Ini disebut TinyML.

Bagi Anda pengembang IoT atau teknisi industri, kemampuan menjalankan AI langsung di perangkat (Edge Computing) adalah game changer. Anda bisa membuat sensor getaran yang “tahu” mesin akan rusak, atau kamera yang “melihat” produk cacat, tanpa perlu koneksi internet terus-menerus.

Di Kartanagari, kami sering mengimplementasikan teknologi ini untuk klien industri. Kali ini, kami akan membagikan contoh dasar bagaimana struktur pemrograman AI di dalam Arduino IDE.

Apa yang Anda Butuhkan?

Untuk menjalankan contoh ini, biasanya dibutuhkan:

1. Hardware:

   Board yang cukup powerful (seperti ESP32, Arduino Nano 33 BLE Sense, atau Raspberry Pi Pico).

2. Library:

   TensorFlow Lite for Microcontrollers (TFLite).

3. Model:

   File hasil “pelatihan” (training) yang sudah dikonversi menjadi array C byte.

Studi Kasus: Klasifikasi Gerakan (Smart Gesture)

Bayangkan kita ingin membuat alat yang bisa membedakan apakah alat sedang “DIAM” atau “DIGOYANG” (Wave), menggunakan sensor Accelerometer.

Alih-alih menulis kode if (x > 10), kita akan menggunakan model AI yang sudah dilatih untuk mengenali pola getaran yang kompleks.

Struktur Kode di Arduino IDE

Berikut adalah potongan kode (snippet) yang disederhanakan untuk menunjukkan logika bagaimana AI “ditanam” dalam skrip Arduino:

/*
  Contoh Sederhana Integrasi TinyML di Arduino IDE
  Kasus: Klasifikasi Gerakan (Diam vs Goyang)
  Oleh: Tim Engineering Kartanagari
*/

// 1. Include Library TensorFlow Lite
#include <TensorFlowLite.h>
#include "model_data.h" // File ini berisi 'otak' AI yang sudah dilatih

// Variabel Global untuk TFLite
tflite::MicroInterpreter* interpreter;
tflite::Model* model;
TfLiteTensor* input;
TfLiteTensor* output;

void setup(){
  Serial.begin(9600);

  // 2. Memuat Model AI (The Brain)
  model = tflite::GetModel(g_model_data);
  if (model->version() != TFLITE_SCHEMA_VERSION) {
    Serial.println("Error: Versi model tidak kompatibel!");
    return;
  }

  // 3. Alokasi Memori untuk Operasi AI
  static tflite::MicroMutableOpResolver<3> micro_op_resolver;
  micro_op_resolver.AddFullyConnected(); // Tambahkan operasi matematika yang dibutuhkan
  micro_op_resolver.AddSoftmax();
  
  // Inisialisasi Interpreter
  static tflite::MicroInterpreter static_interpreter(
      model, micro_op_resolver, tensor_arena, kTensorArenaSize, error_reporter);
  interpreter = &static_interpreter;
  interpreter->AllocateTensors();

  // Pointer ke input dan output model
  input = interpreter->input(0);
  output = interpreter->output(0);
}

void loop(){
  // 4. Input Data: Baca Sensor (Accelerometer)
  float x, y, z;
  bacaSensorIMU(&x, &y, &z); // Fungsi buatan untuk baca sensor fisik

  // Masukkan data sensor ke 'Input' Model AI
  input->data.f[0] = x;
  input->data.f[1] = y;
  input->data.f[2] = z;

  // 5. Proses Inferensi (AI Berpikir)
  TfLiteStatus invoke_status = interpreter->Invoke();
  if (invoke_status != kTfLiteOk) {
    Serial.println("Gagal menjalankan inferensi!");
    return;
  }

  // 6. Output: Baca Hasil Prediksi
  float probabilitas_diam = output->data.f[0];   // Index 0: Kelas 'Diam'
  float probabilitas_goyang = output->data.f[1]; // Index 1: Kelas 'Goyang'

  // 7. Keputusan (Decision Making)
  if (probabilitas_goyang > 0.8) {
    Serial.println("Status: ALAT SEDANG DIGOYANG! (Action: Kirim Alert)");
    // Tambahkan kode untuk menyalakan LED atau kirim data ke LoRaWAN disini
  } else {
    Serial.println("Status: Stabil.");
  }

  delay(100);
}

Penjelasan Logika Program

Kode di atas mungkin terlihat rumit, tapi intinya hanya ada 3 langkah utama:

1. Load Model (setup):

   Arduino memuat “otak” buatan (file model_data.h) ke dalam memori. File ini dihasilkan sebelumnya menggunakan Python/Google Colab saat fase training.

2. Invoke/Inference (loop):

   Arduino memasukkan data sensor mentah ke dalam model, lalu menyuruh model untuk “menghitung”.

3. Act (Aksi):

   Arduino membaca hasil probabilitas (misal: 90% yakin itu goyangan) dan melakukan aksi fisik seperti menyalakan relay atau mengirim notifikasi.

Mengapa Ini Penting untuk Industri?

Penerapan kode seperti ini adalah dasar dari Predictive Maintenance.

Ganti sensor “Goyangan” di atas dengan Sensor Getaran Industri, dan ganti target “Diam/Goyang” dengan “Mesin Sehat/Bearing Rusak”.

Dengan kode AI ini, mikrokontroler di pabrik Anda bisa mendeteksi kerusakan mesin dari pola getaran halus yang tidak mungkin diprogram dengan rumus if-else biasa.

Kesimpulan: Software + Hardware = Solusi Cerdas

Menulis kode AI di Arduino IDE adalah jembatan antara dunia data sains dan dunia fisik. Ini memungkinkan peralatan Anda menjadi lebih mandiri, responsif, dan hemat bandwidth.

Di Kartanagari, kami menggabungkan keahlian coding tingkat lanjut ini dengan instalasi hardware yang tangguh untuk menciptakan solusi IoT industri yang benar-benar cerdas.

Ingin menerapkan kecerdasan buatan pada produk atau mesin Anda?

Anda tidak perlu pusing dengan coding yang rumit. Serahkan pengembangan hardware dan software AIoT Anda kepada tim engineer Kartanagari.