arduino etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster

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

```

Devamını oku

💡 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

```

Devamını oku

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

```

Devamını oku

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

```

Devamını oku

Arduino Programlama Dili: Temel Yapılar (Setup)

Merhaba Arduino severler!

Bu yazımızda Arduino programlamanın temel taşlarından biri olan setup() fonksiyonunu derinlemesine inceleyeceğiz. Arduino dünyasına yeni adım attıysanız veya bilgilerinizi tazelemek istiyorsanız, doğru yerdesiniz. Hazırsanız, başlayalım!

Setup Fonksiyonu Nedir?

Arduino kartınızın beyni olan mikrodenetleyici, enerji verildiğinde veya resetlendiğinde ilk olarak setup() fonksiyonunu çalıştırır. Bu fonksiyon, programınızın temelini oluşturur ve kartınızın başlangıç ayarlarını (pin modları, seri iletişim, vb.) yapılandırmak için kullanılır. Bir nevi, Arduino projenizin "hazırlık aşaması"dır diyebiliriz.

Setup Fonksiyonunun Sözdizimi

setup() fonksiyonu, C++ temelli Arduino dilinde aşağıdaki gibi tanımlanır:


 void setup() {
   // Buraya ayarlarınızı yazın
 }

Gördüğünüz gibi, setup() fonksiyonu herhangi bir değer döndürmez (void) ve herhangi bir parametre almaz. İçine yazdığınız kodlar, sadece bir kez, programın başında çalıştırılır.

Setup Fonksiyonunda Neler Yapabiliriz?

setup() fonksiyonunda yapabileceklerinizin sınırı yoktur, ancak en sık kullanılan işlemler şunlardır:

Pin Modlarını Ayarlama: Pinleri giriş (INPUT) veya çıkış (OUTPUT) olarak tanımlayabilirsiniz. Örneğin, bir LED'i kontrol etmek için bir pini çıkış olarak ayarlayabilirsiniz.
Seri İletişimi Başlatma: Arduino'nun bilgisayarınızla veya diğer cihazlarla iletişim kurmasını sağlamak için seri iletişimi başlatabilirsiniz (Serial.begin()).
LCD Ekranı Başlatma: Bir LCD ekran kullanıyorsanız, ekranı başlatabilir ve temel ayarlarını yapabilirsiniz.
Sensörleri Başlatma: Bağladığınız sensörlerin başlangıç ayarlarını yapabilir ve kalibrasyon işlemlerini gerçekleştirebilirsiniz.
Değişkenleri Başlatma: Programınızın kullanacağı değişkenlere başlangıç değerleri atayabilirsiniz.

Örneklerle setup() Fonksiyonu

Şimdi birkaç örnekle setup() fonksiyonunun nasıl kullanıldığına bakalım.

Örnek 1: LED Yakıp Söndürme

Bu örnekte, 13 numaralı pine bağlı bir LED'i yakıp söndüreceğiz. İlk olarak, setup() fonksiyonunda 13 numaralı pini çıkış olarak ayarlamamız gerekiyor. Devre bağlantısı ise şu şekilde:

LED'in anot (+) ucu -> 220 ohm direnç -> Arduino'nun 13 numaralı pini
LED'in katot (-) ucu -> Arduino'nun GND pini


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

 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 kodda, pinMode(13, OUTPUT); satırı setup() fonksiyonunda yer alıyor ve 13 numaralı pini çıkış olarak ayarlıyor. loop() fonksiyonu ise sürekli çalışarak LED'i yakıp söndürme işlemini gerçekleştiriyor.

Örnek 2: Seri İletişimi Başlatma

Bu örnekte, Arduino'nun bilgisayarınızla seri iletişim kurmasını sağlayacağız. setup() fonksiyonunda Serial.begin() fonksiyonunu kullanarak seri iletişimi başlatmamız gerekiyor. Bağlantı gerektirmeyen bu örnek sadece kod ile yapılır.


 void setup() {
   Serial.begin(9600); // Seri iletişimi 9600 baud hızında başlat
 }

 void loop() {
   Serial.println("Merhaba, Arduino!"); // Seri port ekranına mesaj yazdır
   delay(1000);                      // 1 saniye bekle
 }

Bu kodda, Serial.begin(9600); satırı setup() fonksiyonunda yer alıyor ve seri iletişimi 9600 baud hızında başlatıyor. loop() fonksiyonu ise sürekli olarak seri port ekranına "Merhaba, Arduino!" mesajını yazdırıyor.

Sonuç

setup() fonksiyonu, Arduino projelerinizin temelini oluşturur ve kartınızın başlangıç ayarlarını yapılandırmak için hayati öneme sahiptir. Bu yazımızda, setup() fonksiyonunun ne olduğunu, nasıl kullanıldığını ve örneklerle nasıl uygulandığını detaylı bir şekilde inceledik. Umarım bu bilgiler, Arduino yolculuğunuzda size yardımcı olur.

Bir sonraki yazımızda, Arduino programlamanın diğer önemli bir yapısı olan loop() fonksiyonunu inceleyeceğiz. Takipte kalın!

Etiketler: Arduino, Programlama, Setup, Temel Yapılar, C++, Mikrodenetleyici, Eğitim, Başlangıç, Arduino setup fonksiyonu

```

Devamını oku

🧠 Arduino IDE ve Alternatifleri: Kurulum ve İlk Kod

Merhaba sevgili Arduino severler! Bu yazımızda, elektronik projeler dünyasına adım atmanın en temel adımlarından biri olan Arduino IDE kurulumunu ve ilk kodumuzu yazmayı ele alacağız. Ayrıca, Arduino IDE'ye alternatif bazı geliştirme ortamlarına da göz atacağız. Hazırsanız, başlayalım!

Arduino IDE: Nedir ve Neden Kullanmalıyız?

Arduino IDE (Entegre Geliştirme Ortamı), Arduino kartlarımızı programlamak için kullandığımız ücretsiz ve açık kaynaklı bir yazılımdır. Kullanıcı dostu arayüzü sayesinde, hem yeni başlayanlar hem de deneyimli kullanıcılar için ideal bir seçenektir. Arduino IDE ile kod yazabilir, derleyebilir ve Arduino kartımıza yükleyebiliriz.

Arduino IDE Kurulumu

Arduino IDE'yi kurmak oldukça basittir. İşte adım adım kurulum rehberi:

Arduino'nun Resmi Web Sitesini Ziyaret Edin: https://www.arduino.cc/en/software adresine gidin.
İşletim Sistemine Uygun Sürümü İndirin: Windows, macOS veya Linux işletim sisteminize uygun olan sürümü seçerek indirin.
Kurulum Dosyasını Çalıştırın: İndirdiğiniz kurulum dosyasını çalıştırın ve ekrandaki yönergeleri takip edin. Genellikle "Next" (İleri) butonuna tıklayarak ve lisans sözleşmesini kabul ederek kurulumu tamamlayabilirsiniz.
Sürücüleri Yükleyin (Gerekirse): Kurulum tamamlandıktan sonra, Arduino kartınızı bilgisayarınıza bağlayın. Windows kullanıcıları için, Arduino sürücülerinin otomatik olarak yüklenmesi gerekebilir. Eğer sürücüler otomatik olarak yüklenmezse, Arduino IDE'nin kurulu olduğu klasördeki "drivers" klasöründen sürücüleri manuel olarak yükleyebilirsiniz.

İlk Kodumuz: "Hello World" (Blink Örneği)

Her programlama dilinde olduğu gibi, Arduino'da da ilk kodumuz genellikle "Hello World" olarak bilinir. Arduino dünyasındaki "Hello World" karşılığı ise, kart üzerindeki LED'i yakıp söndürmektir (Blink örneği). İşte Blink örneğinin kodu:


 void setup() {
  // LED'in bağlı olduğu pini çıkış olarak ayarla
  pinMode(LED_BUILTIN, OUTPUT);
 }

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

Kodun Açıklaması:

void setup(): Bu fonksiyon, programın başında sadece bir kez çalışır. Burada, LED'in bağlı olduğu pini (LED_BUILTIN) çıkış olarak ayarlıyoruz.
void loop(): Bu fonksiyon, program çalıştığı sürece sürekli olarak tekrar eder. Burada, LED'i yakıp söndürme işlemlerini gerçekleştiriyoruz.
digitalWrite(LED_BUILTIN, HIGH): LED'i yakar (pini yüksek voltaja ayarlar).
digitalWrite(LED_BUILTIN, LOW): LED'i söndürür (pini düşük voltaja ayarlar).
delay(1000): 1000 milisaniye (1 saniye) bekler.

Arduino Kartına Yükleme:

Arduino kartınızı bilgisayarınıza USB kablosu ile bağlayın.
Arduino IDE'de, "Araçlar" menüsünden kartınızı (Örneğin, "Arduino Uno") ve portunuzu (Örneğin, "COM3" veya "/dev/ttyACM0") seçin.
Yukarıdaki kodu Arduino IDE'ye yapıştırın.
"Yükle" butonuna tıklayın (sağ üst köşedeki ok işareti).
Yükleme tamamlandıktan sonra, Arduino kartınız üzerindeki LED'in yanıp söndüğünü göreceksiniz.

Blink Devresi (Harici LED ile)

Eğer dahili LED yerine harici bir LED kullanmak isterseniz, aşağıdaki bağlantıları yapmanız gerekecektir:

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

Bu durumda kodunuzda LED_BUILTIN yerine 13 kullanmalısınız:


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

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

Arduino IDE Alternatifleri

Arduino IDE, başlangıç için harika bir seçenek olsa da, daha gelişmiş özelliklere ihtiyaç duyan kullanıcılar için bazı alternatifler de bulunmaktadır. İşte bazı popüler Arduino IDE alternatifleri:

PlatformIO IDE: Daha gelişmiş bir geliştirme ortamıdır. VS Code, Atom gibi popüler editörlerle entegre çalışabilir. Proje yönetimi, kütüphane yönetimi ve hata ayıklama gibi konularda daha gelişmiş özellikler sunar.
Visual Micro: Visual Studio içerisinde Arduino projeleri geliştirmek için bir eklentidir. Visual Studio'nun tüm avantajlarından faydalanmanızı sağlar.
Codebender: Web tabanlı bir Arduino IDE'dir. Herhangi bir kurulum gerektirmez ve projelerinizi bulutta saklayabilirsiniz.
Tinkercad Circuits: Başlangıç seviyesi için harika bir seçenek. Hem devre tasarımı hem de kod yazma imkanı sunar. Simülasyon özelliği sayesinde, projelerinizi fiziksel olarak kurmadan test edebilirsiniz.

Sonuç

Bu yazımızda, Arduino IDE kurulumunu, ilk kodumuzu yazmayı ve alternatif geliştirme ortamlarını inceledik. Umarız bu bilgiler, Arduino dünyasına adım atmanıza yardımcı olur. Unutmayın, elektronik projeler dünyası sonsuz olasılıklarla dolu! Denemekten, öğrenmekten ve yaratmaktan çekinmeyin!

Etiketler: Arduino, Arduino IDE, Arduino Kurulumu, İlk Kod, Blink, PlatformIO, Visual Micro, Codebender, Tinkercad, Elektronik Projeler, Arduino Dersleri

```

Devamını oku

🔌 Arduino Nedir? Nasıl Çalışır? Başlangıç Rehberi

Merhaba sevgili Arduino meraklıları! Elektronikle uğraşmaya yeni başlayan ya da sadece merak eden herkes için Arduino, harika bir başlangıç noktasıdır. Bu yazıda, Arduino'nun ne olduğunu, nasıl çalıştığını ve temel prensiplerini en basit haliyle anlatmaya çalışacağım. Hazırsanız, elektronik dünyaya adım atalım!

