Dari Coding Blok ke MicroPython: Sensor dan Raspberry Pi Pico

Beralih dari coding blok ke MicroPython paling mudah kalau kamu sudah bisa membaca sensor dengan blok. Membaca sensor dengan blok artinya mendapatkan nilai tanpa mengetik kode: blok “baca analog A0” mengambil tingkat cahaya dari LDR, dan blok “cetak serial” mengirim angka itu ke Serial Monitor di komputermu. Di tulisan ini kamu lebih dulu membaca sensor dengan blok di Arduino lewat proyek LDR dan HC-SR04, sambil membandingkan setiap blok dengan baris analogRead(), Serial.begin(), Serial.println() dan pulseIn()-nya. Setelah itu kamu melangkah dari blok ke MicroPython di Raspberry Pi Pico dan melihat apa yang berubah ketika blok yang sama menjadi kode Python.

Sejauh ini setiap program di seri ini membuat sesuatu terjadi di dunia luar: kita menyalakan LED, mengecek tombol, dan membuat penghitung dengan perulangan. Membaca sensor bekerja ke arah sebaliknya: board mengukur dunia dan kamu bisa melihat angkanya. Karena itu port serial ikut berperan di sini, sebab cara termudah untuk memahami apa yang diukur sensor adalah melihat nilainya di layar. Di paruh kedua, proyek coding blok Raspberry Pi Pico dipetakan ke MicroPython, bukan ke C++. Semua proyek yang dipakai di sini gratis di BlueGrays, dan kode yang dikutip di bawah sama persis dengan kode proyeknya.

Apa artinya membaca sensor: input digital dan analog

Tombol hanya melaporkan dua keadaan: ditekan atau tidak. Kamu membacanya dengan blok baca pin digital (digitalRead), dan hasilnya 0 atau 1. Komponen seperti LDR, potensiometer, atau sensor kelembapan tanah memberikan semua nilai di antaranya: tegangan di pin berubah mulus antara 0 dan 5 V. Rangkaian yang mengubah tegangan ini menjadi angka disebut ADC (analog-to-digital converter, pengubah analog ke digital). ADC Arduino Uno 10-bit, jadi tegangan dibagi menjadi 1024 tingkat dan hasilnya angka dari 0 sampai 1023; setiap tingkat kira-kira 4,9 mV. ESP32 dan Pico punya ADC 12-bit yang bekerja di 3,3 V. Perbedaan antar-board ini adalah salah satu sumber kebingungan yang paling sering muncul ketika beralih dari blok ke kode; detailnya ada di tulisan ADC dan konversi analog ke digital.

Membaca LDR dengan blok di Arduino

Contoh pertama kita adalah proyek Mengukur Intensitas Cahaya dengan LDR. LDR adalah resistor yang hambatannya turun ketika cahaya makin terang; LDR sendiri tidak menghasilkan tegangan. Untuk mengukurnya, kita pasang LDR seri dengan resistor tetap 10 kΩ sehingga terbentuk pembagi tegangan, lalu titik tengahnya kita sambungkan ke A0. Dengan pengkabelan di bawah, LDR berada di sisi 5V, jadi makin banyak cahaya berarti tegangan di A0 makin tinggi dan angka yang terbaca makin besar; tukar posisi LDR dan resistor, maka arahnya terbalik. Kamu bisa menghitung output pembagi untuk berbagai nilai LDR dengan kalkulator pembagi tegangan, dan melihat berapa ohm hambatan LDR dalam gelap dan dalam cahaya terang di tulisan sensor cahaya LDR. Kolom Pico di tabel ini akan kita pakai di contoh MicroPython menjelang akhir tulisan.

