🔁 Döngüler ve Koşullu Yapılar ile Akıllı Kararlar: Arduino'da Programlamanın Temelleri

🔁 Döngüler ve Koşullu Yapılar ile Akıllı Kararlar: Arduino'da Programlamanın Temelleri

🔁 Döngüler ve Koşullu Yapılar ile Akıllı Kararlar: Arduino'da Programlamanın Temelleri

Merhaba Arduino severler!

Bu yazımızda, Arduino projelerinizin kalbi olan döngüler ve koşullu yapılar konusuna derinlemesine dalacağız. Bu iki kavram, Arduino'nuzun çevresindeki dünyayı algılayıp, buna göre akıllı kararlar vermesini sağlamanın anahtarıdır. Basit bir LED'i yakıp söndürmekten, karmaşık robot kontrol sistemlerine kadar her şey bu temel üzerine kuruludur. Hazırsanız, Arduino dünyasında akıllı kararlar vermeye başlayalım!

Döngüler: İşleri Tekrar Tekrar Yapmak

Döngüler, bir kod bloğunu belirli bir sayıda veya belirli bir koşul sağlanana kadar tekrar tekrar çalıştırmanızı sağlar. Arduino'da en sık kullanılan döngüler for ve while döngüleridir. Şimdi bunları yakından inceleyelim.

for Döngüsü: Kontrollü Tekrarlar

for döngüsü, belirli bir sayıda tekrar gerektiren işler için idealdir. Genellikle bir değişkeni başlatır, bir koşul belirler ve her döngü adımında bu değişkeni güncelleriz. Örneğin, bir LED'i 5 kez yakıp söndürmek için for döngüsünü şu şekilde kullanabiliriz:


 int ledPin = 13; // LED'in bağlı olduğu pin

 void setup() {
   pinMode(ledPin, OUTPUT); // LED pinini çıkış olarak ayarla
 }

 void loop() {
   for (int i = 0; i < 5; i++) { // 5 kez dönecek bir döngü
     digitalWrite(ledPin, HIGH); // LED'i yak
     delay(500); // Yarım saniye bekle
     digitalWrite(ledPin, LOW); // LED'i söndür
     delay(500); // Yarım saniye bekle
   }
   delay(2000); // Döngü bittikten sonra 2 saniye bekle
 }
 

Bu kodda, for döngüsü i değişkenini 0'dan başlatır, i < 5 koşulu sağlandığı sürece döngüyü devam ettirir ve her döngü adımında i'yi 1 artırır. Böylece LED 5 kez yanıp söner.

while Döngüsü: Koşul Sağlandığı Sürece

while döngüsü, belirli bir koşul doğru olduğu sürece bir kod bloğunu çalıştırmaya devam eder. Bu, bir sensörden gelen veriye bağlı olarak bir işlemi tekrarlamak gibi durumlarda çok kullanışlıdır. Örneğin, bir buton basılı tutulduğu sürece bir LED'i yakmak için while döngüsünü kullanabiliriz:


 int buttonPin = 2; // Butonun bağlı olduğu pin
 int ledPin = 13; // LED'in bağlı olduğu pin

 void setup() {
   pinMode(buttonPin, INPUT_PULLUP); // Buton pinini giriş olarak ayarla (dahili pull-up direnci ile)
   pinMode(ledPin, OUTPUT); // LED pinini çıkış olarak ayarla
 }

 void loop() {
   while (digitalRead(buttonPin) == LOW) { // Buton basılı olduğu sürece
     digitalWrite(ledPin, HIGH); // LED'i yak
   }
   digitalWrite(ledPin, LOW); // Buton bırakıldığında LED'i söndür
 }
 

Bağlantılar:

  • Butonun bir bacağı -> Arduino pin 2
  • Butonun diğer bacağı -> Arduino GND
  • LED'in anot (+) bacağı -> Arduino pin 13 (220 ohm direnç üzerinden)
  • LED'in katot (-) bacağı -> Arduino GND

Bu kodda, while döngüsü digitalRead(buttonPin) == LOW koşulu doğru olduğu sürece (yani buton basılı olduğu sürece) LED'i yakmaya devam eder. Buton bırakıldığında koşul sağlanmaz ve döngü sona erer, LED söner.

Koşullu Yapılar: Karar Verme Zamanı

Koşullu yapılar, programınızın belirli koşullara göre farklı eylemler gerçekleştirmesini sağlar. Arduino'da en yaygın kullanılan koşullu yapılar if, else if ve else ifadeleridir.

if İfadesi: Eğer...

if ifadesi, belirli bir koşul doğruysa bir kod bloğunu çalıştırır. Örneğin, bir sensörden gelen değer belirli bir eşiği aştığında bir alarmı tetiklemek için if ifadesini kullanabiliriz:


 int sensorPin = A0; // Sensörün bağlı olduğu analog pin
 int alarmPin = 8; // Alarmın bağlı olduğu dijital pin
 int threshold = 500; // Eşik değeri

 void setup() {
   pinMode(alarmPin, OUTPUT); // Alarm pinini çıkış olarak ayarla
 }

 void loop() {
   int sensorValue = analogRead(sensorPin); // Sensörden değeri oku

   if (sensorValue > threshold) { // Eğer sensör değeri eşiği aşarsa
     digitalWrite(alarmPin, HIGH); // Alarmı tetikle
   } else {
     digitalWrite(alarmPin, LOW); // Alarmı kapat
   }
   delay(100); // Kısa bir süre bekle
 }
 

