Konsep Sistem Tertanam

Papan mikrokontroler Breadboard + jumper
Arduino Uno · ESP32 · STM32 merangkai tanpa solder
Sensor Servo / motor DC
LDR · suhu · jarak · DHT/BME aktuator (PWM)
Cukup satu papan mikrokontroler, breadboard, dan beberapa

LED + resistor Push button
output digital paling dasar input digital
v
Kabel USB Multimeter / logic analyzer
daya + upload program mengukur dan debugging
komponen dasar untuk mengikuti seluruh materi

Sistem tertanam (embedded system)
adalah sistem komputer khusus yang
menjadi bagian dari perangkat atau sistem
yang lebih besar
Dirancang untuk satu fungsi atau
sekumpulan tugas tertentu
Biasanya berjalan terus-menerus tanpa
campur tangan pengguna
Pengguna melihat produknya (mesin cuci,
AC), bukan "komputernya"

PERANGKAT: mesin cuci
INPUT Catu daya OUTPUT
Sensor Motor
level air drum
SISTEM
TERTANAM
Sensor
(MCU + firmware) Pompa air
suhu
Tombol Display /
program buzzer
Satu fungsi khusus:
mengatur siklus cuci secara otomatis
Pengguna melihatnya sebagai "mesin cuci",
bukan sebagai komputer.

Fungsi khusus: dirancang untuk satu
pekerjaan
Ukuran kecil & hemat daya: sering
bertenaga baterai
Sumber daya terbatas: memori dan
prosesor secukupnya
Real-time: harus merespons dalam batas
waktu tertentu
Andal: berjalan 24/7, sering dipasang di
tempat sulit dijangkau

Fungsi
khusus
Andal Ukuran
24/7 kecil
Sistem
tertanam
Sumber daya Hemat
terbatas daya
Real-time

1966 1974 1996
Apollo Guidance TI TMS1000 Atmel
Computer (NASA) mikrokontroler awal memori flash
1971 1980
Intel 4004 Intel 8051
mikroprosesor 1-chip (MCS-51)
Dari komputer navigasi Apollo hingga mikrokontroler

2005 2016
AVR Arduino ESP32
on-chip belajar jadi mudah Wi-Fi + Bluetooth
2004 2007
ARM Cortex-M3 STM32
inti 32-bit murah famili Cortex-M ST
Wi-Fi yang harganya hanya beberapa dolar

Rumah tangga Otomotif
Mesin cuci, kulkas, AC ECU mesin (injeksi BBM)
Microwave, rice cooker ABS, airbag, TPMS
Remote & smart plug Lampu, jendela, sensor
Medis Elektronik konsumen
Alat pacu jantung TV pintar, kamera digital
Pemantau tekanan darah Jam tangan pintar
Pompa infus, glukometer Konsol game, drone
Sistem tertanam ada di hampir semua

Industri
PLC & robot pabrik
Kontrol proses & motor
parkir Sensor jalur produksi
IoT & kota pintar
Sensor pertanian
Lampu jalan cerdas
Pelacak GPS, smart meter
perangkat elektronik di sekitar kita

Catu daya
+ regulator
MIKROKONTROLER
Sensor analog Pengondisi digital
CPU
(suhu, cahaya, sinyal
jarak, tombol) + ADC
Timer
dunia nyata
dunia digital / pengguna
Antarmuka pengguna
(tombol, display, LED)
Alur umum: sensor → pemrosesan → aktuator, dengan

kendali Driver daya Aktuator
Memori
(transistor, (motor, lampu,
H-bridge) buzzer, relay)
GPIO
Komunikasi: UART · SPI · I2C · Wi-Fi
· Bluetooth
catu daya dan komunikasi sebagai pendukung

Perangkat keras: mikrokontroler, memori,
sensor, aktuator, catu daya
Firmware: program yang tersimpan di
memori flash dan berjalan begitu daya
menyala
Dapat berupa bare-metal (tanpa OS) atau
berjalan di atas RTOS
Umumnya ditulis dalam C/C++ (kadang
assembly)
Pembaruan firmware: lewat
kabel/programmer atau OTA (over-the-air)

Aplikasi
ERAWMRIF
logika program: kontrol suhu, protokol
RTOS / middleware
/
KANUL
task, jaringan, file system
TAKGNAREP
Driver / HAL
GPIO, UART, SPI, I2C, ADC
Boot & startup
reset vector, inisialisasi clock
Perangkat keras
MCU, memori, sensor, aktuator
Firmware tersimpan di memori flash
dan berjalan begitu daya menyala

Biaya: harga per unit sangat menentukan
pada produksi massal
Daya: baterai harus awet berbulan-bulan
Ukuran & berat: harus muat di dalam
produk
Memori & kinerja: KB–MB memori,
puluhan–ratusan MHz
Waktu rilis, keandalan, dan keamanan
juga membatasi pilihan

Biaya
trade-off
desain
Kinerja Daya
Kinerja naik → daya & biaya naik
Daya turun → clock diturunkan, kinerja turun
Biaya turun → memori dan fitur terbatas

MIKROPROSESOR (MPU): banyak chip di satu papan
CPU
(mikroprosesor)
BUS alamat · data · kontrol
ROM / Pengendali Timer /
RAM
Flash I/O UART
chip terpisah, papan lebih besar, daya & biaya lebih tinggi
Mikrokontroler = CPU + memori

MIKROKONTROLER (MCU): semua dalam satu chip
satu chip (SoC)
CPU Flash RAM Timer
bus internal
GPIO ADC UART SPI / I2C
ukuran kecil, hemat daya, murah, siap pakai
+ periferal dalam satu chip

von Neumann: satu memori, satu bus
satu bus Memori
CPU (program
+ data)
instruksi dan data bergantian lewat
bus yang sama (bottleneck)
Contoh: PC (x86), Cortex-M0/M0+
Harvard memungkinkan instruksi dan data

Harvard: memori program & data terpisah
Memori program
bus instruksi
(Flash)
CPU
bus data Memori data
(SRAM)
instruksi dan data diakses bersamaan
(lebih cepat)
Contoh: AVR, 8051, PIC, Cortex-M3/M4 (modified)
diakses serentak, sehingga lebih cepat

RISC: instruksi sedikit, sederhana, panjang
tetap (ARM, AVR, RISC-V)
CISC: instruksi banyak dan kompleks (x86,
8051)
Pipeline memecah eksekusi menjadi tahap
fetch–decode–execute yang tumpang tindih
Throughput naik: mendekati 1 instruksi per
siklus
Cortex-M3/M4 memakai pipeline 3 tahap

Nomor siklus clock
Tanpa pipeline: 2 instruksi = 6 siklus
1 2 3 4 5 6
I1 F D E
I2 F D E
Dengan pipeline: 4 instruksi = 6 siklus
1 2 3 4 5 6
I1 F D E
I2 F D E
I3 F D E
I4 F D E
F = fetch D = decode E = execute
Tiap siklus, tahap berbeda bekerja paralel

Fetch: CPU mengambil instruksi dari
memori pada alamat yang ditunjuk PC
Decode: unit kontrol menafsirkan opcode
dan operand
Execute: ALU, memori, atau I/O
mengerjakan operasi
PC bertambah, lalu siklus berulang tanpa
henti
Lompatan (jump) dan interupsi mengubah
nilai PC

1 FETCH
ambil instruksi dari
memori[PC]
PC
+ 1
3 EXECUTE 2 DECODE
ALU / memori / I/O unit kontrol menafsirkan
mengerjakan operasi opcode & operand
Contoh instruksi: ADD R1, R2
R1 ← R1 + R2, lalu PC menunjuk instruksi berikutnya
diulang jutaan–miliaran kali per detik

Register umum (R0–R15): tempat data
sementara, akses 1 siklus
PC (program counter): alamat instruksi
berikutnya
SP (stack pointer): puncak stack untuk
variabel lokal, alamat balik, dan konteks
Status/flag: hasil operasi terakhir (nol,
negatif, carry, overflow)
ALU memakai register sebagai operan dan
penyimpan hasil

