Arduino Serial Monitor Kullanımı: Baud Hızı, Veri Okuma, Plotter

Arduino Serial Monitor (Türkçe arayüzde Seri Port Ekranı), Arduino IDE'nin içinde yer alan ve kartınla bilgisayarın USB kablosu üzerinden yazışmasını sağlayan penceredir. Kodundaki Serial.println() satırlarının çıktısını burada okur, klavyeden yazdığın komutları da buradan karta gönderirsin. Sensörün o an hangi değeri ölçtüğünü, programın hangi satıra kadar çalıştığını ya da bir butonun gerçekten basılıp basılmadığını görmenin en hızlı yolu budur; bu yüzden Arduino'da hata ayıklamanın bir numaralı aracıdır. Çalıştırmak için kodunda Serial.begin(9600) yazman, kart seçicide doğru portu seçmen ve ekrandaki hızı koddakiyle aynı yapman yeterlidir.

Bu rehberde Serial Monitor'ü açmaktan başlayıp baud hızının gerçekte ne anlama geldiğini, print ve println ile sayıları onluk, onaltılık ve ikilik tabanda yazdırmayı, ondalık basamak sayısını ayarlamayı ve snprintf ile düzenli satırlar kurmayı göreceksin. Ekrana dökülen anlamsız karakterlerin bütün sebeplerini, satır sonu ayarının kodunu nasıl etkilediğini, bilgisayardan karta sayı ve metin komutu göndermeyi (Serial.read, parseInt, readStringUntil), Serial Plotter ile canlı grafik çizmeyi ve işini kolaylaştıracak hata ayıklama tekniklerini derlenen örnek kodlarla anlatıyoruz. Son bölümlerde ESP32'de ve Raspberry Pi Pico'da (Arduino ve MicroPython ile) seri çıktının nasıl farklılaştığını ve ekranın boş kalması gibi sık sorunların çözümlerini bulacaksın.

Arduino Serial Monitor nedir, nasıl çalışır?

Arduino Uno'nun beyni olan ATmega328P, dış dünyayla UART adlı seri haberleşme birimiyle konuşur: veriyi tek bir hattan (TX) bit bit gönderir, başka bir hattan (RX) alır. Bilgisayarlarda ise artık bu tür bir seri port yoktur; bu yüzden kartın üzerindeki ikinci bir yonga (orijinal Uno'da ATmega16U2, klonlarda çoğunlukla CH340) bu sinyali USB'ye çevirir. Bilgisayar kartı sanal bir seri port olarak görür: Windows'ta COM3 gibi, Linux'ta /dev/ttyACM0 ya da /dev/ttyUSB0, macOS'ta ise /dev/cu.usbmodem ya da /dev/cu.usbserial ile başlayan bir adla. Serial Monitor bu portu açar, gelen baytları metin olarak gösterir, senin yazdıklarını da aynı yoldan karta yollar. Arduino varsayılan olarak 8N1 biçimini kullanır: her bayt için bir başlangıç biti, 8 veri biti, eşlik biti yok ve bir durma biti. Yani tek bir karakter hatta 10 bit yer kaplar; hız hesaplarında bu sayıyı kullanacağız.

Serial Monitor nasıl açılır ve kullanılır?