Bu kodda, if ifadesi sensorValue > threshold koşulunu kontrol eder. Eğer sensörden okunan değer eşik değerini aşarsa, digitalWrite(alarmPin, HIGH) komutuyla alarm tetiklenir. Aksi takdirde, alarm kapatılır.

else if ve else İfadeleri: Birden Fazla Koşul

else if ve else ifadeleri, birden fazla koşulu kontrol etmek ve farklı koşullara göre farklı eylemler gerçekleştirmek için kullanılır. Örneğin, bir sıcaklık sensöründen gelen değere göre farklı LED'leri yakmak için bu ifadeleri kullanabiliriz:


 int tempPin = A0; // Sıcaklık sensörünün bağlı olduğu analog pin
 int redLedPin = 11; // Kırmızı LED'in bağlı olduğu dijital pin
 int greenLedPin = 12; // Yeşil LED'in bağlı olduğu dijital pin
 int blueLedPin = 13; // Mavi LED'in bağlı olduğu dijital pin

 void setup() {
   pinMode(redLedPin, OUTPUT); // Kırmızı LED pinini çıkış olarak ayarla
   pinMode(greenLedPin, OUTPUT); // Yeşil LED pinini çıkış olarak ayarla
   pinMode(blueLedPin, OUTPUT); // Mavi LED pinini çıkış olarak ayarla
 }

 void loop() {
   int tempValue = analogRead(tempPin); // Sıcaklık sensöründen değeri oku
   float temperature = map(tempValue, 20, 358, -40, 125); // Değeri sıcaklığa dönüştür

   if (temperature < 10) { // Eğer sıcaklık 10 dereceden düşükse
     digitalWrite(blueLedPin, HIGH); // Mavi LED'i yak
     digitalWrite(greenLedPin, LOW);
     digitalWrite(redLedPin, LOW);
   } else if (temperature < 25) { // Eğer sıcaklık 10 ile 25 derece arasındaysa
     digitalWrite(greenLedPin, HIGH); // Yeşil LED'i yak
     digitalWrite(blueLedPin, LOW);
     digitalWrite(redLedPin, LOW);
   } else { // Eğer sıcaklık 25 dereceden yüksekse
     digitalWrite(redLedPin, HIGH); // Kırmızı LED'i yak
     digitalWrite(blueLedPin, LOW);
     digitalWrite(greenLedPin, LOW);
   }
   delay(100); // Kısa bir süre bekle
 }
 

Bu kodda, sıcaklık değerine göre farklı LED'ler yakılır. if, else if ve else ifadeleri, sıcaklığın farklı aralıklarda olup olmadığını kontrol eder ve buna göre ilgili LED'i yakar.

Bağlantılar:

  • Sıcaklık Sensörü sinyal pini -> Arduino A0
  • Sıcaklık Sensörü VCC pini -> Arduino 5V
  • Sıcaklık Sensörü GND pini -> Arduino GND
  • Kırmızı LED'in anot (+) bacağı -> Arduino pin 11 (220 ohm direnç üzerinden)
  • Kırmızı LED'in katot (-) bacağı -> Arduino GND
  • Yeşil LED'in anot (+) bacağı -> Arduino pin 12 (220 ohm direnç üzerinden)
  • Yeşil LED'in katot (-) bacağı -> Arduino GND
  • Mavi LED'in anot (+) bacağı -> Arduino pin 13 (220 ohm direnç üzerinden)
  • Mavi LED'in katot (-) bacağı -> Arduino GND

Sonuç

Döngüler ve koşullu yapılar, Arduino programlamanın temel yapı taşlarıdır. Bu kavramları iyi anlamak, projelerinizde daha karmaşık ve akıllı davranışlar sergilemenizi sağlar. Bu yazıda öğrendiklerinizi kullanarak, Arduino projelerinizde yaratıcılığınızı konuşturabilir ve harika şeyler ortaya çıkarabilirsiniz!

Umarım bu yazı size faydalı olmuştur. Bir sonraki yazımızda görüşmek üzere!

Etiketler: Arduino, Döngüler, Koşullu Yapılar, Programlama, Elektronik, Proje, Eğitim, For Döngüsü, While Döngüsü, If Else, Başlangıç

