Serial Monitor Arduino: Baud Rate, Mengirim Data, dan Serial Plotter

Serial Monitor Arduino adalah jendela di dalam Arduino IDE yang memungkinkan board-mu dan komputer saling bertukar teks lewat kabel USB. Di sinilah kamu membaca output setiap baris Serial.println() di sketch-mu, dan di sini juga kamu mengetik perintah untuk dikirim balik ke board. Ini cara tercepat untuk melihat nilai yang sedang diukur sensor sekarang, sampai mana programmu berjalan, atau apakah sebuah tombol benar-benar ditekan, sehingga Serial Monitor menjadi alat debugging nomor satu di dunia Arduino. Untuk memakainya, kamu cukup menulis Serial.begin(9600) di kodemu, memilih port yang benar di pemilih board, dan menyetel kecepatan yang sama di monitor seperti di kode.

Di panduan ini kamu akan mulai dari membuka Serial Monitor, lalu melihat arti sebenarnya dari baud rate, cara mencetak angka dalam format desimal, heksadesimal, dan biner dengan print dan println, cara mengatur jumlah angka di belakang koma, dan cara menyusun baris yang rapi dengan snprintf. Dengan contoh sketch yang benar-benar bisa dikompilasi, kami membahas semua penyebab karakter sampah, pengaruh pengaturan line ending terhadap kodemu, cara mengirim angka dan perintah teks dari komputer ke board (Serial.read, parseInt, readStringUntil), menggambar grafik live dengan Serial Plotter, serta teknik debugging yang akan memudahkan pekerjaanmu. Bagian terakhir menunjukkan perbedaan output serial di ESP32 dan Raspberry Pi Pico (dengan Arduino maupun MicroPython) dan cara mengatasi masalah umum seperti monitor yang kosong.

Apa itu Serial Monitor Arduino dan bagaimana cara kerjanya?

ATmega328P, otak Arduino Uno, berkomunikasi dengan dunia luar lewat unit komunikasi serial bernama UART: ia mengirim data bit demi bit di satu jalur (TX) dan menerima di jalur lain (RX). Komputer modern sudah tidak punya port serial seperti ini, jadi chip kedua di board (ATmega16U2 di Uno original, biasanya CH340 di board klon) mengubah sinyal itu menjadi USB. Komputer melihat board sebagai port serial virtual: misalnya COM3 di Windows, /dev/ttyACM0 atau /dev/ttyUSB0 di Linux, dan nama yang diawali /dev/cu.usbmodem atau /dev/cu.usbserial di macOS. Serial Monitor membuka port ini, menampilkan byte yang masuk sebagai teks, dan mengirim apa yang kamu ketik kembali ke board dengan cara yang sama. Secara default Arduino memakai format 8N1: satu start bit, 8 bit data, tanpa bit paritas, dan satu stop bit untuk setiap byte. Jadi satu karakter memakan 10 bit di jalur; angka ini akan kita pakai dalam perhitungan kecepatan.

Cara membuka dan memakai Serial Monitor

1. Tambahkan baris Serial.begin(9600); ke bagian setup() di sketch-mu lalu upload. Tanpa baris ini, board tidak menulis apa pun ke port serial.
2. Pilih port tempat board-mu terhubung di pemilih board pada bilah atas atau di menu Tools › Port. Kalau belum ada port yang dipilih, Serial Monitor menampilkan peringatan Not connected. Select a board and a port to connect automatically. (belum terhubung; pilih board dan port).
3. Klik ikon kaca pembesar di pojok kanan atas, pakai menu Tools › Serial Monitor, atau tekan Ctrl+Shift+M (Cmd+Shift+M di macOS). Di IDE 2, monitor terbuka di panel bawah, di sebelah bagian Output.
4. Di menu kecepatan di sebelah kanan panel, pilih baud rate yang sama dengan di kodemu; di contoh ini 9600. Kalau kecepatannya berbeda, karakter sampah akan membanjiri layar.
5. Untuk mengirim data ke board, ketik di kotak pesan di bagian atas panel lalu tekan Enter. Pilih line ending di menu tepat di sebelahnya; di bawah kami jelaskan kenapa pengaturan ini penting.
6. Dengan tombol di kanan atas, kamu bisa menghentikan autoscroll (berguna ketika membaca baris lama), menyalakan timestamp yang menambahkan jam komputermu di awal setiap baris, dan membersihkan output.