Baca bloknya dari atas ke bawah. Blok “deklarasikan bilangan bulat (int) value = 0” di dalam variabel global (paling atas) adalah baris int value; di bagian paling atas kode. Bagian setup (jalan sekali) hanya berisi satu blok, “mulai serial di 9600 baud”, yaitu Serial.begin(9600);. Di dalam ulangi selamanya, blok pertama adalah “atur value ke baca analog A0”; itulah baris value = analogRead(A0);. Setelah itu ada dua blok “cetak serial”. Yang pertama mencetak teks “Value:” dengan opsi tanpa pindah baris dan menjadi Serial.print(); yang kedua mencetak value dengan opsi baris baru dan menjadi Serial.println(). Dengan begitu setiap pengukuran muncul sebagai satu baris seperti “Value: 512”. Blok terakhir, “tunggu 500 ms”, adalah delay(500);, jadi kamu mendapat dua pembacaan per detik. Untuk mengubah hasil pembacaan menjadi tegangan, pakai value × 5.0 / 1023: 512 kira-kira 2,5 V. Di ruangan gelap nilainya turun ke beberapa ratus, dan kalau LDR disorot senter, nilainya naik di atas 900; angka pastinya tergantung LDR-mu dan ruangannya.

1int value;   // Işık değeri / Light reading (0-1023)
2
3void setup() {
4  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
5}
6
7void loop() {
8  value = analogRead(A0);   // LDR gerilimini oku / Read the LDR voltage
9  Serial.print("Value: ");
10  Serial.println(value);
11  delay(500);               // 0,5 sn bekle / Wait 0.5 s
12}

Membuka Serial Monitor dan memantau nilainya

1. Tempel kode ke Arduino IDE, pilih board dan port-mu, lalu klik Upload.
2. Begitu upload selesai, klik ikon kaca pembesar di kanan atas atau buka Tools › Serial Monitor (pintasan Ctrl+Shift+M).
3. Atur kotak baud rate di Serial Monitor sesuai nilai di kode: 9600 baud untuk proyek ini.
4. Baris “Value: …” muncul bergulir setiap setengah detik. Tutup LDR dengan tanganmu dan lihat angkanya turun.
5. Untuk melihat perubahannya sebagai grafik, buka Tools › Serial Plotter; data yang sama digambar sebagai garis waktu.
6. Pengaturan akhir baris (line ending) dan cara mengirim data dari Serial Monitor ke board dibahas lengkap di tulisan Serial Monitor Arduino.

Jarak dengan HC-SR04: blok tunggu µs dan lama pulsa

Proyek sensor kedua adalah Pengukuran Jarak HC-SR04 (Tampilan Serial). Proyek ini menambahkan dua blok baru. Tiga blok yang diawali “tulis HIGH ke pin trigPin” menyuruh sensor mengirim semburan suara: blok “tunggu 10 µs” di tengahnya adalah delayMicroseconds(10);, waktu tunggu yang seribu kali lebih pendek daripada “tunggu … ms”. Berikutnya ada “atur duration ke lama pulsa HIGH di pin echoPin (µs)”, yaitu baris unsigned long duration = pulseIn(echoPin, HIGH); yang mengukur berapa mikrodetik pin Echo tetap HIGH. Suara merambat di udara dengan kecepatan sekitar 0,034 cm/µs, dan waktu itu mencakup perjalanan pergi-pulang. Jadi “atur totalPath ke duration × 0.034” menghitung seluruh lintasan dan “atur distance ke totalPath ÷ 2” menghitung jarak satu arah. Pulsa 1000 µs, misalnya, berarti lintasan 34 cm, jadi bendanya berjarak 17 cm; karena distance bertipe int, angka desimalnya dibuang. Terakhir, blok “jika distance > minDistance dan distance < maxDistance” menjadi if (distance > minDistance && distance < maxDistance) dan hanya mencetak pembacaan antara 3 dan 100 cm. Kalau sensor tidak menerima gema, pulseIn() mengembalikan 0, dan pengecekan ini juga mencegah angka nol palsu itu muncul di layar. Di kode, pin-nya adalah trigPin = 7 dan echoPin = 6. Untuk jangkauan dan akurasi sensornya, lihat tulisan sensor jarak HC-SR04.

Ide yang sama di ESP32: ADC 12-bit

