Daftar Perintah Arduino: Sintaks, Contoh, dan Kesalahan Umum

Perintah Arduino adalah fungsi siap pakai yang memberi tahu board apa yang harus dilakukan: pinMode() menjadikan pin sebagai output, digitalWrite() menyalakan LED, analogRead() membaca sensor, dan Serial.println() mengirim pesan ke komputermu. Kebanyakan sketch Arduino sebenarnya hanya sekitar dua puluh perintah dasar yang digabung dengan cara berbeda. Begitu kamu memahami perintah-perintah ini dan artinya, kamu bisa membaca kode apa pun yang kamu temui, dari LED berkedip sampai mobil robot, dan menulis proyekmu sendiri dari nol.

Di panduan ini kami mengelompokkan perintah Arduino yang paling sering dipakai menjadi empat kategori: input/output, waktu, matematika, dan komunikasi. Untuk setiap perintah kamu akan menemukan sintaksnya, arti parameternya, contoh singkat yang bisa dikompilasi dan dijalankan di Arduino Uno, dan kesalahan yang paling sering dilakukan pemula. Di bagian terakhir kita juga akan melihat bagaimana perintah yang sama berperilaku berbeda di ESP32 dan apa padanan MicroPython-nya di Raspberry Pi Pico.

Apa itu perintah Arduino, dan bagaimana sketch berjalan?

Kode Arduino dibangun di atas C/C++; kebanyakan yang kita sebut “perintah” sebenarnya adalah fungsi yang disediakan core Arduino untukmu. Sebuah fungsi menerima parameter di dalam kurung (misalnya nomor pin dan sebuah nilai), dan sebagian mengembalikan hasil: digitalRead() memberimu keadaan pin, millis() waktu yang sudah berlalu. Setiap sketch Arduino punya dua fungsi wajib: setup() hanya berjalan sekali ketika board menyala atau di-reset, dan loop() setelah itu berulang selamanya. Persiapan seperti pengaturan pin dan Serial.begin() masuk ke setup(), dan pekerjaan yang harus terus berlangsung masuk ke loop().

1// Her Arduino programı bu iki fonksiyondan oluşur / Every Arduino sketch has these two functions
2void setup() {
3  // Açılışta ya da resetten sonra bir kez çalışır / Runs once at power-up or after reset
4  pinMode(13, OUTPUT);      // dahili LED pini çıkış / built-in LED pin as output
5}
6
7void loop() {
8  // Sonsuza kadar tekrar eder / Repeats forever
9  digitalWrite(13, HIGH);   // LED'i yak / turn the LED on
10  delay(500);               // 500 ms bekle / wait 500 ms
11  digitalWrite(13, LOW);    // LED'i söndür / turn the LED off
12  delay(500);
13}

Mengingat tiga aturan sejak awal menyelamatkanmu dari banyak error kompilasi: perintah membedakan huruf besar dan kecil (jika kamu mengetik digitalwrite kamu mendapat error “'digitalwrite' was not declared in this scope”), setiap pernyataan diakhiri titik koma, dan teks ditulis di dalam tanda kutip ganda sedangkan karakter tunggal di dalam tanda kutip tunggal. Untuk tipe variabel dan struktur seperti if dan for, lihat dasar-dasar pemrograman Arduino.

Daftar perintah Arduino: tabel per kategori

Empat tabel di bawah merangkum hampir semua perintah yang akan kamu pakai di proyek sehari-hari. Kelompok pertama adalah perintah input/output; perintah ini menentukan peran pin, memberi tegangan padanya, atau membaca nilai darinya. Kamu bisa melihat nomor pin board-mu di alat Pinout.

Kelompok kedua adalah perintah waktu. Memahami perbedaan antara delay(), yang menunggu, dengan millis() dan micros(), yang mengukur waktu, adalah kunci untuk menulis sketch yang berjalan lancar.