```

0 yorum:

Arduino ile Zamanlama ve Gecikme: delay(), millis() ve Gerçek Zamanlı Kontrol

Arduino ile Zamanlama ve Gecikme: delay(), millis() ve Gerçek Zamanlı Kontrol

Arduino ile Zamanlama ve Gecikme: delay(), millis() ve Gerçek Zamanlı Kontrol

Merhaba Arduino severler!

Bu yazımızda Arduino projelerinizde olmazsa olmaz konulardan biri olan zamanlama ve gecikme fonksiyonlarını inceleyeceğiz. Özellikle delay(), millis() fonksiyonlarının ne işe yaradığını, nasıl kullanıldığını ve aralarındaki farkları detaylı bir şekilde anlatmaya çalışacağım. Ayrıca, gerçek zamanlı kontrol konusuna da değinerek projelerinizi daha hassas ve güvenilir hale getirmenize yardımcı olacağım.

delay() Fonksiyonu: Basit Ama Sınırlayıcı

delay() fonksiyonu, Arduino programının belirli bir süre boyunca duraklamasını sağlar. Kullanımı oldukça basittir. Örneğin, bir LED'i yakıp söndürmek için aşağıdaki gibi bir kod kullanabilirsiniz:


 void setup() {
  pinMode(13, OUTPUT);  // 13. pini çıkış olarak tanımla
 }

 void loop() {
  digitalWrite(13, HIGH);  // LED'i yak
  delay(1000);              // 1 saniye bekle
  digitalWrite(13, LOW);   // LED'i söndür
  delay(1000);              // 1 saniye bekle
 }
 

Bu kod, 13 numaralı pine bağlı olan LED'i 1 saniye yakacak ve 1 saniye söndürecektir. Ancak delay() fonksiyonunun bir dezavantajı vardır: Arduino işlemcisini belirtilen süre boyunca tamamen bloke eder. Yani, delay() fonksiyonu çalışırken Arduino başka hiçbir işlem yapamaz.

millis() Fonksiyonu: Kesintisiz Zamanlama

millis() fonksiyonu, Arduino'nun başlatılmasından itibaren geçen milisaniye sayısını döndürür. Bu fonksiyon, delay()'in aksine programın çalışmasını durdurmaz. Bu sayede, aynı anda birden fazla işlemi gerçekleştirebilirsiniz. Örneğin, hem LED'i yakıp söndürebilir hem de bir sensörden veri okuyabilirsiniz.

millis() fonksiyonunu kullanarak LED'i yakıp söndüren ve aynı zamanda bir potansiyometreden değer okuyan bir örnek kod:


 const int ledPin = 13;
 const int potPin = A0;
 unsigned long previousMillis = 0;
 const long interval = 1000; // 1 saniye

 void setup() {
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
 }

 void loop() {
  unsigned long currentMillis = millis();

  // LED'i yakıp söndürme işlemi (delay() kullanmadan)
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    digitalWrite(ledPin, !digitalRead(ledPin)); // LED'in durumunu tersine çevir
  }

  // Potansiyometreden değer okuma
  int potValue = analogRead(potPin);
  Serial.print("Potansiyometre Değeri: ");
  Serial.println(potValue);

  delay(10); // Kısa bir gecikme (gerekli değil ama okunabilirliği artırır)
 }
 

Bağlantılar:

  • Potansiyometrenin bir ucu -> Arduino GND
  • Potansiyometrenin orta ucu (sinyal) -> Arduino A0 pini
  • Potansiyometrenin diğer ucu -> Arduino VCC (5V)
  • LED'in anot (+) bacağı -> Arduino 13. pini (direnç ile)
  • LED'in katot (-) bacağı -> Arduino GND

Bu kodda, millis() fonksiyonu kullanılarak belirli aralıklarla LED'in durumu değiştirilirken, aynı zamanda potansiyometreden sürekli olarak veri okunmaktadır. delay() fonksiyonu kullanılsaydı, potansiyometre okuma işlemi LED'in yanıp sönme aralığında duraklayacaktı.

Gerçek Zamanlı Kontrol (Real-Time Control)

Gerçek zamanlı kontrol, bir sistemin belirli bir zaman diliminde belirli bir görevi tamamlamasını gerektiren uygulamalarda önemlidir. millis() fonksiyonu, bu tür uygulamalar için idealdir çünkü programın çalışmasını durdurmadan zamanlama yapmanıza olanak tanır.

Örneğin, bir robotun belirli bir rotayı izlemesi veya bir otomasyon sisteminin belirli bir sırayla işlemleri gerçekleştirmesi gibi uygulamalarda gerçek zamanlı kontrol önemlidir. Bu tür uygulamalarda, millis() fonksiyonunu kullanarak zamanlama yapabilir ve sistemin doğru zamanda doğru işlemleri yapmasını sağlayabilirsiniz.

Özet

Bu yazıda, Arduino projelerinizde kullanabileceğiniz temel zamanlama ve gecikme fonksiyonlarını inceledik. delay() fonksiyonunun basitliği ancak sınırlayıcı olması, millis() fonksiyonunun ise daha esnek ve güçlü olması üzerinde durduk. Ayrıca, gerçek zamanlı kontrolün ne olduğunu ve neden önemli olduğunu açıkladık.

Umarım bu yazı, Arduino projelerinizde zamanlama ve gecikme konularında size yardımcı olur. Başarılar dilerim!

Etiketler: Arduino, Zamanlama, Gecikme, delay(), millis(), Gerçek Zamanlı Kontrol, RTC, Arduino Eğitim, Elektronik, Robotik, Proje

```

0 yorum:

🌡️Analog Girişler: Potansiyometre ve analogRead() Kullanımı

🌡️Analog Girişler: Potansiyometre ve analogRead() Kullanımı

🌡️Analog Girişler: Potansiyometre ve analogRead() Kullanımı

Merhaba sevgili Arduino severler! Bu yazımızda, Arduino dünyasının temel taşlarından biri olan analog girişleri ve bu girişleri kullanmanın en kolay yollarından biri olan potansiyometre ile analogRead() fonksiyonunu inceleyeceğiz. Analog sinyallerle çalışmak, projelerinize çok daha fazla esneklik ve interaktivite katmanın harika bir yoludur. Hazırsanız, başlayalım!

Analog Giriş Nedir?

