🧩 Arduino ile Modül Kullanımı: LCD Ekran

13:12 Arduino, LCD Ekran, Modül Kullanımı, Elektronik, Proje, Eğitim, Kodlama, Sensör 0 Yorum

🧩 Arduino ile Modül Kullanımı: LCD Ekran

Merhaba sevgili Arduino meraklıları! Bu blog yazımızda, projelerinizin vazgeçilmezi olacak LCD ekranları Arduino ile nasıl kullanacağımızı adım adım inceleyeceğiz. LCD ekranlar, projelerinizde sensör verilerini, uyarı mesajlarını veya istediğiniz herhangi bir bilgiyi görüntülemek için harika bir araçtır. Hazırsanız, başlayalım!

Neden LCD Ekran Kullanmalıyız?

LCD (Liquid Crystal Display) ekranlar, projelerinize görsel bir boyut kazandırır. Arduino'nun işlem gücünü kullanarak sensörlerden okuduğunuz değerleri, hata mesajlarını veya projenizin durumunu kolayca görüntüleyebilirsiniz. Üstelik, kullanımı oldukça basit ve maliyeti düşüktür.

Gerekli Malzemeler

Bu projeyi gerçekleştirmek için aşağıdaki malzemelere ihtiyacınız olacak:

• Arduino Uno (veya benzeri bir Arduino kartı)
• 16x2 LCD Ekran (HD44780 uyumlu)
• 10k Potansiyometre (Kontrast ayarı için)
• Jumper kablolar
• Breadboard (isteğe bağlı)

LCD Ekran ve Arduino Bağlantısı

Şimdi en önemli kısma geldik: LCD ekranı Arduino'ya nasıl bağlayacağız? Aşağıdaki bağlantı şemasını dikkatlice inceleyin:

• LCD'nin VSS pini -> Arduino GND
• LCD'nin VDD pini -> Arduino 5V
• LCD'nin VO pini -> Potansiyometrenin orta ayağı (Diğer iki ayak GND ve 5V'a bağlanacak)
• LCD'nin RS pini -> Arduino Dijital Pin 12
• LCD'nin EN pini -> Arduino Dijital Pin 11
• LCD'nin D4 pini -> Arduino Dijital Pin 5
• LCD'nin D5 pini -> Arduino Dijital Pin 4
• LCD'nin D6 pini -> Arduino Dijital Pin 3
• LCD'nin D7 pini -> Arduino Dijital Pin 2
• LCD'nin A pini (Arka Işık Anodu) -> Arduino 5V (dirençle kullanılması önerilir, örneğin 220 ohm)
• LCD'nin K pini (Arka Işık Katodu) -> Arduino GND

Bu bağlantıları dikkatlice yaptığınızdan emin olun. Yanlış bağlantılar LCD ekranınıza zarar verebilir!

Arduino Kodu

Bağlantıları tamamladıktan sonra, sıra geldi Arduino kodunu yazmaya. Aşağıdaki kodu Arduino IDE'nize kopyalayın ve Arduino'nuza yükleyin:

 #include <LiquidCrystal.h>

 // LCD pinlerini tanımlayın
 const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
 LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

 void setup() {
  // LCD'nin kolon ve satır sayısını ayarlayın
  lcd.begin(16, 2);
  // LCD'ye bir mesaj yazdırın
  lcd.print("Merhaba Arduino!");
 }

 void loop() {
  // İmleci ikinci satırın başına götürün
  lcd.setCursor(0, 1);
  // Arduino çalışma süresini saniye cinsinden yazdırın
  lcd.print(millis() / 1000);
 }
 

Bu kodda, öncelikle LiquidCrystal kütüphanesini projemize dahil ediyoruz. Ardından, LCD ekranın Arduino'ya bağladığımız pinlerini tanımlıyoruz. `setup()` fonksiyonunda, LCD ekranın boyutlarını belirliyor ve ekrana bir başlangıç mesajı yazdırıyoruz. `loop()` fonksiyonunda ise, sürekli olarak Arduino'nun çalışma süresini saniye cinsinden ikinci satıra yazdırıyoruz.

Kodu Anlamak