Kelompok ketiga adalah perintah matematika; kamu memakainya untuk mengubah pembacaan sensor ke rentang lain, membatasinya, atau menghasilkan angka acak. Kelompok keempat, perintah komunikasi, memungkinkan board bertukar data dengan komputermu dan perangkat lain.

pinMode(): menentukan peran pin

pinMode(pin, mode) memberi tahu board apakah sebuah pin digital adalah input atau output, dan biasanya kamu menulisnya sekali di setup(). Ada tiga mode: OUTPUT menjadikan pin sebagai output (untuk mengendalikan LED, buzzer, atau relay), INPUT menjadikannya input berimpedansi tinggi (untuk rangkaian dengan resistor pull-up atau pull-down eksternal), dan INPUT_PULLUP menjadikannya input dan menyambungkan resistor internal sekitar 20–50 kΩ ke 5 V. Pin analog (A0–A5) juga bisa dipakai sebagai pin digital dengan pinMode; misalnya, pinMode(A0, OUTPUT) adalah perintah yang valid.

digitalWrite() dan digitalRead(): output dan input digital

digitalWrite(pin, HIGH) menarik pin output ke 5 V di Uno, dan digitalWrite(pin, LOW) menariknya ke 0 V. Menarik sampai 20 mA dari satu pin itu aman (maksimum mutlaknya 40 mA); selalu sambungkan LED dengan resistor, dan kamu bisa mencari nilai yang tepat dengan kalkulator resistor LED. digitalRead(pin) melihat tegangan di pin dan mengembalikan HIGH atau LOW; di Uno, kira-kira apa pun di atas 3 V dihitung HIGH dan apa pun di bawah 1,5 V dihitung LOW. Di contoh di bawah, LED bawaan menyala ketika kamu menekan tombol yang tersambung ke D2:

1const int BUTON_PIN = 2;   // buton: bir ucu D2, diğer ucu GND / button: one leg to D2, the other to GND
2const int LED_PIN = 13;    // dahili LED / built-in LED
3
4void setup() {
5  pinMode(BUTON_PIN, INPUT_PULLUP);   // dahili pull-up direnci açık / internal pull-up resistor enabled
6  pinMode(LED_PIN, OUTPUT);
7}
8
9void loop() {
10  int durum = digitalRead(BUTON_PIN); // HIGH ya da LOW döner / returns HIGH or LOW
11  if (durum == LOW) {                 // pull-up ile basılı = LOW / with pull-up, pressed = LOW
12    digitalWrite(LED_PIN, HIGH);
13  } else {
14    digitalWrite(LED_PIN, LOW);
15  }
16}

Dengan INPUT_PULLUP logikanya terbalik: ketika tombol dilepas pin terbaca HIGH berkat resistor internal, dan ketika ditekan terbaca LOW karena tersambung ke GND. Jika kamu menyambungkan tombol tanpa resistor dalam mode INPUT, pin mengambang dan digitalRead() mengembalikan nilai acak; bahkan mendekatkan tangan bisa mengubah hasilnya. Untuk pantulan tombol dan cara yang benar menyambungkan tombol, lihat Cara Menghubungkan Push Button ke Arduino.

analogRead() dan analogWrite(): input analog dan PWM

analogRead(pin) memakai konverter 10 bit (ADC) untuk mengubah tegangan antara 0 dan 5 V di pin A0–A5 menjadi angka dari 0 sampai 1023. Satu pembacaan butuh sekitar 100 µs, jadi kamu bisa mengambil kira-kira 10.000 pembacaan per detik. Untuk mengubah angka menjadi tegangan kamu memakai value × 5.0 / 1023; pembacaan 512, misalnya, berarti sekitar 2,5 V. Tegangan referensi bisa diubah dengan analogReference(): opsi INTERNAL memakai referensi internal 1,1 V milik Uno dan meningkatkan resolusi untuk tegangan kecil. Kamu akan menemukan detail tentang resolusi dan referensi di ADC dan konversi analog ke digital.