Versi ESP32 dari logika LDR yang sama adalah proyek Membaca Intensitas Cahaya dengan Modul LDR ESP32. Bloknya tetap dipetakan ke C++ dan dibaca persis seperti di Arduino, dengan tiga perbedaan. Pertama, setup() mengunci ADC ke 12 bit dengan analogReadResolution(12), sehingga analogRead() mengembalikan 0–4095, bukan 0–1023, dan ambang yang ditulis untuk Arduino seperti “gelap di bawah 500” tidak berarti hal yang sama di ESP32. Kedua, port serial berjalan di 115200 baud, bukan 9600, jadi atur Serial Monitor ke 115200 juga. Ketiga, di output AO modul LDR, tegangan dan nilai mentahnya justru turun ketika cahaya makin terang. Karena itu kodenya memakai nilai kalibrasi RAW_DARK = 4000 dan RAW_LIGHT = 100, menjaga pembacaan tetap di rentang itu dengan constrain(), lalu mengubahnya menjadi 0% untuk gelap dan 100% untuk terang dengan map(). Di ESP32 DevKit klasik, LDR disambungkan ke GPIO 34, pin khusus input di ADC1. Karena pin ADC2 tidak bisa dibaca selama Wi-Fi menyala, menyambungkan sensor analog ke pin ADC1 adalah kebiasaan yang baik. Untuk fitur umum board-nya, lihat Apa Itu ESP32?.

Dari blok ke MicroPython di Raspberry Pi Pico

Di proyek Pico, blok dipetakan ke MicroPython, bukan ke C++. Bloknya terlihat akrab, tetapi bahasa di baliknya berbeda: tidak ada kurung kurawal atau titik koma, blok kode ditandai dengan indentasi, dan tidak ada fungsi setup() atau loop(). Ayo beralih lewat proyek paling sederhana, Raspberry Pi Pico: Mengendalikan LED Eksternal (GP14 + Breadboard). Rangkaiannya kecil sekali: GP14 (pin fisik 19) lewat resistor 220–330 Ω ke kaki panjang LED, dan kaki pendek LED ke GND (misalnya pin fisik 18). Program menyalakan LED selama setengah detik, mematikannya setengah detik, dan mencetak satu baris ke Shell Thonny di setiap langkah. Kalau Pico masih baru buatmu, mulailah dari Apa Itu Raspberry Pi Pico?.

1from machine import Pin
2import time
3
4# ============ PIN / PIN ============
5LED_PIN = 14                    # Boştaki herhangi bir GPIO / Any free GPIO
6led = Pin(LED_PIN, Pin.OUT)
7
8print("== BlueGrays: Pico Harici LED Blink ==")
9print("LED pin: GP" + str(LED_PIN))
10print("500ms yakip 500ms sonduruyor / 500ms on 500ms off")
11
12# ============ ANA DÖNGÜ / MAIN LOOP ============
13while True:
14    led.on()                    # LED'i yak / Turn the LED on
15    print("[LED] ACIK / ON")
16    time.sleep(0.5)
17
18    led.off()                   # LED'i söndür / Turn the LED off
19    print("[LED] KAPALI / OFF")
20    time.sleep(0.5)

Ada empat hal yang menonjol di tabel itu. Pertama, baris from machine import Pin dan import time tidak punya blok; di Python kamu mengimpor modul yang dibutuhkan di bagian atas, dan blok menganggap hal itu sudah beres untukmu. Kedua, blok “mulai serial di 9600 baud” dari Arduino tidak punya padanan di sini: di Pico, output print() langsung lewat USB ke Shell Thonny, tanpa baud rate yang perlu diatur. Ketiga, satuan waktu tunggu berubah: di Arduino “tunggu 500 ms” adalah delay(500), sedangkan di Pico “tunggu 0.5 detik” adalah time.sleep(0.5). Keempat, dan yang paling penting, indentasi: setiap blok yang berada di dalam blok “ulangi selamanya” ditulis menjorok empat spasi di bawah baris while True:. Hapus indentasi sebuah baris, maka baris itu keluar dari perulangan; di Python, spasi melakukan tugas yang di C++ dikerjakan kurung kurawal. Aturan inti MicroPython lainnya ada di tulisan dasar-dasar MicroPython.