REGISTER UMUM (R0–R15) STACK (SRAM)
R0 R1 R2 R3
R4 R5 R6 R7
R8 R9 R10 R11
SP
R12 R13 R14 R15 (kosong)
data C
PC SP
data B
alamat instruksi berikut puncak stack
STATUS (FLAG) data A
N Z C V
negatif · nol · carry · overflow
Register = memori tercepat, ada di dalam CPU

MCU memakai satu ruang alamat untuk
Flash, SRAM, dan register periferal
Memory-mapped I/O: menulis ke alamat
tertentu = mengatur GPIO, timer, UART
Flash: program dan konstanta (non-volatile)
SRAM: variabel, stack, heap (hilang saat
daya mati)
Alamat dasar berbeda per chip: lihat
datasheet / reference manual

tinggi
0xE000 0000
Sistem (NVIC, SysTick) interrupt & debug
0x4000 0000
Register periferal GPIO, timer, UART
0x2000 0000
SRAM variabel, stack, heap
0x0800 0000
Flash program & konstanta
rendah
Contoh peta memori MCU STM32 (Cortex-M)

DALAM SATU CHIP MIKROKONTROLER
Pengendali
CPU core
interupsi
BUS INTERNAL (alamat
Timer
GPIO ADC UART
PWM
LED, motor, sensor PC, GPS,
tombol servo analog modul
Periferal terhubung ke bus internal

Flash SRAM
(program) (data)
· data · kontrol)
SPI I2C Watchdog RTC
SD card, sensor, reset jam &
display EEPROM otomatis alarm
dan ke dunia luar lewat pin

Clock = detak yang mengatur kecepatan
CPU dan periferal
Sumber: osilator RC internal atau kristal
eksternal (lebih akurat)
PLL mengalikan frekuensi; prescaler
membaginya
Clock tinggi → cepat, tetapi boros daya
Reset: power-on, tombol, watchdog,
brown-out; CPU mulai dari reset vector

CLOCK
CPU
Kristal PLL Prescaler
16 MHz × n ÷ n Periferal
Timer
RESET
ATAU
Power-on reset
Tombol RESET
CPU mulai dari
reset vector
Watchdog timeout
(alamat awal program)
Brown-out

Papan = MCU + regulator + USB-serial +
header pin
Pin digital 0–13 (PWM pada 3, 5, 6, 9, 10,
11)
Pin analog A0–A5 terhubung ke ADC 10 bit
Daya lewat USB (5 V) atau jack 7–12 V
LED bawaan di pin 13 (LED_BUILTIN)

4
6
1
3 ATmega328P
8
2
7
5
1 USB (daya + program) 5 Pin analog A0–A5 + daya
2 DC jack 7–12 V 6 Tombol reset
3 Mikrokontroler ATmega328P 7 Kristal 16 MHz
4 Pin digital 0–13 (PWM: ~) 8 Regulator 5 V / 3,3 V

BUILD (di komputer)
main.c Preprocessor Compiler
kode sumber #include, #define C → assembly
firmware.elf objcopy
kode + simbol debug → .hex / .bin
FLASH (ke chip) Satu klik "Upload"
Kompilasi silang (cross-compile): dibuat

Assembler Linker
assembly → .o + library & linker script
Flasher Memori flash MCU
bootloader / SWD / JTAG program siap dijalankan
di IDE menjalankan semua tahap ini
di PC, dijalankan di mikrokontroler

IDE: Arduino IDE, PlatformIO (VS Code),
STM32CubeIDE, ESP-IDF
Bootloader: program kecil di chip yang
menerima firmware lewat USB-serial
Debugger SWD/JTAG: flash sekaligus
debugging (breakpoint)
Pilih board dan port yang benar sebelum
upload
Gagal? Cek kabel data, driver
(CH340/CP210x), dan mode boot

A. Lewat bootloader (Arduino, ESP32)
USB
USB-serial MCU
PC / IDE
+ bootloader (flash)
B. Lewat debugger (STM32, ARM)
SWDIO
USB
ST-Link / SWCLK MCU
PC / IDE
J-Link (target)
GND
Debugger juga bisa: breakpoint, step, baca register
dan memori saat program berjalan
SWD = Serial Wire Debug (2 kabel + GND)

// Blink: LED pada pin 13 berkedip tiap detik
const int LED = 13;
void setup() {
pinMode(LED, OUTPUT); // pin 13 sebagai
}
void loop() {
digitalWrite(LED, HIGH); // nyalakan LED
delay(500); // tunggu 500 ms
digitalWrite(LED, LOW); // matikan LED
delay(500);
}

setup() dijalankan sekali saat
mulai
loop() diulang selamanya
delay() menahan CPU (blocking)
output
Periode 1 s → frekuensi 1 Hz

Alur: edit → build → flash → uji → debug (diulang)
Periksa polaritas (VCC/GND) sebelum menyalakan
Jangan melebihi tegangan logika pin (5 V vs
Beri resistor pada LED; jangan hubungkan pin
Matikan daya sebelum mengubah rangkaian
Hindari ESD: sentuh logam ber-ground dulu,
Simpan kode di Git dan beri komentar yang

daya
3,3 V)
output langsung ke GND/VCC
pegang papan pada tepinya
jelas

GPIO = General Purpose Input/Output: pin
serbaguna yang dapat diprogram
Dikelompokkan dalam port (mis. PORTB
berisi 8 pin)
Output: MCU menulis HIGH/LOW untuk
LED, relay, dll.
Input: MCU membaca level HIGH/LOW dari
tombol atau sensor digital
Arah diatur oleh register arah (DDR /
MODER)

+VCC
pull-up
internal
DDR
(arah: 1 = output)
enable
PIN
PORT
(data keluar)
PIN
(data masuk)
buffer input
Satu pin bisa menjadi input atau output
sesuai isi register arah

Logika digital hanya mengenal HIGH dan
LOW
Ambang bergantung pada tegangan sistem
(5 V atau 3,3 V)
Di antara ambang = tidak terdefinisi →
hasil acak
Arus pin terbatas (tipikal ≈ 20 mA); cek juga
batas per port/chip
5 V → 3,3 V hanya lewat level shifter atau
pembagi tegangan

Sistem 5 V
5 V
HIGH
Sistem 3,3 V
≈ 3,5 V
3,3 V
HIGH
tak terdefinisi
≈ 2,3 V
tak terdefinisi
≈ 1,5 V
≈ 1,0 V
LOW
LOW
0 V 0 V
Jangan hubungkan output 5 V ke input 3,3 V!
Gunakan level shifter atau pembagi tegangan

LED butuh resistor pembatas arus
Rumus: R = (V − V ) / I
pin f
Contoh: (5 − 2) V / 10 mA = 300 Ω → pakai
330 Ω
LED menyala saat arus mengalir dari pin ke
GND (active-high)
Arus 5–15 mA sudah cukup terang untuk
indikator

R = 330 Ω
D13
MCU
I LED
Hukum Ohm: R = (V_pin − V_f) / I
= (5 V − 2 V) / 10 mA = 300 Ω
dipilih nilai standar 330 Ω
I = 3 V / 330 Ω ≈ 9 mA (aman, di bawah 20 mA)
V_f = tegangan maju LED (merah ≈ 2 V)

Pin input tidak boleh floating: harus punya
level pasti
Pull-up: lepas = HIGH, ditekan = LOW
(logika terbalik)
Pull-down: lepas = LOW, ditekan = HIGH
Resistor umum 10 kΩ, atau pakai pull-up
internal (INPUT_PULLUP)
Pull-up internal AVR ≈ 20–50 kΩ

PULL-UP PULL-DOWN
+VCC +VCC
10 kΩ
ke pin ke pin
MCU MCU
10 kΩ
Tanpa resistor, pin "mengambang" (floating)
→ pembacaan acak
Lepas: HIGH Lepas: LOW
Ditekan: LOW Ditekan: HIGH
(logika terbalik) (logika normal)