Walaupun namanya begitu, analogWrite(pin, value) tidak menghasilkan tegangan analog sungguhan. Perintah ini menyalakan dan mematikan pin dengan sangat cepat untuk membuat sinyal PWM: 0 berarti selalu mati, 255 selalu menyala, dan 127 kira-kira setengah menyala. Rata-rata itulah yang membuat LED terlihat setengah terang di mata kita dan motor berputar pelan. Di Uno hanya pin 3, 5, 6, 9, 10, dan 11, yang bertanda ~ di board, yang menyediakan PWM; frekuensinya 490 Hz di kebanyakan pin dan 980 Hz di pin 5 dan 6. analogWrite() mengatur pin sebagai output sendiri, jadi pinMode tidak wajib. Kode di bawah mengatur kecerahan LED dengan potensiometer dan mencetak pembacaan beserta tegangannya ke Serial Monitor; untuk detail duty cycle dan frekuensi, lihat Apa Itu PWM?.

1const int POT_PIN = A0;   // potansiyometrenin orta bacağı / potentiometer wiper
2const int LED_PIN = 9;    // ~9 PWM pini + 220 ohm direnç / ~9 PWM pin + 220 ohm resistor
3
4void setup() {
5  Serial.begin(9600);
6}
7
8void loop() {
9  int ham = analogRead(POT_PIN);         // 0-1023 arası / between 0 and 1023
10  float volt = ham * (5.0 / 1023.0);     // sayıyı gerilime çevir / convert the reading to volts
11  analogWrite(LED_PIN, ham / 4);         // 0-1023 -> 0-255 PWM parlaklığı / 0-1023 -> 0-255 PWM brightness
12
13  Serial.print(F("Ham / raw: "));
14  Serial.print(ham);
15  Serial.print(F("  Gerilim / voltage: "));
16  Serial.print(volt, 2);                 // 2 ondalık basamak / 2 decimal places
17  Serial.println(F(" V"));
18  delay(200);
19}

delay(), millis(), dan micros(): perintah waktu

delay(ms) menunggu selama sekian milidetik, dan selama waktu itu tidak ada baris lain di loop() yang berjalan; delay(1000) adalah jeda penuh satu detik. Untuk jeda singkat dalam orde mikrodetik ada delayMicroseconds(), yang akurat antara 3 dan 16383 µs. millis(), sebaliknya, tidak menunggu; perintah ini mengembalikan waktu sejak board mulai, dalam milidetik. Selalu simpan hasilnya di variabel unsigned long: jika kamu memakai int, di Uno nilainya meluap begitu melewati 32.767, setelah sekitar 33 detik, dan pengaturan waktumu rusak. millis() kembali ke nol kira-kira setiap 49,7 hari; cara pengurangan di bawah tetap bekerja dengan benar bahkan ketika melewati titik itu.

1const int LED_PIN = 13;
2const unsigned long ARALIK = 500;   // yanıp sönme aralığı (ms) / blink interval (ms)
3unsigned long oncekiZaman = 0;      // son değişim anı / time of the last toggle
4
5void setup() {
6  pinMode(LED_PIN, OUTPUT);
7}
8
9void loop() {
10  unsigned long simdi = millis();
11  if (simdi - oncekiZaman >= ARALIK) {               // taşmada da doğru çalışır / safe across overflow
12    oncekiZaman = simdi;
13    digitalWrite(LED_PIN, !digitalRead(LED_PIN));    // LED'i tersine çevir / toggle the LED
14  }
15  // Burada buton, sensör ve ekran işleri de yapılabilir / button, sensor and display tasks can run here
16}

Dengan pola ini loop() tidak pernah berhenti; selagi LED terus berkedip kamu bisa membaca tombol, mengukur sensor, dan memperbarui layar di loop yang sama. micros() bekerja dengan cara yang sama dalam mikrodetik; di Uno ia maju dengan langkah 4 µs dan kembali ke nol setelah sekitar 70 menit. Kami membahas menjalankan beberapa tugas sekaligus secara lengkap di Arduino millis() vs delay().

Serial.begin(), Serial.print(), dan Serial.read(): komunikasi serial