Di Arduino IDE 1.8 versi lama, Serial Monitor terbuka di jendela terpisah; kontrolnya punya fungsi yang sama, hanya letaknya berbeda: kotak centang autoscroll dan timestamp ada di kiri bawah, menu line ending dan kecepatan di kanan bawah. Kamu juga bisa memantau port serial tanpa IDE: PuTTY atau CoolTerm di Windows, perintah screen /dev/ttyUSB0 115200 di Linux dan macOS, dan arduino-cli monitor -p COM3 -c baudrate=115200 di sistem apa pun melakukan hal yang sama. Ingat satu hal: port serial hanya bisa dibuka oleh satu program dalam satu waktu. Selama skrip Python atau PuTTY sedang memegang port, kamu tidak bisa meng-upload kode dari IDE; instalasi IDE dan bagian lain antarmukanya sudah kami bahas di panduan Cara Instal Arduino IDE 2.

Serial.begin() dan baud rate: 9600 atau 115200?

Serial.begin(speed) memulai port serial pada kecepatan yang diberikan dan hampir selalu dipanggil sekali di dalam setup(). Kecepatan dinyatakan dalam baud, yaitu jumlah bit yang dibawa jalur per detik. Karena setiap karakter memakan 10 bit, 9600 baud berarti paling banyak 960 karakter per detik; mengirim satu karakter butuh sekitar 1,04 milidetik. Baris 30 karakter butuh 31 ms pada kecepatan ini, jadi begitu kamu ingin mencetak ratusan pembacaan per detik, kamu langsung menabrak batas ini. Pada 115200 baud, baris yang sama hanya butuh 2,6 ms. Nilai di sketch dan nilai di Serial Monitor harus sama, karena tidak ada sinyal clock bersama dan penerima membaca bit murni berdasarkan timing.

Clock 16 MHz di Uno tidak bisa menghasilkan semua kecepatan dengan tepat: 115200 baud sebenarnya meleset sekitar 2%, yaitu berjalan di 117647 baud. Selisih itu tidak menimbulkan masalah di Serial Monitor, tetapi bisa memicu error ketika berkomunikasi dengan mikrokontroler lain lewat kabel panjang; dalam kasus seperti itu, 57600 atau 250000 baud, yang dihasilkan tanpa error, lebih aman. Kalau kamu baru mulai, pakai 9600 untuk Uno dan Nano, dan 115200 untuk ESP32 dan Pico. Kalau kamu menghubungkan dua board dengan kabel TX-RX, kecepatannya harus sama di kedua sisi, GND-nya harus disatukan, dan jalur TX 5 V harus diturunkan dengan pembagi tegangan sebelum masuk ke input RX 3,3 V (ESP32, Pico). Detailnya ada di artikel Komunikasi Serial UART.

Serial.print() dan Serial.println(): mencetak dan memformat

Serial.print() menulis nilai yang kamu berikan dan membiarkan kursor di baris yang sama; Serial.println() juga menambahkan karakter akhir baris (\r\n) sesudahnya, jadi output berikutnya dimulai di baris baru. Untuk menampilkan beberapa nilai dalam satu baris, tulis bagian-bagian awal dengan print dan bagian terakhir dengan println. Fungsi-fungsi ini menerima hampir semua tipe, seperti int, long, float, char, teks, dan String, dan parameter kedua yang opsional menentukan formatnya. Untuk bilangan bulat kamu bisa memilih DEC, HEX, BIN, dan OCT, sedangkan untuk bilangan desimal (floating-point) parameter kedua adalah jumlah angka di belakang koma. Float dicetak dengan 2 desimal secara default, dan dibulatkan. Di kode di bawah, output setiap baris kami tulis sebagai komentar:

1// Biçimlendirme örnekleri: çıktılar yorumlarda / Formatting examples: output in the comments
2void setup() {
3  Serial.begin(9600);
4  int sayi = 78;
5  float pi = 3.14159;
6
7  Serial.println(sayi);           // 78
8  Serial.println(sayi, HEX);      // 4E
9  Serial.println(sayi, BIN);      // 1001110
10  Serial.println(sayi, OCT);      // 116
11  Serial.println(pi);             // 3.14 (varsayılan 2 basamak / 2 decimals by default)
12  Serial.println(pi, 4);          // 3.1416
13  Serial.write(65);               // A (ham bayt / raw byte)
14  Serial.println();               // yalnız satır sonu / line break only
15
16  Serial.print("Sicaklik:\t");    // \t = sekme / \t = tab
17  Serial.print(23.46, 1);         // 23.5
18  Serial.println(" C");           // Sicaklik:  23.5 C
19
20  char satir[32];
21  int saat = 9, dakika = 5;
22  snprintf(satir, sizeof(satir), "Saat %02d:%02d", saat, dakika);
23  Serial.println(satir);          // Saat 09:05
24
25  char metin[10];
26  dtostrf(pi, 6, 2, metin);       // Uno'da %f yerine / instead of %f on the Uno
27  Serial.println(metin);          // "  3.14"
28}
29
30void loop() {
31}