Kontak mekanis memantul sesaat → satu
tekanan terbaca banyak kali
Durasi bounce ≈ 1–20 ms
Debounce perangkat lunak: baca ulang
setelah ±20 ms, terima jika stabil
Debounce perangkat keras: kapasitor
(RC) atau Schmitt trigger
Jangan pakai delay() panjang untuk
debounce di sistem multitugas

tombol ditekan
Ideal
bounce ≈ 1–20 ms
Nyata (bouncing)
Setelah debounce
Satu tekanan terbaca banyak kali → perlu debounce
(tunda beberapa ms atau pakai kapasitor/filter)

// AVR ATmega328P: LED pada PB5 (pin 13)
DDRB |= (1 << DDB5); // PB5 sebagai output
PORTB |= (1 << PORTB5); // set bit -> HIGH
PORTB &= ~(1 << PORTB5); // clear bit -> LOW
PORTB ^= (1 << PORTB5); // toggle bit
// Membaca bit input (tombol di PD2)
if (PIND & (1 << PIND2)) {
// pin HIGH
}

SET (jadikan 1) bit 7 6 5 4 3 2 1 0
reg |= (1<<5);
sebelum 0 1 0 0 1 0 1 0
sesudah 0 1 1 0 1 0 1 0
CLEAR (jadikan 0)
reg &= ~(1<<5);
sebelum 0 1 1 0 1 0 1 0
sesudah 0 1 0 0 1 0 1 0
TOGGLE (balik)
reg ^= (1<<5);
sebelum 0 1 0 0 1 0 1 0
sesudah 0 1 1 0 1 0 1 0

const int BTN = 2; // tombol ke GND (pull-up internal)
const int LED = 13;
void setup() {
pinMode(BTN, INPUT_PULLUP);
pinMode(LED, OUTPUT);
}
void loop() {
if (digitalRead(BTN) == LOW) { // ditekan
digitalWrite(LED, HIGH);
} else {
digitalWrite(LED, LOW);
}
}

Teknik ini disebut polling: CPU terus
membaca tombol
Tombol aktif-LOW karena memakai
pull-up
Tambahkan debounce bila tombol
dipakai menghitung
Alternatif lebih efisien: interrupt
(Pertemuan 5)

event
POLLING
CPU rajin menanyakan "ada event?"
cek kerja lain cek kerja lain cek kerja lain cek kerja lain
event
INTERRUPT
perangkat "memanggil" CPU saat perlu
program utama (CPU mengerjakan tugas lain)
respons
Interrupt: CPU bekerja dan hanya "diganggu"

terjadi
cek kerja lain cek kerja lain cek kerja lain cek kerja lain cek
terlambat (latency) banyak siklus CPU terbuang untuk mengecek
terjadi
CPU bebas, respons cepat
ISR program utama dilanjutkan
segera
ketika benar-benar ada event

Perangkat meminta layanan lewat IRQ
(interrupt request)
CPU menyelesaikan instruksi, lalu
menyimpan konteks (PC, flag) ke stack
CPU melompat ke ISR (interrupt service
routine)
Instruksi RETI / return memulihkan
konteks
Latency interupsi: waktu dari event sampai
ISR mulai (beberapa–puluhan siklus)

Program utama berjalan
otomatis
Event / permintaan interupsi (IRQ)
CPU menyelesaikan instruksi saat ini
oleh
Simpan konteks (PC, flag) ke stack
hardware
Lompat ke ISR lewat vektor interupsi
Jalankan ISR (singkat!)
Pulihkan konteks (RETI / return)
Program utama dilanjutkan
lanjut tepat di instruksi yang tertunda

Tabel vektor = daftar alamat ISR untuk tiap
sumber interupsi
Sumber: timer, GPIO eksternal, UART,
ADC, dll.
Prioritas: interupsi penting dapat menyela
ISR lain (nested)
Cortex-M: kontroler NVIC; angka prioritas
kecil = lebih tinggi
Bit enable (lokal + global) harus aktif agar
interupsi bekerja

Alamat Vektor (alamat ISR)
0x0000 Nilai awal SP
0x0004 Reset_Handler
0x0008 NMI_Handler kode ISR
di Flash
0x000C HardFault_Handler
void
... ... EXTI0_IRQ-
Handler(void)
{
0x003C SysTick_Handler
...
}
0x0040 IRQ0 (WWDG)
... ...
0x0058 EXTI0_IRQHandler
... ...
Prioritas Cortex-M: angka kecil = prioritas tinggi

volatile bool tombolDitekan = false; // volatile!
void ISR_tombol() { // ISR: singkat dan cepat
tombolDitekan = true; // hanya set flag
}
void setup() {
pinMode(2, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(2),
ISR_tombol, FALLING);
}
void loop() {
if (tombolDitekan) {
tombolDitekan = false;
// ... proses di sini (kerja berat)
}
}

volatile untuk variabel yang diubah di
ISR
ISR singkat: set flag atau isi buffer
Hindari delay(),
Serial.print(), dan perulangan
panjang di ISR
Variabel > 8 bit di AVR: lindungi saat
dibaca (atomic)

RISING: dipicu saat sinyal naik LOW →
HIGH
FALLING: dipicu saat turun HIGH → LOW
(tombol dengan pull-up)
CHANGE: dipicu pada setiap perubahan
LOW level: dipicu terus selama sinyal LOW
Tombol yang memantul bisa memicu ISR
berkali-kali → debounce

Sinyal
RISING
FALLING
CHANGE
LOW level (terpicu selama sinyal LOW)
Panah = saat interupsi dipicu

Timer = register penghitung yang
bertambah tiap detak clock
Prescaler memperlambat clock agar
hitungan lebih lama
Saat counter = nilai compare (OCR) → flag,
interupsi, atau toggle pin
Dipakai untuk: penundaan akurat, PWM,
ukur frekuensi, jam sistem
Timer berjalan paralel dengan CPU,
sehingga CPU bebas bekerja

Clock Prescaler Counter
16 MHz ÷ 64 (TCNT)
OCR Komparator
(nilai banding) TCNT = OCR ?
jika sama = compare match
Flag → Toggle Reset counter
interupsi ISR pin output (mode CTC)
Timer = penghitung yang berdetak dari clock;
saat mencapai nilai tertentu ia memicu aksi.

f = f / prescaler
timer clk
OCR = f / (prescaler × f ) − 1
clk target
Contoh: 16 MHz, prescaler 64 → 250 kHz (4
µs per hitungan)
Target 1 ms → OCR = 250 − 1 = 249
Pilih prescaler agar OCR muat di register (8
bit ≤ 255, 16 bit ≤ 65535)

TCNT
OCR
249
0
waktu
flag
T = 1 ms
f_timer = 16 MHz / 64 = 250 kHz → 1 hitungan = 4 µs
250 hitungan × 4 µs = 1 ms → OCR = 250 − 1 = 249
ISR dipanggil tiap 1 ms ("detak" sistem)

// Timer1 mode CTC: interupsi tiap 1 detik (16 MHz)
volatile bool ledState = false;
void setup() {
pinMode(13, OUTPUT);
noInterrupts();
TCCR1A = 0;
TCCR1B = (1 << WGM12) | (1 << CS12); // CTC, prescaler 256
OCR1A = 62499; // 16e6 / 256 = 62500 Hz -> 1 detik
TIMSK1 = (1 << OCIE1A); // aktifkan compare-match interrupt
interrupts();
}
ISR(TIMER1_COMPA_vect) { // dipanggil tiap 1 detik
ledState = !ledState;
digitalWrite(13, ledState);
}
void loop() { /* CPU bebas mengerjakan tugas lain */ }
Hitungan: 16 MHz / 256 = 62.500 Hz → 62.500 hitungan = 1 s → OCR1A

= 62.500 − 1 = 62.499.

Dunia analog
sampling +
kuantisasi
MCU
ADC (angka
digital)
0110 1010
sensor: suhu, cahaya,
suara, tekanan
MCU hanya memahami angka biner
ADC mengubah analog → digital; DAC

Dunia analog
DAC /
PWM
…
aktuator: kecerahan,
kecepatan, suara
→ perlu konversi di kedua arah
atau PWM mengubah digital → analog