Perintah Serial memungkinkan Arduino berkomunikasi dengan komputermu lewat kabel USB, dan merupakan alat paling penting untuk mencari bug. Serial.begin(9600) membuka port serial dengan 9600 bit per detik; jika kecepatan di Serial Monitor tidak cocok, kamu akan melihat karakter sampah di layar. Serial.print() mencetak data dan tetap di baris yang sama, sedangkan Serial.println() pindah ke baris baru setelah mencetak. Parameter kedua memungkinkanmu memilih formatnya: Serial.print(78, HEX) mencetak “4E”, Serial.print(78, BIN) mencetak “1001110”, dan Serial.print(3.14159, 3) menampilkan “3.142” (bilangan float bawaannya 2 angka di belakang koma). Menaruh teks tetap di dalam F("...") menghemat tempat di RAM 2 KB milik Uno.

Untuk membaca data, kamu cek dulu dengan Serial.available() apakah ada byte yang menunggu di buffer; buffer penerima Uno berukuran 64 byte. Serial.read() mengambil satu byte dari buffer itu dan mengembalikan -1 jika tidak ada yang bisa dibaca. Kode di bawah menyalakan dan mematikan LED dengan karakter 1 dan 0 yang kamu kirim dari Serial Monitor:

1const int LED_PIN = 13;
2
3void setup() {
4  Serial.begin(9600);                    // Seri Monitör de 9600 olmalı / Serial Monitor must be 9600 too
5  pinMode(LED_PIN, OUTPUT);
6  Serial.println(F("1: LED açık / on, 0: LED kapalı / off"));
7}
8
9void loop() {
10  if (Serial.available() > 0) {          // tamponda bayt var mı? / any bytes waiting?
11    char c = Serial.read();              // ilk baytı al / read the first byte
12    if (c == '1') {                      // '1' karakteri, 1 sayısı değil / the character '1', not the number 1
13      digitalWrite(LED_PIN, HIGH);
14      Serial.println(F("LED açık / on"));
15    } else if (c == '0') {
16      digitalWrite(LED_PIN, LOW);
17      Serial.println(F("LED kapalı / off"));
18    }
19    // '\n' ve '\r' gibi diğer karakterler atlanır / other characters such as '\n' and '\r' are ignored
20  }
21}

Perhatikan bahwa perbandingan dilakukan dengan '1' (tanda kutip tunggal, jadi sebuah karakter): angka 1 yang kamu ketik di keyboard sesuai dengan angka 49 di tabel ASCII, jadi kondisi c == 1 tidak pernah benar. Untuk angka dengan beberapa digit kamu bisa memakai Serial.parseInt(), dan untuk mengambil satu baris penuh, Serial.readStringUntil('\n'). Untuk pengaturan akhir baris, baud rate, dan plotter di Serial Monitor, lihat Cara Memakai Serial Monitor Arduino.

map() dan constrain(): menskalakan dan membatasi nilai

map(value, fromLow, fromHigh, toLow, toHigh) memindahkan angka secara proporsional dari satu rentang ke rentang lain. Rumus di baliknya adalah: (x − fromLow) × (toHigh − toLow) / (fromHigh − fromLow) + toLow. Misalnya, map(512, 0, 1023, 0, 255) mengembalikan 127, bukan 127,6, karena map() hanya bekerja dengan bilangan bulat dan membuang pecahannya. Kamu bisa membuat hubungan terbalik dengan menukar rentang tujuan: map(x, 0, 1023, 255, 0). map() tidak membatasi hasilnya; jika input keluar dari rentang yang kamu berikan, output-nya juga keluar. Karena itu map() biasanya digabung dengan constrain(x, low, high).