Dijital sinyaller sadece iki değeri (0 veya 1, yüksek veya düşük) temsil ederken, analog sinyaller sürekli bir değer aralığını temsil edebilir. Arduino üzerindeki analog giriş pinleri (A0, A1, A2, A3, A4, A5), 0 ile 5V arasındaki gerilim değerlerini okuyabilir ve bunları 0 ile 1023 arasında bir sayısal değere dönüştürür. Bu sayede sensörlerden, potansiyometrelerden ve diğer analog cihazlardan gelen verileri Arduino'da işleyebiliriz.

Potansiyometre Nedir ve Neden Kullanırız?

Potansiyometre, ayarlanabilir bir dirençtir. Üzerindeki bir düğmeyi çevirerek direncini değiştirebiliriz. Bu özelliği sayesinde, potansiyometreler Arduino projelerinde sıklıkla kullanılır. Örneğin, bir LED'in parlaklığını ayarlamak, bir motorun hızını kontrol etmek veya bir menüde gezinmek için potansiyometreyi kullanabiliriz.

Gerekli Malzemeler

  • Arduino kartı (Uno, Nano, Mega vb.)
  • Potansiyometre (10kΩ idealdir)
  • Jumper kablolar
  • Breadboard (isteğe bağlı)

Devre Şeması ve Bağlantılar

Potansiyometreyi Arduino'ya bağlamak oldukça basittir. İşte adım adım bağlantı şeması:

  • Potansiyometrenin bir ucu (genellikle sol ucu) -> Arduino GND pinine bağlanır
  • Potansiyometrenin diğer ucu (genellikle sağ ucu) -> Arduino 5V pinine bağlanır
  • Potansiyometrenin orta ucu (wiper) -> Arduino'nun herhangi bir analog giriş pinine (örneğin A0) bağlanır

Arduino Kodu

Şimdi de potansiyometreden okuduğumuz değeri Arduino'da nasıl işleyeceğimize bakalım. Aşağıdaki kodu Arduino IDE'sine kopyalayın ve kartınıza yükleyin:


 const int potPin = A0;  // Potansiyometrenin bağlı olduğu analog pin

 void setup() {
  Serial.begin(9600); // Seri iletişimi başlat
 }

 void loop() {
  int potValue = analogRead(potPin); // Potansiyometrenin değerini oku (0-1023)
  Serial.println(potValue);        // Değeri seri monitöre yazdır
  delay(100);                    // Kısa bir bekleme süresi
 }
 

Bu kod, analogRead(potPin) fonksiyonu ile potansiyometrenin bağlı olduğu A0 pinindeki değeri okur ve bu değeri seri monitöre yazdırır. Seri monitörü açarak potansiyometrenin düğmesini çevirdikçe değerlerin değiştiğini görebilirsiniz.

Kodu Açıklayalım

  • const int potPin = A0;: Potansiyometrenin bağlı olduğu analog pini tanımlar.
  • Serial.begin(9600);: Seri iletişimi başlatır. Bu sayede Arduino'nun okuduğu değerleri bilgisayarımıza gönderebiliriz.
  • int potValue = analogRead(potPin);: analogRead() fonksiyonu ile potansiyometrenin değerini okur ve potValue adlı bir değişkene atar. Bu değer 0 ile 1023 arasında bir sayıdır.
  • Serial.println(potValue);: Okunan değeri seri monitöre yazdırır.
  • delay(100);: Kodun çok hızlı çalışmasını engellemek ve değerlerin daha rahat okunabilmesini sağlamak için kısa bir bekleme süresi ekler.

Projelerinizde Nasıl Kullanabilirsiniz?

Potansiyometre ve analogRead() kombinasyonunu kullanarak birçok farklı proje geliştirebilirsiniz. İşte birkaç örnek:

  • LED Parlaklık Kontrolü: Potansiyometreden okuduğunuz değere göre bir LED'in parlaklığını ayarlayabilirsiniz. analogWrite() fonksiyonunu kullanarak PWM sinyali üretebilir ve LED'in parlaklığını kontrol edebilirsiniz.
  • Servo Motor Kontrolü: Potansiyometre ile servo motorun açısını kontrol edebilirsiniz. Servo motorun açısını potansiyometreden okuduğunuz değere göre ayarlayarak, hassas hareketler elde edebilirsiniz.
  • Ses Kontrolü: Bir amplifikatör devresinde potansiyometre kullanarak ses seviyesini kontrol edebilirsiniz.
  • Oyun Kontrolü: Potansiyometreleri joystick gibi kullanarak basit oyunlar kontrol edebilirsiniz.

Sonuç

Bu yazımızda, Arduino'da analog girişlerin ne olduğunu, potansiyometrenin nasıl kullanıldığını ve analogRead() fonksiyonu ile nasıl veri okuyabileceğimizi öğrendik. Umarım bu bilgiler, Arduino projelerinizi geliştirmenize yardımcı olur. Başarılar dilerim!

Etiketler: Arduino, Analog Giriş, Potansiyometre, analogRead, Elektronik, Proje, Sensör, Eğitim