Arduino Nedir?

Arduino, kullanımı kolay bir donanım (hardware) ve yazılım (software) platformudur. Temelde, bir mikrodenetleyici (microcontroller) içeren bir geliştirme kartıdır. Bu kart sayesinde, sensörlerden veri okuyabilir, motorları kontrol edebilir, LED'leri yakıp söndürebilir ve aklınıza gelebilecek birçok elektronik projeyi gerçekleştirebilirsiniz. Arduino'nun en büyük avantajı, programlanmasının kolay olması ve geniş bir topluluğa sahip olmasıdır.

Arduino Nasıl Çalışır?

Arduino'nun çalışma prensibi oldukça basittir. Arduino kartı üzerinde bulunan mikrodenetleyici, kendisine yüklenen programı (sketch) çalıştırır. Bu program, Arduino'nun giriş (input) ve çıkış (output) pinlerini kontrol eder. Giriş pinleri, sensörlerden gelen verileri okumak için kullanılırken, çıkış pinleri ise LED'leri, motorları veya diğer elektronik bileşenleri kontrol etmek için kullanılır.

Temel Bileşenler

Bir Arduino kartı genellikle şu temel bileşenlerden oluşur:

Mikrodenetleyici (Microcontroller): Arduino'nun beyni olan bu çip, programınızı çalıştırır. Genellikle ATMega serisi mikrodenetleyiciler kullanılır.
Giriş/Çıkış Pinleri (I/O Pins): Sensörlerden veri almak veya elektronik bileşenleri kontrol etmek için kullanılır. Dijital (digital) ve analog (analog) olmak üzere iki tür pini bulunur.
USB Portu: Arduino'yu bilgisayara bağlamak ve program yüklemek için kullanılır. Aynı zamanda Arduino'ya güç de sağlayabilir.
Güç Girişi (Power Input): Arduino'yu harici bir güç kaynağı ile beslemek için kullanılır.
Reset Butonu: Arduino'yu sıfırlamak ve programı yeniden başlatmak için kullanılır.

Arduino ile İlk Proje: LED Yakıp Söndürme

Arduino ile yapılabilecek en basit projelerden biri, bir LED'i yakıp söndürmektir. Bu projeyi gerçekleştirmek için aşağıdaki adımları izleyebilirsiniz:

