Dari Coding Blok ke Arduino C++: Tabel Contekan dengan MicroPython

Cara tercepat untuk pindah dari coding blok ke Arduino C++ adalah menyimpan tabel satu halaman di dekatmu yang menunjukkan setiap blok menjadi baris kode asli yang mana. Jawaban singkatnya: blok bukan bahasa baru, melainkan bentuk visual dari baris-baris Arduino C++. Blok “atur pin 13 sebagai OUTPUT” adalah baris pinMode(13, OUTPUT);, blok “tunggu 1000 ms” adalah delay(1000);, dan blok “jika … lakukan” adalah pernyataan if. Tabel di bawah menyandingkan label asli blok-blok di aplikasi BlueGrays dengan kode Arduino C++-nya dan kode MicroPython-nya di Raspberry Pi Pico.

Halaman ini bukan pelajaran, melainkan lembar referensi. Kamu bisa mencetak tabelnya, menaruhnya di dekat meja, lalu mengecek baris mana yang cocok dengan blok mana sambil melihat sebuah proyek. Setelah tabel, kamu akan menemukan kesalahan yang paling sering dibuat orang ketika beralih, metode empat langkah untuk meninggalkan blok, dan program yang sama yang ditulis sebagai blok, C++, dan MicroPython. Contohnya bisa dikompilasi di Arduino IDE dan berjalan di Pico dengan Thonny.

Sebelum membaca tabel: empat perbedaan di antara ketiganya

Blok, C++, dan MicroPython menyampaikan ide yang sama, tapi aturan penulisannya berbeda. Di empat perbedaan inilah kamu paling sering tersandung. Yang pertama adalah struktur: program Arduino C++ punya dua bagian bernama setup() dan loop(), yang di blok muncul sebagai “setup (jalan sekali)” dan “ulangi selamanya”. MicroPython tidak punya setup terpisah; file berjalan sekali dari atas ke bawah, dan bagian yang berulang masuk ke dalam perulangan while True:. Yang kedua adalah tipe: di C++ setiap variabel punya tipe yang ditulis (int, float, bool), di blok itu adalah pilihan “deklarasikan bilangan bulat (int)”, dan di Python tipe sama sekali tidak ditulis.

Perbedaan ketiga adalah rentang angka. Di Arduino Uno pembacaan analog bernilai 0–1023 dan PWM 0–255; di ESP32 pembacaan analog sampai 0–4095; di Pico, MicroPython memberi pembacaan analog dan duty PWM sama-sama di rentang 0–65535. Karena itu kamu tidak bisa menyalin ambang dari satu board ke board lain begitu saja. Perbedaan keempat adalah satuan waktu: delay() menerima milidetik, time.sleep() menerima detik. Setengah detik ditulis delay(500) di C++ dan time.sleep(0.5) di MicroPython. Ingat empat aturan ini, dan sebagian besar baris tabel akan langsung masuk akal dengan sendirinya.

• Angka di tabel hanyalah contoh: kalau sebuah blok bertuliskan 13, proyekmu mungkin memakai 7, dan angka di baris kodenya ikut berubah.
• Pin di kolom MicroPython adalah nomor GP Pico (GP14, GP15, GP26). Nomornya tidak harus sama dengan nomor pin Uno; cek skema rangkaiannya.
• Baris bertanda “Tidak ada blok Pico” berarti blok itu tidak dipakai di proyek Pico; kode MicroPython yang melakukan tugas yang sama tetap diberikan.
• ESP32 juga diprogram dengan Arduino C++; kolom C++ berlaku juga untuknya, hanya rentang analog dan beberapa nomor pin yang berbeda.

Tabel referensi blok, Arduino C++, dan MicroPython

Tabel dibagi menjadi 12 kelompok: struktur program, pin, waktu, kondisi, perulangan, variabel, matematika, port serial, analog dan PWM, suara, servo, dan sensor. Teks di kolom Blok adalah label yang tercetak di blok di aplikasi, sedangkan “…” dan “?” menandai slot tempat blok lain dipasang. Kalau satu baris berisi lebih dari satu blok, blok-bloknya dipisahkan dengan titik.