1const int LDR_PIN = A0;   // LDR + 10k gerilim bölücü / LDR + 10k voltage divider
2const int LED_PIN = 9;    // ~9 PWM pini / ~9 PWM pin
3
4void setup() {
5  pinMode(LED_PIN, OUTPUT);
6}
7
8void loop() {
9  int isik = analogRead(LDR_PIN);           // odada ölçülen aralık ~200-800 / measured range in the room ~200-800
10  int pwm = map(isik, 200, 800, 255, 0);    // karanlıkta parlak, aydınlıkta sönük / bright in the dark, dim in the light
11  pwm = constrain(pwm, 0, 255);             // aralık dışı değerleri kes / clip out-of-range values
12  analogWrite(LED_PIN, pwm);
13  delay(20);
14}

Di contoh ini LDR memberi nilai antara 200 dan 800 di dalam ruangan. Jika pembacaannya turun ke 100 di malam hari, map() menghitung 297; tanpa constrain(), analogWrite() akan menerima nilai di luar rentang 0–255 ini. Di Uno nilai seperti itu memberi hasil berbeda yang tidak terduga tergantung pinnya: di pin 3, 5, 6, dan 11, yang memakai timer 8 bit, 297 meluap dan berperilaku seperti 41, jadi LED hampir padam dalam gelap total alih-alih menyala terang. Karena constrain(), min(), max(), dan abs() didefinisikan sebagai makro di Uno, jangan taruh x++ atau pemanggilan fungsi lain di dalam kurungnya; ekspresinya bisa dievaluasi lebih dari sekali dan memberi hasil yang tidak terduga. Untuk pengkabelan LDR, lihat sensor cahaya LDR.

tone() dan noTone(): membuat suara dengan buzzer

tone(pin, frequency, duration) menghasilkan gelombang kotak dengan duty cycle 50% di sebuah pin dan membuat buzzer pasif atau speaker kecil berbunyi pada frekuensi itu. Durasinya dalam milidetik dan opsional; tanpa durasi suaranya berlanjut sampai kamu memanggil noTone(pin). Detail penting: tone() tidak menunggu; perintah ini memulai suara lalu langsung lanjut ke baris berikutnya. Jadi ketika kamu memainkan nada satu per satu, kamu butuh delay() yang minimal sepanjang nadanya setelah setiap pemanggilan tone(), kalau tidak kamu hanya mendengar nada terakhir.

1const int BUZZER_PIN = 8;   // pasif buzzer'ın + ucu / passive buzzer + leg
2
3void setup() {
4  int notalar[] = {262, 294, 330, 349, 392};   // Do Re Mi Fa Sol (Hz) / C D E F G (Hz)
5  for (int i = 0; i < 5; i++) {
6    tone(BUZZER_PIN, notalar[i], 200);         // 200 ms çal / play for 200 ms
7    delay(250);                                // tone() beklemez, sen bekle / tone() does not wait, so you do
8  }
9  noTone(BUZZER_PIN);                          // sesi kapat / stop the sound
10}
11
12void loop() {
13}

• Batas frekuensi: Di Uno nada di bawah 31 Hz tidak bisa dihasilkan dan batas atasnya 65.535 Hz; rentang yang berguna dengan buzzer kira-kira 100–5000 Hz.
• Satu suara dalam satu waktu: Hanya satu pin yang bisa memainkan nada dalam satu waktu; untuk membuat suara di pin lain kamu harus menghentikan yang sebelumnya dulu dengan noTone().
• Bentrokan PWM: Di Uno tone() memakai Timer2, jadi analogWrite() di pin 3 dan 11 terganggu selama suara berbunyi.
• Buzzer aktif: Karena punya osilator sendiri, frekuensinya tidak bisa diubah dengan tone(); cukup nyalakan dan matikan buzzer aktif dengan digitalWrite(). Untuk perbedaannya, lihat Apa Itu Buzzer?.

pulseIn(): mengukur panjang pulsa

pulseIn(pin, HIGH) menunggu pin menjadi HIGH, mengukur berapa lama ia tetap HIGH, dan mengembalikan hasilnya dalam mikrodetik; perintah ini bisa mengukur pulsa sepanjang 10 µs sampai 3 menit. Pemakaiannya yang paling terkenal adalah sensor jarak ultrasonik HC-SR04: sensor mengeluarkan pulsa sepanjang waktu yang dibutuhkan suara untuk pergi dan kembali. Suara merambat di udara sekitar 343 m/dtk, atau 0,0343 cm/µs; karena jalurnya bolak-balik, jarak = durasi × 0.0343 / 2.