Gerekli Malzemeler:
- Arduino kartı (Örneğin, Arduino Uno)
- LED
- 220 ohm direnç (LED'i korumak için)
- Jumper kablolar
Devreyi Kurulumu: Aşağıdaki bağlantıları kullanarak devreyi kurun:
- LED'in uzun bacağı (anot) -> 220 ohm direncin bir bacağı
- 220 ohm direncin diğer bacağı -> Arduino'nun 13 numaralı dijital pini
- LED'in kısa bacağı (katot) -> Arduino'nun GND (toprak) pini

Programı Yazma: Arduino IDE'yi açın ve aşağıdaki kodu yazın:


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

void loop() {
  // 13 numaralı pini yüksek (HIGH) yap (LED'i yak)
  digitalWrite(13, HIGH);
  // 1 saniye bekle
  delay(1000);
  // 13 numaralı pini düşük (LOW) yap (LED'i söndür)
  digitalWrite(13, LOW);
  // 1 saniye bekle
  delay(1000);
}

Programı Yükleme: Arduino'yu bilgisayarınıza bağlayın, Arduino IDE'de doğru portu seçin ve programı yükleyin.
Sonuç: LED'inizin 1 saniye aralıklarla yanıp söndüğünü göreceksiniz!

Arduino IDE Nedir?

Arduino IDE (Integrated Development Environment), Arduino programlarını yazmak, derlemek ve Arduino kartına yüklemek için kullanılan bir yazılımdır. Arduino'nun resmi web sitesinden ücretsiz olarak indirilebilir. IDE, basit ve kullanıcı dostu bir arayüze sahiptir ve yeni başlayanlar için idealdir.

Nereden Başlamalıyım?

Arduino ile başlamak için aşağıdaki kaynakları kullanabilirsiniz:

Arduino'nun Resmi Web Sitesi: Arduino hakkında detaylı bilgi, dokümantasyon ve örnek projeler içerir.
Arduino Kitleri: Yeni başlayanlar için hazırlanmış, gerekli malzemeleri ve projeleri içeren başlangıç kitleri mevcuttur.
Online Eğitimler: YouTube, Udemy gibi platformlarda Arduino ile ilgili birçok ücretsiz ve ücretli eğitim bulabilirsiniz.
Arduino Forumları ve Topluluklar: Sorularınızı sorabileceğiniz, deneyimlerinizi paylaşabileceğiniz ve projeleriniz için ilham alabileceğiniz birçok online topluluk bulunmaktadır.

Umarım bu yazı, Arduino'nun ne olduğunu ve nasıl çalıştığını anlamanıza yardımcı olmuştur. Unutmayın, elektronik dünyası sonsuz olasılıklarla dolu! Denemekten, öğrenmekten ve projeler üretmekten çekinmeyin. Başarılar dilerim!

Etiketler: arduino, elektronik, mikrodenetleyici, proje, başlangıç, led, kodlama, sensör, arduino ide

```

Devamını oku

LCD Ekranlı Mini Oyun: Tahmin Etmece (Buton Kontrollü)

Herkese merhaba Arduino severler! Bugün, hem eğlenceli hem de öğretici bir projeye imza atacağız: LCD ekran ve butonlar kullanarak tahmin etmece oyunu geliştireceğiz. Bu proje sayesinde hem LCD ekran kullanımını, hem buton okumayı, hem de temel programlama mantığını pekiştireceğiz. Hazırsanız, malzemeleri hazırlayın ve kodlamaya başlayalım!

Gerekli Malzemeler

Arduino Uno (veya benzeri bir Arduino kartı)
16x2 LCD Ekran
3 adet Buton
10K Ohm Direnç (3 adet)
10K Ohm Potansiyometre
Breadboard
Jumper Kablolar

Devre Şeması

Devremizi kurarken aşağıdaki bağlantıları dikkatlice yapalım:

LCD Ekran Bağlantıları:
- LCD VSS pin -> Arduino GND
- LCD VDD pin -> Arduino 5V
- LCD VO (Contrast) pin -> Potansiyometrenin orta bacağı (Potansiyometrenin diğer iki bacağı 5V ve GND'ye bağlanacak)
- LCD RS pin -> Arduino Pin 12
- LCD Enable pin -> Arduino Pin 11
- LCD D4 pin -> Arduino Pin 5
- LCD D5 pin -> Arduino Pin 4
- LCD D6 pin -> Arduino Pin 3
- LCD D7 pin -> Arduino Pin 2
- LCD A (Anode) pin -> Arduino 5V (direnç üzerinden bağlanabilir)
- LCD K (Cathode) pin -> Arduino GND
Buton Bağlantıları:
- Her bir butonun bir bacağı -> Arduino Dijital Pin 8, 9 ve 10 (sırasıyla)
- Her bir butonun diğer bacağı -> GND (ve 10K Ohm direnç ile Arduino 5V'a pull-up yapılarak)

Açıklama: Butonlar, pull-up dirençler sayesinde normalde HIGH durumunda olacaklar. Butona basıldığında ise LOW sinyali Arduino'ya iletilecek.

Arduino Kodu

Şimdi de kod kısmına geçelim. Aşağıdaki kodu Arduino IDE'sine kopyalayın ve kartınıza yükleyin.


 #include <LiquidCrystal.h>

 // LCD pinleri
 const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
 LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

 // Buton pinleri
 const int buttonUpPin = 8;
 const int buttonDownPin = 9;
 const int buttonEnterPin = 10;

 int randomNumber;
 int guess;
 bool gameStarted = false;

 void setup() {
  lcd.begin(16, 2);
  pinMode(buttonUpPin, INPUT_PULLUP);
  pinMode(buttonDownPin, INPUT_PULLUP);
  pinMode(buttonEnterPin, INPUT_PULLUP);

  lcd.print("Tahmin Etmece!");
  lcd.setCursor(0, 1);
  lcd.print("Baslamak icin OK");
  randomSeed(analogRead(A0)); // Rastgele sayı üretimi için seed
 }

 void loop() {
  if (!gameStarted) {
   if (digitalRead(buttonEnterPin) == LOW) {
    startGame();
   }
  } else {
   checkButtons();
   displayGuess();
  }
 }

 void startGame() {
  gameStarted = true;
  randomNumber = random(1, 101); // 1 ile 100 arasında rastgele sayı
  guess = 50; // Başlangıç tahmini
  lcd.clear();
  lcd.print("Tahmin: ");
 }

 void checkButtons() {
  if (digitalRead(buttonUpPin) == LOW) {
   delay(100); // Buton debounce
   if (guess < 100) {
    guess++;
   }
  }
  if (digitalRead(buttonDownPin) == LOW) {
   delay(100); // Buton debounce
   if (guess > 1) {
    guess--;
   }
  }
  if (digitalRead(buttonEnterPin) == LOW) {
   delay(100); // Buton debounce
   checkGuess();
  }
 }

 void displayGuess() {
  lcd.setCursor(8, 0);
  lcd.print(guess);
  lcd.print("  "); // Sayıyı temizlemek için
 }

 void checkGuess() {
  if (guess == randomNumber) {
   lcd.clear();
   lcd.print("Tebrikler!");
   lcd.setCursor(0, 1);
   lcd.print("Bildiniz!");
   delay(2000);
   gameStarted = false;
   lcd.clear();
   lcd.print("Tekrar icin OK");
   lcd.setCursor(0, 1);
   lcd.print("Basin");


  } else if (guess < randomNumber) {
   lcd.clear();
   lcd.print("Daha Yuksek!");
   delay(1000);
   lcd.clear();
   lcd.print("Tahmin: ");
  } else {
   lcd.clear();
   lcd.print("Daha Dusuk!");
   delay(1000);
   lcd.clear();
   lcd.print("Tahmin: ");
  }
 }

Kodun Açıklaması

LiquidCrystal Kütüphanesi: LCD ekranı kullanabilmek için gerekli olan kütüphane.
Pin Tanımlamaları: LCD ve butonların bağlı olduğu pinler tanımlanıyor.
setup() Fonksiyonu: LCD ekran başlatılıyor, buton pinleri giriş olarak ayarlanıyor ve rastgele sayı üretimi için bir başlangıç değeri (seed) belirleniyor.
loop() Fonksiyonu: Oyunun ana döngüsü. Oyun başlamadıysa, "OK" butonuna basılmasını bekliyor. Oyun başladıysa, butonları kontrol ediyor ve tahmini ekrana yazdırıyor.
startGame() Fonksiyonu: Oyunu başlatıyor, rastgele bir sayı üretiyor ve ilk tahmini ayarlıyor.
checkButtons() Fonksiyonu: Butonlara basılıp basılmadığını kontrol ediyor.
displayGuess() Fonksiyonu: Mevcut tahmini LCD ekrana yazdırıyor.
checkGuess() Fonksiyonu: Tahminin doğru olup olmadığını kontrol ediyor ve kullanıcıya geri bildirim veriyor.

Oyunun Oynanışı

Arduino'yu bilgisayarınıza bağlayın ve kodu yükleyin.
LCD ekranda "Tahmin Etmece!" yazısı belirecek.
Oyunu başlatmak için "OK" butonuna basın.
Yukarı ve aşağı butonlarını kullanarak tahmininizi ayarlayın.
Tahmininizden eminseniz, "OK" butonuna basın.
Eğer tahmininiz doğruysa, "Tebrikler!" yazısı belirecek. Değilse, "Daha Yüksek!" veya "Daha Düşük!" uyarıları alacaksınız.
Tekrar oynamak için "OK" butonuna basın.

İpuçları ve Geliştirme Fikirleri

Oyuna bir zorluk seviyesi ekleyebilirsiniz (örneğin, daha geniş bir sayı aralığı).
Oyuna bir can sayısı ekleyebilirsiniz (örneğin, kullanıcı 5 hakkı olduğunda kaybedecek).
LCD ekranda kalan can sayısını gösterebilirsiniz.
Skor tablosu ekleyerek en iyi skorları saklayabilirsiniz.

Umarım bu proje sizin için faydalı olmuştur. İyi eğlenceler ve kodlamalar!

Etiketler: Arduino, LCD, Buton, Tahmin Etmece, Oyun, Proje, Elektronik, Kodlama, Hobi, Öğrenme

```

Devamını oku

Arduino ile Uyan: Titreşimli Bileklik Alarm Sistemi

Günaydın arkadaşlar! Bugün sizlere Arduino kullanarak nasıl titreşimli bir bileklik alarm sistemi yapacağımızı anlatacağım. Bu proje, özellikle sabahları uyanmakta zorlananlar veya sessiz bir alarm arayanlar için harika bir çözüm olabilir. Gelin, adım adım bu projeyi nasıl hayata geçirebileceğimize birlikte bakalım.

Proje Amacı

Amacımız, belirlenen saatte titreşim motorunu çalıştırarak kullanıcıyı uyandırmak. Bu sayede, hem gürültüsüz bir alarm elde edeceğiz, hem de Arduino'nun potansiyelini kullanarak eğlenceli bir proje geliştirmiş olacağız.

Gerekli Malzemeler

İşte projemiz için ihtiyacımız olan malzemeler:

Arduino Uno (veya benzeri bir Arduino kartı)
Titreşim motoru
DS3231 Gerçek Zaman Saati (RTC) modülü
16x2 LCD ekran (isteğe bağlı, saat bilgisini göstermek için)
Buton (alarmı ayarlamak için)
10k ohm direnç (butona bağlamak için)
Jumper kablolar
Bileklik (Titreşim motorunu ve diğer komponentleri sabitlemek için)

Devre Şeması

Devremizi kurarken aşağıdaki bağlantıları dikkatlice yapalım:

Titreşim Motoru:
- Titreşim Motoru (+) -> Arduino Dijital Pin 8
- Titreşim Motoru (-) -> Arduino GND
DS3231 RTC Modülü:
- RTC VCC -> Arduino 5V
- RTC GND -> Arduino GND
- RTC SDA -> Arduino A4 (SDA)
- RTC SCL -> Arduino A5 (SCL)
LCD Ekran (isteğe bağlı):
- LCD VSS -> Arduino GND
- LCD VDD -> Arduino 5V
- LCD VO -> Potansiyometre orta bacağı (kontrast ayarı için)
- LCD RS -> Arduino Dijital Pin 12
- LCD EN -> Arduino Dijital Pin 11
- LCD D4 -> Arduino Dijital Pin 5
- LCD D5 -> Arduino Dijital Pin 4
- LCD D6 -> Arduino Dijital Pin 3
- LCD D7 -> Arduino Dijital Pin 2
- LCD A -> Arduino 5V (direnç üzerinden)
- LCD K -> Arduino GND
Buton:
- Buton bir bacağı -> Arduino Dijital Pin 9
- Buton diğer bacağı -> Arduino 5V (10k ohm direnç ile GND'ye çekilir)

Arduino Kodu

Şimdi de Arduino kodumuzu inceleyelim. Bu kod, RTC modülünden saat bilgisini alacak, belirlenen alarm saatine ulaşıldığında titreşim motorunu çalıştıracak ve LCD ekranda (isteğe bağlı) saat bilgisini gösterecektir.


#include <Wire.h>
#include <RTClib.h>
#include <LiquidCrystal.h> // LCD ekran kullanıyorsanız bu kütüphaneyi ekleyin

// RTC modülü için nesne oluştur
RTC_DS3231 rtc;

// LCD pin tanımlamaları (isteğe bağlı)
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

// Titreşim motoru pini
const int vibrationPin = 8;

// Buton pini
const int buttonPin = 9;

// Alarm saati
int alarmHour = 7;
int alarmMinute = 0;

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

  // RTC modülünü başlat
  if (! rtc.begin()) {
    Serial.println("RTC bulunamadı!");
    while (1);
  }

  // LCD ekranı başlat (isteğe bağlı)
  lcd.begin(16, 2);
  lcd.print("Titreşimli Alarm");

  // Titreşim motoru pinini çıkış olarak ayarla
  pinMode(vibrationPin, OUTPUT);

  // Buton pinini giriş olarak ayarla ve pull-up direncini etkinleştir
  pinMode(buttonPin, INPUT_PULLUP);

  // İlk alarm saatini ayarla (isteğe bağlı)
  // rtc.adjust(DateTime(2024, 10, 27, 7, 0, 0)); // Yıl, Ay, Gün, Saat, Dakika, Saniye
}

void loop() {
  // Saat bilgisini al
  DateTime now = rtc.now();

  // Saat bilgisini seri port ekranında göster (isteğe bağlı)
  Serial.print(now.year(), DEC);
  Serial.print('/');
  Serial.print(now.month(), DEC);
  Serial.print('/');
  Serial.print(now.day(), DEC);
  Serial.print(" (");
  Serial.print(dayStr(now.dayOfTheWeek()));
  Serial.print(") ");
  Serial.print(now.hour(), DEC);
  Serial.print(':');
  Serial.print(now.minute(), DEC);
  Serial.print(':');
  Serial.println(now.second(), DEC);

  // Saat bilgisini LCD ekranda göster (isteğe bağlı)
  lcd.setCursor(0, 1);
  lcd.print(now.hour());
  lcd.print(":");
  if (now.minute() < 10) {
    lcd.print("0");
  }
  lcd.print(now.minute());
  lcd.print(":");
  if (now.second() < 10) {
    lcd.print("0");
  }
  lcd.print(now.second());

  // Alarm kontrolü
  if (now.hour() == alarmHour && now.minute() == alarmMinute && now.second() == 0) {
    // Alarmı çal (titreşim motorunu çalıştır)
    Serial.println("Alarm Çalıyor!");
    digitalWrite(vibrationPin, HIGH);
    delay(5000); // 5 saniye titreşim
    digitalWrite(vibrationPin, LOW);

    // Butona basılana kadar bekle
    while (digitalRead(buttonPin) == HIGH) {
      delay(100);
    }
    Serial.println("Alarm Susturuldu!");
  }

  delay(1000);
}

// Gün isimlerini döndüren fonksiyon
char* dayStr(int day) {
  switch (day) {
    case 0: return "Pazar";
    case 1: return "Pazartesi";
    case 2: return "Salı";
    case 3: return "Çarşamba";
    case 4: return "Perşembe";
    case 5: return "Cuma";
    case 6: return "Cumartesi";
    default: return "Bilinmiyor";
  }
}

Kodu Açıklayalım

Kütüphaneler: `Wire.h` (I2C iletişimi için), `RTClib.h` (RTC modülü için), `LiquidCrystal.h` (LCD ekran için).
Pin Tanımlamaları: Kullanılan pinlerin tanımları yapılıyor.
RTC Başlatma: `setup()` fonksiyonunda RTC modülü başlatılıyor ve eğer bulunamazsa hata mesajı veriliyor.
LCD Başlatma: Eğer LCD kullanılıyorsa, LCD ekran başlatılıyor.
Alarm Kontrolü: `loop()` fonksiyonunda sürekli olarak saat bilgisi kontrol ediliyor ve alarm saatine ulaşıldığında titreşim motoru çalıştırılıyor.
Buton Kontrolü: Alarm çaldıktan sonra butona basılana kadar bekleniyor ve butona basıldığında alarm susturuluyor.

Proje Uygulaması ve İpuçları

Projeyi bilekliğe monte ederken, titreşim motorunun cilde temas etmesini sağlayın. Bu, titreşimin daha iyi hissedilmesini sağlayacaktır. Ayrıca, kabloların sağlam bir şekilde bağlandığından emin olun. Pil ömrünü uzatmak için, Arduino'nun uyku modunu kullanabilirsiniz.

Bu proje, Arduino ile basit bir alarm sistemi yapmanın güzel bir örneği. Umarım beğenirsiniz ve kendi projelerinizde kullanırsınız. Başarılar dilerim!

Etiketler: Arduino, Titreşimli Bileklik, Alarm, RTC, DS3231, Proje, Elektronik, Hobi, Öğrenci, DIY, Titreşim Motoru, Saat, Alarm Sistemi

```

Devamını oku

Arduino ile Akıllı Geri Sayım Sayacı: Sınavlar ve Egzersizler için İdeal

Merhaba sevgili Arduino severler!

Bugün sizlere, özellikle sınavlara hazırlanan öğrenciler ve düzenli egzersiz yapmak isteyenler için hayat kurtarıcı olabilecek bir projeyi tanıtacağım: Arduino ile Akıllı Geri Sayım Sayacı. Bu proje sayesinde, sınav sürelerinizi hassas bir şekilde takip edebilir, egzersiz aralıklarınızı kolayca kontrol edebilir ve zamanı daha verimli kullanabilirsiniz. Gelin, bu projeyi adım adım nasıl oluşturacağımıza birlikte bakalım.

Neden Akıllı Bir Geri Sayım Sayacına İhtiyacımız Var?

Geri sayım sayaçları, odaklanmayı ve zamanı yönetmeyi kolaylaştıran basit ama etkili araçlardır. Özellikle:

Sınavlara hazırlıkta: Deneme sınavlarını çözerken gerçek sınav süresini simüle etmek, sınav stresini azaltmaya yardımcı olur.
Egzersizlerde: Isınma, setler arası dinlenme ve soğuma sürelerini kontrol etmek, antrenman verimliliğini artırır.
Sunumlarda: Konuşma süresini aşmamak için.
Yemek pişirirken: Pişirme sürelerini hassas bir şekilde takip etmek için.

İşte bu akıllı sayaç tam da bu ihtiyaçları karşılamak için tasarlandı!

Gerekli Malzemeler

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

1 adet Arduino Uno (veya benzeri bir Arduino kartı)
1 adet 16x2 LCD Ekran
1 adet Potansiyometre (LCD ekran kontrastını ayarlamak için)
3 adet Buton (Başlat/Durdur, Arttır, Azalt)
3 adet 10k Ohm Direnç (Butonlar için)
Jumper Kablolar
Breadboard

Devre Şeması ve Bağlantılar

Devreyi kurarken aşağıdaki bağlantıları dikkatlice yapın:

LCD Ekran Bağlantıları:
- LCD RS pini -> Arduino Dijital Pin 12
- LCD Enable pini -> Arduino Dijital Pin 11
- LCD D4 pini -> Arduino Dijital Pin 5
- LCD D5 pini -> Arduino Dijital Pin 4
- LCD D6 pini -> Arduino Dijital Pin 3
- LCD D7 pini -> Arduino Dijital Pin 2
- LCD RW pini -> GND (Toprak)
- LCD VSS pini -> GND (Toprak)
- LCD VDD pini -> Arduino 5V
- LCD A pini (Arka Işık Anot) -> Arduino 5V (100-220 Ohm direnç ile)
- LCD K pini (Arka Işık Katot) -> GND (Toprak)
Potansiyometre Bağlantısı:
- Potansiyometrenin bir ucu -> Arduino 5V
- Potansiyometrenin diğer ucu -> GND (Toprak)
- Potansiyometrenin orta ucu -> LCD VO (Kontrast) pini
Buton Bağlantıları:
- Başlat/Durdur Butonu -> Arduino Dijital Pin 8 (10k Ohm direnç ile GND'ye)
- Arttır Butonu -> Arduino Dijital Pin 9 (10k Ohm direnç ile GND'ye)
- Azalt Butonu -> Arduino Dijital Pin 10 (10k Ohm direnç ile GND'ye)

Arduino Kodu

Aşağıdaki Arduino kodunu kullanarak geri sayım sayacımızı programlayabiliriz:


 #include <LiquidCrystal.h>

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

 // Buton pinlerini tanımla
 const int startStopButton = 8;
 const int increaseButton = 9;
 const int decreaseButton = 10;

 // Değişkenler
 int seconds = 0;
 int minutes = 0;
 bool isRunning = false;

 void setup() {
  // LCD'yi başlat
  lcd.begin(16, 2);
  lcd.print("Geri Sayim");
  lcd.setCursor(0, 1);
  lcd.print("Baslamak Icin");
  delay(2000);
  lcd.clear();

  // Buton pinlerini giriş olarak ayarla ve dahili pull-up dirençlerini etkinleştir
  pinMode(startStopButton, INPUT_PULLUP);
  pinMode(increaseButton, INPUT_PULLUP);
  pinMode(decreaseButton, INPUT_PULLUP);

  // Seri iletişimi başlat (isteğe bağlı, hata ayıklama için)
  Serial.begin(9600);
 }

 void loop() {
  // Buton durumlarını oku
  int startStopState = digitalRead(startStopButton);
  int increaseState = digitalRead(increaseButton);
  int decreaseState = digitalRead(decreaseButton);

  // Başlat/Durdur butonu
  if (startStopState == LOW) {
   isRunning = !isRunning;
   delay(200); // Buton sekmelerini engellemek için kısa bir gecikme
  }

  // Arttır butonu
  if (increaseState == LOW) {
   if (minutes < 59) {
     minutes++;
   } else {
    minutes = 0;
   }
   delay(200);
  }

  // Azalt butonu
  if (decreaseState == LOW) {
   if(minutes > 0) {
      minutes--;
   } else {
      minutes = 59;
   }

   delay(200);
  }

  // Geri sayım işlemi
  if (isRunning) {
   displayTime();
   delay(1000); // 1 saniye bekle
   seconds--;

   if (seconds < 0) {
    seconds = 59;
    minutes--;

    if (minutes < 0) {
     minutes = 0;
     seconds = 0;
     isRunning = false;
     lcd.clear();
     lcd.print("Sure Bitti!");
     delay(2000);
     lcd.clear();
    }
   }
  } else {
   // Sayaç durduğunda saati göster
   displayTime();
  }
 }

 // Zamanı LCD'ye yazdıran fonksiyon
 void displayTime() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Kalan Sure:");
  lcd.setCursor(0, 1);
  if (minutes < 10) {
   lcd.print("0");
  }
  lcd.print(minutes);
  lcd.print(":");
  if (seconds < 10) {
   lcd.print("0");
  }
  lcd.print(seconds);
 }

Kodu Açıklayalım

#include <LiquidCrystal.h>: LCD kütüphanesini projeye dahil eder.
Pin tanımlamaları: LCD ekran ve butonların Arduino üzerindeki pin bağlantılarını belirtir.
LiquidCrystal lcd(...): LCD ekran nesnesini oluşturur.
setup() fonksiyonu: LCD'yi başlatır, buton pinlerini giriş olarak ayarlar ve seri iletişimi başlatır (isteğe bağlı).
loop() fonksiyonu: Sürekli olarak buton durumlarını okur, geri sayım işlemini gerçekleştirir ve zamanı LCD ekrana yazdırır.
displayTime() fonksiyonu: Kalan süreyi LCD ekrana yazdırmak için kullanılır.

Projenin Kullanımı

Devreyi kurun ve kodu Arduino'ya yükleyin.
Potansiyometreyi kullanarak LCD ekranın kontrastını ayarlayın.
Arttır ve Azalt butonlarını kullanarak başlangıç süresini belirleyin.
Başlat/Durdur butonuna basarak geri sayımı başlatın veya durdurun.
Geri sayım bittiğinde LCD ekranda "Süre Bitti!" mesajı görünecektir.

Geliştirme İpuçları

Sesli Alarm: Geri sayım bittiğinde bir buzzer ile sesli alarm çalabilirsiniz.
Farklı Modlar: Sınav modu, egzersiz modu gibi farklı modlar ekleyebilirsiniz.
Bluetooth Kontrolü: Bluetooth modülü ile sayacı akıllı telefonunuzdan kontrol edebilirsiniz.
Daha Büyük Ekran: Daha büyük bir LCD ekran veya bir LED matris kullanarak daha görünür bir sayaç yapabilirsiniz.

Umarım bu proje size ilham verir ve Arduino dünyasına keyifli bir adım atmanızı sağlar. Unutmayın, elektronik projeler deneme yanılma yoluyla öğrenilir. Başarılar dilerim!

Etiketler: arduino, geri sayım sayacı, sınav, egzersiz, lcd, proje, elektronik, kod, eğitim

```

Devamını oku

Arduino ile Sesle Kontrol Edilebilen Lamba Sistemi (Arduino + Ses Sensörü)

Merhaba sevgili Arduino meraklıları!

Bu yazımızda, Arduino kullanarak sesle kontrol edilebilen basit bir lamba sistemi geliştireceğiz. Bu proje hem yeni başlayanlar için harika bir başlangıç noktası olacak, hem de daha deneyimli kullanıcılar için ilham verici bir fikir olabilir. Projemiz, bir ses sensörü ve bir Arduino kartı kullanarak, belirli bir ses komutu algılandığında lambayı açıp kapatacak.

Gerekli Malzemeler

Arduino Uno (veya benzeri bir Arduino kartı)
Ses Sensörü Modülü (KY-038 veya benzeri)
LED Lamba (veya bir röle ile kontrol edilebilen bir lamba devresi)
220 Ohm Direnç (LED için)
Jumper Kablolar

Devre Şeması ve Bağlantılar

Devremizi kurarken aşağıdaki bağlantıları dikkatlice yapalım:

Ses Sensörü VCC pini -> Arduino 5V pinine
Ses Sensörü GND pini -> Arduino GND pinine
Ses Sensörü OUT pini -> Arduino Dijital 2 numaralı pinine
LED'in anot (+) bacağı -> 220 Ohm direnç üzerinden Arduino Dijital 13 numaralı pinine
LED'in katot (-) bacağı -> Arduino GND pinine

Eğer daha güçlü bir lamba kullanmak isterseniz, LED yerine bir röle modülü kullanarak lambanızı kontrol edebilirsiniz. Röle bağlantıları için röle modülünüzün kullanım kılavuzuna başvurmanız önemlidir.

Arduino Kodu

Şimdi de Arduino kartımıza yükleyeceğimiz kodu inceleyelim:


// Pin tanımlamaları
const int sesSensoruPin = 2;   // Ses sensörünün bağlandığı pin
const int ledPin = 13;         // LED'in bağlandığı pin

// Değişkenler
int sesDegeri = 0;          // Ses sensöründen okunan değer
bool lambaDurumu = false;    // Lambanın açık/kapalı durumu

void setup() {
  // Pin modlarını ayarla
  pinMode(sesSensoruPin, INPUT);
  pinMode(ledPin, OUTPUT);

  // Seri haberleşmeyi başlat (debug için)
  Serial.begin(9600);
}

void loop() {
  // Ses sensöründen değeri oku
  sesDegeri = digitalRead(sesSensoruPin);

  // Eğer ses algılandıysa (sesDegeri LOW ise)
  if (sesDegeri == LOW) {
    Serial.println("Ses Algilandi!"); // Seri port ekranına yazdır

    // Lambanın durumunu tersine çevir
    lambaDurumu = !lambaDurumu;

    // Lambayı aç veya kapat
    digitalWrite(ledPin, lambaDurumu);

    // Kısa bir gecikme ile durumu sabitle
    delay(500);
  }
}

Bu kodu Arduino IDE'sine kopyalayıp, kartınıza yükleyin. Kod, ses sensöründen gelen veriyi sürekli olarak okur. Ses algılandığında (sensörden LOW sinyali geldiğinde), lambanın durumunu tersine çevirir (açıksa kapatır, kapalıysa açar). Serial.println komutu, seri port ekranında "Ses Algilandi!" mesajını gösterir. Bu sayede projenizin doğru çalışıp çalışmadığını kontrol edebilirsiniz.

Kodun Açıklaması

`const int sesSensoruPin = 2;` ve `const int ledPin = 13;`: Ses sensörünün ve LED'in Arduino kartında bağlandığı pinleri tanımlar.
`int sesDegeri = 0;` ve `bool lambaDurumu = false;`: Ses sensöründen okunan değeri ve lambanın mevcut durumunu (açık/kapalı) saklamak için kullanılan değişkenlerdir.
`pinMode(sesSensoruPin, INPUT);` ve `pinMode(ledPin, OUTPUT);`: Belirtilen pinlerin giriş (ses sensörü) veya çıkış (LED) olarak ayarlanmasını sağlar.
`sesDegeri = digitalRead(sesSensoruPin);`: Ses sensöründen dijital bir değer okur (HIGH veya LOW).
`if (sesDegeri == LOW)`: Eğer ses sensöründen LOW sinyali gelirse (yani ses algılandıysa) koşulunu kontrol eder. Çoğu ses sensörü, ses algıladığında LOW sinyali verir.
`lambaDurumu = !lambaDurumu;`: Lambanın mevcut durumunu tersine çevirir (TRUE ise FALSE, FALSE ise TRUE yapar).
`digitalWrite(ledPin, lambaDurumu);`: LED'i (veya röle üzerinden lambayı) açar veya kapatır.
`delay(500);`: Durumu sabitlemek için kısa bir gecikme ekler (yarım saniye). Bu, lambanın çok hızlı bir şekilde açılıp kapanmasını engeller.

Projenin Çalışması

Devreyi kurup kodu yükledikten sonra, ses sensörüne yakın bir yerde (örneğin, elinizi çırparak veya belirli bir kelime söyleyerek) ses çıkarın. Sensör sesi algıladığında, lamba açılacak veya kapanacaktır. Ses komutunuzun net ve yüksek olduğundan emin olun.

Geliştirme Fikirleri

Farklı ses komutları için farklı lambaları kontrol edebilirsiniz.
Ses sensörünün hassasiyetini potansiyometre ile ayarlayabilirsiniz.
Bluetooth modülü ekleyerek, lambayı akıllı telefonunuzdan kontrol edebilirsiniz.
Ev otomasyonu sisteminize entegre edebilirsiniz.

Umarım bu proje size Arduino dünyasına güzel bir giriş yapmanız için yardımcı olur. Herhangi bir sorunuz olursa, yorumlarda belirtmekten çekinmeyin. İyi kodlamalar!

Etiketler: arduino, ses sensörü, lamba kontrolü, elektronik, proje, kendinyap, otomasyon, sesle kontrol

```

Devamını oku

Arduino ile Hava Durumu İstasyonu: Sıcaklık, Nem ve Basınç Ölçümü

Merhaba sevgili Arduino severler!

Bu yazımızda, Arduino kullanarak basit ama etkili bir hava durumu istasyonu kurmayı öğreneceğiz. Bu istasyon sayesinde ortam sıcaklığını, nemini ve basıncını ölçebilecek ve bu verileri bir LCD ekranda görüntüleyebileceğiz. Projemiz özellikle hava durumuyla ilgilenen öğrenciler ve hobi amaçlı projeler geliştirmek isteyenler için ideal. Hadi başlayalım!

Gerekli Malzemeler

Arduino Uno (veya uyumlu bir kart)
BMP180 veya BMP280 Barometrik Basınç Sensörü (sıcaklık da ölçer)
DHT11 veya DHT22 Sıcaklık ve Nem Sensörü
16x2 LCD Ekran
I2C LCD Adaptörü (isteğe bağlı, kablolamayı kolaylaştırır)
Jumper Kabloları
Breadboard (isteğe bağlı, prototip için kullanışlı)

Kablolama

Sensörleri ve LCD ekranı Arduino'ya nasıl bağlayacağımızı adım adım inceleyelim:

DHT11/DHT22 Bağlantısı:

DHT11/DHT22 VCC pini -> Arduino 5V
DHT11/DHT22 DATA pini -> Arduino Dijital Pin 2 (veya istediğiniz bir dijital pin)
DHT11/DHT22 GND pini -> Arduino GND

BMP180/BMP280 Bağlantısı:

Eğer I2C kullanıyorsanız (önerilir):

BMP180/BMP280 VIN pini -> Arduino 3.3V veya 5V (sensörün spesifikasyonuna bakın)
BMP180/BMP280 GND pini -> Arduino GND
BMP180/BMP280 SDA pini -> Arduino A4 (SDA)
BMP180/BMP280 SCL pini -> Arduino A5 (SCL)

Eğer SPI kullanıyorsanız, sensörün dökümantasyonuna göre bağlantıları yapın.

LCD Ekran Bağlantısı (I2C ile):

LCD VCC pini -> Arduino 5V
LCD GND pini -> Arduino GND
LCD SDA pini -> Arduino A4 (SDA)
LCD SCL pini -> Arduino A5 (SCL)

Arduino Kodu

Şimdi de Arduino kodunu inceleyelim. Bu kod, sensörlerden verileri okuyacak ve LCD ekrana yazdıracak:


 #include <Wire.h>
 #include <LiquidCrystal_I2C.h>
 #include <DHT.h>
 #include <Adafruit_BMP280.h>

 #define DHTPIN 2     // DHT veri pini
 #define DHTTYPE DHT11   // DHT modeli (DHT11, DHT22, DHT21)

 DHT dht(DHTPIN, DHTTYPE);
 Adafruit_BMP280 bmp; // I2C

 LiquidCrystal_I2C lcd(0x27, 16, 2);  // LCD adresini kontrol edin, gerekirse değiştirin.

 void setup() {
  Serial.begin(9600);
  lcd.init();
  lcd.backlight();
  dht.begin();
  if (!bmp.begin(0x76)) { // BMP280 adresini kontrol edin, gerekirse değiştirin.
    Serial.println(F("BMP280 bulunamadı, bağlantıları kontrol edin!"));
    while (1) delay(10);
  }
  Serial.println(F("BMP280 bulundu!"));
}

 void loop() {
  // Sensörlerden veri okuma
  float sicaklik = dht.readTemperature();
  float nem = dht.readHumidity();
  float basin = bmp.readPressure() / 100.0F;  // HPa cinsinden basınç

  // Veri kontrolü
  if (isnan(sicaklik) || isnan(nem) || isnan(basin)) {
    Serial.println(F("Sensör okuma hatası!"));
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Hata!");
    delay(2000);
    return;
  }

  // LCD ekrana yazdırma
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Sicaklik: ");
  lcd.print(sicaklik);
  lcd.print(" C");

  lcd.setCursor(0, 1);
  lcd.print("Nem: ");
  lcd.print(nem);
  lcd.print(" %  Basin: ");
  lcd.print(basin);
  lcd.print(" hPa");

  // Seri port'a yazdırma (isteğe bağlı)
  Serial.print("Sicaklik: ");
  Serial.print(sicaklik);
  Serial.print(" C, Nem: ");
  Serial.print(nem);
  Serial.print(" %, Basin: ");
  Serial.print(basin);
  Serial.println(" hPa");

  delay(2000); // 2 saniyede bir ölçüm yap
 }

Kod Açıklaması

Kütüphaneler: Gerekli kütüphaneler (`Wire.h`, `LiquidCrystal_I2C.h`, `DHT.h`, `Adafruit_BMP280.h`) eklenir.
Pin Tanımları: DHT sensörünün bağlı olduğu pin numarası ve DHT sensörünün modeli tanımlanır.
Nesne Oluşturma: DHT, BMP280 ve LCD nesneleri oluşturulur. LCD adresini kontrol etmeyi unutmayın (genellikle 0x27 veya 0x3F).
`setup()` Fonksiyonu: Seri port başlatılır, LCD başlatılır ve arka ışığı açılır, DHT sensörü başlatılır ve BMP280 sensörü başlatılır. BMP280 sensörünün bulunup bulunmadığı kontrol edilir.
`loop()` Fonksiyonu:
- Sensörlerden sıcaklık, nem ve basınç değerleri okunur.
- Okunan verilerin geçerli olup olmadığı kontrol edilir (`isnan()`).
- Veriler LCD ekrana yazdırılır.
- Veriler seri porta (isteğe bağlı) yazdırılır.
- 2 saniye beklenir.

Ek Bilgiler ve İpuçları

LCD Adresi: LCD ekranınızın adresini bulmak için I2C tarayıcı kodu kullanabilirsiniz.
Sensör Seçimi: DHT11 daha ucuzdur ancak DHT22 daha hassas ölçümler yapar. BMP180 ve BMP280 de benzer şekilde farklı hassasiyetlere sahiptir.
Kalibrasyon: Daha doğru sonuçlar için sensörleri kalibre edebilirsiniz.
Geliştirme: Bu projeyi daha da geliştirmek için, verileri bir SD karta kaydedebilir, bir web sunucusuna gönderebilir veya bir grafik arayüzü oluşturabilirsiniz.

Umarım bu proje size ilham verir ve Arduino ile hava durumu istasyonu kurma konusunda yardımcı olur. Herhangi bir sorunuz olursa, yorumlarda sormaktan çekinmeyin!

Bol projeli günler!

Etiketler: arduino, hava durumu istasyonu, sıcaklık, nem, basınç, bmp180, bmp280, dht11, dht22, lcd, i2c, sensör, proje, elektronik, hobi

```

Devamını oku

Arduino ile Evcil Hayvan Mama Otomatiği: Zamanlayıcılı ve Manuel Kontrol Destekli

Merhaba sevgili Arduino severler ve evcil hayvan dostları!

Bugün sizlerle hem Arduino projelerine yeni başlayanlar, hem de minik dostlarımızın beslenmesini kolaylaştırmak isteyenler için harika bir proje paylaşacağım: Arduino ile evcil hayvan mama otomatiği! Bu proje sayesinde, evcil hayvanınızın beslenme saatlerini otomatik olarak ayarlayabilir, dilerseniz manuel olarak da mama verebilirsiniz. Hem pratik, hem de eğlenceli!

Neden Bu Proje?

Zaman Tasarrufu: Yoğun bir gününüzde mama verme derdinden kurtulun.
Düzenli Beslenme: Evcil hayvanınızın düzenli saatlerde beslenmesini sağlayın.
Eğlenceli Proje: Arduino ile temel elektronik ve programlama becerilerinizi geliştirin.
Uygun Maliyet: İhtiyacınız olan malzemeler genellikle uygun fiyatlıdır.

Gerekli Malzemeler

Arduino Uno (veya benzeri bir Arduino kartı)
Servo Motor (SG90 tavsiye edilir)
RTC Modülü (DS3231 gerçek zaman saati modülü)
Buton (Manuel kontrol için)
Jumper Kablolar
Mama Kabı ve Haznesi (Uygun bir kap ve hazne tasarlayabilirsiniz veya hazır bir ürün kullanabilirsiniz)
5V Güç Kaynağı
Breadboard (isteğe bağlı)
Direnç (Buton için 10k ohm)

Proje Şeması ve Bağlantılar

Projemizin temelinde, RTC modülü sayesinde zamanı takip edip, belirlenen saatlerde servo motoru çalıştırarak mamayı dökmesini sağlamak yatıyor. Buton ise manuel mama verme işlemine olanak tanıyacak.

Bağlantıları aşağıdaki gibi yapabilirsiniz:

Servo Motor:
- Sinyal Kablosu -> Arduino Dijital Pin 9
- VCC Kablosu -> Arduino 5V
- GND Kablosu -> Arduino GND
RTC Modülü (DS3231):
- SDA -> Arduino A4
- SCL -> Arduino A5
- VCC -> Arduino 5V
- GND -> Arduino GND
Buton:
- Bir bacak -> Arduino Dijital Pin 2
- Diğer bacak -> 5V (10k ohm direnç ile GND'ye bağlayın)

Arduino Kodu

Aşağıdaki kod, projenin temel işlevselliğini sağlamaktadır. Kodu Arduino IDE'sine kopyalayıp, kendi ihtiyaçlarınıza göre düzenleyebilirsiniz.


 #include <Servo.h>
 #include <RTClib.h>

 Servo servoMotor;
 RTC_DS3231 rtc;

 const int buttonPin = 2;
 int buttonState = 0;

 // Beslenme Saatleri (Saat, Dakika)
 int beslenmeSaati[] = {8, 0, 18, 0}; // Sabah 8 ve Akşam 6

 int servoAcikPozisyon = 90; // Servonun mamayı dökeceği pozisyon
 int servoKapaliPozisyon = 0; // Servonun kapalı pozisyonu

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

  if (! rtc.begin()) {
   Serial.println("RTC Modülü Bulunamadı!");
   while (1);
  }

  //RTC ilk defa kullanılıyorsa saati ayarlayın
  //rtc.adjust(DateTime(2024, 10, 27, 12, 0, 0)); // Yıl, Ay, Gün, Saat, Dakika, Saniye

  servoMotor.attach(9);
  pinMode(buttonPin, INPUT_PULLUP); // Dahili pull-up direnci kullanılıyor
  servoMotor.write(servoKapaliPozisyon); //Başlangıçta kapalı pozisyonda
 }

 void loop() {
  DateTime now = rtc.now();
  buttonState = digitalRead(buttonPin);

  Serial.print(now.hour(), DEC);
  Serial.print(':');
  Serial.print(now.minute(), DEC);
  Serial.print(':');
  Serial.print(now.second(), DEC);
  Serial.println();

  // Otomatik Besleme
  for (int i = 0; i < sizeof(beslenmeSaati) / sizeof(beslenmeSaati[0]); i += 2) {
   if (now.hour() == beslenmeSaati[i] && now.minute() == beslenmeSaati[i + 1] && now.second() == 0) {
    Serial.println("Otomatik Besleme Zamanı!");
    mamaVer();
   }
  }

  // Manuel Besleme (Butona Basıldığında)
  if (buttonState == LOW) {
   Serial.println("Manuel Besleme!");
   mamaVer();
   delay(3000); // Butona basılı tutulduğunda sürekli mama vermeyi engellemek için bir gecikme
  }

  delay(1000);
 }

 void mamaVer() {
  servoMotor.write(servoAcikPozisyon); // Servoyu aç
  delay(2000); // Mamanın dökülmesi için bekle
  servoMotor.write(servoKapaliPozisyon); // Servoyu kapat
  delay(5000); // Bir sonraki beslemeye kadar bekle
 }

Kod Açıklaması

Kütüphaneler: Servo motor ve RTC modülü için gerekli kütüphaneler ekleniyor.
Pin Tanımları: Motorun ve düğmenin bağlı olduğu pinler tanımlanıyor.
Beslenme Saatleri: Evcil hayvanınızın beslenme saatleri tanımlanıyor.
`setup()` Fonksiyonu: Seri haberleşme başlatılıyor, RTC modülü ve servo motor ayarlanıyor.
`loop()` Fonksiyonu: Sürekli olarak saati kontrol ediyor, belirlenen saatlerde veya buton basıldığında `mamaVer()` fonksiyonunu çağırıyor.
`mamaVer()` Fonksiyonu: Servo motoru belirli bir süre hareket ettirerek mama verme işlemini gerçekleştiriyor.

İpuçları ve Öneriler

Mama haznesini ve mekanizmasını evcil hayvanınızın boyutuna ve mama türüne göre uyarlayın.
RTC modülünün pilini takmayı unutmayın, aksi takdirde saat bilgisi kaybolabilir.
Servo motorun hareket hızını ve açısını, mama miktarını kontrol edecek şekilde ayarlayın.
Kodu kendi ihtiyaçlarınıza göre özelleştirmekten çekinmeyin!

Sonuç

Bu proje ile evcil hayvanınızın beslenmesini kolaylaştırırken, Arduino ile de keyifli bir deneyim yaşayacaksınız. Unutmayın, güvenlik her zaman öncelikli olmalı. Evcil hayvanınızın sağlığı için güvenilir bir sistem kurduğunuzdan emin olun. Şimdiden kolay gelsin!

Etiketler: arduino, evcil hayvan, mama otomatiği, zamanlayıcı, servo motor, rtc, ds3231, proje, diy, elektronik

```

Devamını oku

Arduino ile Temassız Ateş Ölçer Yapımı (IR Sensör Kullanarak)

Merhaba sevgili Arduino meraklıları!

Bu yazımızda, Arduino kullanarak temassız bir ateş ölçer yapımını adım adım inceleyeceğiz. Özellikle son zamanlarda oldukça popüler hale gelen bu tür cihazlar, nesnelerin veya insanların vücut sıcaklığını temas etmeden ölçmemize olanak tanıyor. Bu projeyi hayata geçirerek hem eğlenceli bir deneyim yaşayacak, hem de günlük hayatta kullanabileceğiniz faydalı bir alet yapmış olacaksınız.

Projemizde MLX90614 gibi bir kızılötesi (IR) sensör kullanacağız. Bu sensör, bir nesnenin yaydığı kızılötesi radyasyonu algılayarak sıcaklığını ölçer. Arduino ile bu sensörü kullanarak, ölçtüğümüz sıcaklık değerlerini bir LCD ekranda göstereceğiz.

Gerekli Malzemeler

Arduino Uno (veya benzeri bir Arduino kartı)
MLX90614 Temassız Sıcaklık Sensörü
16x2 LCD Ekran
10k Potansiyometre (LCD kontrast ayarı için)
Jumper Kablolar
Breadboard (isteğe bağlı, devre kurmayı kolaylaştırır)

Devre Şeması ve Bağlantılar

Devremizi kurarken aşağıdaki bağlantıları dikkatlice yapalım:

MLX90614 Sensörü:
- VCC -> Arduino 5V
- GND -> Arduino GND
- SDA -> Arduino A4 (SDA)
- SCL -> Arduino A5 (SCL)
LCD Ekran:
- VSS -> Arduino GND
- VDD -> Arduino 5V
- VO (Kontrast) -> Potansiyometrenin orta ucu. Potansiyometrenin diğer uçları Arduino 5V ve GND'ye bağlanacak.
- RS -> Arduino Dijital Pin 12
- EN -> Arduino Dijital Pin 11
- D4 -> Arduino Dijital Pin 5
- D5 -> Arduino Dijital Pin 4
- D6 -> Arduino Dijital Pin 3
- D7 -> Arduino Dijital Pin 2
- A (Anot) -> Arduino 5V (100 ohm direnç ile)
- K (Katot) -> Arduino GND

Arduino Kodu

Aşağıdaki kodu Arduino IDE'nize kopyalayın ve Arduino kartınıza yükleyin.


 #include 
 #include 
 #include 

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

 // MLX90614 sensörünü tanımla
 Adafruit_MLX90614 mlx = Adafruit_MLX90614();

 void setup() {
  Serial.begin(9600);
  Serial.println("Adafruit MLX90614 Temassız Sıcaklık Sensörü Testi");

  mlx.begin();

  // LCD'yi başlat
  lcd.begin(16, 2);
  lcd.print("Temassiz Ates");
  lcd.setCursor(0,1);
  lcd.print("Olcere Hosgeldin!");
  delay(2000);
  lcd.clear();
 }

 void loop() {
  // Ortam sıcaklığını ve nesne sıcaklığını oku
  float ambientTemp = mlx.readAmbientTempC();
  float objectTemp = mlx.readObjectTempC();

  // Sıcaklık değerlerini serial monitöre yazdır
  Serial.print("Ortam Sıcaklığı: ");
  Serial.print(ambientTemp);
  Serial.println(" *C");

  Serial.print("Nesne Sıcaklığı: ");
  Serial.print(objectTemp);
  Serial.println(" *C");

  // Sıcaklık değerlerini LCD ekrana yazdır
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Ortam: ");
  lcd.print(ambientTemp);
  lcd.print(" C");
  lcd.setCursor(0, 1);
  lcd.print("Nesne: ");
  lcd.print(objectTemp);
  lcd.print(" C");

  delay(1000); // 1 saniye bekle
 }

Kodun Açıklaması

#include <Wire.h>, #include <LiquidCrystal.h>, #include <Adafruit_MLX90614.h>: Gerekli kütüphaneleri projemize dahil ediyoruz.
LCD pinlerini tanımlıyoruz.
Adafruit_MLX90614 mlx = Adafruit_MLX90614();: MLX90614 sensörünü tanımlıyoruz.
mlx.begin();: Sensörü başlatıyoruz.
lcd.begin(16, 2);: LCD ekranı 16x2 boyutunda başlatıyoruz.
mlx.readAmbientTempC(); ve mlx.readObjectTempC();: Ortam ve nesne sıcaklıklarını Celsius cinsinden okuyoruz.
lcd.print(); ve lcd.setCursor();: Sıcaklık değerlerini LCD ekrana yazdırıyoruz.

Çalıştırma ve Sonuç

Devreyi kurduktan ve kodu Arduino'ya yükledikten sonra, LCD ekranda ortam ve nesne sıcaklıklarını görmelisiniz. MLX90614 sensörünü bir nesneye yaklaştırdığınızda, nesne sıcaklığının değiştiğini gözlemleyebilirsiniz. Potansiyometre ile LCD ekranın kontrastını ayarlayarak daha net bir görüntü elde edebilirsiniz.

Ek Notlar

MLX90614 sensörünün doğru sonuçlar vermesi için, sensörün yüzeyinin temiz olduğundan emin olun.
Ölçüm yaparken, sensörü nesneye çok yaklaştırmamaya özen gösterin. Genellikle birkaç santimetre mesafe yeterlidir.
Kodu ve devreyi kendi ihtiyaçlarınıza göre modifiye edebilirsiniz. Örneğin, sıcaklık değerlerini farklı bir ekranda görüntüleyebilir, farklı sıcaklık birimlerinde gösterebilir veya bir alarm sistemi ekleyebilirsiniz.

Umarım bu proje sizin için faydalı olmuştur. Arduino ile keyifli projeler geliştirmeye devam edin!

Etiketler: Arduino, Temassız Ateş Ölçer, IR Sensör, MLX90614, LCD Ekran, Sıcaklık Ölçümü, Proje, Kendin Yap

```

Devamını oku

Arduino ile Akıllı Saksı: Bitkilerinizin Ne Zaman Suya İhtiyacı Olduğunu Öğrenin

Merhaba sevgili Arduino meraklıları ve bitki severler! Bu yazımızda, Arduino kullanarak bitkilerinizin ne zaman suya ihtiyacı olduğunu anlayan akıllı bir saksı projesi geliştireceğiz. Bu proje sayesinde bitkilerinizle daha yakından ilgilenebilir, onların sağlıklı ve mutlu bir şekilde büyümelerini sağlayabilirsiniz. Hazırsanız, malzemeleri hazırlayalım ve kodlamaya başlayalım!

Gerekli Malzemeler

Arduino Uno (veya benzeri bir Arduino kartı)
Toprak Nem Sensörü (örn. YL-69 veya benzeri)
Jumper kablolar
10k Ohm direnç (opsiyonel, daha hassas ölçümler için)
Breadboard (gerekli değil ama işleri kolaylaştırır)

Toprak Nem Sensörü Nasıl Çalışır?

Toprak nem sensörü, topraktaki su miktarını ölçerek bize bir değer verir. Bu değer, toprağın ne kadar kuru veya ıslak olduğunu anlamamızı sağlar. Sensör, iki metal çubuktan oluşur ve bu çubuklar arasındaki elektriksel iletkenlik, topraktaki nem miktarıyla doğru orantılıdır. Kuru toprak daha az iletkenken, ıslak toprak daha fazla iletkendir.

Devre Şeması ve Bağlantılar

Şimdi de devremizi nasıl kuracağımıza bir göz atalım. Bağlantıları aşağıdaki gibi yapabilirsiniz:

Toprak Nem Sensörü Bağlantıları:
- Sensörün VCC pini -> Arduino'nun 5V pinine
- Sensörün GND pini -> Arduino'nun GND pinine
- Sensörün A0 (Analog Out) pini -> Arduino'nun A0 pinine

Eğer daha hassas bir ölçüm almak isterseniz, 10k Ohm'luk bir direnci sensörün A0 pininden GND'ye bağlayabilirsiniz. Bu, voltaj bölücü oluşturarak ölçüm aralığını genişletecektir.

Arduino Kodu

Artık devremizi kurduğumuza göre, Arduino kodunu yazmaya başlayabiliriz. Aşağıdaki kodu Arduino IDE'nize kopyalayın ve Arduino'nuza yükleyin:


// Toprak nem sensörü pinini tanımla
const int nemSensorPin = A0;

void setup() {
  // Seri iletişimi başlat
  Serial.begin(9600);
  Serial.println("Akilli Saksı Başlatılıyor...");
}

void loop() {
  // Sensörden okunan değeri al
  int nemDegeri = analogRead(nemSensorPin);

  // Okunan değeri seri port ekranına yazdır
  Serial.print("Nem Değeri: ");
  Serial.println(nemDegeri);

  // Nem seviyesine göre yorum yap
  if (nemDegeri < 300) {
    Serial.println("Toprak çok kuru, sulama zamanı!");
  } else if (nemDegeri < 600) {
    Serial.println("Toprak kuru, yakında sulama gerekebilir.");
  } else {
    Serial.println("Toprak yeterince nemli.");
  }

  // 1 saniye bekle
  delay(1000);
}

Kod Açıklaması:

const int nemSensorPin = A0; satırı, toprak nem sensörünün bağlı olduğu Arduino pinini tanımlar.
Serial.begin(9600); satırı, seri iletişimi başlatır. Bu sayede sensörden okunan değerleri bilgisayar ekranında görebiliriz.
int nemDegeri = analogRead(nemSensorPin); satırı, sensörden okunan değeri nemDegeri değişkenine atar.
Serial.print("Nem Değeri: "); ve Serial.println(nemDegeri); satırları, okunan değeri seri port ekranına yazdırır.
if ve else if blokları, nem seviyesine göre yorum yapar ve kullanıcıya ne yapması gerektiği konusunda bilgi verir.
delay(1000); satırı, programın 1 saniye beklemesini sağlar.

Projenin Çalıştırılması

Kodu Arduino'nuza yükledikten sonra, seri port ekranını açın (Arduino IDE'de "Araçlar" menüsünden "Seri Port Ekranı"nı seçin). Toprak nem sensörünü saksınıza yerleştirin ve seri port ekranında okunan değerleri gözlemleyin. Değerler değiştiğinde, toprağın nem seviyesi hakkında fikir sahibi olabilirsiniz. Kodda yer alan eşik değerlerini (300 ve 600) kendi bitkinizin ihtiyaçlarına göre ayarlayabilirsiniz.