Operasi yang sama dalam tiga bahasa: blok, C++ dan MicroPython

Contohmu sendiri: membaca LDR di Pico dengan MicroPython

Sekarang ayo pindahkan proyek LDR Arduino ke Pico. Pengkabelannya mengikuti kolom Pico di tabel di atas: satu kaki LDR ke pin 3V3(OUT), kaki lainnya ke GP26 sekaligus ke salah satu ujung resistor 10 kΩ, dan ujung resistor yang lain ke GND. Pico punya tiga pin yang bisa membaca nilai analog: GP26 (ADC0), GP27 (ADC1) dan GP28 (ADC2). Di MicroPython kamu membuat objek ADC(26) lalu memanggil read_u16(); meskipun ADC Pico secara hardware 12-bit, fungsi ini menskalakan hasilnya ke 0–65535. Untuk mendapatkan tegangan, kalikan nilainya dengan 3.3 lalu bagi dengan 65535. Programnya mengikuti alur yang sama dengan versi Arduino: ukur, cetak, tunggu setengah detik. Selain itu kami menambahkan ambang: ketika ruangan menjadi gelap, LED bawaan di board menyala. Kalau dipikirkan dalam bentuk blok, baris sebelum while True adalah bagian “setup (jalan sekali)”, while True: adalah “ulangi selamanya”, if/else adalah blok jika (if) dengan tombol dari bagian 3 seri ini, led.on() adalah “nyalakan (on) pin led”, time.sleep(0.5) adalah “tunggu 0.5 detik”, dan + str() di dalam print() adalah blok “gabungkan teks”. Baris ADC(26).read_u16() melakukan tugas blok “baca analog A0” di Arduino. Sesuaikan THRESHOLD dengan angka yang kamu lihat di Shell di ruanganmu sendiri.

1from machine import Pin, ADC
2import time
3
4# ============ PIN / PIN ============
5ldr = ADC(26)                   # GP26 = ADC0, bölücünün orta noktası / divider midpoint
6led = Pin(25, Pin.OUT)          # Dahili LED; Pico W'de Pin("LED") / Onboard LED; Pico W: Pin("LED")
7THRESHOLD = 20000               # Karanlık eşiği, odana göre ayarla / Darkness threshold, tune for your room
8
9print("== BlueGrays: Pico LDR ==")
10
11# ============ ANA DÖNGÜ / MAIN LOOP ============
12while True:
13    value = ldr.read_u16()                      # 0-65535
14    voltage = value * 3.3 / 65535               # Volt / Volts
15    print("Value: " + str(value) + "  Voltage: " + str(round(voltage, 2)) + " V")
16
17    if value < THRESHOLD:                       # Az ışık = küçük değer / Little light = small value
18        led.on()
19    else:
20        led.off()
21
22    time.sleep(0.5)                             # 0,5 sn = 500 ms / 0.5 s = 500 ms

Meng-upload ke Pico dengan Thonny dan main.py

1. Instal Thonny di komputermu. Kalau Pico belum punya MicroPython, tahan tombol BOOTSEL sambil mencolokkan kabel USB; Thonny akan menawarkan instalasi MicroPython pada koneksi pertama.
2. Di pojok kanan bawah Thonny, pilih MicroPython (Raspberry Pi Pico) sebagai interpreter. Kalau kamu melihat prompt >>> di Shell di bagian bawah, berarti sudah terhubung.
3. Salin kode proyek dari BlueGrays dan tempelkan ke editor Thonny.
4. Klik tombol hijau Run atau tekan F5. Kode berjalan di Pico dan output print() muncul di Shell. Pakai tombol Stop (Ctrl+F2) untuk menghentikannya.
5. Kalau kamu ingin kodenya berjalan tanpa komputer, pilih File › Save as, pilih Raspberry Pi Pico di dialognya, lalu beri nama file main.py. Pico menjalankan file ini secara otomatis setiap kali mendapat daya, jadi charger USB atau power bank sudah cukup.
6. Kalau Thonny tidak mendeteksi board-nya, cek kabel dan driver sesuai urutan di tulisan Raspberry Pi Pico tidak terdeteksi.