1const int TRIG_PIN = 9;
2const int ECHO_PIN = 10;
3
4void setup() {
5  Serial.begin(9600);
6  pinMode(TRIG_PIN, OUTPUT);
7  pinMode(ECHO_PIN, INPUT);
8}
9
10void loop() {
11  digitalWrite(TRIG_PIN, LOW);
12  delayMicroseconds(2);
13  digitalWrite(TRIG_PIN, HIGH);            // 10 µs tetik darbesi / 10 µs trigger pulse
14  delayMicroseconds(10);
15  digitalWrite(TRIG_PIN, LOW);
16
17  unsigned long sure = pulseIn(ECHO_PIN, HIGH, 30000UL);   // en fazla 30 ms bekle / wait at most 30 ms
18  if (sure == 0) {
19    Serial.println(F("Menzil dışı / out of range"));
20  } else {
21    float mesafe = sure * 0.0343 / 2.0;    // ses hızı 343 m/s, gidiş-dönüş / speed of sound 343 m/s, round trip
22    Serial.print(mesafe, 1);
23    Serial.println(F(" cm"));
24  }
25  delay(100);
26}

Parameter ketiga, timeout, sangat penting. Tanpa itu, pulseIn() menunggu 1 detik ketika tidak ada pulsa yang datang dan mengembalikan 0; jika kabel sensor lepas, seluruh program macet satu detik di setiap putaran loop. Timeout 30000 µs sesuai dengan sekitar 5 meter, yang cukup untuk jangkauan 4 meter HC-SR04. Untuk pengkabelan dan akurasi sensornya, lihat sensor jarak HC-SR04.

attachInterrupt(): bereaksi seketika dengan interupsi

attachInterrupt(digitalPinToInterrupt(pin), function, mode) menjalankan fungsi yang kamu berikan tepat ketika sebuah pin berubah, apa pun yang sedang dikerjakan loop() pada momen itu. Fungsi ini disebut interrupt service routine (ISR). Mode-nya bisa bernilai empat: RISING terpicu pada perpindahan LOW ke HIGH, FALLING pada perpindahan HIGH ke LOW, CHANGE pada setiap perubahan, dan LOW selama pin tetap LOW. Di Uno dan Nano hanya pin D2 dan D3 yang bisa memicu interupsi dengan cara ini; di Mega kamu bisa memakai pin 2, 3, 18, 19, 20, dan 21. Ini ideal agar tidak melewatkan encoder yang berputar cepat, pulsa anemometer, atau tekanan tombol yang sangat singkat.

1const int BUTON_PIN = 2;            // Uno'da kesme pinleri: 2 ve 3 / interrupt pins on the Uno: 2 and 3
2volatile unsigned long sayac = 0;   // ISR'de değişen değişken volatile olmalı / variables changed in an ISR must be volatile
3
4void say() {                        // kesme fonksiyonu (ISR): kısa tut / interrupt service routine: keep it short
5  sayac++;
6}
7
8void setup() {
9  Serial.begin(9600);
10  pinMode(BUTON_PIN, INPUT_PULLUP);
11  attachInterrupt(digitalPinToInterrupt(BUTON_PIN), say, FALLING);   // HIGH'dan LOW'a geçişte / on a HIGH-to-LOW edge
12}
13
14void loop() {
15  noInterrupts();                   // 4 baytlık değeri güvenle kopyala / copy the 4-byte value safely
16  unsigned long kopya = sayac;
17  interrupts();
18
19  Serial.print(F("Basma sayısı / presses: "));
20  Serial.println(kopya);
21  delay(500);
22}

random() dan randomSeed(): menghasilkan angka acak