Proje Geliştirme Fikirleri

Bu proje oldukça temel bir versiyon. Daha da geliştirerek akıllı saksınızı daha kullanışlı hale getirebilirsiniz. İşte bazı geliştirme fikirleri:

Otomatik Sulama: Bir röle ve su pompası kullanarak, toprak nem seviyesi belirli bir değerin altına düştüğünde otomatik olarak sulama yapabilirsiniz.
LCD Ekran: Okunan nem değerini bir LCD ekranda gösterebilirsiniz.
Mobil Uygulama: Bluetooth veya Wi-Fi modülü kullanarak, akıllı saksınızdan gelen verileri bir mobil uygulamada görüntüleyebilirsiniz.
Işık Sensörü: Işık sensörü ekleyerek bitkinin ışık ihtiyacını da takip edebilirsiniz.

Umarım bu proje size ilham vermiştir ve Arduino dünyasına güzel bir başlangıç yapmanızı sağlamıştır. Kendi akıllı saksı projelerinizi bizimle paylaşmayı unutmayın! Bol kodlu günler dilerim!

Etiketler: Arduino, Akıllı Saksı, Toprak Nem Sensörü, Bitki Bakımı, DIY Proje, Elektronik, Hobi

```

Devamını oku

Arduino Kontrollü Akıllı Masa Lambası: Ortam Işığına Göre Ayarlanabilir

Herkese merhaba Arduino severler! Bu yazımızda, etrafımızdaki ışık koşullarına göre parlaklığını otomatik olarak ayarlayan, akıllı bir masa lambası projesi geliştireceğiz. Bu proje hem Arduino'ya yeni başlayanlar için harika bir giriş olacak, hem de daha deneyimli kullanıcılar için keyifli bir uygulama örneği sunacak. Hazırsanız, malzemelere ve kodlamaya geçelim!

Neden Akıllı Masa Lambası?

Akıllı masa lambası, okuma, çalışma veya hobilerinizle uğraşırken gözlerinizi yormamak için ideal bir çözüm sunar. Ortamdaki ışık azaldığında lamba otomatik olarak parlaklığını artırır, ortam aydınlandığında ise parlaklığı kısar. Böylece, her zaman ideal bir aydınlatma seviyesine sahip olursunuz.

Gerekli Malzemeler

Arduino Uno (veya benzeri bir Arduino kartı)
LDR (Işık Bağımlı Direnç)
10k Ohm Direnç
Potansiyometre (10k Ohm idealdir)
LED (Yüksek parlaklığa sahip)
220 Ohm Direnç (LED için)
Breadboard
Jumper kablolar

Devre Şeması ve Bağlantılar

Devremizi kurarken aşağıdaki bağlantı şemasına dikkat edelim:

LDR:
- LDR'nin bir bacağı -> Arduino 5V (Vcc) pinine
- LDR'nin diğer bacağı -> 10k Ohm direncin bir bacağına
- 10k Ohm direncin diğer bacağı -> GND'ye
- LDR ve 10k Ohm direncin birleştiği noktadan -> Arduino A0 pinine
Potansiyometre:
- Potansiyometrenin bir ucu -> Arduino 5V'a (VCC)
- Potansiyometrenin diğer ucu -> GND'ye
- Potansiyometrenin orta ucu (silgi) -> Arduino A1 pinine
LED:
- LED'in uzun bacağı (anot) -> 220 Ohm direncin bir bacağına
- 220 Ohm direncin diğer bacağı -> Arduino Dijital 9 pinine (PWM pini)
- LED'in kısa bacağı (katot) -> GND'ye

Arduino Kodu

Şimdi de Arduino kodumuza göz atalım. Bu kod, LDR'den gelen ışık değerini okuyacak, bu değeri potansiyometre ile ayarlanan hassasiyete göre ölçeklendirecek ve LED'in parlaklığını buna göre ayarlayacak.


 const int ldrPin = A0;
 const int potPin = A1;
 const int ledPin = 9;

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

 void loop() {
  // LDR'den ışık değerini oku
  int ldrValue = analogRead(ldrPin);

  // Potansiyometreden hassasiyet değerini oku
  int potValue = analogRead(potPin);

  // Hassasiyet değerini 0-1023'ten 1-100 arasına ölçeklendir
  int sensitivity = map(potValue, 0, 1023, 1, 100);

  // Işık değerini 0-255 arasına ölçeklendir ve hassasiyet ile çarp
  int ledBrightness = map(ldrValue, 0, 1023, 255, 0); // Ters çevrildi çünkü düşük ışıkta daha parlak istiyoruz
  ledBrightness = constrain(ledBrightness * sensitivity / 100, 0, 255); // Hassasiyet ayarı ve sınırlama

  // LED'in parlaklığını ayarla
  analogWrite(ledPin, ledBrightness);

  // Seri monitöre değerleri yazdır (isteğe bağlı)
  Serial.print("LDR: ");
  Serial.print(ldrValue);
  Serial.print(", Pot: ");
  Serial.print(potValue);
  Serial.print(", Brightness: ");
  Serial.println(ledBrightness);

  delay(50); // Daha kararlı okumalar için kısa bir gecikme
 }

Kodun Açıklaması

ldrPin, potPin, ledPin: LDR, potansiyometre ve LED'in bağlandığı pinleri tanımlar.
setup(): Seri iletişimi başlatır ve LED pinini çıkış olarak ayarlar.
loop(): Sürekli olarak çalışan ana döngüdür.
- analogRead(): LDR ve potansiyometreden analog değerleri okur.
- map(): Değerleri farklı aralıklara ölçeklendirir. LDR değeri ters çevrilir (255'ten 0'a) çünkü düşük ışıkta LED'in daha parlak olmasını isteriz.
- constrain(): LED parlaklığının 0 ile 255 arasında kalmasını sağlar. Hassasiyet ayarı bu noktada yapılır.
- analogWrite(): LED'in parlaklığını PWM sinyali ile ayarlar.
- Serial.print(): Değerleri seri monitöre yazdırır (isteğe bağlı, hata ayıklama için yararlı).
- delay(): Kısa bir gecikme ekler.

Proje Nasıl Çalışır?

LDR, üzerine düşen ışık miktarına göre direnci değişen bir sensördür. Ortamdaki ışık azaldığında direnci artar ve Arduino A0 pinine daha düşük bir voltaj gönderir. Arduino, bu voltajı okuyarak ortamın ne kadar karanlık olduğunu anlar. Potansiyometre ise, sistemin hassasiyetini ayarlamanıza olanak tanır. Potansiyometre ile, ortam ışığındaki küçük değişikliklere lamba ne kadar tepki versin, onu belirleyebilirsiniz. Arduino, LDR ve potansiyometreden gelen verileri işleyerek, LED'in parlaklığını otomatik olarak ayarlar.

İpuçları ve İyileştirmeler

Kalibrasyon: LDR'nin hassasiyeti ortam ışığına göre değişebilir. Kodu çalıştırmadan önce farklı ışık koşullarında LDR'nin değerlerini kontrol edin ve `map()` fonksiyonundaki aralıkları buna göre ayarlayın.
Hassasiyet Ayarı: Potansiyometre ile hassasiyet ayarını deneyerek, farklı ışık koşullarına en uygun ayarı bulun.
LED Seçimi: Daha parlak bir LED kullanarak, daha iyi bir aydınlatma sağlayabilirsiniz. Ancak, LED'in akım gereksinimlerini dikkate alarak uygun bir direnç kullanmayı unutmayın.
Kasa Tasarımı: Devrenizi daha şık hale getirmek için 3D yazıcıda veya farklı malzemeler kullanarak özel bir kasa tasarlayabilirsiniz.
Renk Ayarı: RGB LED kullanarak, lamba rengini de ortam ışığına göre otomatik olarak ayarlayabilirsiniz.

Umarım bu proje size Arduino dünyasına keyifli bir giriş yapmanıza yardımcı olur. Herhangi bir sorunuz olursa, yorumlarda sormaktan çekinmeyin. İyi kodlamalar!

Etiketler: arduino, akıllı lamba, ortam ışığı, ldr, potansiyometre, led, proje, elektronik, kodlama, diy

```