1. Kodunun setup() bölümüne Serial.begin(9600); satırını ekle ve kodu karta yükle. Bu satır olmadan kart seri porta hiçbir şey yazmaz.
2. Üst çubuktaki kart seçiciden ya da Araçlar > Port menüsünden kartının bağlı olduğu portu seç. Port seçili değilse Seri Port Ekranı Bağlı değil. Otomatik olarak bağlanacak bir kart ve bir port seçin. uyarısını gösterir (İngilizce arayüzde: Not connected. Select a board and a port to connect automatically.).
3. Sağ üst köşedeki büyüteç simgesine tıkla, Araçlar > Seri Port Ekranı menüsünü kullan ya da Ctrl+Shift+M (macOS'ta Cmd+Shift+M) kısayoluna bas. IDE 2'de ekran, alt paneldeki Çıktı bölümünün yanında açılır.
4. Panelin sağındaki hız menüsünden koddaki değerle aynı baud hızını seç; bu örnekte 9600. Hız farklıysa ekrana anlamsız karakterler dökülür.
5. Karta veri göndermek için panelin üstündeki mesaj kutusuna yaz ve Enter'a bas. Hemen yanındaki menüden satır sonu ayarını seç; bu ayarın neden önemli olduğunu aşağıda anlatıyoruz.
6. Sağ üstteki düğmelerle otomatik kaydırmayı durdurabilir (eski satırları okurken işe yarar), her satırın başına bilgisayar saatini ekleyen zaman damgasını açabilir ve ekranı temizleyebilirsin.

Eski Arduino IDE 1.8 sürümünde Serial Monitor ayrı bir pencerede açılır; düğmeler aynı işi görür, yalnızca yerleri farklıdır: otomatik kaydırma ve zaman damgası kutuları sol altta, satır sonu ve hız menüleri sağ alttadır. IDE kullanmadan da seri porta bakabilirsin: Windows'ta PuTTY ya da CoolTerm, Linux ve macOS'ta screen /dev/ttyUSB0 115200 komutu, her sistemde de arduino-cli monitor -p COM3 -c baudrate=115200 aynı işi yapar. Şunu unutma: bir seri port aynı anda yalnızca tek bir program tarafından açılabilir. Bir Python betiği ya da PuTTY portu tutarken IDE'den kod yükleyemezsin; IDE kurulumunu ve arayüzün geri kalanını Arduino IDE kurulumu yazısında anlattık.

Serial.begin() ve baud hızı: 9600 mü, 115200 mü?

Serial.begin(hız), seri portu verilen hızda başlatır ve neredeyse her zaman setup() içinde bir kez çağrılır. Hız baud cinsindendir ve hatta saniyede kaç bit taşındığını gösterir. Her karakter 10 bit tuttuğu için 9600 baud saniyede en fazla 960 karakter demektir; tek bir karakterin gönderilmesi yaklaşık 1,04 milisaniye sürer. 30 karakterlik bir satır bu hızda 31 ms yer kaplar, yani saniyede yüzlerce ölçüm yazdırmak istediğinde bu sınır hemen önüne çıkar. 115200 baud'da aynı satır yalnızca 2,6 ms sürer. Karttaki koddaki değerle Serial Monitor'deki değerin aynı olması şarttır, çünkü ortada ortak bir saat sinyali yoktur ve alıcı bitleri yalnızca zamanlamaya bakarak okur.

Uno'nun 16 MHz'lik saati her hızı tam olarak üretemez: 115200 baud gerçekte yaklaşık %2 sapmayla, 117647 baud olarak çalışır. Bu sapma Serial Monitor'de sorun çıkarmaz, ama başka bir mikrodenetleyiciyle uzun kablo üzerinden konuşurken hatalara yol açabilir; böyle durumlarda 57600 ya da hatasız üretilen 250000 baud daha güvenlidir. Yeni başlıyorsan Uno ve Nano için 9600 ile başla, ESP32 ve Pico için 115200 kullan. İki kartı TX-RX kablolarıyla birbirine bağlayacaksan hız iki tarafta da aynı olmalı, GND'ler ortak olmalı ve 5 V'luk bir TX hattı, 3,3 V ile çalışan bir RX girişine (ESP32, Pico) gerilim bölücü ile düşürülerek bağlanmalıdır. Ayrıntıları UART seri haberleşme yazısında bulabilirsin.

Serial.print() ve Serial.println(): yazdırma ve biçimlendirme

Serial.print() verdiğin değeri yazar ve imleci aynı satırda bırakır; Serial.println() ise yazdıktan sonra satır sonu karakterlerini (\r\n) de ekler, böylece bir sonraki çıktı yeni satırdan başlar. Bir satırda birden çok değer göstermek için ilk parçaları print, sonuncuyu println ile yazarsın. Bu fonksiyonlar int, long, float, char, metin ve String gibi hemen her türü kabul eder; isteğe bağlı ikinci parametre ise biçimi belirler. Tam sayılarda DEC, HEX, BIN ve OCT tabanlarını seçebilirsin, ondalık sayılarda ise ikinci parametre basamak sayısıdır. Ondalık sayılar varsayılan olarak 2 basamakla ve yuvarlanarak yazılır. Aşağıdaki kodda her satırın çıktısını yorum olarak yazdık:

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}