Sampling: tegangan diukur pada selang
waktu tetap
Kuantisasi: nilai dibulatkan ke salah satu
n
dari 2 level
Pengkodean: level dinyatakan sebagai
bilangan biner n bit
Selisih nilai asli dan hasil = error kuantisasi
(≤ ½ LSB)
Contoh pada gambar: 3 bit = 8 level

tegangan
111
110
101
100
011
010
001
000
waktu
● sampel nilai asli ■ hasil kuantisasi (3 bit = 8 level)
Garis biru: sinyal analog asli

n
Resolusi: n bit → 2 level
n
LSB = V / 2
ref
Contoh: ADC 10 bit, V = 5 V → LSB = 5 / 1024
ref
n
Nilai digital = V / V × 2 (dibulatkan ke bawah)
in ref
Nyquist: laju sampling harus > 2 × frekuensi
Arduino Uno: 10 bit (0–1023); STM32 umumnya
CONTOH HITUNG
V_in = 2,5 V, V_ref = 5 V, 10 bit → nilai ≈ 2,5 / 5 × 1024 = 512

≈ 4,88 mV
tertinggi sinyal
12 bit (0–4095)

SAR (Successive Approximation) adalah
tipe ADC paling umum di MCU
Menebak bit dari MSB ke LSB,
dibandingkan dengan keluaran DAC internal
n bit → hanya n perbandingan per konversi
Waktu konversi ≈ puluhan µs (Arduino Uno
≈ 100 µs)
Jenis lain: flash (sangat cepat),
sigma-delta (resolusi tinggi, lambat)

Vin Register SAR
Komparator
(sample) (logika tebak biner)
DAC
Contoh: 4 bit, Vref = 5 V, Vin = 3,4 V
Langkah Tebakan V_DAC Vin ≥ V_DAC? Bit
1 1000 2,500 V Ya 1
2 1100 3,750 V Tidak 0
3 1010 3,125 V Ya 1
4 1011 3,438 V Tidak 0
Hanya 4 perbandingan untuk 4 bit (pencarian biner)
Hasil = 1010₂ = 10 → 3,125 V (1 LSB = 5/16 = 0,3125 V)

Banyak sensor mengubah besaran fisik
menjadi hambatan (LDR, termistor)
Pembagi tegangan mengubah hambatan
menjadi tegangan
V = V × R / (R + R )
out cc 2 1 2
Pilih R ≈ hambatan sensor pada titik kerja
1
tengah
Sensor lain langsung keluar tegangan:
LM35 (10 mV/°C), potensiometer

+5 V
R1 = 10 kΩ
pin ADC
Vout
LDR
= Vcc × R2 / (R1+R2)
(R2)
Terang: R2 ≈ 1 kΩ → Vout ≈ 0,45 V → ADC ≈ 93
Gelap: R2 ≈ 100 kΩ → Vout ≈ 4,55 V → ADC ≈ 930
(ADC 10 bit: nilai = Vout / 5 V × 1024)
Pembagi tegangan mengubah hambatan → tegangan

DAC mengubah kode digital menjadi
tegangan analog
n
V = V × kode / 2
out ref
R-2R ladder: hanya memakai dua nilai
resistor
Beberapa MCU punya DAC internal
(STM32, ESP32: 8 bit, 2 kanal)
Arduino Uno tidak punya DAC → pakai
PWM + filter RC

DAC tangga R-2R, 3 bit
Vout R R
2R 2R 2R 2R
B2 B1 B0
Vref / 0 V Vref / 0 V Vref / 0 V
Vout = Vref × (B2·4 + B1·2 + B0·1) / 8
Contoh: B2B1B0 = 101₂ = 5 → 5 V × 5/8 = 3,125 V
Hanya butuh dua nilai resistor (R dan 2R)

PWM (Pulse Width Modulation): sinyal kotak
dengan lebar pulsa yang diatur
Duty cycle = t / T × 100 %
ON
Tegangan rata-rata = duty × V
cc
Frekuensi tetap (≈ 490 Hz atau 980 Hz di
Arduino Uno); lebar pulsa yang diubah
analogWrite(pin, 0–255) → duty
0–100 %

periode T
25%
1,25 V
50% 2,5 V
3,75 V
75%
Garis oranye = tegangan rata-rata (Vcc = 5 V)
duty cycle = t_ON / T × 100%

Dimming LED: duty rendah = redup, tinggi
= terang
Kecepatan motor DC: duty menentukan
tegangan rata-rata
Servo hobi: periode 20 ms; lebar pulsa 1–2
ms menentukan sudut
Contoh: 1 ms ≈ 0°, 1,5 ms ≈ 90°, 2 ms ≈
180°
Pustaka Servo.h mengatur pewaktuan
secara otomatis

periode 20 ms (50 Hz)
1,0 ms
0°
1,5 ms
90°
2,0 ms
180°
Lebar pulsa menentukan sudut servo

Pin MCU lemah (≈ 20 mA): tidak boleh
langsung menggerakkan motor atau relay
Transistor / MOSFET berfungsi sebagai
saklar daya
Dioda flyback untuk beban induktif (motor,
relay, solenoid)
H-bridge (L298N, L293D, TB6612) untuk
membalik arah putar motor
Daya motor dari sumber terpisah; GND
harus disatukan

V motor
M dioda
flyback
C
B
D9 (PWM) 1 kΩ
MCU
E
Pin MCU hanya sanggup ± 20 mA, motor butuh 100–1000 mA
Transistor = saklar: arus kecil di basis mengatur arus besar
Dioda flyback meredam lonjakan tegangan saat motor dimatikan
Motor arah dua: gunakan H-bridge (L298N, L293D, TB6612)

const int LDR = A0; // sensor cahaya (pembagi tegangan)
const int LED = 9; // pin PWM
void setup() {
pinMode(LED, OUTPUT);
}
void loop() {
int cahaya = analogRead(LDR); // 0..1023
int duty = map(cahaya, 0, 1023, 0, 255); // gelap -> LED
analogWrite(LED, duty); // PWM 0..255
delay(20);
}

LDR ke GND, R tetap ke 5 V →
makin gelap, V makin naik
out
map() menskalakan 0–1023 ke
0–255
Hasilnya: lampu otomatis yang makin
terang saat gelap
terang
Rata-ratakan beberapa sampel untuk
mengurangi noise

P1–P2 Dasar & arsitektur P3 Platform
definisi, ciri, contoh Arduino · ESP32 ·
MPU vs MCU, Harvard toolchain & flashing
register, memori program Blink
SISTEM
TERTANAM
P5 Interrupt & timer P6 Analog
polling vs interrupt ADC, resolusi, LSB
ISR, vektor, edge DAC & PWM
prescaler, OCR sensor, motor, servo
Gunakan peta ini untuk memeriksa bagian

P4 GPIO & C
STM32 input / output digital
pull-up, debounce
operasi bit register
P7 Review
rumus penting
latihan soal
persiapan UTS
mana yang sudah dan belum dikuasai

Ciri yang paling membedakan sistem tertanam dari komputer
1
a. Memakai prosesor
b. Dirancang untuk fungsi khusus dengan sumber daya terbatas
c. Memiliki memori
d. Dapat terhubung ke internet
Pernyataan yang benar tentang mikrokontroler:
2
a. Hanya berisi CPU
b. Berisi CPU, memori, dan periferal dalam satu chip
c. Selalu menjalankan Linux
d. Tidak dapat diprogram ulang
Arsitektur Harvard dicirikan oleh...
3
a. Satu memori dan satu bus
b. Memori program dan data terpisah dengan bus terpisah
c. Tidak memakai register
d. Tidak memakai clock

serba guna adalah...

Register yang menyimpan alamat instruksi berikutnya
1
a. SP
b. PC
c. ALU
d. Flag
Urutan toolchain yang benar:
2
a. linker → compiler → assembler → flasher
b. compiler → assembler → linker → flasher
c. flasher → compiler → linker
d. assembler → flasher → compiler
Memori yang menyimpan firmware dan isinya tetap setelah
3
a. SRAM
b. Flash
c. Register CPU
d. Stack

adalah...
daya mati:

LED merah (V_f = 2 V) dihubungkan ke pin 3,3 V dengan
1
a. 130 Ω
b. 330 Ω
c. 1 kΩ
d. 13 Ω
Tombol dengan pull-up internal ke GND. Saat ditekan,
2
a. HIGH
b. LOW
c. Floating
d. Tidak terdefinisi
f_clk = 8 MHz, prescaler 8, target 1 ms (mode CTC). Nilai
3
a. 99
b. 999
c. 1000
d. 7999

arus 10 mA. Nilai R yang diperlukan ≈ ...
pin terbaca...
OCR = ...

ADC 12 bit dengan V_ref = 3,3 V memiliki 1 LSB ≈ ...
1
a. 0,81 mV
b. 3,3 mV
c. 8,05 mV
d. 1,61 mV
PWM dengan duty cycle 40 % pada tegangan 5 V menghasilkan
2
a. 1 V
b. 2 V
c. 3 V
d. 4 V
Mengapa motor tidak boleh langsung dihubungkan ke
3
a. Motor membutuhkan arus lebih besar daripada kemampuan
b. Pin MCU tidak punya tegangan
c. Motor hanya bekerja dengan AC
d. Pin MCU hanya untuk input

tegangan rata-rata...
pin MCU?
pin

Soal 1: 1-b · 2-b · 3-b
Soal 2: 1-b (PC) · 2-b (compiler → assembler
Soal 3: 1-a: R = (3,3 − 2) / 0,01 = 130 Ω · 2-b:
hitungan → OCR = 999
Soal 4: 1-a: 3,3 V / 4096 ≈ 0,81 mV · 2-b: 0,4 ×

→ linker → flasher) · 3-b (Flash)
aktif-LOW · 3-b: 8 MHz / 8 = 1 MHz → 1000
5 V = 2 V · 3-a

Cakupan: Pertemuan 1–7 (dasar, arsitektur,
Format (sesuaikan dengan pengumuman dosen):
dan analisis kode singkat
Persiapan: ulangi latihan soal Pertemuan 7
Strategi: tulis satuan dengan jelas (Ω, mA, MHz)
Cek ulang: operasi bit, prescaler/OCR, dan
paling sering
Waktu, bobot, dan aturan ujian mengikuti pengumuman resmi dosen pengampu.

platform, GPIO, interrupt/timer, ADC/PWM)
pilihan ganda, isian singkat, hitungan,
dan contekan rumus (bila diizinkan)
pada setiap hitungan
resolusi ADC adalah sumber salah yang

Paralel: banyak bit sekaligus
D0
D1
D2
D3
A B
D4
D5
D6
D7
8 kabel data + kontrol
→ cepat tetapi boros pin dan kabel
Serial memakai sedikit kabel, sehingga lebih praktis

Serial: bit satu per satu
arah data
1 0 1 1 0 0 1 0
A B
1–2 kabel data (+ GND)
→ hemat pin, jarak lebih jauh
untuk jarak yang lebih jauh dan menghemat pin

UART = Universal Asynchronous
Receiver/Transmitter
Dua jalur data: TX (kirim) dan RX (terima)
Sambungan silang: TX perangkat A ke RX
perangkat B, dan sebaliknya
GND harus disatukan
Asinkron: tidak ada jalur clock; kedua sisi
sepakat pada baud rate

Kabel disilang: TX milik A masuk ke RX milik B
MCU A MCU B
TX → RX
TX TX
RX RX
TX → RX
GND GND
GND bersama
Asinkron: tidak ada kabel clock
kedua sisi harus sepakat soal baud rate & format frame
tegangan logika harus sama (3,3 V atau 5 V)

Satu frame UART (contoh: karakter
idle START D0 D1 D2 D3 D4
8 bit data, LSB dikirim lebih
1 0 1 0 0 0 0
"A" = 0x41 = 0100 0001₂ →
Parity genap: jumlah bit 1 pada data
1 bit = 1 / baud = 104
Jalur diam = HIGH; start bit (LOW), 8 data

"A", 8E1)
D5 D6 D7 P STOP idle
dulu
0 1 0 0 1 1
urutan kirim: 1 0 0 0 0 0 1 0
= 2 (genap) → bit P = 0 (opsional)
µs pada 9600 baud
bit LSB lebih dulu, [parity], stop bit (HIGH)

void setup() {
Serial.begin(9600); // baud rate harus sama di kedua
}
void loop() {
if (Serial.available() > 0) { // ada data masuk?
char c = Serial.read();
if (c == '1') digitalWrite(13, HIGH);
if (c == '0') digitalWrite(13, LOW);
Serial.print("Terima: ");
Serial.println(c);
}
}

Serial.begin() menetapkan baud
rate
sisi
Serial.available() jumlah byte
di buffer
Serial.read() mengambil 1 byte
Buffer terima Arduino 64 byte

Serial.print() = "printf" ala sistem
tertanam
Tampilkan nilai sensor, status, dan pesan
galat di Serial Monitor
Baud rate Serial Monitor harus sama
dengan program
Cetak berlebihan memperlambat program
dan membuat buffer penuh
Hapus atau nonaktifkan log pada firmware
produksi

TX · RX · GND
PC
USB-TTL USB
MCU CP2102 / CH340 Suhu: 27.5
FT232 Suhu: 27.6
Suhu: 27.4
Serial Monitor
Cara menguji komunikasi serial
Serial Monitor cetak nilai variabel, perintah dari PC
Logic analyzer lihat bit TX/RX & ukur baud rate
Loopback sambung TX ke RX, kirim, lalu baca kembali
Setelan umum 9600 / 115200 baud, 8N1

SPI = Serial Peripheral Interface, sinkron,
full-duplex
Empat jalur: SCLK, MOSI, MISO, CS/SS
Satu master mengatur clock; slave dipilih
lewat CS (aktif-LOW)
Tiap slave tambahan = satu pin CS
tambahan
Kecepatan tinggi: beberapa hingga puluhan
MHz

SPI: 3 jalur bersama + 1 CS per slave
SCK
SCK
MOSI
Slave 1
MOSI MISO
MISO CS
CS0
MASTER SCK
CS1
(MCU) MOSI
Slave 2
MISO
CS2
CS
SCK
MOSI
Slave 3
MISO
CS
Hanya slave dengan CS = LOW yang menjawab

Data dikirim bersamaan dengan clock:
MOSI dan MISO
CPOL: level clock saat diam; CPHA: tepi
mana yang dipakai sampling
Empat mode SPI (0–3); master dan slave
harus memakai mode yang sama
Mode 0 (CPOL=0, CPHA=0) paling umum
CS diturunkan sebelum dan dinaikkan
sesudah transaksi

bit 7 6 5 4 3 2 1 0
CS
SCK
MOSI
MISO
Mode 0 (CPOL = 0, CPHA = 0): SCK idle LOW
data dibaca di tepi naik, diubah di tepi turun; MSB lebih dulu

Master dan slave punya register geser
yang tersambung melingkar
Setiap clock: satu bit keluar dari master dan
satu bit masuk
Setelah 8 clock, isi kedua register bertukar
Karenanya membaca dan menulis terjadi
sekaligus

Register geser MASTER
1 0 1 1 0 0 1 0
MSB LSB
MOSI
MISO
SCK × 8 pulsa
Register geser SLAVE
0 1 1 0 1 0 0 1
MSB LSB
Tiap pulsa SCK menggeser kedua register 1 bit
Setelah 8 pulsa, isi master dan slave sudah bertukar
= full-duplex: kirim dan terima bersamaan

#include <SPI.h>
const int CS = 10;
void setup() {
pinMode(CS, OUTPUT);
digitalWrite(CS, HIGH); // slave tidak dipilih
SPI.begin();
}
byte bacaRegister(byte alamat) {
SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));
digitalWrite(CS, LOW); // pilih slave
SPI.transfer(alamat | 0x80); // kirim alamat (bit 7
byte nilai = SPI.transfer(0x00); // clock-kan data keluar
digitalWrite(CS, HIGH);
SPI.endTransaction();
return nilai;
}