Devamını oku

Smart Pot with Arduino: Know When Your Plants Need Water

Hey everyone! Welcome back to CapAndCoil! Today, we're diving into a super fun and practical project: building a smart pot using an Arduino. Ever forget to water your plants? This project will help you keep those green friends happy and thriving by letting you know exactly when they need a drink!

Why a Smart Pot?

We all know the struggle. Sometimes life gets busy, and our plants suffer. A smart pot takes the guesswork out of watering. By continuously monitoring the soil moisture, it can alert you when the levels are low, preventing overwatering (which is just as bad as underwatering!) and ensuring your plants get exactly what they need.

What You'll Need

Here's a list of the components you'll need for this project:

Arduino Uno (or similar)
Soil Moisture Sensor
Jumper Wires
LED (Optional, for visual indication)
Resistor (220 Ohm, if using an LED)
A Pot (of course!)

Understanding the Soil Moisture Sensor

The soil moisture sensor works by measuring the resistance between two probes. The more water in the soil, the lower the resistance. The sensor outputs an analog voltage that corresponds to the soil moisture level. The Arduino can then read this voltage and determine if the soil is dry or wet.

Wiring it Up

Let's get everything connected! Here's how you'll wire up the components:

Soil Moisture Sensor VCC → Arduino 5V
Soil Moisture Sensor GND → Arduino GND
Soil Moisture Sensor AOUT → Arduino Analog Pin A0