Daripada mencetak baris panjang sepotong demi sepotong, kamu bisa menyusun satu string dengan snprintf(): %d adalah bilangan bulat, %02d bilangan bulat dua digit dengan nol di depan, %s teks, dan %lu unsigned long seperti millis(). Untuk menghemat memori, library C di Uno tidak mendukung %f; kalau kamu mencoba mencetak float, yang muncul di tempatnya adalah ?. Jadi ubah dulu float menjadi teks dengan dtostrf(number, width, decimals, buffer). Di ESP32 dan Pico kamu bisa langsung memakai Serial.printf(). Uno hanya punya RAM 2 KB; menulis teks tetap dengan makro F(), seperti Serial.println(F("Hello")), menyimpannya di memori flash, bukan di RAM, dan mencegah masalah memori Arduino tidak cukup di proyek besar.

Karakter sampah di Serial Monitor dan cara mengatasinya

Kalau kamu melihat ⸮⸮⸮, �, atau tumpukan huruf dan simbol acak, berarti data sampai ke komputer tetapi diterjemahkan dengan salah. Karena komunikasi serial tidak punya sinyal clock bersama, penerima menghitung titik tengah setiap bit berdasarkan kecepatannya sendiri, dimulai dari momen ia melihat start bit. Kalau kecepatannya salah, atau clock board tidak sesuai dengan yang seharusnya, bit-bit dibaca pada momen yang salah dan setiap byte berubah menjadi karakter lain. Penyebabnya biasanya hanya satu pengaturan; tabel di bawah mencantumkan kasus yang paling umum berdasarkan gejalanya. Untuk board dengan pilihan clock yang berbeda, seperti Pro Mini, lihat juga artikel Arduino Pro Mini.

Pengaturan line ending: No Line Ending, New Line, Carriage Return, Both NL & CR

Ketika kamu mengetik di kotak pesan dan menekan Enter, Serial Monitor tidak hanya mengirim karakter yang kamu ketik, tetapi juga satu atau dua karakter tak terlihat, tergantung line ending yang kamu pilih. Kalau kodemu tidak mengharapkannya, misalnya kalau kodemu memperlakukan setiap byte yang masuk sebagai perintah, maka '\n' (nilai 10) dan '\r' (13) juga ikut terbaca sebagai perintah. Sebaliknya, kalau kodemu menunggu akhir baris sedangkan pengaturannya No Line Ending, barisnya tidak pernah selesai; readStringUntil() menunggu sampai timeout habis. Tabel di bawah menunjukkan byte yang dikirim ke board ketika kamu mengetik 42 lalu menekan Enter:

Aturan praktisnya begini: untuk kode yang membaca baris demi baris, pilih New Line dan terapkan trim() pada teks yang kamu baca; dengan begitu kodemu tetap jalan apa pun pengaturan yang dipilih pengguna. Untuk perintah satu karakter seperti 1, 0, atau a, No Line Ending adalah pilihan paling bersih. IDE mengingat pilihanmu, jadi jangan lupa memeriksanya ketika pindah ke proyek lain.

Mengirim data dari komputer ke Arduino: Serial.read(), parseInt(), readStringUntil()

Byte yang kamu kirim dari Serial Monitor mengantre di buffer penerima board (64 byte di Uno). Serial.available() memberi tahu berapa byte yang sedang menunggu di sana, Serial.read() mengambil byte berikutnya dan menghapusnya dari buffer, serta mengembalikan -1 kalau tidak ada data, dan Serial.peek() melihat byte berikutnya tanpa menghapusnya. Ingat bahwa semua yang datang dari keyboard tiba sebagai karakter ASCII: ketika kamu mengetik 7, board tidak menerima angka 7, melainkan 55, yaitu kode karakter '7'. Contoh perintah sederhana dengan satu tombol ada di artikel Daftar Perintah Arduino; di sini kita membahas angka multi-digit dan perintah yang terdiri dari kata. Kalau buffer penuh, byte yang baru datang akan hilang, jadi mengatur waktu dengan millis() alih-alih menunggu lama dengan delay() di dalam loop() juga membuat pembacaan serial lebih aman.