```

0 yorum:

💡 Dijital Giriş ve Çıkış Pinleri Nedir? Nasıl Kullanılır? (pinMode(), digitalWrite(), digitalRead())

💡 Dijital Giriş ve Çıkış Pinleri Nedir? Nasıl Kullanılır? (pinMode(), digitalWrite(), digitalRead())

💡 Dijital Giriş ve Çıkış Pinleri Nedir? Nasıl Kullanılır? (pinMode(), digitalWrite(), digitalRead())

Merhaba Arduino severler! Bu yazımızda Arduino'nun temel taşlarından olan dijital giriş ve çıkış pinlerini yakından tanıyacağız. Arduino projelerinizde sensörlerden veri okumak, LED'leri kontrol etmek veya motorları sürmek gibi birçok işlem için bu pinleri kullanmanız gerekecek. Hazırsanız, dijital dünyanın kapılarını aralayalım!

Dijital Pinler Ne İşe Yarar?

Arduino'nun dijital pinleri, sadece iki farklı durumda (HIGH veya LOW) sinyal gönderebilir veya alabilir. Bu durumlar genellikle "1" (HIGH) ve "0" (LOW) olarak temsil edilir. Arduino'nun çalışma voltajına bağlı olarak, HIGH genellikle 5V (veya 3.3V), LOW ise 0V anlamına gelir. Dijital pinler, sensörlerden basit aç/kapa sinyallerini okumak veya LED'leri yakıp söndürmek gibi temel işlemleri gerçekleştirmek için idealdir.

Pinleri Tanımlama: pinMode() Fonksiyonu

Herhangi bir pini kullanmadan önce, o pinin giriş mi yoksa çıkış mı olarak kullanılacağını Arduino'ya bildirmemiz gerekir. İşte tam bu noktada pinMode() fonksiyonu devreye giriyor. Bu fonksiyon, bir pinin davranışını tanımlamamızı sağlar.


 pinMode(pinNumarasi, MOD);
 
  • pinNumarasi: Ayarlamak istediğiniz pinin numarası (2-13 ve A0-A5 gibi).
  • MOD: Pin modunu belirtir. Üç farklı seçenek vardır:
    • INPUT: Pin, dışarıdan bir sinyal alacak şekilde ayarlanır (sensörlerden veri okuma gibi).
    • OUTPUT: Pin, dışarıya bir sinyal gönderecek şekilde ayarlanır (LED'i yakma, motoru kontrol etme gibi).
    • INPUT_PULLUP: INPUT moduna benzer, ancak dahili bir direnç etkinleştirilir. Bu, harici bir direnç kullanmadan pini belirli bir durumda tutmaya yardımcı olur.

Örnek:


 // 7 numaralı pini çıkış olarak ayarla
 pinMode(7, OUTPUT);

 // 8 numaralı pini giriş olarak ayarla
 pinMode(8, INPUT);

 // 9 numaralı pini dahili dirençli giriş olarak ayarla
 pinMode(9, INPUT_PULLUP);
 

Çıkış Pinlerini Kontrol Etme: digitalWrite() Fonksiyonu

Bir pini OUTPUT olarak ayarladıktan sonra, o pinden HIGH veya LOW sinyali göndermek için digitalWrite() fonksiyonunu kullanırız. Bu fonksiyon, çıkış pinlerimizin davranışını kontrol etmemizi sağlar.


 digitalWrite(pinNumarasi, DEGER);
 
  • pinNumarasi: Kontrol etmek istediğiniz çıkış pininin numarası.
  • DEGER: Pinin alacağı değer. İki seçenek vardır:
    • HIGH: Pinden 5V (veya 3.3V) sinyali gönderilir.
    • LOW: Pinden 0V sinyali gönderilir.

Örnek:


 // 7 numaralı pini HIGH yap (LED'i yak)
 digitalWrite(7, HIGH);

 // 7 numaralı pini LOW yap (LED'i söndür)
 digitalWrite(7, LOW);
 

Giriş Pinlerinden Veri Okuma: digitalRead() Fonksiyonu

Bir pini INPUT olarak ayarladıktan sonra, o pindeki sinyali okumak için digitalRead() fonksiyonunu kullanırız. Bu fonksiyon, giriş pinlerimizdeki durumu (HIGH veya LOW) belirlememizi sağlar.


 int okunanDeger = digitalRead(pinNumarasi);
 
  • pinNumarasi: Okumak istediğiniz giriş pininin numarası.
  • okunanDeger: Fonksiyonun döndürdüğü değer. HIGH (1) veya LOW (0) olabilir.

Örnek:


 // 8 numaralı pindeki değeri oku
 int sensorDegeri = digitalRead(8);

 // Eğer sensör değeri HIGH ise
 if (sensorDegeri == HIGH) {
   // Bir şeyler yap...
 } else {
   // Başka bir şeyler yap...
 }
 

Basit Bir LED Yakıp Söndürme Projesi

Şimdi öğrendiklerimizi kullanarak basit bir LED yakıp söndürme projesi yapalım. Bu projede, 13 numaralı pine bağlı bir LED'i her saniye yakıp söndüreceğiz.

Malzemeler:

  • Arduino kartı
  • LED
  • 220 ohm direnç (LED'i korumak için)
  • Breadboard (isteğe bağlı)
  • Jumper kabloları

Bağlantılar:

  • LED'in uzun bacağı (anot) -> 220 ohm direnç -> Arduino'nun 13 numaralı pini
  • LED'in kısa bacağı (katot) -> Arduino'nun GND (toprak) pini

Kod:


 int ledPin = 13; // LED'in bağlı olduğu pin

 void setup() {
   // 13 numaralı pini çıkış olarak ayarla
   pinMode(ledPin, OUTPUT);
 }

 void loop() {
   // LED'i yak
   digitalWrite(ledPin, HIGH);
   delay(1000); // 1 saniye bekle

   // LED'i söndür
   digitalWrite(ledPin, LOW);
   delay(1000); // 1 saniye bekle
 }
 

Bu kod, LED'i her saniye yakıp söndürecektir. Kodu Arduino'ya yükleyin ve sonucu gözlemleyin!

Daha Fazla İpucu ve Püf Noktası

  • Direnç Kullanımı: LED'leri Arduino'ya bağlarken mutlaka bir direnç kullanın. Aksi takdirde, LED'iniz zarar görebilir veya yanabilir.
  • Pull-up Dirençleri: Buton gibi elemanlarla çalışırken, INPUT_PULLUP modunu kullanarak harici bir direnç kullanmaktan kurtulabilirsiniz.
  • Pin Kısıtlamaları: Bazı pinler özel amaçlar için kullanılır (örneğin, 0 ve 1 numaralı pinler seri iletişim için kullanılır). Bu pinleri kullanırken dikkatli olun.

Umarım bu yazı, Arduino'nun dijital giriş ve çıkış pinleri hakkında size temel bir anlayış kazandırmıştır. Artık basit projeler yapmaya başlayabilir ve Arduino dünyasını keşfedebilirsiniz. Bol şans!

Etiketler: Arduino, Dijital Giriş, Dijital Çıkış, pinMode, digitalWrite, digitalRead, LED, Sensör, Elektronik

```