If you're using an LED to visually indicate when the soil is dry:

LED Anode (Longer leg) → Resistor (220 Ohm)
Resistor → Arduino Digital Pin 8
LED Cathode (Shorter leg) → Arduino GND

The Arduino Code

Now for the brain of the operation! This code reads the soil moisture sensor, compares it to a threshold, and either turns on the LED (if used) or prints a message to the serial monitor indicating the soil is dry.


// Define the pins
const int sensorPin = A0;
const int ledPin = 8; // Optional LED

// Define the threshold for dry soil
const int dryThreshold = 600; // Adjust this value based on your sensor and soil

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT); // If using an LED
}

void loop() {
  // Read the sensor value
  int sensorValue = analogRead(sensorPin);

  // Print the sensor value to the serial monitor
  Serial.print("Sensor Value: ");
  Serial.println(sensorValue);

  // Check if the soil is dry
  if (sensorValue > dryThreshold) {
    Serial.println("Soil is dry! Please water your plant.");
    digitalWrite(ledPin, HIGH); // Turn on the LED (if used)
  } else {
    Serial.println("Soil is moist.");
    digitalWrite(ledPin, LOW);  // Turn off the LED (if used)
  }

  delay(1000); // Wait for 1 second
}

Important: You'll need to adjust the `dryThreshold` value to suit your specific sensor and soil conditions. Monitor the sensor values in the serial monitor when the soil is dry and wet to find the appropriate threshold.