• `#include <LiquidCrystal.h>`: Bu satır, LCD ekranı kontrol etmek için gerekli olan LiquidCrystal kütüphanesini projenize dahil eder.
• `LiquidCrystal lcd(rs, en, d4, d5, d6, d7);`: Bu satır, LCD ekran nesnesini oluşturur ve hangi pinlerin hangi fonksiyonlara bağlı olduğunu belirtir.
• `lcd.begin(16, 2);`: Bu satır, LCD ekranın boyutlarını (16 sütun, 2 satır) ayarlar.
• `lcd.print("Merhaba Arduino!");`: Bu satır, LCD ekrana "Merhaba Arduino!" mesajını yazdırır.
• `lcd.setCursor(0, 1);`: Bu satır, imleci ikinci satırın başına (sütun 0, satır 1) götürür.
• `lcd.print(millis() / 1000);`: Bu satır, Arduino'nun çalışma süresini milisaniye cinsinden alır, 1000'e bölerek saniyeye çevirir ve LCD ekrana yazdırır.

Ek İpuçları

• Potansiyometreyi kullanarak LCD ekranın kontrastını ayarlayabilirsiniz.
• `lcd.clear();` komutu ile ekranı temizleyebilirsiniz.
• `lcd.setCursor(sütun, satır);` komutu ile imlecin yerini değiştirebilirsiniz.
• LCD ekranın arka ışığını açıp kapatmak için, ilgili pinlere bağladığınız transistörü veya röleyi kontrol edebilirsiniz.

Sonuç

Bu yazımızda, Arduino ile LCD ekran kullanımının temellerini öğrendik. Artık projelerinizde sensör verilerini, uyarı mesajlarını veya istediğiniz herhangi bir bilgiyi kolayca görüntüleyebilirsiniz. Denemekten ve yeni şeyler keşfetmekten çekinmeyin! Başarılar dilerim!

Etiketler: Arduino, LCD Ekran, Modül Kullanımı, Elektronik, Proje, Eğitim, Kodlama, Sensör

```

🧩 Arduino ile Modül Kullanımı: Servo Motor

13:01 Arduino, Servo Motor, Modül Kullanımı, Robotik, Elektronik, Proje, Kodlama, Arduino Projeleri 0 Yorum

🧩 Arduino ile Modül Kullanımı: Servo Motor

Herkese merhaba Arduino severler! Bu yazımızda, Arduino projelerinizde sıklıkla kullanacağınız servo motorları yakından tanıyacağız. Servo motorlar, hassas hareket kontrolü gerektiren projelerde vazgeçilmezdir. Robot kollarından, kamera platformlarına kadar geniş bir kullanım alanına sahiptirler. Hadi gelin, bu kullanışlı modülü Arduino ile nasıl kontrol edeceğimize birlikte bakalım.

Servo Motor Nedir?

Servo motorlar, belirli bir açıya hareket edebilen ve bu açıyı koruyabilen motorlardır. İçerisinde bir DC motor, bir dişli kutusu, bir potansiyometre ve bir kontrol devresi bulunur. Potansiyometre, motorun mevcut konumunu kontrol devresine bildirir. Kontrol devresi, istenen açıyla mevcut açı arasındaki farkı hesaplayarak motoru doğru konuma getirir.

Servo Motor Çeşitleri

Piyasada birçok farklı servo motor çeşidi bulunmaktadır. En yaygın olanları:

• Standart Servo Motorlar: Genel amaçlı kullanımlar için idealdir. 180 dereceye kadar hareket edebilirler.
• Sürekli Dönüşlü Servo Motorlar (Continuous Rotation): Belirli bir açıya gitmek yerine, sürekli olarak dönerler. Hız ve yön kontrolü yapılabilir. Robot tekerlekleri gibi uygulamalarda kullanılırlar.
• Mikro Servo Motorlar: Küçük ve hafiftirler. Küçük robotlar veya model uçaklarda tercih edilirler.

Arduino ile Servo Motor Bağlantısı

Servo motoru Arduino'ya bağlamak oldukça basittir. Genellikle üç kablosu bulunur:

• GND (Toprak): Genellikle siyah veya kahverengi renktedir. Arduino'nun GND pinine bağlanır.
• VCC (Güç): Genellikle kırmızı renktedir. Servo motorun çalışma voltajına uygun bir güç kaynağına (genellikle 5V) bağlanır. Arduino'nun 5V pinine bağlanabilir.
• Sinyal (Kontrol): Genellikle sarı veya turuncu renktedir. Arduino'nun bir dijital pinine (PWM özelliği olan bir pin tercih edilir) bağlanır.

Özetlemek gerekirse:

Servo Motor GND pini -> Arduino GND pini
Servo Motor VCC pini -> Arduino 5V pini
Servo Motor Sinyal pini -> Arduino Dijital Pin (Örneğin 9. pin)

Arduino Servo Motor Kontrol Kodu

Şimdi, servo motoru Arduino ile kontrol etmek için basit bir örnek kod yazalım:

#include <Servo.h>

Servo servoMotor;  // Servo nesnesi oluştur

int servoPin = 9;    // Servo motorun bağlı olduğu pin
int aci = 0;       // Servo motorun açısı

void setup() {
  servoMotor.attach(servoPin);  // Servo motoru belirtilen pine bağla
  Serial.begin(9600); // Seri iletişimi başlat
}

void loop() {
  // 0 dereceden 180 dereceye kadar dön
  for (aci = 0; aci <= 180; aci++) {
    servoMotor.write(aci); // Servo motoru belirtilen açıya ayarla
    Serial.print("Aci: ");
    Serial.println(aci);
    delay(15);            // Kısa bir süre bekle
  }

  // 180 dereceden 0 dereceye kadar dön
  for (aci = 180; aci >= 0; aci--) {
    servoMotor.write(aci); // Servo motoru belirtilen açıya ayarla
    Serial.print("Aci: ");
    Serial.println(aci);
    delay(15);            // Kısa bir süre bekle
  }
}

Bu kod, servo motoru önce 0 dereceden 180 dereceye, sonra da 180 dereceden 0 dereceye döndürür. Serial monitör yardımı ile açı değerlerini takip edebilirsiniz. `Servo.h` kütüphanesi, servo motorları kontrol etmek için gerekli fonksiyonları içerir. `servoMotor.attach(servoPin)` fonksiyonu, servo motoru belirtilen pine bağlar. `servoMotor.write(aci)` fonksiyonu, servo motoru istenen açıya ayarlar.

Kodun Açıklaması

• `#include <Servo.h>`: Servo kütüphanesini projeye dahil eder.
• `Servo servoMotor;`: Bir Servo nesnesi oluşturur. Bu nesne üzerinden servo motoru kontrol edeceğiz.
• `int servoPin = 9;`: Servo motorun bağlı olduğu dijital pini belirtir.
• `servoMotor.attach(servoPin);`: Servo motoru belirtilen pine bağlar.
• `servoMotor.write(aci);`: Servo motoru istenen `aci` değerine (0-180 derece arası) hareket ettirir.
• `delay(15);`: Her açı değişiminden sonra kısa bir süre bekler. Bu, servo motorun istenen konuma ulaşması için gereklidir.