Serial.parseInt() mengambil bilangan bulat pertama dari karakter yang masuk: fungsi ini melewati huruf dan spasi di depan, menggabungkan digit-digitnya, dan berhenti di karakter pertama yang bukan digit; tanda minus juga dikenali. Jadi teks “128” menjadi angka 128. Untuk float, Serial.parseFloat() melakukan hal yang sama. Fungsi-fungsi ini punya satu kebiasaan yang perlu kamu ketahui: kalau tidak ada angka yang datang, secara default ia menunggu 1000 ms lalu mengembalikan 0. Bug klasiknya begini: dengan pengaturan New Line kamu mengirim 42, parseInt membaca 42, tetapi '\n' tertinggal di buffer. Pada putaran berikutnya, loop() melihat available() lebih dari 0 dan memanggil parseInt lagi, yang menunggu satu detik lalu mengembalikan 0. Hasilnya, setiap angka diikuti angka 0, dan kamu bingung kenapa LED padam satu detik setelah setiap angka. Kode di bawah menyelesaikan masalah ini dari akarnya dengan membuang karakter berikutnya kalau bukan digit, dan mempersingkat waktu tunggu dengan setTimeout().

1// Seri Port Ekranı'ndan sayı al: LED parlaklığı 0-255
2// Read a number from the Serial Monitor: LED brightness 0-255
3const int LED_PIN = 9;   // ~9 PWM pini + 220 ohm direnç / ~9 PWM pin + 220 ohm resistor
4
5void setup() {
6  pinMode(LED_PIN, OUTPUT);
7  Serial.begin(9600);
8  Serial.setTimeout(100);   // parseInt en fazla 100 ms bekler / parseInt waits at most 100 ms
9  Serial.println(F("0-255 arasi bir sayi yaz / Type a number from 0 to 255"));
10}
11
12void loop() {
13  if (Serial.available() > 0) {
14    char c = Serial.peek();               // sıradakine bak, silme / look at the next byte, keep it
15    if (isDigit(c) || c == '-') {
16      int deger = Serial.parseInt();      // "128" -> 128
17      deger = constrain(deger, 0, 255);   // aralığın dışına çıkma / stay within range
18      analogWrite(LED_PIN, deger);
19      Serial.print(F("Parlaklik / Brightness: "));
20      Serial.println(deger);
21    } else {
22      Serial.read();                      // '\r', '\n' ve harfleri at / drop '\r', '\n' and letters
23    }
24  }
25}

Untuk perintah yang terdiri dari kata, cara paling mudah adalah membaca seluruh baris sebagai String. Serial.readStringUntil('\n') membaca sampai '\n' datang, membuang karakter akhir baris, lalu mengembalikan sisanya. Kalau pengaturannya Both NL & CR, sebuah '\r' tertinggal di akhir teks, perintah “on”-mu menjadi “on\r”, dan perbandingannya gagal. Karena itu, langsung terapkan trim() pada baris tersebut: fungsi ini menghapus spasi di awal dan akhir serta karakter '\r' dan '\n'. toLowerCase() membuat ON, On, dan on dianggap sama. Contoh di bawah memahami perintah on, off, blink 250, dan status; pakai Serial Monitor pada 115200 baud dengan New Line. Karena kedipannya diatur dengan millis() alih-alih delay(), program langsung menjawab perintah baru kapan saja.

1// Metin komutları: on, off, blink 250, status
2// Text commands: on, off, blink 250, status
3const int LED_PIN = LED_BUILTIN;   // Uno'da pin 13 / pin 13 on the Uno
4bool ledAcik = false;              // LED'in şu anki durumu / current LED state
5bool yanipSon = false;             // yanıp sönme modu / blink mode
6unsigned long aralik = 500;        // yanıp sönme aralığı (ms) / blink interval (ms)
7unsigned long sonDegisim = 0;      // LED'in son değiştiği an / last time the LED changed
8
9void ledYaz(bool acik) {
10  ledAcik = acik;
11  digitalWrite(LED_PIN, acik ? HIGH : LOW);
12}
13
14void komutuIsle(String komut) {
15  if (komut == "on") {
16    yanipSon = false;
17    ledYaz(true);
18    Serial.println(F("LED: on"));
19  } else if (komut == "off") {
20    yanipSon = false;
21    ledYaz(false);
22    Serial.println(F("LED: off"));
23  } else if (komut.startsWith("blink")) {
24    long ms = komut.substring(5).toInt();       // "blink 250" -> 250
25    aralik = (ms >= 50) ? ms : 500;             // çok küçükse 500 ms / fall back to 500 ms
26    yanipSon = true;
27    Serial.print(F("Blink (ms): "));
28    Serial.println(aralik);
29  } else if (komut == "status") {
30    Serial.print(F("LED: "));
31    Serial.print(ledAcik ? F("on") : F("off"));
32    Serial.print(F(", blink: "));
33    Serial.println(yanipSon ? F("yes") : F("no"));
34  } else {
35    Serial.print(F("Bilinmeyen komut / Unknown command: "));
36    Serial.println(komut);
37  }
38}
39
40void setup() {
41  pinMode(LED_PIN, OUTPUT);
42  Serial.begin(115200);
43  Serial.setTimeout(100);   // satır sonu gelmezse 100 ms sonra bırak / give up after 100 ms without a line ending
44  Serial.println(F("Komutlar / Commands: on, off, blink 250, status"));
45}
46
47void loop() {
48  if (Serial.available() > 0) {
49    String komut = Serial.readStringUntil('\n');   // Enter'a kadar oku / read up to Enter
50    komut.trim();                                  // '\r' ve boşlukları sil / strip '\r' and spaces
51    komut.toLowerCase();                           // ON ile on aynı olsun / treat ON like on
52    if (komut.length() > 0) {
53      komutuIsle(komut);
54    }
55  }
56
57  if (yanipSon && millis() - sonDegisim >= aralik) {   // delay() olmadan yanıp sön / blink without delay()
58    sonDegisim = millis();
59    ledYaz(!ledAcik);
60  }
61}