0 yorum:

Arduino Programlama Dili: Temel Yapılar (Değişkenler)

Arduino Programlama Dili: Temel Yapılar (Değişkenler)

Arduino Programlama Dili: Temel Yapılar - Değişkenler

Merhaba Arduino severler!

Bu yazımızda Arduino programlamanın temel taşlarından biri olan değişkenleri inceleyeceğiz. Değişkenler, programlarımızda verileri saklamak, işlemek ve yönetmek için kullandığımız temel araçlardır. Tıpkı bir kutu gibi düşünebilirsiniz, bu kutunun içine sayı, yazı veya herhangi bir bilgiyi koyup, gerektiğinde bu bilgiye erişebiliriz.

Değişken Nedir?

Değişkenler, bilgisayarın belleğinde (RAM) belirli bir alanı temsil eden, adlandırılmış depolama birimleridir. Her değişkenin bir adı (identifier) ve bir türü (data type) vardır. Tür, değişkenin hangi türde veriyi saklayabileceğini (sayı, metin, vb.) belirler. Ad ise, değişkenin değerine erişmek için kullandığımız etikettir.

Değişken Tanımlama (Declaration)

Bir değişkeni kullanmadan önce tanımlamamız gerekir. Tanımlama işlemi, değişkenin adını ve türünü belirtmekten ibarettir. Arduino'da değişken tanımlama sözdizimi şöyledir:


 veri_tipi değişken_adı;
 

Örneğin, bir tam sayı (integer) değişkeni tanımlamak için:


 int sayac;
 

Bu ifade, "sayac" adında bir tam sayı değişkeni oluşturur. Henüz bu değişkene bir değer atamadık, ancak artık bu değişkeni programımızda kullanabiliriz.

Veri Tipleri (Data Types)

Arduino'da sıkça kullanılan bazı veri tipleri şunlardır:

  • int: Tam sayıları (örneğin, -10, 0, 5, 100) saklamak için kullanılır. 2 byte (16 bit) yer kaplar. -32,768 ile 32,767 arasındaki değerleri saklayabilir.
  • long: Daha büyük tam sayıları saklamak için kullanılır. 4 byte (32 bit) yer kaplar. -2,147,483,648 ile 2,147,483,647 arasındaki değerleri saklayabilir.
  • float: Kayan noktalı sayıları (ondalıklı sayılar, örneğin 3.14, -2.5, 1.0) saklamak için kullanılır. 4 byte yer kaplar.
  • double: Daha yüksek hassasiyette kayan noktalı sayıları saklamak için kullanılır. Arduino'da `float` ile aynıdır (4 byte yer kaplar).
  • char: Tek bir karakteri (örneğin, 'a', 'B', '5') saklamak için kullanılır. 1 byte yer kaplar.
  • boolean: Doğru (true) veya yanlış (false) değerlerini saklamak için kullanılır. 1 byte yer kaplar.
  • byte: 0 ile 255 arasındaki değerleri saklamak için kullanılır. 1 byte yer kaplar.
  • word: 0 ile 65535 arasındaki değerleri saklamak için kullanılır. 2 byte yer kaplar.
  • unsigned int: `int` veri tipinin işaretsiz versiyonudur. 0 ile 65535 arasındaki değerleri saklayabilir.
  • unsigned long: `long` veri tipinin işaretsiz versiyonudur. 0 ile 4,294,967,295 arasındaki değerleri saklayabilir.
  • String: Metin dizilerini saklamak için kullanılır. Ancak Arduino'da `String` sınıfını kullanmak yerine, karakter dizilerini (char array) kullanmak daha iyi bir pratiktir, çünkü `String` sınıfı bellek yönetiminde sorunlara yol açabilir.