Projelerinizde Servo Motorları Kullanma İpuçları

• Servo motorun çalışma voltajına dikkat edin ve Arduino'nun 5V pinini kullanırken, motorun gerektirdiği akımı aşmadığınızdan emin olun. Gerekirse harici bir güç kaynağı kullanın.
• Servo motoru hareket ettirirken, ani ve büyük açı değişikliklerinden kaçının. Bu, motorun zarar görmesine neden olabilir.
• Servo motorun montajı için uygun bağlantı elemanları kullanın. Titreşimleri azaltmak için kauçuk veya sünger yastıklar kullanabilirsiniz.
• Arduino'nun PWM (Pulse Width Modulation) özellikli pinlerini (genellikle ~ işaretiyle belirtilir) kullanarak servo motoru daha hassas bir şekilde kontrol edebilirsiniz.

Umarım bu yazı, servo motorları Arduino projelerinizde kullanmaya başlamanız için size yardımcı olmuştur. Başarılar dilerim!

Etiketler: Arduino, Servo Motor, Modül Kullanımı, Robotik, Elektronik, Proje, Kodlama, Arduino Projeleri

```

🧩 Arduino ile Modül Kullanımı: Buzzer

13:02 arduino, buzzer, modül, elektronik, proje, sensör, ses, turkce 0 Yorum

🧩 Arduino ile Modül Kullanımı: Buzzer

Merhaba Arduino severler!

Bu yazımızda, Arduino projelerinizde sıklıkla kullanacağınız basit ama etkili bir modül olan buzzer'ı inceleyeceğiz. Buzzer, basitçe ses üreten bir elektronik bileşendir. Uyarı sesleri, basit melodiler veya geri bildirimler için harika bir seçenektir. Hadi başlayalım!

Buzzer Nedir?

Buzzer, üzerine uygulanan elektrik akımı ile ses çıkaran bir elemandır. İki temel türü vardır:

• Aktif Buzzer: İçinde bir osilatör devresi bulunur. Sadece enerji verdiğinizde ses çıkarır.
• Pasif Buzzer: Sesi kendisi üretemez. Arduino'dan gelen bir sinyali kullanarak ses üretir. Farklı frekanslarda sinyaller göndererek farklı tonlarda sesler elde edebilirsiniz. Biz bu yazımızda pasif buzzer'ı kullanacağız.

Gerekli Malzemeler

Bu projeyi gerçekleştirmek için aşağıdaki malzemelere ihtiyacınız olacak:

• Arduino kartı (Uno, Nano, Mega vb.)
• Pasif Buzzer
• Jumper kablolar
• Breadboard (isteğe bağlı)

Bağlantı Şeması

Buzzer'ı Arduino'ya bağlamak oldukça basittir. Aşağıdaki bağlantı şemasını takip edebilirsiniz:

• Buzzer'ın (+) bacağı -> Arduino'nun dijital pinlerinden birine (örneğin, 8. pine)
• Buzzer'ın (-) bacağı -> Arduino'nun GND (Toprak) pinine

Daha net bir ifadeyle:

• Buzzer (+) pin -> Arduino Digital Pin 8
• Buzzer (-) pin -> Arduino GND

Breadboard kullanarak bağlantıları daha düzenli hale getirebilirsiniz.

Arduino Kodu

Şimdi de buzzer'ı kontrol etmek için kullanacağımız Arduino koduna göz atalım:

 const int buzzerPin = 8; // Buzzer'ın bağlı olduğu pin

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

 void loop() {
  // Buzzer'dan basit bir ses çıkarma
  tone(buzzerPin, 1000); // 1000 Hz frekansında ses üret
  delay(500);           // 500 milisaniye bekle
  noTone(buzzerPin);     // Sesi kapat
  delay(500);           // 500 milisaniye bekle
 }
 

Kodun Açıklaması:

• const int buzzerPin = 8;: Buzzer'ın bağlı olduğu pin numarasını tanımlıyoruz.
• pinMode(buzzerPin, OUTPUT);: Buzzer pinini çıkış olarak ayarlıyoruz.
• tone(buzzerPin, 1000);: Buzzer'dan 1000 Hz frekansında ses çıkarıyoruz. tone() fonksiyonu, belirtilen pinden belirtilen frekansta bir sinyal üretir.
• delay(500);: 500 milisaniye (yarım saniye) bekliyoruz.
• noTone(buzzerPin);: Buzzer'dan sesi kapatıyoruz.
• delay(500);: Tekrar 500 milisaniye bekliyoruz.

Farklı Sesler Üretmek

tone() fonksiyonuna farklı frekans değerleri vererek farklı tonlarda sesler elde edebilirsiniz. Örneğin:

 tone(buzzerPin, 440); // A notası
 delay(500);
 tone(buzzerPin, 880); // A notası (bir oktav yüksek)
 delay(500);
 noTone(buzzerPin);
 delay(500);
 

Bu kodu kullanarak farklı notalarda basit melodiler oluşturabilirsiniz. İnternette çeşitli notaların frekans değerlerini bulabilirsiniz.

Proje Önerileri

Buzzer'ı kullanarak birçok farklı proje geliştirebilirsiniz. İşte birkaç öneri:

• Alarm Sistemi: Sensörlerden gelen verilere göre alarm çalmasını sağlayabilirsiniz.
• Basit Oyunlar: Butonlara basıldığında farklı sesler çıkaran bir oyun tasarlayabilirsiniz.
• Geri Bildirim Sistemi: Bir işlem tamamlandığında veya bir hata oluştuğunda sesli geri bildirim sağlayabilirsiniz.

Sonuç

Bu yazımızda Arduino ile buzzer modülünü nasıl kullanacağımızı öğrendik. Umarım bu bilgiler, Arduino projelerinizde size yardımcı olur. İyi eğlenceler!

Etiketler: arduino, buzzer, modül, elektronik, proje, sensör, ses, turkce

```

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

13:01 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

🔁 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ıç

```

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

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

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

```

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

13:01 analog , analog Giris , Analog Giriş , analogread , arduino , eğitim , elektronik , potansiyometre , proje , sensör 0 Yorum

🌡️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

```

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

13:02 arduino , digitalRead , digitalWrite , Dijital Çıkış , Dijital Giriş , elektronik , led , Mikrodenetleyici , pinMode , sensör 0 Yorum

💡 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

```

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

13:02 arduino , Arduino başlangıç , arduino değişkenler , arduino dersleri , C , c değişkenler , C++ , değişkenler , Programlama , variables , Veri Tipleri 0 Yorum

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ıç

```

Arduino Programlama Dili: Temel Yapılar (Loop)

13:02 arduino , arduino dersleri , Arduino Temelleri , do-while , Döngü , for , loop , Programlama , while 0 Yorum

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

```