SPISettings: kecepatan, urutan
bit, mode
Konvensi bit-7 = baca bergantung
pada chip (lihat datasheet)
Contoh perangkat: SD card, display
TFT, ADC, IMU
= baca)

I2C = Inter-Integrated Circuit: sinkron,
half-duplex
Dua jalur: SDA (data) dan SCL (clock)
Banyak perangkat pada satu bus,
masing-masing punya alamat 7 bit
Jalur open-drain → perlu resistor pull-up
(≈ 4,7 kΩ)
Kecepatan standar: 100 kHz; Fast: 400 kHz

+VCC
Satu bus dipakai banyak perangkat
4,7 kΩ
Master Sensor OLED RTC
(MCU) 0x76 0x3C 0x68
SCL (clock)
SDA (data)
Open-drain: perangkat hanya menarik garis ke GND
resistor pull-up mengembalikannya ke HIGH
Tiap perangkat punya alamat 7 bit yang unik
Kecepatan umum: 100 kHz (standar), 400 kHz (fast)

START A6 A5 A4 A3 A2 A1
SCL
SDA turun
saat SCL HIGH
SDA
0 1 1 1 1 0
Alamat 0x3C (OLED) = 0111100₂ · slave menarik
Data hanya boleh berubah saat SCL
START = SDA turun saat SCL HIGH; STOP = SDA

A0 R/W ACK STOP
SDA naik
saat SCL HIGH
0 0 = W 0
SDA ke LOW pada bit ke-9 sebagai ACK
LOW; dibaca saat SCL HIGH
naik saat SCL HIGH; data stabil saat SCL HIGH

TULIS register sensor
S Alamat 7 bit + W A Alamat register A Data
BACA register sensor
S Alamat + W A Alamat reg A Sr Alamat +
dikirim master dikirim slave S = START · Sr = repeated START
START → alamat 7 bit + R/W → ACK

A P
R A Data NA P
· P = STOP · A = ACK · NA = NACK
→ data → ACK → … → STOP

#include <Wire.h>
const byte ALAMAT = 0x48; // contoh: sensor suhu TMP102
void setup() {
Wire.begin();
Serial.begin(9600);
}
void loop() {
Wire.beginTransmission(ALAMAT);
Wire.write(0x00); // pilih register
Wire.endTransmission();
Wire.requestFrom(ALAMAT, (byte)2); // minta 2 byte
if (Wire.available() == 2) {
int raw = (Wire.read() << 8) | Wire.read();
Serial.println(raw >> 4); // nilai mentah
}
delay(1000);
}

Alamat dan register: lihat datasheet
Wire = pustaka I2C Arduino
Pin Uno: SDA = A4, SCL = A5
Tak ada respons? Cek alamat (I2C
scanner) dan pull-up
suhu

Kebenaran hasil bergantung pada nilai dan
waktu keluarannya
Real-time ≠ cepat: yang penting adalah
dapat diprediksi (deterministik)
Deadline: batas waktu respons yang harus
dipenuhi
Hasil benar tetapi terlambat dapat sama
buruknya dengan hasil salah

Real-time = benar secara logika DAN tepat waktu
nilai
HARD
lewat deadline = kegagalan fatal
airbag, rem ABS, pacu jantung
deadline waktu
nilai
FIRM
hasil terlambat tak berguna,
sistem tetap jalan
pemrosesan frame kamera industri
deadline waktu
nilai
SOFT
kualitas menurun bertahap jika
terlambat
streaming video, UI layar sentuh
deadline waktu

Respons terhadap event
event mulai
berespons
latency waktu eksekusi (WCET)
Tugas periodik dan jitter
periode T
ideal
aktual
Latency: jeda dari event sampai respons. Jitter: variasi

DEADLINE
selesai
slack
jitter = selisih waktu
aktual terhadap ideal
latency dari satu kejadian ke kejadian lain

Semua tugas dipanggil berurutan dalam
satu while(1)
Sederhana, murah, tanpa OS
Waktu respons = jumlah waktu semua
tugas → sulit diprediksi
delay() atau tugas lambat menghambat
semuanya
Cocok untuk sistem kecil dengan sedikit
tugas

Baca sensor
Tampilkan data while(1) Proses / logika
"super loop"
Update output
Kelemahan:
satu langkah lambat (mis. delay(500)) menunda semua langkah lain
waktu respons = lama satu putaran loop penuh

Background: super loop untuk pekerjaan
biasa
Foreground: ISR menangani event kritis
segera
Respons kritis cepat; tetapi tugas
background masih tidak terjamin waktunya
ISR dan loop berbagi data lewat flag/buffer
(volatile)

Foreground / background
ISR
ISR ISR ISR
(foreground)
main loop
tugas A tugas B tugas C ...
(background)
waktu
ISR: respons cepat terhadap event (interupsi)
ISR hanya mengisi flag / buffer; kerja berat di main loop
Lebih responsif daripada super loop biasa,
tetapi main loop tetap tanpa prioritas & penjadwal

RTOS (Real-Time Operating System)
membagi pekerjaan menjadi beberapa task
Scheduler memilih task berdasarkan
prioritas secara deterministik
Kode lebih modular; menambah fitur tak
merusak pewaktuan tugas lain
Harga: memori (RAM/Flash) dan sedikit
overhead CPU
Layanan: task, antrean, semaphore, mutex,
timer

Arsitektur sistem berbasis RTOS
Task 1 Task 2 Task 3
baca sensor komunikasi tampilan
KERNEL RTOS
Penjadwal Tick timer
(scheduler) & delay
Antrean, semaphore, Manajemen
mutex (IPC) memori
PERANGKAT KERAS
SysTick
CPU Interupsi Periferal
timer

Task = potongan program yang berjalan
seolah-olah sendirian, biasanya berupa
fungsi dengan while(1)
Tiap task punya stack sendiri dan prioritas
TCB (Task Control Block): data pengelola —
status, prioritas, SP tersimpan
Scheduler memilih task mana yang
memakai CPU

Daftar task (TCB) Stack di SRAM
Task Status Prio
T1 Running 3
T2 Ready 2
T3 Blocked 1
TCB = Task Control Block:
nama, status, prioritas,
stack pointer, ...
Stack Stack Stack
T1 T2 T3
Tiap task punya stack sendiri untuk variabel lokal
dan menyimpan register saat context switch

Running: sedang dieksekusi CPU (hanya
satu pada MCU 1-inti)
Ready: siap, menunggu giliran CPU
Blocked: menunggu event (delay,
semaphore, queue)
Suspended: dihentikan sementara secara
eksplisit
Task yang menunggu sebaiknya Blocked,
bukan sibuk-looping

Siklus hidup sebuah task
dijadwalkan
Ready Running
preempt / yield
menunggu
suspend resume delay, queue,
semaphore
event / timeout
Suspended Blocked
Hanya SATU task Running pada CPU 1 inti;
task Blocked tidak memakai waktu CPU

Berpindah dari task A ke B: simpan register
A, muat register B
Disimpan di stack tiap task (SP tersimpan di
TCB)
Dipicu oleh tick timer atau event (mis.
semaphore diberikan)
Punya overhead (mikrodetik); terlalu sering
→ boros

Stack Task A Stack Task B
scheduler memilih B
2
1
simpan
PC CPU PC
(register) 3
LR LR
muat
R4–R11 R4–R11
R0–R3 R0–R3
Context switch: simpan konteks task lama,
muat konteks task baru (butuh puluhan–ratusan siklus)

Penjadwal preemptive berbasis prioritas: task
Tinggi (3)
rilis
Sedang (2) Sedang
rilis
Rendah (1) Rendah
rilis
0 1 2 3 4 5
Task berprioritas lebih tinggi langsung menyela

prioritas lebih tinggi langsung merebut CPU
Tinggi
siap Sedang
siap (ditunda) Rendah
6 7 8 9 10 11 waktu
(preempt) task yang lebih rendah begitu siap

Task berprioritas sama bergiliran,
masing-masing mendapat time slice
Satu slice biasanya = satu atau beberapa
tick (mis. 1 ms)
Adil, tetapi tidak memberi jaminan waktu
antarprioritas berbeda
FreeRTOS: aktifkan dengan
configUSE_TIME_SLICING