Beberapa baris kelihatan satu lawan satu pada pandangan pertama, tapi perlu hati-hati. Di “hitung dengan i dari 0 sampai 5”, angka 5 ikut dihitung dan perulangan berjalan 6 kali; karena itu C++ memakai <= alih-alih <, dan Python butuh range(0, 6) karena range tidak mengikutkan angka akhirnya. Blok pembagian juga jebakan: ketika kamu membagi dua bilangan bulat, C++ membuang sisanya dan 7 / 2 menghasilkan 3, sedangkan Python menghasilkan 3.5. Untuk pembagian bulat ala C++ di Python, kamu memakai //. Fungsi map() di balik blok “petakan x” tidak tersedia bawaan di MicroPython; di contoh di bawah, fungsi arduino_map() dua baris melakukan perhitungan yang sama.

Bagaimana blok bersarang berubah menjadi kode?

Mengenal blok satu per satu belum cukup; keterampilan yang sebenarnya adalah mengubah blok bersarang menjadi satu baris. Untuk itu, bedakan dua bentuk. Blok yang bertumpuk ke bawah dengan takik di tepinya adalah perintah, dan masing-masing menjadi satu baris kode. Blok oval atau runcing yang dipasang ke slot blok lain adalah nilai; di kode, nilai berada di dalam tanda kurung, di sebelah kanan tanda sama dengan, atau di dalam kondisi. Baris-baris di bawah diambil dari proyek gratis Mengatur Frekuensi Buzzer: empat tombol menyalakan dan mematikan nada serta menaikkan atau menurunkan frekuensinya, yang dijaga di antara 50 dan 5000 Hz.

Bangun satu kebiasaan sambil membaca tabel ini: terjemahkan blok paling dalam lebih dulu, lalu bergerak ke luar. Di “atur frequency ke (batasi frequency antara 50 dan 5000)”, bagian paling dalam adalah constrain(frequency, 50, 5000), dan blok atur di luarnya membungkusnya sebagai frequency = …. Blok nilai tidak bisa menjadi satu baris sendiri; kalau kamu membiarkannya dengan titik koma, compiler mungkin tidak protes, tapi hasilnya tidak disimpan di mana pun.

Kesalahan umum ketika beralih dari blok ke kode

Editor blok tidak membiarkanmu membuat sebagian besar kesalahan ini; bentuk kepingannya mencegah blok terpasang di tempat yang salah. Kode menghilangkan perlindungan itu, jadi hampir semua orang bertemu kesalahan di bawah ini di minggu-minggu pertama. Pesan error-nya dalam bahasa Inggris, tapi polanya hanya sedikit, dan setelah melihatnya beberapa kali kamu akan langsung mengenalinya.

Meninggalkan blok: metode 4 langkah

Mencoba beralih sekaligus itu melelahkan. Empat langkah di bawah bergerak dari membaca ke menulis sedikit demi sedikit. Satu atau dua proyek per langkah sudah cukup; kamu siap ke langkah berikutnya kalau bisa mengerjakan langkah yang sekarang tanpa melihat tabel.

1. Baca berdampingan. Buka blok dan kode sebuah proyek bersamaan, lalu cocokkan setiap blok dengan barisnya di kode memakai jarimu. Simpan tabel di dekatmu di langkah ini. Tujuan: bisa menghubungkan setiap baris kode dengan sebuah blok.
2. Sembunyikan blok dan tebak. Lihat bloknya dulu, lalu matikan tampilan blok dan tulis kode C++ untuk blok-blok itu di kertas tanpa melihat kodenya. Setelah itu bandingkan dengan kode aslinya. Coba juga sebaliknya: baca kodenya dan tebak bloknya.
3. Ubah satu nilai di kode. Pindahkan kode ke komputermu dan ubah satu angka saja: naikkan waktu tunggu dari 100 ke 500, atau ambang dari 400 ke 600. Upload, lalu lihat sendiri perbedaannya. Kalau muncul error kompilasi, kembali ke tabel kesalahan di atas.
4. Tulis baris baru. Tambahkan baris yang tidak ada di blok: Serial.println() yang mencetak nilai ke Serial Monitor, LED kedua, atau if yang bekerja dengan tombol. Sekarang kamu tidak lagi menerjemahkan blok, tapi langsung menulis kode.