Uzun satırları parça parça yazmak yerine snprintf() ile tek bir metin hazırlayabilirsin: %d tam sayı, %02d iki haneli ve başı sıfırlı tam sayı, %s metin, %lu ise millis() gibi unsigned long değerler için kullanılır. Uno'daki C kütüphanesi bellekten tasarruf etmek için %f desteklemez; ondalık sayı vermeye çalışırsan yerinde bir ? görürsün. Bu yüzden ondalıkları önce dtostrf(sayı, genişlik, basamak, tampon) ile metne çevir. ESP32 ve Pico'da ise doğrudan Serial.printf() kullanabilirsin. Uno'da RAM yalnızca 2 KB'tır; sabit metinleri Serial.println(F("Merhaba")) biçiminde F() makrosuyla yazmak onları RAM yerine flaş bellekte tutar ve büyük projelerde bellek yetersiz sorunlarının önüne geçer.

Anlamsız karakter sorunu ve çözümü

Ekranda ⸮⸮⸮, � ya da rastgele harf ve sembol yığınları görüyorsan veri bilgisayara ulaşıyor ama yanlış çözülüyor demektir. Seri haberleşmede ortak bir saat sinyali olmadığından alıcı, başlangıç bitini gördüğü andan itibaren her bitin ortasını kendi hızına göre hesaplar. Hız yanlışsa ya da kartın saati olması gerekenden farklıysa bitler yanlış anlarda okunur ve her bayt başka bir karaktere dönüşür. Sebep çoğu zaman tek bir ayardır; aşağıdaki tablo en sık durumları belirtiye göre sıralıyor. Pro Mini gibi farklı saat seçenekleri olan kartlar için Arduino Pro Mini yazısına da göz atabilirsin.

Satır sonu ayarı: Satır Sonu Yok, Yeni Satır, Satır Başı, NL ve CR

Mesaj kutusuna yazıp Enter'a bastığında Serial Monitor yalnızca yazdığın karakterleri değil, seçtiğin satır sonu ayarına göre görünmeyen bir ya da iki karakter daha gönderir. Kodun bu karakterleri beklemiyorsa, örneğin gelen her baytı tek tek komut olarak işliyorsan, '\n' (sayı değeri 10) ve '\r' (13) de birer komutmuş gibi okunur. Tersine, kodun satır sonunu bekliyorsa ve ayar Satır Sonu Yok ise satır hiç bitmez; readStringUntil() zaman aşımı dolana kadar bekler. Aşağıdaki tabloda 42 yazıp Enter'a bastığında karta giden baytları görebilirsin:

Pratik kural şu: satır satır okuyan kodlar için Yeni Satır seç ve kodunda okuduğun metne trim() uygula; böylece kullanıcı hangi ayarı seçerse seçsin kodun çalışır. 1, 0, a gibi tek karakterlik komutlarda ise Satır Sonu Yok en temiz seçimdir. Seçtiğin ayar IDE tarafından hatırlanır; başka bir projeye geçtiğinde kontrol etmeyi unutma.

Bilgisayardan Arduino'ya veri gönderme: Serial.read(), parseInt(), readStringUntil()

Serial Monitor'den gönderdiğin baytlar karttaki alma tamponunda (Uno'da 64 bayt) sıraya girer. Serial.available() bu tamponda kaç bayt beklediğini söyler, Serial.read() sıradaki baytı alıp tampondan siler ve veri yoksa -1 döndürür, Serial.peek() ise sıradakine bakar ama silmez. Klavyeden gelen her şeyin ASCII karakter olduğunu unutma: 7 yazdığında karta 7 sayısı değil, '7' karakterinin kodu olan 55 gider. Tek tuşla çalışan basit komutların örneği Arduino komutları yazısında var; burada çok basamaklı sayıları ve kelimelerden oluşan komutları ele alıyoruz. Tampon dolarsa yeni gelen baytlar kaybolur; bu yüzden loop() içinde delay() ile uzun süre beklemek yerine millis() ile zamanlama yapmak seri okumayı da güvenli hâle getirir.