time slice
Task A A A A A
Task B B B B B
Task C C C C C
0 2 4 6 8 10 12 tick
Prioritas sama: bergiliran tiap tick (mis. 1 ms)

#include <Arduino_FreeRTOS.h>
void TaskBlink(void *pv) {
pinMode(13, OUTPUT);
for (;;) { // task tidak boleh return
digitalWrite(13, !digitalRead(13));
vTaskDelay(pdMS_TO_TICKS(500)); // Blocked 500 ms
}
}
void TaskSerial(void *pv) {
for (;;) {
Serial.println("hidup");
vTaskDelay(pdMS_TO_TICKS(1000));
}
}
void setup() {
Serial.begin(9600);
xTaskCreate(TaskBlink, "Blink", 128, NULL, 1, NULL);
xTaskCreate(TaskSerial, "Serial", 128, NULL, 2, NULL);
// scheduler dijalankan otomatis (Arduino) / vTaskStartScheduler()
}
void loop() {}

xTaskCreate(fungsi, nama,
stack, param, prioritas,
handle)
Angka prioritas besar = lebih tinggi
(FreeRTOS)
vTaskDelay membuat task
Blocked, tidak membuang CPU

Setiap task butuh stack untuk variabel lokal,
alamat balik, dan konteks
Terlalu kecil → stack overflow (data rusak,
crash)
Terlalu besar → memboroskan RAM yang
terbatas
Ukur memakai
uxTaskGetStackHighWaterMark()
Hindari array besar di variabel lokal task

Pemakaian stack tiap task (256 word)
meluap!
100%
85%
35%
T1 T2 T3
Garis putus-putus = high-water mark (pemakaian puncak)

Dua task mengakses data bersama tanpa
pengaturan → hasil bergantung pada urutan
eksekusi
Contoh: counter++ bukan operasi atom
(baca–ubah–tulis)
Critical section: bagian kode yang hanya
boleh dijalankan satu pihak sekaligus
Solusi: mutex, semaphore, atau
menonaktifkan interupsi sebentar

Dua task menaikkan variabel bersama: counter = 5
Task A Task B
LOAD R ← counter
1
(R = 5)
LOAD R ← counter
2
(R = 5)
R = R + 1 → 6
3
STORE counter = 6
R = R + 1 → 6 4
STORE counter = 6 5
Hasil: counter = 6, seharusnya 7!
satu pembaruan hilang akibat interleaving (race condition)

Bernilai 0 atau 1: sinyal antar-task atau dari
ISR ke task
xSemaphoreGive() memberi sinyal;
xSemaphoreTake() menunggu (Blocked)
Pola umum: ISR → semaphore → task
pemroses (deferred interrupt handling)
ISR memakai versi ...FromISR()

Task pemroses ISR / event
Take(sem)
BLOCKED
(menunggu) event terjadi!
Give(sem)
sinyal
READY → RUNNING
Semaphore biner = bendera sinyal
proses event
ISR singkat, kerja berat di task

Menghitung sumber daya atau event yang
tersedia
Give menambah, Take mengurangi; Take
saat 0 → Blocked
Contoh: kolam 3 buffer, atau menghitung
event yang cepat

Semaphore penghitung (jumlah sumber daya = 3)
count = 3
R1 R2 R3
Task A Take → dapat R1
Task B Take → dapat R2
Task C Take → dapat R3
Task D Take → BLOCKED
Give → count naik; Task D yang menunggu pun lanjut

SemaphoreHandle_t mutexSerial;
void tulis(const char *pesan) {
if (xSemaphoreTake(mutexSerial, pdMS_TO_TICKS(100)) == pdTRUE)
Serial.println(pesan); // critical section
xSemaphoreGive(mutexSerial); // selalu dikembalikan
}
}
void setup() {
mutexSerial = xSemaphoreCreateMutex();
// ... buat task yang memanggil tulis()
}