random(max) mengembalikan bilangan bulat acak antara 0 dan max−1, dan random(min, max) antara min dan max−1; batas atasnya tidak termasuk dalam hasil. Karena itu kamu menulis random(1, 7) untuk dadu 1 sampai 6. Arduino tidak menghasilkan keacakan sejati; ia menghitung deret angka dengan rumus tetap, jadi jika kamu tidak memanggil randomSeed(), kamu akan melihat angka yang sama dengan urutan yang sama setiap kali board menyala. Memakai noise dari pin analog yang tidak tersambung sebagai seed menyelesaikan ini dalam praktik:

1void setup() {
2  Serial.begin(9600);
3  randomSeed(analogRead(A3));     // boştaki A3 pininin gürültüsü / noise from the unconnected A3 pin
4}
5
6void loop() {
7  int zar = random(1, 7);         // 1-6 arası; üst sınır dahil değil / 1 to 6; the upper bound is exclusive
8  Serial.print(F("Zar / dice: "));
9  Serial.println(zar);
10  delay(1000);
11}

Perintah Arduino di ESP32: apa yang perlu diperhatikan

ESP32 diprogram di Arduino IDE dengan perintah yang sama, dan sebagian besar kode di artikel ini langsung berjalan begitu kamu mengubah nomor pin. Namun karena hardware-nya berbeda, beberapa perintah berperilaku berbeda. Perbedaan terpenting adalah tegangannya: pin ESP32 bekerja di 3,3 V, digitalWrite(pin, HIGH) mengeluarkan 3,3 V, dan sinyal 5 V tidak boleh disambung langsung ke pin. Untuk mengenal board ini lebih baik, lihat Apa Itu ESP32?.

1const int POT_PIN = 34;     // ADC1 pini, Wi-Fi açıkken de okur / ADC1 pin, works with Wi-Fi on
2const int LED_PIN = 2;      // çoğu DevKit'te dahili LED / onboard LED on most DevKits
3const int BUTON_PIN = 4;    // butonun diğer ucu GND / other button leg to GND
4
5volatile bool basildi = false;
6
7void IRAM_ATTR butonISR() { // ESP32'de ISR IRAM'e yerleşmeli / on the ESP32 the ISR should live in IRAM
8  basildi = true;
9}
10
11void setup() {
12  Serial.begin(115200);
13  pinMode(BUTON_PIN, INPUT_PULLUP);
14  attachInterrupt(digitalPinToInterrupt(BUTON_PIN), butonISR, FALLING);   // her GPIO kesme destekler / every GPIO supports interrupts
15}
16
17void loop() {
18  int ham = analogRead(POT_PIN);                     // 0-4095 (12 bit)
19  analogWrite(LED_PIN, map(ham, 0, 4095, 0, 255));   // 8 bit PWM / 8-bit PWM
20  if (basildi) {
21    basildi = false;
22    Serial.println("Butona basıldı / button pressed");
23  }
24  Serial.println(ham);
25  delay(200);
26}

Karena analogRead() mengembalikan 0–4095 di ESP32, rentang map() berubah menyesuaikan. IRAM_ATTR di depan ISR menaruh kode di memori internal yang cepat; tanpa itu, dalam situasi tertentu board bisa memulai ulang dengan “Guru Meditation Error”. Pembacaan analog ESP32 tidak linear di dekat ujung rentang (sekitar 0 V dan 3,3 V); jika kamu butuh pengukuran yang lebih akurat, fungsi analogReadMilliVolts() mengembalikan nilai terkalibrasi dalam milivolt.

Raspberry Pi Pico: padanan MicroPython untuk perintah Arduino

Jika kamu memprogram Raspberry Pi Pico dengan Arduino IDE (core arduino-pico), setiap perintah di artikel ini bekerja dengan nama yang sama; analogRead() bawaannya mengembalikan 10 bit dan analogWrite() menghasilkan PWM 1 kHz. Namun kebanyakan orang memakai Pico dengan MicroPython. Di sana perintah ditulis dengan objek dari modul machine dan time; logikanya sama, hanya sintaksnya yang berubah. Pin Pico juga 3,3 V, dan input analognya adalah pin GP26, GP27, dan GP28. Untuk memulai, lihat Apa Itu Raspberry Pi Pico?.