Proyek blok Pico gratis lainnya

• Kedip LED Bawaan Raspberry Pi Pico (GP25): sama sekali tanpa pengkabelan; proyek ini mengedipkan LED di board dengan LED_PIN = 25. Kodenya hampir sama dengan proyek di atas, jadi buka keduanya berdampingan dan kamu akan melihat bahwa hanya nomor pin-nya yang berubah. Di Pico W, LED bawaan tersambung ke chip Wi-Fi, jadi yang dipakai adalah Pin("LED").
• Dua LED Bergantian Raspberry Pi Pico (GP14 + GP13): program dimulai dari keadaan berlawanan dengan led1.value(1) dan led2.value(0), lalu memanggil toggle() pada kedua LED di dalam perulangan. Karena kodenya menulis from time import sleep, waktu tunggunya muncul sebagai sleep(0.5), bukan time.sleep(0.5).
• Simulator Lampu Lalu Lintas Raspberry Pi Pico (GP11/GP12/GP13): fungsi bernama all_off() mematikan semua LED; hijau menyala 4 detik, kuning 1,5 detik, dan merah 3 detik, lalu disusul fase awal merah+kuning selama 1 detik.
• Efek Lampu Strobo Polisi Raspberry Pi Pico (GP11 + GP12): kali ini waktu tunggunya dalam milidetik dengan sleep_ms(WAIT_MS), dengan WAIT_MS = 300. Melihat fungsi detik dan milidetik berdampingan di dua proyek adalah cara terbaik untuk menghindari kesalahan paling umum di bawah ini.

Kesalahan umum dan cara memperbaikinya

Lanjutkan dengan blok di aplikasi BlueGrays

Semua proyek di tulisan ini gratis di aplikasi BlueGrays. Nyalakan sakelar Tampilkan sebagai blok di bagian kode sebuah proyek, maka kode diganti dengan program yang sama dalam bentuk blok; ketuk gambarnya untuk membukanya layar penuh. Tab Pahami blok memandumu menelusuri program langkah demi langkah, dan setiap langkah hanya menampilkan bloknya sendiri beserta fungsinya. Di situlah kamu bisa melihat dengan tepat apa yang diukur blok lama pulsa di proyek HC-SR04, atau kenapa bagian setup di proyek Pico ada sebelum while True. Semua contoh perintah Arduino dan MicroPython di Panduan kode juga ditampilkan sebagai blok. Untuk menguji apa yang sudah kamu pelajari, Soal harian memberimu 5 soal sehari dari level A1 sampai C2, peringkat mingguan, dan lencana. Ingat, blok tidak pernah di-upload langsung ke board: board selalu menerima kode asli proyek, yang kamu salin ke Arduino IDE untuk Arduino dan ESP32, atau ke Thonny untuk Pico. Kamu bisa memfilter daftar proyek untuk menampilkan proyek bertanda blok, dan menemukan semua proyek blok untuk Arduino, ESP32 dan Pico di halaman coding blok.

Setelah menguasai port serial dan pembacaan sensor, sekarang kamu bisa membaca setiap bagian dasar sebuah proyek, baik sebagai blok maupun sebagai kode. Bagian terakhir seri ini membawa langkah-langkah ini ke kelas: rencana pelajaran coding blok untuk robotika bagi guru. Sambil menunggu, kamu bisa menelusuri skema rangkaian dan kode proyek LDR, HC-SR04, dan LED Pico langkah demi langkah di aplikasi BlueGrays, beralih ke versi blok dari program yang sama dengan Tampilkan sebagai blok, dan mengikuti fungsi setiap langkah dengan Pahami blok.