Uploading the Code

Connect your Arduino to your computer using a USB cable. Open the Arduino IDE, copy and paste the code, select the correct board and port, and click the upload button. Once the code is uploaded, open the serial monitor (Tools > Serial Monitor) to see the sensor readings and messages.

Putting it All Together

Place the soil moisture sensor probes into the soil of your plant. Make sure they're inserted deeply enough to get an accurate reading. Monitor the serial monitor (or watch the LED) to see when the soil is dry. Adjust the `dryThreshold` in the code as needed to fine-tune the sensitivity of the system.

Going Further

This is just the beginning! Here are some ideas for expanding this project:

Add a buzzer: Use a buzzer to create an audible alert when the soil is dry.
Connect to the internet: Use a WiFi module to send notifications to your phone when the plant needs water.
Automated Watering System: Connect a small water pump to the Arduino and automatically water the plant when the soil is dry.
Multiple Sensors: Monitor moisture levels in different pots with multiple sensors connected to a single Arduino.

Happy planting, and happy coding!

Tags: Arduino, Smart Pot, Soil Moisture Sensor, Electronics Project, DIY, Beginner Project, Plant Care, Sensors, Watering Plants, Arduino Uno, Home Automation, Electronics Hobby

```

Devamını oku

LED Şerit ile Ses Ritim Işığı (Müzik ile Dans Eden Işıklar)

Merhaba sevgili Arduino severler! Bugün sizlerle, müzikle senkronize bir şekilde dans eden ışıklar yaratacağımız harika bir proje yapacağız. Bu proje ile evinizde, odanızda veya partilerde müthiş bir ambiyans oluşturabilirsiniz. Gelin, adım adım bu eğlenceli projeye birlikte göz atalım.

Proje İçin Gerekli Malzemeler

Arduino Uno (veya benzeri bir Arduino kartı)
WS2812B LED Şerit (veya benzeri adreslenebilir LED şerit)
Ses Sensörü (KY-038 veya benzeri bir ses algılama modülü)
Jumper Kablolar
Güç Kaynağı (LED şerit için uygun voltaj ve akımda)
1000µF Kondansatör (Opsiyonel, ancak LED şeridin kararlılığını artırır)

Devre Şeması ve Bağlantılar

Devre bağlantıları oldukça basit. Aşağıdaki bağlantıları dikkatlice yapmanız yeterli:

Ses Sensörü VCC pini -> Arduino 5V pini
Ses Sensörü GND pini -> Arduino GND pini
Ses Sensörü OUT pini -> Arduino Analog A0 pini (veya herhangi bir uygun analog pin)
LED Şerit VCC pini -> Güç Kaynağı VCC pini (ÖNEMLİ: Arduino'nun 5V pininden direkt olarak yüksek akım çeken LED şeritleri beslemeyin. Ayrı bir güç kaynağı kullanın.)
LED Şerit GND pini -> Güç Kaynağı GND pini ve Arduino GND pini (Ortak GND önemli!)
LED Şerit Data In (DI) pini -> Arduino Dijital 6 pini (veya kodda belirlediğiniz başka bir dijital pin)
Kondansatör (+) ucu -> LED Şerit VCC pini
Kondansatör (-) ucu -> LED Şerit GND pini

Uyarı: Yüksek akım çeken LED şeritleri doğrudan Arduino üzerinden beslemek Arduino'ya zarar verebilir. Bu nedenle ayrı bir güç kaynağı kullanmak önemlidir. Ayrıca, kondansatör kullanımı, LED şeridin ani akım çekmelerinde daha kararlı çalışmasını sağlar.

Arduino Kodu

Şimdi de Arduino kodumuza geçelim. Bu kod, ses sensöründen gelen analog veriyi okuyacak, belirli bir eşiği geçen ses seviyelerine göre LED şeridi farklı renklerde yakacak.


#include <FastLED.h>

#define LED_PIN     6       // LED şeridin data pini
#define NUM_LEDS    60      // LED şerit üzerindeki LED sayısı
#define BRIGHTNESS  50      // Maksimum parlaklık (0-255)
#define COLOR_ORDER GRB     // LED şeridin renk sırası (GRB veya RGB)
#define LED_TYPE    WS2812B // LED şerit tipi

CRGB leds[NUM_LEDS];

#define AUDIO_INPUT A0      // Ses sensörünün bağlı olduğu analog pin
#define THRESHOLD   150     // Ses eşik değeri (deneyerek bulun)

void setup() {
  FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
  FastLED.setBrightness( BRIGHTNESS );
  Serial.begin(9600);
}

void loop() {
  int sensorValue = analogRead(AUDIO_INPUT);
  Serial.println(sensorValue); // Debug için ses değerini seri portta görüntüle

  if (sensorValue > THRESHOLD) {
    // Ses eşiği aşıldığında yapılacak işlemler
    for (int i = 0; i < NUM_LEDS; i++) {
      leds[i] = CHSV(map(i, 0, NUM_LEDS - 1, 0, 255), 255, 255); // Gökkuşağı renkleri
    }
    FastLED.show();
    delay(50); // Kısa bir süre bekle
  } else {
    // Ses eşiği aşılmadığında yapılacak işlemler
    fill_solid(leds, NUM_LEDS, CRGB::Black); // Tüm LED'leri söndür
    FastLED.show();
  }
}

Kod Açıklaması:

#include <FastLED.h>: FastLED kütüphanesini projeye dahil ediyoruz. Bu kütüphane, adreslenebilir LED şeritleri kontrol etmemizi kolaylaştırır.
Tanımlamalar: LED pinini, LED sayısını, parlaklığı, renk sırasını ve LED tipini tanımlıyoruz.
leds[NUM_LEDS]: LED'leri tutacak bir CRGB dizisi oluşturuyoruz.
AUDIO_INPUT ve THRESHOLD: Ses sensörünün bağlı olduğu analog pini ve ses eşik değerini tanımlıyoruz. THRESHOLD değerini, ortam gürültüsüne göre deneme yanılma yoluyla ayarlamanız gerekebilir.
setup() fonksiyonu: FastLED'i başlatıyor ve seri iletişimi başlatıyoruz (debug için).
loop() fonksiyonu: Sürekli olarak ses sensöründen veri okuyor. Eğer okunan değer eşik değerini aşarsa, LED şeridi gökkuşağı renklerinde yakıyor. Aksi takdirde tüm LED'leri söndürüyor.

Kodu Arduino'ya Yükleme ve Test Etme

Arduino IDE'yi kullanarak kodu Arduino kartınıza yükleyin. Kodu yükledikten sonra seri port monitörünü açarak ses sensöründen okunan değerleri gözlemleyebilirsiniz. Ortamdaki sesi artırarak veya sensöre yakın konuşarak LED şeridin tepki verip vermediğini kontrol edin. Eğer LED'ler tepki vermiyorsa, THRESHOLD değerini ayarlayarak hassasiyeti artırabilir veya azaltabilirsiniz.

Proje Geliştirme İpuçları

Farklı renk efektleri deneyin: Kodda CHSV yerine farklı renk kombinasyonları kullanarak farklı efektler yaratabilirsiniz.
Ses seviyesine göre parlaklığı ayarlayın: Ses seviyesi arttıkça LED'lerin parlaklığını da artırabilirsiniz.
Farklı LED şerit türleri kullanın: WS2812B yerine farklı adreslenebilir LED şeritler (örn. APA102) kullanarak farklı sonuçlar elde edebilirsiniz.
Müzik analizi yapın: Daha gelişmiş projelerde, FFT (Fast Fourier Transform) algoritması kullanarak müziğin frekanslarını analiz edebilir ve LED'leri bu frekanslara göre kontrol edebilirsiniz.

Umarım bu proje size ilham vermiştir ve elektronik dünyasına adım atmanızda yardımcı olmuştur. İyi eğlenceler!

Etiketler: Arduino, LED Şerit, Ses Sensörü, Müzik, Işık, Proje, Hobi, Elektronik, WS2812B, FastLED

```