Serial.parseInt(), gelen karakterlerden ilk tam sayıyı ayıklar: baştaki harf ve boşlukları atlar, rakamları birleştirir ve rakam olmayan ilk karakterde durur; eksi işaretini de tanır. Böylece "128" metni 128 sayısına dönüşür. Ondalık sayılar için Serial.parseFloat() aynı işi yapar. Bu fonksiyonların bilinmesi gereken bir huyu vardır: sayı gelmezse varsayılan olarak 1000 ms bekler ve sonunda 0 döndürür. Klasik hata şöyle oluşur: ayar Yeni Satır iken 42 gönderirsin, parseInt 42'yi okur ama '\n' tamponda kalır. loop() bir sonraki turda available() değerini 0'dan büyük gördüğü için yeniden parseInt çağırır; o da bir saniye bekleyip 0 döndürür. Sonuçta her sayının ardından bir de 0 gelir ve LED'in her seferinde bir saniye sonra neden söndüğünü bulamazsın. Aşağıdaki kod, sıradaki karakter rakam değilse onu atarak bu sorunu kökten çözer ve setTimeout() ile bekleme süresini kısaltır.

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}

Kelimelerden oluşan komutlar için en rahat yol bütün satırı bir String olarak almaktır. Serial.readStringUntil('\n'), '\n' gelene kadar okur, satır sonu karakterini atar ve geri kalanını döndürür. Ayar NL ve CR ile Birlikte ise metnin sonunda bir '\r' kalır, "on" komutun "on\r" olur ve karşılaştırma tutmaz. Bu yüzden okuduğun satıra hemen trim() uygula: baştaki ve sondaki boşlukları, '\r' ve '\n' karakterlerini siler. toLowerCase() ise ON, On ve on yazımlarını eşitler. Aşağıdaki örnek on, off, blink 250 ve status komutlarını anlar; Serial Monitor'ü 115200 baud ve Yeni Satır ayarıyla kullan. Yanıp sönmeyi delay() yerine millis() ile yaptığı için yeni bir komuta her an anında cevap verir.

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}

Serial Plotter ile canlı grafik çizme

Serial Plotter (Türkçe arayüzde Seri Çizici), seri porttan gelen sayıları canlı bir çizgi grafiğe dönüştürür; IDE'nin sağ üst köşesindeki dalga simgesinden ya da Araçlar > Seri Çizici menüsünden açılır. Biçimi çok basittir: bir satırdaki değerleri virgül, boşluk ya da sekme ile ayırır ve satırı println ile bitirirsin. Her satır grafikte bir zaman adımı, satırdaki her değer ise ayrı renkte bir çizgi olur. Değerlerin önüne etiket:değer biçiminde bir ad yazarsan çizgiler o adla anılır ve grafiğin üstündeki kutucuklarla tek tek gizlenip gösterilebilir; etiket yazmazsan çizgiler value 1, value 2 gibi adlar alır. Hız menüsü burada da koddaki değerle aynı olmalıdır. Aşağıdaki kod A0'daki ham ölçümü ve yumuşatılmış hâlini aynı grafikte çizer:

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}

• Ölçeği sabitle: Serial Plotter dikey ekseni gelen değerlere göre sürekli yeniden ölçekler, bu yüzden küçük dalgalanmalar dev gibi görünür. Her satıra Min:0,Max:1023, gibi iki sabit değer eklemek ekseni sabitler.
• Etiketlerde boşluk kullanma: Boşluk ve virgül ayraç sayıldığı için "Oda Sicakligi:24" iki ayrı parçaya bölünür; Oda_Sicakligi gibi alt çizgili adlar kullan.
• Satırda yalnızca etiket ve sayı olsun: "Sicaklik 24 C" gibi birimler ve açıklamalar grafiği bozar; açıklamaları Serial Monitor için ayrı bir kodda yazdır.
• Gönderme hızını ayarla: delay(20) saniyede yaklaşık 50 satır demektir. Çok hızlı gönderirsen grafik bir anda kayıp gider, çok yavaş gönderirsen çizgi basamak basamak görünür.
• Filtreyi gözünle gör: Ham değerle ortalamayı aynı grafikte çizmek, bir filtrenin gürültüyü ne kadar azalttığını anında gösterir; yöntemler sensör verisi filtreleme yazısında.
• Kayıt için başka araç kullan: Serial Plotter veriyi dosyaya kaydetmez. Uzun ölçümler için değerleri CSV satırları olarak yazdırıp Excel'e aktarabilir ya da Python ile okuyabilirsin.

Serial Monitor ile hata ayıklama (debug) teknikleri

Arduino Uno'da kodu adım adım çalıştıran bir hata ayıklayıcı yoktur; bu işi Serial Monitor görür. Ancak koda gelişigüzel serpiştirilmiş print satırları kısa sürede okunamaz bir yazı yığınına dönüşür. Şu alışkanlıklar hatayı çok daha hızlı bulmanı sağlar:

• Önce setup()'tan bir mesaj yazdır: "Basladi" satırını her açılışta bir kez görüyorsan kart çalışıyordur. Bu satır durmadan tekrar ediyorsa kart sürekli resetleniyordur ve sorun koddan çok beslemededir; Arduino resetleniyor rehberine bak.
• Değeri adıyla yazdır: Yalnızca 512 yazmak yerine sicaklik=24.5 nem=40 biçiminde yaz; hangi sayının neye ait olduğunu sonradan düşünmek zorunda kalmazsın.
• Nerede kaldığını işaretle: Program bir yerde donuyorsa önemli adımların başına A, B, C gibi kısa işaretler koy. Ekranda görünen son işaret, programın takıldığı yeri gösterir.
• Her turda değil, değişince yazdır: loop() saniyede binlerce kez döner. Her turda yazdırmak ekranı boğar ve programı yavaşlatır; değeri yalnızca değiştiğinde ya da millis() ile saniyede bir yazdır.
• Süreyi ölç: Bir işlemin ne kadar sürdüğünü görmek için önce ve sonra micros() değerini kaydet, farkı yazdır. Yavaş bir sensör okumasını ya da uzun bir döngüyü böyle yakalarsın.
• Kesme fonksiyonunda yazdırma: Seri gönderim zaman alır; kesme (interrupt) fonksiyonunun içinde Serial.print kullanmak onu gereksiz uzatır ve başka olayları kaçırmana yol açar. Kesmede yalnızca bir değişkene işaret koy, yazdırmayı loop() içinde yap; ayrıntılar Arduino interrupt yazısında.
• Debug satırlarını tek anahtara bağla: Aşağıdaki makrolarla bütün hata ayıklama çıktılarını DEBUG değerini 0 yaparak koddan tamamen çıkarabilirsin; bitmiş projede hem flaş bellek hem de zaman kazanırsın.

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}

Seri çıktının bir bedeli olduğunu unutma. Uno'da gönderim tamponu da 64 bayttır; tampon dolduğunda Serial.print() yer açılana kadar bekler ve loop() yavaşlar. Bunu yukarıdaki koddaki tur sayacıyla kendin ölçebilirsin: loop() içine her turda yazdıran 25 karakterlik bir satır eklersen 9600 baud'da program saniyede yaklaşık kırk tura düşer, yalnızca değişince yazdırmak ise binlerce turu korur. Kartın kilitlenmeden ya da resetlenmeden hemen önce ne yazdığını kesin görmek istiyorsan kritik satırdan sonra Serial.flush() çağır; tampondaki her şey gönderilene kadar bekler. Daha karmaşık programlarda kodu durum makinesi yapısına geçirip yalnızca durum değiştiğinde tek satır yazdırmak, hatanın izini sürmeyi çok kolaylaştırır.

ESP32'de seri çıktı

ESP32 DevKit kartlarında Serial, GPIO 1 (TX) ve GPIO 3 (RX) pinlerindeki UART0'dır ve kart üzerindeki CP2102 ya da CH340 yongası üzerinden USB'ye bağlanır. Yaygın hız 115200 baud'dır, çünkü yonganın içindeki ROM da açılışta rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT) gibi satırları bu hızda yazar; monitörü 115200'de tutarsan bu satırlar da okunur olur. ESP32'nin Arduino çekirdeği Serial.printf() sunar ve %f ile ondalık yazdırmayı destekler. Ek seri portlar Serial1 ve Serial2 istediğin pinlere atanabilir; bir modül bağlarken Serial2'yi GPIO 16 ve 17'de kullanmak yaygındır. ESP32-S3 ve ESP32-C3 gibi yerleşik USB'li kartlarda Serial Monitor boş kalıyorsa Araçlar > USB CDC On Boot ayarını Enabled yap. Çekirdeğin kendi uyarılarını görmek için Araçlar > Core Debug Level menüsünden Error, Warn, Info, Debug ya da Verbose seçebilir, kendi kodunda da log_e, log_w ve log_i makrolarıyla dosya ve satır bilgisi içeren kayıtlar yazdırabilirsin.

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}