Menggambar grafik live dengan Serial Plotter

Serial Plotter mengubah angka yang datang dari port serial menjadi grafik garis live; buka lewat ikon gelombang di pojok kanan atas IDE atau dari menu Tools › Serial Plotter. Formatnya sangat sederhana: pisahkan nilai-nilai dalam satu baris dengan koma, spasi, atau tab, lalu akhiri baris dengan println. Setiap baris menjadi satu langkah waktu di grafik, dan setiap nilai di baris itu menjadi garis berwarna tersendiri. Kalau kamu menaruh nama di depan nilai dalam bentuk label:nilai, garisnya akan dinamai sesuai label itu dan bisa disembunyikan atau ditampilkan satu per satu dengan kotak centang di atas grafik; tanpa label, garis mendapat nama seperti value 1 dan value 2. Di sini pun menu kecepatan harus sama dengan kodemu. Kode di bawah memplot pembacaan mentah di A0 dan versi yang sudah dihaluskan di grafik yang sama:

1// Seri Çizici: ham değer ve yumuşatılmış değer / Serial Plotter: raw and smoothed value
2const int SENSOR_PIN = A0;   // potansiyometre ya da LDR bölücü çıkışı / potentiometer or LDR divider output
3float yumusak = 0;           // üstel ortalama / exponential moving average
4
5void setup() {
6  Serial.begin(115200);
7}
8
9void loop() {
10  int ham = analogRead(SENSOR_PIN);           // 0-1023
11  yumusak = yumusak * 0.9 + ham * 0.1;        // yeni ölçümün payı %10 / the new reading weighs 10%
12
13  Serial.print("Min:0,Max:1023,");            // dikey ekseni sabitler / keeps the y-axis fixed
14  Serial.print("Ham:");
15  Serial.print(ham);
16  Serial.print(",Yumusak:");
17  Serial.println(yumusak);                    // satırı bitir: bir ölçüm / end the line: one sample
18  delay(20);                                  // saniyede yaklaşık 50 satır / about 50 lines per second
19}

• Kunci skalanya: Serial Plotter terus menyesuaikan skala sumbu vertikal dengan nilai yang masuk, sehingga fluktuasi kecil terlihat sangat besar. Menambahkan dua nilai konstan seperti Min:0,Max:1023, ke setiap baris membuat sumbunya tetap.
• Jangan pakai spasi di label: Karena spasi dan koma dihitung sebagai pemisah, “Suhu Ruang:24” terpecah menjadi dua bagian; pakai nama dengan garis bawah seperti Suhu_Ruang.
• Hanya label dan angka di baris: Satuan dan keterangan seperti “Suhu 24 C” merusak grafik; cetak keterangan untuk Serial Monitor di kode terpisah.
• Atur laju pengiriman: delay(20) berarti sekitar 50 baris per detik. Kalau terlalu cepat, grafiknya bergulir lewat dalam sekejap; kalau terlalu lambat, garisnya tampak seperti anak tangga.
• Lihat efek filter dengan matamu sendiri: Memplot nilai mentah dan rata-ratanya di grafik yang sama langsung menunjukkan seberapa banyak filter mengurangi derau; metodenya ada di artikel menyaring data sensor.
• Pakai alat lain untuk pencatatan: Serial Plotter tidak menyimpan data ke file. Untuk pengukuran yang lama, cetak nilai sebagai baris CSV lalu impor ke Excel atau baca dengan Python.

Teknik debugging dengan Serial Monitor

Arduino Uno tidak punya debugger yang bisa menjalankan kodemu langkah demi langkah; tugas itu dikerjakan Serial Monitor. Tapi baris print yang ditebar sembarangan di kodemu cepat berubah menjadi tumpukan teks yang tak terbaca. Kebiasaan berikut akan membantumu menemukan bug jauh lebih cepat:

• Cetak pesan dari setup() lebih dulu: Kalau kamu melihat baris “Started” sekali setiap kali board menyala, berarti board berjalan. Kalau baris itu terus berulang, board terus reset dan masalahnya ada di catu daya, bukan di kode; lihat panduan Arduino terus reset.
• Cetak nilai beserta namanya: Daripada hanya mencetak 512, tulis temp=24.5 hum=40; kamu tidak perlu lagi menebak angka mana milik apa.
• Tandai posisimu: Kalau program macet di suatu tempat, taruh penanda pendek seperti A, B, C sebelum langkah-langkah penting. Penanda terakhir yang muncul di layar menunjukkan di mana program tersangkut.
• Cetak ketika berubah, bukan di setiap putaran: loop() berjalan ribuan kali per detik. Mencetak di setiap putaran membanjiri layar dan memperlambat program; cetak nilai hanya ketika nilainya berubah, atau sekali per detik dengan millis().
• Ukur waktunya: Untuk melihat berapa lama sebuah operasi berlangsung, simpan nilai micros() sebelum dan sesudahnya lalu cetak selisihnya. Dengan cara ini kamu bisa menangkap pembacaan sensor yang lambat atau loop yang terlalu panjang.
• Jangan mencetak di dalam interrupt: Output serial butuh waktu; memakai Serial.print di dalam fungsi interrupt membuatnya lama tanpa perlu dan bisa membuatmu melewatkan event lain. Di interrupt cukup set variabel flag, lalu lakukan pencetakan di loop(); detailnya ada di artikel interrupt Arduino.
• Taruh baris debug di balik satu sakelar: Dengan makro di bawah, kamu bisa menghapus seluruh output debug dari kode dengan menyetel DEBUG ke 0; di proyek yang sudah jadi, kamu menghemat memori flash sekaligus waktu.

1// Hata ayıklama makroları: tek satırla aç ya da kapat
2// Debug macros: switch all debug output on or off with one line
3#define DEBUG 1                  // 0 yaparsan debug satırları koddan çıkar / set to 0 to strip debug lines
4
5#if DEBUG
6  #define DBG(x)   Serial.print(x)
7  #define DBGLN(x) Serial.println(x)
8#else
9  #define DBG(x)
10  #define DBGLN(x)
11#endif
12
13const int SENSOR_PIN = A0;
14const int ESIK = 800;            // uyarı eşiği / warning threshold
15bool esikUstunde = false;        // son durum / last state
16unsigned long sonRapor = 0;
17unsigned long turSayisi = 0;     // saniyedeki loop() turu / loop() passes per second
18
19void setup() {
20  Serial.begin(115200);
21  DBGLN(F("Basladi / Started"));
22}
23
24void loop() {
25  turSayisi++;
26  int deger = analogRead(SENSOR_PIN);
27
28  bool simdi = deger > ESIK;
29  if (simdi != esikUstunde) {          // yalnız değişince yaz / print only on change
30    esikUstunde = simdi;
31    DBG(F("[esik / threshold] "));
32    DBG(simdi ? F("ustunde / above") : F("altinda / below"));
33    DBG(F(", deger / value = "));
34    DBGLN(deger);
35  }
36
37  if (millis() - sonRapor >= 1000) {   // saniyede bir özet / one summary per second
38    sonRapor = millis();
39    DBG(F("t = "));
40    DBG(sonRapor);
41    DBG(F(" ms, tur/s / loops/s = "));
42    DBGLN(turSayisi);
43    turSayisi = 0;
44  }
45}

Ingat bahwa output serial ada harganya. Di Uno, buffer pengirim juga 64 byte; ketika penuh, Serial.print() menunggu sampai ada ruang dan loop() melambat. Kamu bisa mengukurnya sendiri dengan penghitung putaran di kode atas: kalau kamu menambahkan baris 25 karakter yang dicetak di setiap putaran, pada 9600 baud program turun menjadi sekitar empat puluh putaran per detik, sedangkan mencetak hanya ketika ada perubahan tetap mempertahankan ribuan putaran. Kalau kamu ingin yakin apa yang dicetak board tepat sebelum macet atau reset, panggil Serial.flush() setelah baris penting itu; fungsi ini menunggu sampai semua isi buffer terkirim. Di program yang lebih kompleks, beralih ke struktur state machine dan mencetak satu baris hanya ketika state berubah membuat pelacakan bug jauh lebih mudah.

Output serial di ESP32