Setiap langkah punya pelajaran yang cocok di seri ini. Untuk langkah pertama, tabel blok-ke-baris di LED berkedip dengan blok adalah awal yang bagus. Untuk berlatih dengan kondisi dan perulangan di langkah kedua dan ketiga, lihat blok jika (if) dan perulangan dan variabel. Kalau kamu pindah ke MicroPython di Pico, dari blok ke MicroPython juga membahas cara menyiapkan Thonny. Untuk menyebar peralihan ini ke beberapa minggu di kelas, rencana coding robotika 8 minggu memberimu urutan yang siap pakai.

Membuka blok dan kode berdampingan di aplikasi BlueGrays

Kamu paling sering memakai tabel ini ketika bolak-balik antara blok dan kode sebuah proyek sungguhan. Aplikasi BlueGrays punya tampilan blok untuk lebih dari 100 proyek; di lebih dari 30 proyek gratis bloknya juga terbuka, dan di proyek Premium bloknya terbuka dengan Premium. Blok untuk dibaca: kamu tidak bisa mengedit blok di aplikasi, dan blok tidak di-upload ke board. Yang masuk ke board selalu kode asli; kamu mengambilnya dengan Salin, atau dengan Salin tautan untuk membukanya di komputer, lalu menempelkannya ke Arduino IDE, atau ke Thonny untuk Pico.

• Tampilkan sebagai blok: nyalakan sakelar ini di samping kode sumber di halaman proyek, dan program yang sama muncul sebagai gambar blok dalam bahasa aplikasi. Ketuk gambarnya untuk membukanya layar penuh; mematikan dan menyalakannya lagi persis cara berlatih langkah satu dan dua.
• Pahami blok: ketika tampilan blok menyala, tab “Pahami kode” berganti nama menjadi ini. Program dibagi menjadi langkah-langkah, masing-masing dengan bagian yang dibahas dan penjelasannya. Tugas “Coba sendiri” di bagian akhir adalah latihan siap pakai untuk langkah empat.
• Panduan kode: masing-masing dari 36 kartu di bagian Belajar (18 Arduino C++, 18 MicroPython) menunjukkan contohnya dalam tiga cara lewat tab Blok, Arduino, dan MicroPython. Kalau kamu ingin melihat satu baris tabel lebih rinci, buka kartu yang cocok.
• Proyek dengan blok: pilihan di bawah Filter di Jelajahi > Proyek ini hanya menampilkan proyek yang punya tampilan blok, jadi memilih proyek untuk latihan peralihan jadi lebih mudah.

Cara kerja panduan kode sudah kita bahas di artikel Panduan kode, dan bagian “Pahami kode” serta “Coba sendiri” di panduan Pahami kode. Untuk penjelasan setiap perintah satu per satu, Daftar Perintah Arduino cocok dipakai bersama tabel ini.

Satu program dalam tiga cara: lampu tidur yang meredup mengikuti cahaya

Untuk melihat tabel ini beraksi, ayo buat program kecil. LDR mengukur cahaya; selama ruangan terang LED tetap mati, dan makin gelap, LED pelan-pelan makin terang. Program ini memakai blok variabel, baca analog, kondisi, petakan, PWM, serial, dan tunggu, jadi lebih dari separuh tabel muncul dalam satu contoh. Idenya berdasarkan proyek gratis Lampu Tidur dengan LDR; di sana LED hanya nyala atau mati, di sini PWM meredupkannya. Untuk pengkabelan LDR, kamu juga bisa melihat skema rangkaian proyek Mengukur Intensitas Cahaya dengan LDR.

Pertama versi bloknya. Dengan label dari aplikasi, program ini tersusun dari blok-blok di bawah; setiap butir cocok dengan satu atau beberapa baris kode C++ berikutnya:

1. variabel global (paling atas): deklarasikan bilangan bulat (int) lightValue = 0 dan deklarasikan bilangan bulat (int) brightness = 0
2. setup (jalan sekali): mulai serial di 9600 baud, lalu atur pin 9 sebagai OUTPUT
3. ulangi selamanya: atur lightValue ke (baca analog A0)
4. jika (lightValue < 400) lakukan: atur brightness ke (petakan lightValue : 0 – 400 → 255 – 0); jika tidak: atur brightness ke 0
5. tulis PWM brightness ke pin 9
6. cetak serial “Light: ” tanpa pindah baris, cetak serial lightValue tanpa pindah baris, cetak serial “ PWM: ” tanpa pindah baris, cetak serial brightness baris baru
7. tunggu 200 ms