Devamını oku

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

Analog Giriş Nedir?

Potansiyometre Nedir ve Neden Kullanırız?

Gerekli Malzemeler

Devre Şeması ve Bağlantılar

Arduino Kodu

Kodu Açıklayalım

Projelerinizde Nasıl Kullanabilirsiniz?

Sonuç

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

Dijital Pinler Ne İşe Yarar?

Pinleri Tanımlama: pinMode() Fonksiyonu

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

Giriş Pinlerinden Veri Okuma: digitalRead() Fonksiyonu

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

Daha Fazla İpucu ve Püf Noktası

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

Değişken Nedir?

Değişken Tanımlama (Declaration)

Veri Tipleri (Data Types)

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

Örnek Uygulama

Değişkenlerin Kapsamı (Scope)

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

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

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

void loop() Döngüsü

for Döngüsü

while Döngüsü

do...while Döngüsü

Sonuç

Setup Fonksiyonu Nedir?

Setup Fonksiyonunun Sözdizimi

Setup Fonksiyonunda Neler Yapabiliriz?

Örneklerle setup() Fonksiyonu

Örnek 1: LED Yakıp Söndürme

Örnek 2: Seri İletişimi Başlatma

Sonuç

🧠 Arduino IDE ve Alternatifleri: Kurulum ve İlk Kod

Arduino IDE: Nedir ve Neden Kullanmalıyız?

Arduino IDE Kurulumu

İlk Kodumuz: "Hello World" (Blink Örneği)

Blink Devresi (Harici LED ile)

Arduino IDE Alternatifleri

Sonuç

🔌 Arduino Nedir? Nasıl Çalışır? Başlangıç Rehberi

Arduino Nedir?

Arduino Nasıl Çalışır?

Temel Bileşenler

Arduino ile İlk Proje: LED Yakıp Söndürme

Arduino IDE Nedir?

Nereden Başlamalıyım?

LCD Ekranlı Mini Oyun: Tahmin Etmece (Buton Kontrollü)

Gerekli Malzemeler

Devre Şeması

Arduino Kodu

Kodun Açıklaması

Oyunun Oynanışı

İpuçları ve Geliştirme Fikirleri

Arduino ile Uyan: Titreşimli Bileklik Alarm Sistemi

Proje Amacı

Gerekli Malzemeler

Devre Şeması

Arduino Kodu

Kodu Açıklayalım

Proje Uygulaması ve İpuçları

Arduino ile Akıllı Geri Sayım Sayacı: Sınavlar ve Egzersizler için İdeal

Neden Akıllı Bir Geri Sayım Sayacına İhtiyacımız Var?

Gerekli Malzemeler

Devre Şeması ve Bağlantılar

Arduino Kodu

Kodu Açıklayalım

Projenin Kullanımı

Geliştirme İpuçları

Arduino ile Sesle Kontrol Edilebilen Lamba Sistemi (Arduino + Ses Sensörü)

Gerekli Malzemeler

Devre Şeması ve Bağlantılar

Arduino Kodu

Kodun Açıklaması

Projenin Çalışması

Pinleri Tanımlama: `pinMode()` Fonksiyonu

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

Giriş Pinlerinden Veri Okuma: `digitalRead()` Fonksiyonu

`void loop()` Döngüsü

`for` Döngüsü

`while` Döngüsü

`do...while` Döngüsü