Mutex = semaphore dengan
kepemilikan: yang Take harus yang
Give
{
Dipakai untuk mutual exclusion
Selalu pasangkan Take dengan Give
Beri timeout, jangan menunggu
selamanya

Inversi prioritas: Tinggi terhambat
Rendah memegang mutex (garis ungu), tetapi
Tinggi blocked:
rilis
Sedang Sedang
rilis
Rendah siap (kalah dari
rilis mutex dipegang Rendah
0 1 2 3 4 5
Task H (tinggi) menunggu L yang memegang mutex, tetapi

oleh Sedang
Sedang menyela Rendah
menunggu mutex Tinggi
Sedang)
6 7 8 9 10 11 waktu
L disela M (menengah) → H tertunda tak terbatas

Priority inheritance: Rendah "meminjam"
Rendah segera selesai dan melepas mutex,
Tinggi blocked
rilis
Sedang siap
rilis
Rendah prio naik
rilis
0 1 2 3 4 5
L dinaikkan sementara ke prioritas H selama memegang

prioritas Tinggi
Tinggi hanya menunggu singkat
Tinggi
Sedang
6 7 8 9 10 11 waktu
mutex, sehingga M tidak dapat menyela

Queue = antrean FIFO berukuran tetap
yang aman antar-task
xQueueSend() dan xQueueReceive()
(Blocked bila kosong/penuh)
Menyalin data (by copy) → pengirim bebas
memakai variabelnya lagi
Pola producer–consumer: task sensor
mengirim, task tampilan menerima

Antrean (queue) FIFO
Task Sensor Task Display
(producer) ISR (event) (consumer)
buffer 5 slot
21.5 21.7 22.0
Receive
Send
Queue penuh Queue kosong
pengirim BLOCKED penerima BLOCKED
sampai ada ruang sampai ada data
Data disalin ke queue: aman tanpa variabel global
komunikasi antar-task & dari ISR

QueueHandle_t antreanSuhu;
void TaskSensor(void *pv) {
for (;;) {
int suhu = analogRead(A0);
xQueueSend(antreanSuhu, &suhu, portMAX_DELAY);
vTaskDelay(pdMS_TO_TICKS(200));
}
}
void TaskTampil(void *pv) {
int nilai;
for (;;) {
if (xQueueReceive(antreanSuhu, &nilai, portMAX_DELAY) == pdTRUE)
Serial.println(nilai);
}
}
void setup() {
Serial.begin(9600);
antreanSuhu = xQueueCreate(8, sizeof(int)); // 8 elemen
xTaskCreate(TaskSensor, "Sensor", 128, NULL, 2, NULL);
xTaskCreate(TaskTampil, "Tampil", 128, NULL, 1, NULL);
}
void loop() {}
Hindari variabel global bersama tanpa pelindung; antrean memberi sinkronisasi

dan transfer data sekaligus.

Daya dinamis ≈ C·V²·f: turunkan clock dan
tegangan
Mode tidur (sleep/deep sleep): CPU
berhenti, bangun lewat interupsi atau timer
Matikan periferal dan pin yang tidak dipakai
Kerjakan cepat lalu tidur (race to sleep)
Daya tidur dapat ≈ 1000× lebih kecil
daripada saat aktif

Arus tipikal tiap mode (skala log)
Aktif + radio
Aktif (CPU)
Idle / sleep
Deep sleep
Hibernasi
1 µA 10 µA 100 µA 1 mA 10 mA 100 mA
Contoh orde besaran — nilai nyata tergantung chip
Selisih deep sleep vs aktif bisa ribuan kali lipat

Rata-rata arus = (I × t + I × t )
aktif aktif tidur tidur
/ T
Contoh: 20 mA aktif 10 ms per 1 s, 10 µA
tidur → rata-rata ≈ 0,21 mA
Umur baterai ≈ kapasitas / arus rata-rata
(2000 mAh / 0,21 mA ≈ 9.500 jam ≈ 13
bulan)
Perhitungan teoretis: nyata lebih pendek
(self-discharge, regulator)

arus
T = 10 s
100 ms
20 mA
10 µA
waktu
I_rata-rata = (I_aktif·t_aktif + I_sleep·t_sleep) / T
= (20 mA × 0,1 s + 0,01 mA × 9,9 s) / 10 s
≈ 0,21 mA
Umur baterai = kapasitas / I_rata-rata
2000 mAh / 0,21 mA ≈ 9500 jam ≈ 400 hari
Tidur lebih lama → baterai jauh lebih awet

Watchdog = timer yang me-reset MCU bila
tidak "diberi makan" tepat waktu
Program yang sehat memanggil
wdt_reset() secara berkala
Jika program hang/loop tak berujung →
reset otomatis
Atur timeout lebih panjang dari siklus
terpanjang program
Jangan memberi makan watchdog dari ISR
saja (menutupi hang)

Normal: program "menendang" (kick) watchdog
timeout
Gangguan: program hang → tidak ada kick
RESET!
program hang
Counter watchdog berjalan terus; program sehat menyetelnya ulang

Lonjakan arus menyebabkan noise pada
VCC → reset acak
Kapasitor decoupling 100 nF dekat setiap
pin VCC chip
Tambahkan kapasitor besar (10–100 µF) di
jalur catu
Brown-out detector mereset MCU saat
tegangan terlalu rendah
Gunakan jalur GND yang pendek dan lebar

Kapasitor decoupling di dekat pin daya
+3,3 V
VDD
10 µF 100 nF
MCU
(bulk) (dekat pin)
GND
GND
Kapasitor menyediakan arus sesaat saat MCU berpindah-pindah
sehingga tegangan tidak "goyang" (noise, reset tak terduga)
Letakkan 100 nF sedekat mungkin dengan setiap pasang VDD–GND
Tambahkan kapasitor bulk 10 µF di dekat regulator

Serial print / LED: cepat, tetapi mengubah
pewaktuan
Debugger SWD/JTAG: breakpoint, step,
lihat register dan memori
Logic analyzer dan osiloskop: amati sinyal
UART/SPI/I2C
Multimeter: cek tegangan dan kontinuitas
Strategi: reproduksi → isolasi → hipotesis →
uji satu perubahan setiap kali

Alat debugging: dari sederhana ke lengkap
1 LED / toggle GPIO tanda "kode sampai sini"
2 printf / Serial cetak nilai variabel ke PC
3 Logic analyzer lihat bit digital: UART, SPI, I2C
4 Osiloskop bentuk gelombang analog, noise, timing
5 Debugger SWD/JTAG breakpoint, step, baca register & memori
makin lengkap = makin banyak detail (dan biasanya makin mahal)

Sisi kiri: kebutuhan → arsitektur → desain
modul → kode
Sisi kanan: uji unit → uji integrasi → uji
sistem → uji penerimaan
Setiap tahap desain punya tahap uji
pasangannya
Verifikasi: dibangun dengan benar?
Validasi: membangun hal yang benar?

Model-V: tiap tahap desain punya pengujian
Kebutuhan Uji penerimaan
Desain sistem Uji sistem
Desain modul Uji integrasi
Implementasi Uji unit
Kiri: dari kebutuhan ke kode · Kanan: verifikasi balik
garis putus-putus: tahap yang saling memverifikasi

Siklus pengembangan
1 Kebutuhan 2 Spesifikasi 3 Desain
apa yang harus daya, waktu, pilih MCU,
dilakukan? biaya, antarmuka arsitektur HW/SW
umpan balik: temuan pengujian kembali ke desain / implementasi
Pemeliharaan: perbaikan bug, pembaruan fitur,
Iteratif: spesifikasi → desain → implementasi →

sistem tertanam
4 Implementasi 5 Pengujian 6 Rilis / OTA
rangkaian + unit, integrasi, produksi &
firmware sistem update firmware
dan keamanan sepanjang umur produk
uji → perbaiki; dokumentasikan di setiap tahap

Stasiun cuaca mini Penyiram tanaman
BME280 (suhu, kelembapan, tekanan) sensor kelembapan tanah
OLED + kirim data lewat Wi-Fi pompa mini + relay +
Menggabungkan: GPIO · timer · ADC/PWM · I2C/UART Menggabungkan: GPIO · timer
Parkir pintar Robot line follower
sensor ultrasonik per slot sensor IR + driver motor
lampu hijau/merah + penghitung kontrol PWM (opsional
Menggabungkan: GPIO · timer · ADC/PWM · I2C/UART Menggabungkan: GPIO · timer
Pilih ide yang memakai minimal: sensor, aktuator,

otomatis Alarm keamanan pintu
sensor magnet / PIR
timer buzzer + notifikasi
· ADC/PWM · I2C/UART Menggabungkan: GPIO · timer · ADC/PWM · I2C/UART
Pengontrol suhu ruangan
sensor suhu + kipas/heater
PID) histeresis atau PID, layar LCD
· ADC/PWM · I2C/UART Menggabungkan: GPIO · timer · ADC/PWM · I2C/UART
komunikasi serial, dan (opsional) RTOS

Contoh arsitektur: node
ESP32 + FreeRTOS
MASUKAN
BME280
(I2C)
Task Sensor Task
(1 detik) (OLED)
LDR
(ADC)
Tombol
Queue data sensor · Mutex
(interrupt)
deep sleep di antara
Daya: baterai Li-ion + regulator
Tunjukkan blok perangkat keras, tugas

pemantau lingkungan
KELUARAN
OLED
(I2C)
Display Task Komunikasi
(Wi-Fi / MQTT)
Wi-Fi → MQTT
Dashboard
layar · Watchdog LED status
pengukuran
3,3 V + kapasitor decoupling
perangkat lunak, dan aliran data

Masalah & tujuan proyek
Desain: diagram blok, skematik, pemilihan komponen
Implementasi: diagram alir/task, potongan kode
Hasil uji: tabel/grafik, bukti pengukuran
Demo langsung dan kendala yang dihadapi
Kesimpulan serta pengembangan lanjutan

kunci

Catu daya cadangan dan kabel sudah dicoba
Firmware final sudah di-flash dan dicadangkan
Rangkaian rapi, diberi label, tidak ada kabel
Skenario demo dilatih; siapkan video cadangan
Setiap anggota paham seluruh sistem
Kode tersimpan di repositori (Git) dengan README

longgar
singkat

Jalur belajar lanjutan
Nirkabel
DMA & daya rendah
Dasar (kuliah ini)
BLE, Wi-Fi, LoRa,
MQTT, protokol IoT
transfer data tanpa CPU,
mode sleep, energi
GPIO, interrupt, timer,
ADC/PWM, UART/SPI/I2C,
RTOS dasar
Lanjutkan ke IoT, kontrol, robotika,

Edge AI / FPGA
Keamanan & OTA
Embedded Linux
TinyML, akselerator,
desain hardware
secure boot, enkripsi,
update firmware jarak jauh
Raspberry Pi, Yocto,
device driver
FPGA/SoC, atau embedded Linux

Cakupan: UART, SPI, I2C, real-time, RTOS
daya, watchdog, debugging, proyek
Latihan: hitung baud/throughput, gambar frame
Kode: baca potongan FreeRTOS dan temukan
Konsep: bandingkan UART/SPI/I2C; super loop
Tips: tulis satuan, gambar diagram waktu bila
Waktu, bobot, dan aturan ujian mengikuti pengumuman resmi dosen pengampu.

(task, scheduling, semaphore, mutex, queue),
UART/I2C, analisis priority inversion
kesalahan (mis. lupa Give, stack kecil)
vs RTOS; hard vs soft real-time
membantu

Wolf, W. Computers as Components: Principles
Morgan Kaufmann.
Barr, M. & Massa, A. Programming Embedded
Valvano, J. Embedded Systems: Real-Time
Barry, R. Mastering the FreeRTOS Real Time
Datasheet ATmega328P, ESP32, STM32; dokumentasi
Periksa edisi terbaru dan ketersediaan di perpustakaan kampus; sesuaikan

of Embedded Computing System Design.
Systems. O'Reilly.
Interfacing to ARM Cortex-M Microcontrollers.
Kernel (freertos.org).
Arduino (arduino.cc).
dengan daftar pustaka pada RPS.