Belajar Embedded Engineer - Arsitektur Sistem Embedded

#Pendahuluan

Di episode 1 kalian tahu apa itu embedded engineer dan perangkat apa saja yang mereka tangani. Sekarang saatnya membuka kap mesin: memahami arsitektur yang menyatukan semua komponen itu. Episodo ini adalah lensa yang akan kalian pakai untuk membaca datasheet board apa pun — termasuk board yang belum pernah kalian pegang.

Mengapa arsitektur penting? Karena di embedded, kalian tidak bisa menulis kode tanpa tahu di mana ia hidup. Kode disimpan di flash, data berjalan di RAM, dan peripheral diakses lewat blok register di alamat tertentu. Datasheet adalah peta — dan episode ini mengajari kalian membaca petanya sebelum mencari harta karun.

#MCU vs SoC

Istilah yang paling sering membingungkan pemula adalah perbedaan MCU (microcontroller) dan SoC (System-on-Chip):

Bayangkan MCU sebagai dapur kamar kos: semuanya serba pas, satu kompor, satu kulkas kecil, cukup untuk memasak menu sederhana. SoC adalah dapur restoran: banyak peralatan, ruang luas, bisa masak banyak menu sekaligus — tapi butuh lebih banyak energi dan sumber daya untuk dikelola.

Di arsitektur embedded Linux (episode 10), SoC sering berdampingan dengan MCU kecil sebagai companion untuk tugas real-time — pola yang disebut heterogeneous architecture.

#Struktur Memory Map

Setiap MCU menerbitkan memory map — peta alamat yang menentukan di mana segala sesuatu tinggal. Untuk STM32F4 (Cortex-M4) peta konseptualnya kira-kira begini:

Tiga wilayah yang wajib kalian hafal:

1. Flash — menyimpan instruksi program dan konstanta. Isinya bertahan tanpa listrik.
2. RAM — menyimpan variabel runtime, stack, dan heap. Volatile; hilang saat mati.
3. Peripheral registers — jendela ke hardware: menulis register GPIO artinya memerintah pin fisik.

#Peripheral: Jendela ke Dunia Nyata

Peripheral adalah modul hardware di dalam MCU yang berkomunikasi dengan dunia luar: GPIO untuk pin digital, UART/SPI/I2C untuk komunikasi, timer untuk pengukuran waktu, ADC untuk membaca tegangan. Kalian mengendalikannya bukan dengan fungsi ajaib, melainkan dengan menulis register.

Peripheral modelnya begitu: setiap modul punya blok register di memory map, masing-masing register punya fungsi per bit. Contoh STM32F4 GPIOA (base address 0x40020000):

/* GPIOA_MODER: 2 bit per pin untuk memilih mode (input/output/alternate) */
#define GPIOA_MODER (*(volatile uint32_t *)0x40020000)
 
/* Set pin 5 ke mode output: MODER[11:10] = 01 */
GPIOA_MODER = (GPIOA_MODER & ~(0x3UL << 10)) | (0x1UL << 10);

Pola read-modify-write di atas adalah cara standar mengubah sebagian bit tanpa merusak bit lain. Library seperti STM32 HAL dan Arduino hanyalah pembungkus rapi dari operasi register seperti ini — ketika kalian paham level bawahnya, library apa pun terasa transparan.

#Praktik: Memetakan Arsitektur Board

Mari petakan board kalian sendiri. Ambil board yang kalian siapkan di episode 0, buka datasheet/reference manual-nya, dan isi tabel berikut:

Kategori             | Isi
-------------------- | -------------------------
MCU / SoC            | STM32F401RE, ESP32-WROOM, RP2040
Arsitektur CPU       | ARM Cortex-M4, Xtensa LX6
Flash                | 512 KB (0x08000000)
RAM                  | 96 KB   (0x20000000)
Base GPIO            | GPIOA @ 0x40020000
Peripheral utama     | UART2, SPI1, I2C1, TIM2
Tegangan logic       | 3.3V

Cara mengisi: dari halaman "Memory Map" dan "Pin Multiplexing" di reference manual (STM32) atau datasheet (ESP32). Untuk STM32 gunakan RM0368 Reference Manual; untuk RP2040 gunakan datasheet 646 halaman resmi Raspberry Pi.

Saat memetakan, perhatikan satu detail kritis: pin multiplexing. Sebuah pin fisik bisa berfungsi sebagai GPIO, UART TX, atau PWM — tergantung register alternate function yang kalian set. Kesalahan paling umum pemula: menghubungkan sensor ke pin yang sebenarnya sudah dipakai peripheral lain. Pemetaan board menyelesaikan kebingungan ini sebelum terjadi.

#Common Pitfalls

1. Mengira semua MCU sama. STM32 dan ESP32 punya memory map berbeda — kode yang satu tidak otomatis jalan di yang lain. Selalu baca reference manual board kalian.
2. Mengabaikan datasheet. "Coba-coba" tanpa datasheet berakhir dengan pin terbakar atau berjam-jam debugging yang sia-sia.
3. Menulis ke register tanpa memahami fungsi bitnya. Baca tabel bit di reference manual sebelum menulis nilai apa pun ke register.
4. Lupa perbedaan MCU dan SoC. Memaksa pola MCU (bare-metal C) di platform Linux board, atau sebaliknya, adalah sumber konflik arsitektur paling umum di tim.

#Penutup

Inti yang harus dibawa pulang:

• MCU = resource kecil tanpa OS; SoC = prosesor kuat yang menjalankan Linux. Keduanya saling melengkapi.
• Memory map punya tiga wilayah inti: Flash (kode), RAM (data), dan peripheral registers (kontrol hardware).
• Peripheral dikendalikan dengan menulis register — pola read-modify-write adalah bread and butter firmware.
• Petakan board kalian sekarang: CPU, flash, RAM, base address GPIO, dan peripheral utamanya.

Di episode 3 selanjutnya kita masuk ke bahasa: C/C++ untuk embedded — pointer, memory management, volatile, dan pola-pola kode embedded yang menentukan apakah firmware kalian andal atau rapuh. Fondasi arsitektur yang barusan dibangun akan dipakai langsung untuk memahami mengapa kode embedded ditulis seperti yang kalian lihat. Sampai jumpa di episode 3!