1from machine import Pin, ADC, PWM
2import time
3
4led = PWM(Pin(15))                       # pinMode + analogWrite karşılığı / pinMode + analogWrite equivalent
5led.freq(1000)                           # 1 kHz PWM
6buton = Pin(14, Pin.IN, Pin.PULL_UP)     # INPUT_PULLUP karşılığı / INPUT_PULLUP equivalent
7pot = ADC(26)                            # GP26 = ADC0
8
9def map_deger(x, giris_min, giris_max, cikis_min, cikis_max):   # Arduino map() karşılığı / Arduino map() equivalent
10    return (x - giris_min) * (cikis_max - cikis_min) // (giris_max - giris_min) + cikis_min
11
12onceki = time.ticks_ms()                 # millis() karşılığı / millis() equivalent
13while True:
14    ham = pot.read_u16()                 # 0-65535 (analogRead)
15    led.duty_u16(ham)                    # parlaklık / brightness (analogWrite)
16    if buton.value() == 0:               # digitalRead; basılı = 0 / pressed = 0
17        print("Butona basıldı / button pressed")
18    if time.ticks_diff(time.ticks_ms(), onceki) >= 1000:   # saniyede bir / once a second
19        onceki = time.ticks_ms()
20        print("Yüzde / percent:", map_deger(ham, 0, 65535, 0, 100))
21    time.sleep_ms(50)                    # delay(50)

Seperti terlihat di tabel, random.randint(1, 6) di MicroPython menyertakan batas atas dan memberi hasil yang sama dengan random(1, 7) di Arduino; time.ticks_diff() memberi keamanan yang sama terhadap kembali-ke-nol seperti pengurangan millis(). Perbedaan kecil seperti inilah yang paling membingungkan ketika berpindah di antara kedua platform. Untuk perintah dasar MicroPython lainnya, lihat dasar-dasar MicroPython.

Ide proyek yang bisa kamu buat dengan perintah-perintah ini

• Lampu lalu lintas: Nyalakan tiga LED berurutan dengan pinMode(), digitalWrite(), dan delay(); kami menjelaskannya langkah demi langkah di Lampu Lalu Lintas Arduino.
• Dadu digital: Hasilkan angka 1 sampai 6 dengan random() dan, ketika tombol ditekan, tampilkan hasilnya dengan LED atau di display 7-segmen.
• Sensor parkir: Ukur jarak dengan pulseIn(), ubah menjadi jeda bunyi dengan map(), dan bunyikan peringatan dengan tone().
• Lampu tidur otomatis: Baca tingkat cahaya dengan analogRead() dan atur kecerahan analogWrite() dengan map() dan constrain().
• Remote lewat port serial: Kendalikan LED, relay, atau motor servo dengan perintah dari komputermu memakai Serial.read().
• Tes reaksi: Nyalakan LED pada momen acak dengan random() dan ukur waktu reaksimu menekan tombol sampai milidetik dengan attachInterrupt() dan millis().

Kesalahan umum dan cara memperbaikinya

Perintah-perintah di artikel ini adalah batu bata dari kebanyakan proyek yang akan kamu buat dengan Arduino; sisanya kebanyakan adalah fungsi tambahan yang disediakan library. Mencoba setiap perintah sekali di rangkaian kecilnya sendiri dan melihat hasilnya di Serial Monitor membuat pelajarannya jauh lebih melekat daripada menghafalnya. Di aplikasi BlueGrays kamu bisa menemukan proyek yang memakai perintah-perintah ini, seperti menyalakan LED, mengendalikan LED dengan tombol, mengukur cahaya dengan LDR, mengatur frekuensi buzzer, mengukur jarak dengan HC-SR04, dan proyek dadu, langkah demi langkah dengan skema rangkaian dan kode yang diberi komentar.