1// ─────────────────────────────────────────
2//   BlueGrays · bluegrays.com
3//   Işığa göre kısılan gece lambası / Dimming night light
4// ─────────────────────────────────────────
5
6int lightValue = 0;   // LDR okuması / LDR reading (0-1023)
7int brightness = 0;   // LED parlaklığı / LED brightness (0-255)
8
9void setup() {
10  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
11  pinMode(9, OUTPUT);   // LED, PWM pini D9 / LED on PWM pin D9
12}
13
14void loop() {
15  lightValue = analogRead(A0);   // Az ışık = küçük değer / Little light = small value
16
17  if (lightValue < 400) {
18    // Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
19    brightness = map(lightValue, 0, 400, 255, 0);
20  } else {
21    brightness = 0;   // Oda aydınlık, LED kapalı / Room is bright, LED off
22  }
23
24  analogWrite(9, brightness);   // PWM 0-255 / PWM 0-255
25
26  Serial.print("Light: ");
27  Serial.print(lightValue);
28  Serial.print("  PWM: ");
29  Serial.println(brightness);
30
31  delay(200);   // 0,2 sn bekle / Wait 0.2 s
32}
33

1# ─────────────────────────────────────────
2#   BlueGrays · bluegrays.com
3#   Işığa göre kısılan gece lambası / Dimming night light
4# ─────────────────────────────────────────
5from machine import Pin, ADC, PWM
6import time
7
8ldr = ADC(26)                # GP26 = ADC0 / GP26 = ADC0
9led = PWM(Pin(15))           # LED, GP15 / LED on GP15
10led.freq(1000)               # PWM frekansı 1000 Hz / PWM frequency 1000 Hz
11
12THRESHOLD = 25600            # Uno'daki 400'ün karşılığı / Same as 400 on the Uno
13
14
15def arduino_map(x, in_min, in_max, out_min, out_max):
16    # Arduino map() ile aynı hesap / Same math as Arduino map()
17    return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
18
19
20while True:
21    light_value = ldr.read_u16()          # 0-65535 / 0-65535
22
23    if light_value < THRESHOLD:
24        # Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
25        brightness = arduino_map(light_value, 0, THRESHOLD, 65535, 0)
26    else:
27        brightness = 0                    # Oda aydınlık, LED kapalı / Room is bright, LED off
28
29    led.duty_u16(brightness)              # PWM 0-65535 / PWM 0-65535
30
31    print("Light:", light_value, " PWM:", brightness)
32
33    time.sleep(0.2)                       # 0,2 sn bekle / Wait 0.2 s
34

Bandingkan kedua program baris demi baris, dan setiap perbedaan dari tabel akan terlihat. setup() di C++ menjadi baris-baris sebelum while True di Python, dan Serial.begin() hilang. analogRead(A0) menjadi ADC(26).read_u16() dan rentangnya membesar dari 0–1023 menjadi 0–65535, karena itulah ambangnya 25600, bukan 400. Alih-alih analogWrite(9, …), objek PWM dibuat lebih dulu dan kecerahan diatur dengan duty_u16() antara 0 dan 65535. Karena map() tidak tersedia bawaan, ditulis fungsi arduino_map(); pembagian bulat // di dalamnya sama dengan pembagian bilangan bulat di C++. Satu print() menggantikan empat panggilan Serial.print() terpisah, dan delay(200) menjadi time.sleep(0.2).

Pindah dari coding blok ke Arduino C++ bukan soal menghafal sesuatu yang baru, tapi lebih soal mengenali bentuk tertulis dari blok yang sudah kamu kenal. Simpan tabel ini di dekatmu, baca berdampingan dulu di setiap proyek, lalu sembunyikan bloknya dan tulis sendiri. Kalau kamu ingin melihat baris-baris ini di proyek sungguhan, buka proyek yang punya tampilan blok di aplikasi BlueGrays, lalu beralih di antara dua bentuk program yang sama dengan Tampilkan sebagai blok.