Di board ESP32 DevKit, Serial adalah UART0 di GPIO 1 (TX) dan GPIO 3 (RX), yang terhubung ke USB lewat chip CP2102 atau CH340 di board. Kecepatan yang umum adalah 115200 baud, karena ROM di dalam chip juga mencetak baris seperti rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT) pada kecepatan ini ketika boot; kalau monitor tetap di 115200, baris-baris itu juga bisa terbaca. Core Arduino untuk ESP32 menyediakan Serial.printf() dan mendukung pencetakan float dengan %f. Port serial tambahan Serial1 dan Serial2 bisa dipasang di pin mana pun yang kamu mau; ketika menghubungkan modul, Serial2 umumnya dipakai di GPIO 16 dan 17. Di board dengan USB bawaan seperti ESP32-S3 dan ESP32-C3, kalau Serial Monitor tetap kosong, setel Tools › USB CDC On Boot ke Enabled. Untuk melihat peringatan dari core itu sendiri, pilih Error, Warn, Info, Debug, atau Verbose di menu Tools › Core Debug Level, dan di kodemu sendiri kamu bisa mencetak entri log yang berisi informasi file dan baris dengan makro log_e, log_w, dan log_i.

1// ESP32: Serial (USB), Serial2 (GPIO16/17), printf ve log
2// ESP32: Serial (USB), Serial2 (GPIO16/17), printf and logging
3const int POT_PIN = 34;              // ADC1, yalnız giriş pini / ADC1, input-only pin
4unsigned long sonYazdirma = 0;
5
6void setup() {
7  Serial.begin(115200);                       // açılış mesajlarıyla aynı hız / same rate as the boot messages
8  delay(500);
9  Serial2.begin(9600, SERIAL_8N1, 16, 17);    // RX = GPIO16, TX = GPIO17
10
11  Serial.printf("Model: %s, CPU: %lu MHz\n", ESP.getChipModel(), (unsigned long)ESP.getCpuFreqMHz());
12  Serial.printf("Bos RAM / Free heap: %lu bayt / bytes\n", (unsigned long)ESP.getFreeHeap());
13  log_i("Core Debug Level en az Info ise gorunur / shown when Core Debug Level is Info or higher");
14}
15
16void loop() {
17  while (Serial2.available() > 0) {           // Serial2'den geleni USB'ye aktar / forward Serial2 data to USB
18    Serial.write(Serial2.read());
19  }
20
21  if (millis() - sonYazdirma >= 1000) {       // delay() yok, tampon taşmaz / no delay(), no buffer overflow
22    sonYazdirma = millis();
23    float volt = analogReadMilliVolts(POT_PIN) / 1000.0;          // kalibre gerilim / calibrated voltage
24    Serial.printf("t=%lu ms, GPIO34=%.2f V\n", millis(), volt);   // ESP32'de %f çalışır / %f works on ESP32
25  }
26}

Pada masalah koneksi Wi-Fi, reset yang tak terduga, dan error Guru Meditation, Serial Monitor adalah tempat pertama yang perlu dilihat: jenis error, penyebab reset, dan baris backtrace muncul di sini. Cara membaca pesan-pesan ini kami jelaskan di panduan brownout dan Guru Meditation ESP32 serta ESP32 tidak mau terhubung ke Wi-Fi. Kalau ini pertama kalinya kamu memakai ESP32, mulailah dari artikel Apa Itu ESP32?

Output serial di Raspberry Pi Pico: Arduino dan MicroPython

Raspberry Pi Pico tidak punya chip jembatan USB-ke-serial; RP2040 menangani USB sendiri dan langsung terlihat oleh komputer sebagai port serial (USB CDC). Di core Arduino-Pico buatan Earle Philhower, Serial adalah port USB ini, dan karena datanya mengalir pada kecepatan USB, nilai kecepatan di Serial.begin() diabaikan. Ini punya dua akibat: kecepatan yang kamu pilih di monitor tidak lagi berpengaruh, tetapi board tidak reset seperti Uno ketika kamu membuka Serial Monitor. Pesan pertama yang kamu cetak di setup() sudah terkirim dan hilang sebelum kamu sempat membuka monitor, jadi tunggu sebentar sampai komputer membuka port, seperti di bawah. Hal yang sama berlaku untuk board ATmega32U4 seperti Leonardo, Micro, dan Pro Micro. UART asli Pico di pin GP0 dan GP1 dipakai dengan nama Serial1.

1// Raspberry Pi Pico (Arduino-Pico çekirdeği): USB seri port
2// Raspberry Pi Pico (Arduino-Pico core): USB serial port
3void setup() {
4  Serial.begin(115200);                  // USB'de hız değeri önemsiz / the baud value is ignored over USB
5  unsigned long baslangic = millis();
6  while (!Serial && millis() - baslangic < 3000) {
7    delay(10);                           // port açılana kadar en çok 3 sn bekle / wait up to 3 s for the port
8  }
9  Serial1.begin(9600);                   // UART0: GP0 = TX, GP1 = RX
10  Serial.println("Pico hazir / Pico ready");
11}
12
13void loop() {
14  Serial.print("Sicaklik / Temperature (C): ");
15  Serial.println(analogReadTemp(), 1);   // dahili sensör, yaklaşık / internal sensor, approximate
16  Serial1.println(millis());             // aynı anda UART0'a da yaz / also write to UART0
17  delay(1000);
18}

Di MicroPython semuanya lebih sederhana lagi: semua yang kamu cetak dengan print() dikirim ke komputer lewat USB dan muncul di Shell Thonny; tidak ada baud rate yang perlu disetel. Kalau kamu membuka menu View › Plotter di Thonny, angka-angka di setiap baris berubah menjadi grafik live, persis seperti di Serial Plotter. Untuk menerima data dari komputer kamu bisa memakai input(), tetapi input() menghentikan program sampai ada satu baris yang datang. Untuk mendengarkan perintah sambil terus mengukur, cek apakah ada data yang menunggu di stdin dengan select.poll(), seperti di bawah; cukup ketik on atau off di Shell lalu tekan Enter. Pico dan instalasi MicroPython sudah kami bahas di artikel Apa Itu Raspberry Pi Pico?

1# Pico MicroPython: print() ile yazdır, programı durdurmadan komut al
2# Pico MicroPython: print with print(), read commands without blocking
3import sys
4import select
5import time
6from machine import ADC, Pin
7
8led = Pin(25, Pin.OUT)            # Pico'da dahili LED; Pico W'de Pin("LED") / onboard LED; Pin("LED") on Pico W
9sensor = ADC(4)                   # dahili sıcaklık sensörü / internal temperature sensor
10poll = select.poll()
11poll.register(sys.stdin, select.POLLIN)
12
13while True:
14    volt = sensor.read_u16() * 3.3 / 65535
15    sicaklik = 27 - (volt - 0.706) / 0.001721
16    print("Sicaklik:{:.1f}".format(sicaklik))    # Thonny Plotter da çizer / Thonny's Plotter can graph it
17    if poll.poll(0):                              # bekleyen veri var mı? / is input waiting?
18        komut = sys.stdin.readline().strip()      # satırı al, boşlukları sil / read the line, strip spaces
19        if komut == "on":
20            led.value(1)
21        elif komut == "off":
22            led.value(0)
23        print("Komut / Command:", komut)
24    time.sleep(1)

Serial Monitor kosong atau port sibuk: error umum dan solusinya

Ide proyek dengan komunikasi serial

• LED dan relay yang dikendalikan dari komputer: Kembangkan parser perintah dari artikel ini untuk mengendalikan relay atau motor dengan perintah on, off, dan blink.
• Data logger sensor: Cetak suhu dan kelembapan sebagai baris CSV yang dipisahkan koma, lalu ubah menjadi tabel dan grafik di komputer; DHT11 adalah sensor yang bagus untuk memulai.
• Grafik cahaya live: Pantau nilai LDR atau potensiometer di Serial Plotter dan lihat efek filter di grafik yang sama.
• Panel desktop dengan Python: Baca data yang dikirim Arduino dengan program Python dan buat antarmuka dengan tombol; detailnya ada di artikel komunikasi serial Arduino dan Python.
• Stasiun uji modul: Modul GPS, Bluetooth, dan GSM juga memakai port serial; teruskan data mentah dari modul ke Serial Monitor untuk melihat apakah modulnya bekerja (HC-05, GPS NEO-6M).
• Mencoba tanpa board: Kalau tidak ada board di tanganmu, Tinkercad juga punya Serial Monitor; kode dari artikel ini bisa kamu jalankan di simulasi Tinkercad.

Begitu kamu terbiasa dengan Serial Monitor, mencari bug di Arduino tidak lagi soal menebak-nebak, melainkan soal mengukur. Sebagai langkah berikutnya, baca artikel Komunikasi Serial UART untuk membuat dua board saling berkomunikasi lewat TX dan RX, dan artikel konverter USB-TTL untuk memprogram board tanpa USB. Di aplikasi BlueGrays kamu akan menemukan proyek seperti mencetak jarak yang diukur HC-SR04 ke Serial Monitor, membaca intensitas cahaya dengan LDR, mengukur suhu dan kelembapan dengan DHT11, dan menghubungkan dua Arduino lewat jalur serial, langkah demi langkah dengan skema rangkaian dan kode siap pakai.