Değişkene Değer Atama (Assignment)

Bir değişkene değer atamak için eşittir (=) işaretini kullanırız.


 değişken_adı = değer;
 

Örneğin:


 int sayac = 10; // "sayac" değişkenine 10 değerini atadık
 float pi = 3.14;  // "pi" değişkenine 3.14 değerini atadık
 char ilkHarf = 'A'; // "ilkHarf" değişkenine 'A' karakterini atadık
 boolean durum = true; // "durum" değişkenine doğru (true) değerini atadık
 

Örnek Uygulama

Şimdi basit bir örnekle değişkenlerin kullanımını görelim. Bu örnekte, bir LED'i yakıp söndüreceğiz. LED'i kontrol etmek için bir pini çıkış olarak ayarlayacak ve bir değişken kullanarak LED'in durumunu (yanıp yanmadığını) kontrol edeceğiz.

Devre Bağlantısı:

  • LED'in anot (uzun bacak) -> 220 ohm direnç -> Arduino Dijital Pin 13
  • LED'in katot (kısa bacak) -> Arduino GND

 // LED'in bağlı olduğu pini tanımlıyoruz
 const int ledPin = 13;

 // LED'in durumunu saklayacak değişkeni tanımlıyoruz
 boolean ledDurumu = false;

 void setup() {
  // LED pinini çıkış olarak ayarlıyoruz
  pinMode(ledPin, OUTPUT);
 }

 void loop() {
  // LED'in durumunu tersine çeviriyoruz (yanıyorsa söndürüyor, sönükse yakıyoruz)
  ledDurumu = !ledDurumu;

  // LED'i yakıp söndürüyoruz
  digitalWrite(ledPin, ledDurumu);

  // Kısa bir süre bekliyoruz (1 saniye)
  delay(1000);
 }
 

Bu kodda, ledDurumu adında bir boolean değişkeni tanımladık. Bu değişken, LED'in o anki durumunu (yanıp yanmadığını) saklar. loop() fonksiyonunda, bu değişkenin değerini sürekli olarak tersine çevirerek (true ise false, false ise true yaparak) LED'i yakıp söndürüyoruz.

Değişkenlerin Kapsamı (Scope)

Bir değişkenin nerede tanımlandığı, o değişkenin hangi bölgelerde kullanılabileceğini belirler. Buna değişkenin kapsamı denir. Arduino'da genel (global) ve yerel (local) olmak üzere iki tür kapsam vardır.

  • Genel Değişkenler: Fonksiyonların dışında tanımlanan değişkenlerdir. Programın herhangi bir yerinden erişilebilirler.
  • Yerel Değişkenler: Bir fonksiyon içinde tanımlanan değişkenlerdir. Sadece o fonksiyon içinde erişilebilirler.

Örneğin:


 int globalSayi = 10; // Genel değişken

 void setup() {
  int yerelSayi = 5; // Yerel değişken

  Serial.begin(9600);
  Serial.println(globalSayi); // Global değişken kullanılabilir
  Serial.println(yerelSayi);  // Yerel değişken kullanılabilir
 }

 void loop() {
  // Serial.println(yerelSayi); // Hata! Yerel değişken loop() içinde erişilemez
  Serial.println(globalSayi); // Global değişken kullanılabilir
  delay(1000);
 }
 

Unutmayın, değişkenleri doğru şekilde kullanmak, Arduino projelerinizin başarısı için kritik öneme sahiptir. Bu temel bilgileri özümsedikten sonra, daha karmaşık projelere geçebilirsiniz.

Umarım bu yazı değişkenler konusunda size yardımcı olmuştur. Bir sonraki yazımızda görüşmek üzere!

Etiketler: Arduino, Programlama, Değişkenler, Veri Tipleri, Arduino Dersleri, Arduino Başlangıç