Wi-Fi bağlantı sorunlarında, beklenmedik resetlerde ve Guru Meditation hatalarında Serial Monitor bakılacak ilk yerdir: hata türü, reset sebebi ve geri izleme (backtrace) satırları burada çıkar. Bu mesajları nasıl yorumlayacağını ESP32 brownout ve Guru Meditation ile ESP32 Wi-Fi bağlanmıyor rehberlerinde anlattık. ESP32'yi ilk kez kullanıyorsan ESP32 nedir? yazısıyla başlayabilirsin.

Raspberry Pi Pico'da seri çıktı: Arduino ve MicroPython

Raspberry Pi Pico'da USB-seri köprü yongası yoktur; RP2040 USB'yi kendisi yönetir ve bilgisayara doğrudan bir seri port (USB CDC) olarak görünür. Earle Philhower'ın Arduino-Pico çekirdeğinde Serial bu USB portudur ve veri USB hızında aktığı için Serial.begin() içindeki hız değeri dikkate alınmaz. Bunun iki sonucu vardır: monitörde hangi hızı seçtiğinin önemi kalmaz, ama Serial Monitor'ü açtığında kart Uno gibi resetlenmez. setup() içinde yazdırdığın ilk mesajlar, sen monitörü açana kadar gönderilip kaybolmuş olur; bu yüzden aşağıdaki gibi bilgisayarın portu açmasını kısa bir süre bekle. Aynı durum Leonardo, Micro ve Pro Micro gibi ATmega32U4'lü kartlar için de geçerlidir. Pico'nun GP0 ve GP1 pinlerindeki gerçek UART ise Serial1 adıyla kullanılır.

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}

MicroPython'da işler daha da basittir: print() ile yazdırdığın her şey USB üzerinden bilgisayara gider ve Thonny'nin Shell (kabuk) bölümünde görünür; ayarlanacak bir baud hızı yoktur. Thonny'de View > Plotter menüsünü açarsan satırlardaki sayılar Serial Plotter'daki gibi canlı grafiğe dönüşür. Bilgisayardan veri almak için input() kullanabilirsin, ama input() bir satır gelene kadar programı durdurur. Ölçüm yapmaya devam ederken komut dinlemek için aşağıdaki gibi select.poll() ile stdin'de bekleyen veri olup olmadığına bakılır; Shell'e on ya da off yazıp Enter'a basman yeterlidir. Pico'yu ve MicroPython kurulumunu Raspberry Pi Pico nedir? yazısında anlattık.

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 boş, port meşgul: sık hatalar ve çözümleri

Seri haberleşmeyle proje fikirleri

• Bilgisayardan kontrol edilen LED ve röle: Bu yazıdaki komut ayrıştırıcıyı genişleterek on, off ve blink komutlarıyla bir röleyi ya da motoru yönet.
• Sensör veri kaydedici: Sıcaklık ve nemi virgüllü CSV satırları olarak yazdır, bilgisayarda tabloya ve grafiğe dök; sensör olarak DHT11 iyi bir başlangıçtır.
• Canlı ışık grafiği: LDR ya da potansiyometre değerini Serial Plotter'da izle, filtrenin etkisini aynı grafikte gör.
• Python ile masaüstü paneli: Arduino'nun gönderdiği verileri bir Python programıyla okuyup düğmeli bir arayüz yap; ayrıntılar Arduino Python seri haberleşme yazısında.
• Modül test istasyonu: GPS, Bluetooth ve GSM modülleri de seri port kullanır; modülden gelen ham veriyi Serial Monitor'e aktararak çalışıp çalışmadığını gör (HC-05, NEO-6M GPS).
• Kartsız deneme: Elinde kart yoksa Tinkercad'in de bir Serial Monitor'ü vardır; bu yazıdaki kodları Tinkercad simülasyonunda çalıştırabilirsin.

Serial Monitor'ü rahat kullanmaya başladığında Arduino'da hata bulmak tahmin yürütmekten çıkar, ölçerek ilerlemeye dönüşür. Bir sonraki adımda iki kartı TX ve RX hatlarıyla konuşturmak için UART seri haberleşme, USB'siz kartları programlamak için USB-TTL dönüştürücü yazılarına göz atabilirsin. BlueGrays uygulamasında HC-SR04 ile ölçülen mesafeyi Seri Port Ekranı'na yazdırma, LDR ile ışık şiddeti okuma, DHT11 ile sıcaklık ve nem ölçme ve iki Arduino'yu seri hatla haberleştirme projelerini devre şemaları ve hazır kodlarıyla adım adım bulabilirsin.