```

0 yorum:

Arduino Programlama Dili: Temel Yapılar (Loop)

Arduino Programlama Dili: Temel Yapılar (Loop)

Arduino Programlama Dili: Temel Yapılar (Döngüler - Loop)

Merhaba Arduino severler! Bu yazımızda Arduino programlamanın temel taşlarından biri olan ve kodumuzun tekrar tekrar çalışmasını sağlayan döngüler (loop) konusuna değineceğiz. Arduino ile projeler geliştirirken sensörlerden veri okumak, LED'leri yakıp söndürmek veya motorları kontrol etmek gibi işlemleri sürekli olarak yapmamız gerekir. İşte bu noktada döngüler devreye girer ve işimizi oldukça kolaylaştırır.

Arduino'da Döngüler Neden Önemli?

Döngüler sayesinde:

  • Kod tekrarından kurtuluruz. Aynı kod bloğunu defalarca yazmak yerine, döngü kullanarak tek seferde istediğimiz kadar tekrar edebiliriz.
  • Programımızı daha okunaklı ve anlaşılır hale getiririz.
  • Projemizin karmaşıklığını azaltırız.
  • Gerçek zamanlı uygulamalar geliştirebiliriz (Örneğin, sürekli olarak sensör değerlerini okuyup tepki vermek).

Arduino'da Kullanılan Temel Döngüler

Arduino programlamada en sık kullanılan döngüler şunlardır:

  • void loop(): Arduino programının ana döngüsüdür. setup() fonksiyonu bir kez çalıştıktan sonra, loop() fonksiyonu sonsuza kadar tekrar tekrar çalışır.
  • for Döngüsü: Belirli bir sayıda tekrar yapmak istediğimizde kullanırız.
  • while Döngüsü: Belirli bir koşul sağlandığı sürece tekrar eden bir döngüdür.
  • do...while Döngüsü: while döngüsüne benzer ancak koşul döngünün sonunda kontrol edilir, bu nedenle döngü en az bir kere çalışır.

void loop() Döngüsü

Arduino IDE'si ile yeni bir proje oluşturduğumuzda karşımıza çıkan temel yapıdır. Arduino kartımız enerji verildiği sürece bu döngü sürekli çalışmaya devam eder. Örneğin, bir LED'i yakıp söndürmek için kullanabiliriz:


 void setup() {
  // LED'in bağlı olduğu pini çıkış olarak tanımlıyoruz.
  pinMode(13, OUTPUT);
 }

 void loop() {
  // LED'i yak.
  digitalWrite(13, HIGH);
  delay(1000); // 1 saniye bekle.

  // LED'i söndür.
  digitalWrite(13, LOW);
  delay(1000); // 1 saniye bekle.
 }
 

Yukarıdaki kodda, LED'i 1 saniye yakıp 1 saniye söndürerek sürekli tekrarlayan bir yanıp sönme efekti oluşturuyoruz.

Devre Bağlantısı:

  • LED anot (+) -> 220 Ohm direnç -> Arduino Dijital Pin 13
  • LED katot (-) -> Arduino GND

for Döngüsü

for döngüsü, belirli bir sayıda tekrar yapmak istediğimizde idealdir. Üç bölümden oluşur:

  • Başlangıç: Döngünün başlangıcında sadece bir kez çalıştırılan kısım. Genellikle bir sayaç değişkeni tanımlanır ve başlangıç değeri atanır.
  • Koşul: Döngünün devam edip etmeyeceğini belirleyen koşul. Koşul doğru (true) olduğu sürece döngü çalışmaya devam eder.
  • Artış/Azalış: Her döngü tekrarından sonra sayaç değişkeninin değerini günceller.

Örneğin, 1'den 10'a kadar olan sayıları seri monitöre yazdırmak için for döngüsünü şu şekilde kullanabiliriz:


 void setup() {
  Serial.begin(9600); // Seri iletişimi başlatıyoruz.
 }

 void loop() {
  for (int i = 1; i <= 10; i++) {
   Serial.println(i);
   delay(500); // 0.5 saniye bekle.
  }
  delay(5000); // 5 saniye bekle ve tekrar başla.
 }
 

while Döngüsü

while döngüsü, belirli bir koşul sağlandığı sürece tekrar eden bir döngüdür. Koşul başlangıçta kontrol edilir. Koşul yanlış (false) ise döngü hiç çalışmaz.

Örneğin, bir butona basılana kadar beklemek için while döngüsünü kullanabiliriz:


 const int buttonPin = 2; // Butonun bağlı olduğu pin.

 void setup() {
  Serial.begin(9600);
  pinMode(buttonPin, INPUT_PULLUP); // Dahili pull-up direnci kullanıyoruz.
 }

 void loop() {
  while (digitalRead(buttonPin) == HIGH) {
   // Butona basılana kadar bekle.
   Serial.println("Butona basılmasını bekliyorum...");
   delay(100);
  }

  Serial.println("Butona basıldı!");
  delay(1000); // 1 saniye bekle ve tekrar başla.
 }
 

Devre Bağlantısı:

  • Buton bir bacağı -> Arduino Dijital Pin 2
  • Buton diğer bacağı -> Arduino GND

Bu kodda, dahili pull-up direnci kullanıldığı için butona basılmadığında pin HIGH değerini alır. Butona basıldığında ise pin LOW değerini alır. while döngüsü, buton HIGH olduğu sürece (yani basılmadığı sürece) çalışmaya devam eder.

do...while Döngüsü

do...while döngüsü, while döngüsüne benzer ancak koşul döngünün sonunda kontrol edilir. Bu nedenle döngü en az bir kere çalışır.


 int sayac = 0;

 void setup() {
  Serial.begin(9600);
 }

 void loop() {
  do {
   Serial.println(sayac);
   sayac++;
   delay(500);
  } while (sayac <= 5);

  delay(5000); // 5 saniye bekle ve tekrar başla.
  sayac = 0; // Sayacı sıfırla.
 }
 

Bu örnekte, sayaç 0'dan başlar ve her döngüde ekrana yazdırılır ve 1 artırılır. Koşul döngünün sonunda kontrol edildiği için, sayaç değeri 0 olduğunda ekrana yazdırılır ve sonra sayaç değeri 1 olur. Döngü, sayaç 5'e eşit veya küçük olduğu sürece devam eder.

Sonuç

Bu yazımızda Arduino programlamanın temel döngü yapılarını inceledik. loop(), for, while ve do...while döngüleri, Arduino projelerinizde tekrar eden işlemleri kolayca gerçekleştirmek için güçlü araçlardır. Umarım bu bilgiler, Arduino yolculuğunuzda size yardımcı olur. Bir sonraki yazımızda görüşmek üzere!

Etiketler: Arduino, Programlama, Döngü, Loop, for, while, do-while, Arduino Dersleri, Arduino Temelleri

```

0 yorum: