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

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

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

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

  1. Arduino'yu bilgisayarınıza bağlayın ve kodu yükleyin.
  2. LCD ekranda "Tahmin Etmece!" yazısı belirecek.
  3. Oyunu başlatmak için "OK" butonuna basın.
  4. Yukarı ve aşağı butonlarını kullanarak tahmininizi ayarlayın.
  5. Tahmininizden eminseniz, "OK" butonuna basın.
  6. Eğer tahmininiz doğruysa, "Tebrikler!" yazısı belirecek. Değilse, "Daha Yüksek!" veya "Daha Düşük!" uyarıları alacaksınız.
  7. 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

```

Arduino ile Uyan: Titreşimli Bileklik Alarm Sistemi

Arduino ile Uyan: Titreşimli Bileklik Alarm Sistemi

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

```

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

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

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

```

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

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

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

```

Smart Pot with Arduino: Know When Your Plants Need Water

Smart Pot with Arduino: Know When Your Plants Need Water

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

```

Arduino ve Bluetooth ile Kablosuz Uzaktan Kumanda Yapımı

Arduino ve Bluetooth ile Kablosuz Uzaktan Kumanda Yapımı

Arduino ve Bluetooth ile Kablosuz Uzaktan Kumanda Yapımı

Merhaba sevgili Arduino meraklıları!

Bu yazımızda, Arduino ve Bluetooth kullanarak nasıl kablosuz bir uzaktan kumanda yapabileceğinizi adım adım anlatacağım. Bu proje hem eğlenceli hem de birçok farklı uygulama için temel oluşturabilecek bir proje. İster robotunuzu kontrol edin, ister ev otomasyon sisteminizi yönetin, bu uzaktan kumanda size esneklik sağlayacak.

Gerekli Malzemeler

  • Arduino Uno (veya benzeri bir Arduino kartı)
  • HC-05 veya HC-06 Bluetooth Modülü
  • Butonlar (İhtiyacınız kadar)
  • 10k Ohm Dirençler (Buton başına bir adet)
  • Breadboard
  • Jumper Kablolar
  • Akıllı Telefon (Bluetooth uygulaması için)

Devre Şeması ve Bağlantılar

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

  • Bluetooth Modülü:
    • HC-05 VCC -> Arduino 5V
    • HC-05 GND -> Arduino GND
    • HC-05 TXD -> Arduino Dijital Pin 10 (veya farklı bir pin, yazılımda belirtilmeli)
    • HC-05 RXD -> Arduino Dijital Pin 11 (veya farklı bir pin, yazılımda belirtilmeli)
  • Butonlar:
    • Her bir butonun bir bacağı Arduino'nun dijital giriş pinlerinden birine (örneğin 2, 3, 4, 5) bağlanır.
    • Aynı bacağa 10k Ohm direnç bağlanarak Arduino GND'ye çekilir (pull-down direnci).
    • Butonun diğer bacağı Arduino'nun 5V pinine bağlanır.

Önemli Not: HC-05 ve HC-06 modüllerinin TX ve RX pinlerini Arduino'ya bağlarken dikkatli olun. RX pinini Arduino'nun TX pinine, TX pinini ise Arduino'nun RX pinine bağlamanız gerekmektedir. Ayrıca, Arduino IDE'de Serial Monitor'ü kullanırken veya kod yüklerken Bluetooth modülünün bağlantısını kesmeniz önerilir. Aksi takdirde, kod yüklemede sorun yaşayabilirsiniz.

Arduino Kodu

Aşağıdaki kodu Arduino IDE'sine kopyalayın ve kartınıza yükleyin. Bu kod, butonlara basıldığında belirli karakterleri Bluetooth üzerinden gönderecektir.


// Buton pinlerini tanımla
const int button1Pin = 2;
const int button2Pin = 3;
const int button3Pin = 4;
const int button4Pin = 5;

// Değişkenleri tanımla
int button1State = 0;
int button2State = 0;
int button3State = 0;
int button4State = 0;

void setup() {
  // Buton pinlerini giriş olarak ayarla
  pinMode(button1Pin, INPUT_PULLUP); // Dahili pull-up direnci kullanılıyor
  pinMode(button2Pin, INPUT_PULLUP); // Dahili pull-up direnci kullanılıyor
  pinMode(button3Pin, INPUT_PULLUP); // Dahili pull-up direnci kullanılıyor
  pinMode(button4Pin, INPUT_PULLUP); // Dahili pull-up direnci kullanılıyor

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

void loop() {
  // Buton durumlarını oku
  button1State = digitalRead(button1Pin);
  button2State = digitalRead(button2Pin);
  button3State = digitalRead(button3Pin);
  button4State = digitalRead(button4Pin);

  // Butonlara basıldığında ilgili karakteri gönder
  if (button1State == LOW) {
    Serial.println("A"); // Buton 1 basıldığında 'A' karakterini gönder
    delay(200); // Debouncing için kısa bir gecikme
  }
  if (button2State == LOW) {
    Serial.println("B"); // Buton 2 basıldığında 'B' karakterini gönder
    delay(200); // Debouncing için kısa bir gecikme
  }
  if (button3State == LOW) {
    Serial.println("C"); // Buton 3 basıldığında 'C' karakterini gönder
    delay(200); // Debouncing için kısa bir gecikme
  }
  if (button4State == LOW) {
    Serial.println("D"); // Buton 4 basıldığında 'D' karakterini gönder
    delay(200); // Debouncing için kısa bir gecikme
  }
}

Kod Açıklaması:

  • Kod, buton pinlerini ve buton durumlarını tutacak değişkenleri tanımlar.
  • setup() fonksiyonunda, buton pinleri giriş olarak ayarlanır ve seri iletişim başlatılır. INPUT_PULLUP modu kullanılarak harici dirençlere ihtiyaç duyulmaz.
  • loop() fonksiyonunda, butonların durumları sürekli olarak okunur.
  • Eğer bir butona basılırsa (LOW seviyesine düşerse), ilgili karakter Bluetooth üzerinden gönderilir.
  • delay() fonksiyonu, butonun birden fazla kez tetiklenmesini önlemek için (debouncing) kullanılır.

Bluetooth Uygulaması

Akıllı telefonunuz için Bluetooth Terminal uygulaması indirmeniz gerekiyor. Google Play Store veya App Store'dan "Bluetooth Terminal" veya benzeri bir uygulama indirebilirsiniz. Uygulamayı kurduktan sonra, aşağıdaki adımları izleyin:

  1. Telefonunuzun Bluetooth'unu açın.
  2. Bluetooth Terminal uygulamasını açın.
  3. Uygulama içinden Bluetooth cihazlarını tarayın ve HC-05 veya HC-06 modülünüzü seçin. Genellikle "HC-05" veya "HC-06" olarak görünecektir.
  4. Eşleştirme şifresi sorarsa genellikle "1234" veya "0000"dır.
  5. Bağlantı kurulduktan sonra, butonlara bastığınızda terminal ekranında ilgili karakterleri görmelisiniz.

Sonuç ve Uygulama Alanları

Tebrikler! Artık basit bir kablosuz uzaktan kumanda yaptınız. Bu projeyi geliştirerek farklı uygulamalarda kullanabilirsiniz. Örneğin:

  • Robot kontrolü
  • Ev otomasyon sistemleri
  • Model araba veya uçak kontrolü
  • Sunum kontrolü

Bu projenin temelini öğrendikten sonra, hayal gücünüzü kullanarak çok daha karmaşık ve ilginç projeler geliştirebilirsiniz. Unutmayın, Arduino ile her şey mümkün!

Herkese iyi çalışmalar!

Etiketler: Arduino, Bluetooth, Uzaktan Kumanda, Kablosuz, HC-05, HC-06, Proje, DIY, Elektronik, Robotik

```

Arduino ile Park Sensörü Yapımı: Buzzer ve Mesafe Sensörü Kullanımı

Arduino ile Park Sensörü Yapımı: Buzzer ve Mesafe Sensörü Kullanımı

Arduino ile Park Sensörü Yapımı: Buzzer ve Mesafe Sensörü Kullanımı

Merhaba sevgili Arduino meraklıları!

Bu yazımızda, günlük hayatta oldukça işimize yarayan bir projeye, Arduino ile park sensörü yapımına odaklanacağız. Özellikle yeni sürücüler veya park etme konusunda hassas olanlar için bu proje, hem eğlenceli bir öğrenme deneyimi sunacak, hem de pratik bir çözüm olacaktır. Projemizde, HC-SR04 ultrasonik mesafe sensörü ve bir buzzer (sesli uyarıcı) kullanarak, aracımızın arkasındaki engelleri tespit edip, mesafeye göre farklı sesli uyarılar vermesini sağlayacağız.

Gerekli Malzemeler

Bu projeyi hayata geçirmek için ihtiyacımız olan malzemeler oldukça basit ve kolayca temin edilebilir:

  • Arduino Uno (veya benzeri bir Arduino kartı)
  • HC-SR04 Ultrasonik Mesafe Sensörü
  • Buzzer (Aktif veya Pasif fark etmez, aktif buzzer kullanımı daha basittir)
  • Jumper kablolar (erkek-dişi ve erkek-erkek)
  • Breadboard (isteğe bağlı, ancak önerilir)

Devre Şeması ve Bağlantılar

Şimdi de malzemelerimizi nasıl bağlayacağımıza geçelim. Bağlantıları dikkatlice yaparak herhangi bir hatanın önüne geçebiliriz:

  • HC-SR04 Mesafe Sensörü:
    • VCC pini -> Arduino 5V pinine
    • GND pini -> Arduino GND pinine
    • Trig pini -> Arduino Dijital Pin 9'a
    • Echo pini -> Arduino Dijital Pin 10'a
  • Buzzer:
    • (+) bacağı -> Arduino Dijital Pin 8'e (direkt olarak veya bir dirençle)
    • (-) bacağı -> Arduino GND pinine

Eğer aktif buzzer kullanıyorsanız, genellikle bir direnç kullanmanıza gerek kalmaz. Ancak pasif buzzer kullanıyorsanız, 220Ω - 1kΩ arasında bir direnç kullanmanız buzzer'ınızın zarar görmesini engelleyebilir.

Arduino Kodu

Gelelim projemizin beyni olan Arduino koduna. Aşağıdaki kodu Arduino IDE'sine kopyalayıp, Arduino kartınıza yükleyebilirsiniz:


 // Tanımlamalar
 const int trigPin = 9;
 const int echoPin = 10;
 const int buzzerPin = 8;

 // Değişkenler
 long sure;
 int mesafe;

 void setup() {
  // Pinleri tanımla
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(buzzerPin, OUTPUT);

  // Seri iletişimi başlat (isteğe bağlı, değerleri görmek için)
  Serial.begin(9600);
 }

 void loop() {
  // Mesafe ölçümü
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  sure = pulseIn(echoPin, HIGH);
  mesafe = sure * 0.034 / 2;

  // Mesafe kontrolü ve buzzer uyarıları
  if (mesafe <= 30) {
   tone(buzzerPin, 1000); // Yüksek ton
   delay(100);
  } else if (mesafe <= 60) {
   tone(buzzerPin, 500); // Orta ton
   delay(200);
  } else if (mesafe <= 100) {
   tone(buzzerPin, 250); // Düşük ton
   delay(300);
  } else {
   noTone(buzzerPin); // Ses yok
  }

  // Seri porttan mesafeyi yazdır (isteğe bağlı)
  Serial.print("Mesafe: ");
  Serial.print(mesafe);
  Serial.println(" cm");

  delay(50); // Gecikme
 }
 

Kodun Açıklaması

  • Tanımlamalar: Hangi pinlerin hangi bileşenlere bağlı olduğunu tanımlıyoruz.
  • Mesafe Ölçümü: Mesafe sensörünü kullanarak mesafeyi ölçüyoruz.
  • Mesafe Kontrolü ve Buzzer Uyarıları: Ölçülen mesafeye göre buzzer'dan farklı tonlarda sesler çıkarıyoruz. Mesafe azaldıkça, sesin frekansını artırıyoruz.
  • Seri Porttan Mesafeyi Yazdır: (İsteğe bağlı) Ölçülen mesafeyi seri port ekranında görüntüleyerek, sensörün doğru çalışıp çalışmadığını kontrol edebiliriz.

Projenin Çalışması

Kodu Arduino'ya yükledikten sonra, mesafe sensörünü bir engele doğru tuttuğunuzda, sensörün mesafeyi ölçüp buzzer'dan uygun tonlarda ses çıkardığını göreceksiniz. Mesafe azaldıkça sesin şiddeti ve frekansı artacaktır.

İpuçları ve Geliştirmeler

  • Mesafe sensörünü aracınızın arkasına monte ederek, gerçek bir park sensörü haline getirebilirsiniz.
  • Buzzer yerine farklı sesler çıkaran bir hoparlör kullanabilirsiniz.
  • LCD ekran kullanarak mesafeyi sayısal olarak da görüntüleyebilirsiniz.
  • Mesafe aralıklarını ve ses tonlarını kendi zevkinize göre ayarlayabilirsiniz.

Sonuç

Bu yazımızda, Arduino ile basit bir park sensörü yapımını adım adım inceledik. Umarım bu proje, Arduino dünyasına giriş yapmanız ve elektronik projeler geliştirmeniz için size ilham verir. Unutmayın, elektronik projeler sadece bilgi birikimi değil, aynı zamanda yaratıcılığınızı da geliştirmenize yardımcı olur.

Herkese iyi kodlamalar!

Etiketler: Arduino, Park Sensörü, HC-SR04, Buzzer, Mesafe Sensörü, Elektronik Proje, DIY, Kendin Yap, Arduino Projeleri, Arduino Dersleri

```

Arduino ile Uyan: Titreşimli Bileklik Alarm Sistemi

Arduino ile Uyan: Titreşimli Bileklik Alarm Sistemi

Arduino ile Uyan: Titreşimli Bileklik Alarm Sistemi

Merhaba sevgili Arduino dostları!

Sabahları alarm sesinden nefret mi ediyorsunuz? Belki de etrafınızdakileri uyandırmadan kendinizi nazikçe uyandırmak istiyorsunuz. O zaman bu proje tam size göre! Bu yazımızda, Arduino kullanarak titreşimli bir bileklik alarm sistemi nasıl yapacağımızı adım adım inceleyeceğiz. Projemiz hem eğlenceli hem de pratik, özellikle öğrenci arkadaşlarımızın yurt odalarında kullanabileceği harika bir alternatif.

Neye İhtiyacımız Var?

Projemize başlamadan önce aşağıdaki malzemelere ihtiyacımız olacak:

  • Arduino Uno (veya benzeri bir Arduino geliştirme kartı)
  • Titreşim motoru (küçük boyutlu, bilekliğe sığabilecek)
  • DS3231 RTC (Gerçek Zamanlı Saat) Modülü
  • 330 Ohm direnç
  • NPN Transistör (örn. 2N2222 veya BC547)
  • Bileklik (Saat kayışı veya benzeri)
  • Jumper kablolar
  • Breadboard (isteğe bağlı, ama işleri kolaylaştırır)
  • Pil veya güç kaynağı (Arduino için)

Bağlantılar ve Şema

Şimdi de devre bağlantılarımızı nasıl yapacağımıza bakalım. Aşağıdaki bağlantıları dikkatlice uygulayın:

  • DS3231 RTC Modülü:
    • VCC -> Arduino 5V
    • GND -> Arduino GND
    • SDA -> Arduino A4
    • SCL -> Arduino A5
  • Titreşim Motoru:
    • Titreşim Motoru (+) -> 330 Ohm Direnç -> Transistör Base (Orta bacak)
    • Titreşim Motoru (-) -> Transistör Collector (Genellikle sağdaki bacak)
    • Transistör Emitter (Genellikle soldaki bacak) -> Arduino GND
    • Arduino Dijital Pin 9 -> 330 Ohm Direncin diğer ucu (direkt olarak transistörün base'ine gidiyor)

Açıklama: Titreşim motorunu doğrudan Arduino pinine bağlamak yerine transistör kullanmamızın sebebi, motorun Arduino'dan çok fazla akım çekmesini engellemektir. Transistör, motor için bir anahtar görevi görür ve motorun ihtiyacı olan akımı Arduino'ya zarar vermeden sağlar.

Arduino Kodu

Şimdi de Arduino kodumuza geçelim. Aşağıdaki kodu Arduino IDE'nize kopyalayın ve Arduino'nuza yükleyin. Kodu yüklemeden önce DS3231 RTC modülünün doğru zamanı gösterdiğinden emin olun. Bunun için Arduino Türkiye gibi sitelerdeki RTC modülü ayarlama örneklerine göz atabilirsiniz.

```cpp #include #include RTC_DS3231 rtc; int vibrationPin = 9; // Titreşim motorunun bağlı olduğu pin int alarmHour = 7; // Alarm saati (örneğin, 7:00) int alarmMinute = 0; // Alarm dakikası void setup() { Serial.begin(9600); if (! rtc.begin()) { Serial.println("RTC Modülü Bulunamadı!"); while (1); } pinMode(vibrationPin, OUTPUT); } void loop() { DateTime now = rtc.now(); Serial.print(now.hour(), DEC); Serial.print(':'); Serial.print(now.minute(), DEC); Serial.print(':'); Serial.println(now.second(), DEC); if (now.hour() == alarmHour && now.minute() == alarmMinute && now.second() == 0) { // Alarm çalma zamanı geldi! vibrate(10); // 10 saniye titreşim } delay(1000); // Her saniyede bir kontrol et } void vibrate(int seconds) { for (int i = 0; i < seconds; i++) { digitalWrite(vibrationPin, HIGH); // Titreşimi başlat delay(500); digitalWrite(vibrationPin, LOW); // Titreşimi durdur delay(500); } } ```

Açıklama: Bu kod, RTC modülünden saat ve dakika bilgilerini okur ve önceden belirlenmiş alarm saatiyle karşılaştırır. Saat ve dakika eşleştiğinde, `vibrate()` fonksiyonu çağrılır ve titreşim motoru belirtilen süre boyunca çalışır.

Bilekliği Tasarlama ve Birleştirme

Devremizi kurduktan sonra, bileklik kısmını tasarlamaya geçebiliriz. Arduino'nun ve pilin bileğe rahatça sığması için dikkatli bir tasarım yapmamız gerekiyor. 3D yazıcı kullanarak özel bir kutu tasarlayabilir veya hazır bilekliklerden yararlanabilirsiniz. Titreşim motorunu bileğinizle temas edecek şekilde yerleştirmeniz, titreşimi daha iyi hissetmenizi sağlayacaktır.

Sonuç

Tebrikler! Artık kendi titreşimli bileklik alarm sisteminize sahipsiniz. Bu proje sadece bir başlangıç noktası. Kodu ve tasarımı kendi ihtiyaçlarınıza göre geliştirebilirsiniz. Örneğin, alarm erteleme özelliği ekleyebilir, farklı titreşim desenleri oluşturabilir veya Bluetooth ile telefonunuza bağlayarak alarmı telefonunuzdan kontrol edebilirsiniz.

Umarım bu proje size ilham vermiştir. Arduino ile yaratıcılığınızı kullanarak harika projeler geliştirmeye devam edin!

Bol kodlu günler!

Etiketler: arduino, titreşimli bileklik, alarm, proje, diy, rtc, ds3231, elektronik, hobi, öğrenci

```

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

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

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

Merhaba sevgili Arduino meraklıları!

Bugün sizlere Arduino ile nasıl akıllı bir geri sayım sayacı yapabileceğinizi anlatacağım. Bu proje, özellikle sınavlara hazırlanan öğrenciler veya egzersiz yapanlar için çok kullanışlı olabilir. Hatta mutfakta yemek yaparken bile size yardımcı olacak bir zamanlayıcıya dönüştürebilirsiniz.

Projenin Amacı

Bu projenin amacı, Arduino kullanarak belirli bir süre geri sayım yapabilen ve süre dolduğunda sesli veya görsel bir uyarı verebilen bir cihaz oluşturmaktır. Bu cihazı ihtiyacınıza göre özelleştirebilirsiniz.

Gerekli Malzemeler

İhtiyacımız olan malzemeler oldukça basit:

  • Arduino Uno (veya benzeri bir Arduino kartı)
  • Bir adet 16x2 LCD ekran
  • 4 adet buton (veya push button)
  • 1 adet buzzer (sesli uyarı için)
  • 10k potansiyometre (LCD ekran kontrast ayarı için)
  • Birkaç adet jumper kablo
  • Breadboard (isteğe bağlı, ama önerilir)

Bağlantı Şeması

Şimdi de malzemeleri Arduino'ya nasıl bağlayacağımıza bakalım:

  1. LCD Ekran Bağlantısı:
    • LCD VSS pin -> Arduino GND
    • LCD VDD pin -> Arduino 5V
    • LCD VO pin -> Potansiyometrenin orta pini (Potansiyometrenin diğer iki pini GND ve 5V'a bağlanacak)
    • LCD RS pin -> Arduino Dijital Pin 12
    • LCD Enable pin -> Arduino Dijital Pin 11
    • LCD D4 pin -> Arduino Dijital Pin 5
    • LCD D5 pin -> Arduino Dijital Pin 4
    • LCD D6 pin -> Arduino Dijital Pin 3
    • LCD D7 pin -> Arduino Dijital Pin 2
    • LCD A pin (Arka ışık anot) -> Arduino 5V (direnç ile bağlanması önerilir, örneğin 220 ohm)
    • LCD K pin (Arka ışık katot) -> Arduino GND
  2. Buton Bağlantıları:

    Her bir buton bir ucu Arduino'nun bir dijital pinine (örneğin 6, 7, 8, 9) bağlanacak. Diğer ucu ise GND'ye bir 10k ohm'luk direnç ile bağlanacak. Butona basıldığında, dijital pin HIGH sinyali alacak.

    • 1. Buton -> Arduino Dijital Pin 6
    • 2. Buton -> Arduino Dijital Pin 7
    • 3. Buton -> Arduino Dijital Pin 8
    • 4. Buton -> Arduino Dijital Pin 9
    • Her butonun GND tarafına 10k direnç
  3. Buzzer Bağlantısı:
    • Buzzer pozitif (+) ucu -> Arduino Dijital Pin 10
    • Buzzer negatif (-) ucu -> Arduino GND

Arduino Kodu

Aşağıdaki kod, temel bir geri sayım sayacı işlevini yerine getirir. Butonlar ile süreyi ayarlayabilir, başlatıp durdurabilirsiniz. LCD ekran üzerinde kalan süre gösterilir ve süre bittiğinde buzzer çalar.


#include <LiquidCrystal.h>

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

// Buton pin tanımlamaları
const int button1Pin = 6; // Süreyi artırma
const int button2Pin = 7; // Süreyi azaltma
const int button3Pin = 8; // Başlat/Durdur
const int button4Pin = 9; // Reset
const int buzzerPin = 10;   // Buzzer pini

int timeLeft = 60;          // Geri sayım süresi (saniye)
bool timerRunning = false;  // Zamanlayıcının çalışıp çalışmadığı

void setup() {
  lcd.begin(16, 2);
  pinMode(button1Pin, INPUT_PULLUP);
  pinMode(button2Pin, INPUT_PULLUP);
  pinMode(button3Pin, INPUT_PULLUP);
  pinMode(button4Pin, INPUT_PULLUP);
  pinMode(buzzerPin, OUTPUT);

  updateDisplay();
}

void loop() {
  if (digitalRead(button1Pin) == LOW) { // Süreyi artır
    timeLeft += 10;
    if (timeLeft > 3600) timeLeft = 3600; // Maksimum 1 saat
    updateDisplay();
    delay(200); // Buton debounce
  }

  if (digitalRead(button2Pin) == LOW) { // Süreyi azalt
    timeLeft -= 10;
    if (timeLeft < 0) timeLeft = 0;
    updateDisplay();
    delay(200); // Buton debounce
  }

  if (digitalRead(button3Pin) == LOW) { // Başlat/Durdur
    timerRunning = !timerRunning;
    delay(200); // Buton debounce
  }
    if (digitalRead(button4Pin) == LOW) { // Reset
    timeLeft = 60;
    timerRunning = false;
    updateDisplay();
    delay(200); // Buton debounce
  }

  if (timerRunning) {
    delay(1000);
    timeLeft--;
    updateDisplay();

    if (timeLeft <= 0) {
      timerRunning = false;
      buzzerAlarm();
      timeLeft = 0; // Süre negatif olmasın
      updateDisplay();
    }
  }
}

void updateDisplay() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Kalan Sure:");
  lcd.setCursor(0, 1);
  lcd.print(timeLeft / 60);
  lcd.print(":");
  if (timeLeft % 60 < 10) lcd.print("0"); // Saniyeyi iki haneli gösterme
  lcd.print(timeLeft % 60);
}

void buzzerAlarm() {
  for (int i = 0; i < 5; i++) {
    tone(buzzerPin, 1000); // 1 kHz ton
    delay(500);
    noTone(buzzerPin);
    delay(500);
  }
}

Bu kodu Arduino IDE'sine kopyalayın ve kartınıza yükleyin.

Kod Açıklaması

  • #include <LiquidCrystal.h>: LCD kütüphanesini projeye dahil eder.
  • LiquidCrystal lcd(rs, en, d4, d5, d6, d7);: LCD ekranın pin bağlantılarını tanımlar.
  • pinMode(buttonPin, INPUT_PULLUP);: Buton pinlerini giriş olarak ayarlar ve dahili pull-up dirençlerini etkinleştirir. Bu, butonlara harici direnç bağlamamıza gerek kalmadan çalışmasını sağlar.
  • updateDisplay(): LCD ekranı günceller ve kalan süreyi gösterir.
  • buzzerAlarm(): Süre bittiğinde buzzer'ı çaldırır.

Projenin Geliştirilmesi

Bu projeyi daha da geliştirmek isterseniz, şunları ekleyebilirsiniz:

  • Farklı alarm sesleri
  • Menü sistemi ile süre ayarlama
  • Bluetooth modülü ile uzaktan kontrol
  • Gerçek zamanlı saat modülü (RTC) ile doğru zaman takibi

Sonuç

Arduino ile akıllı bir geri sayım sayacı yapmak oldukça kolay ve eğlenceli. Bu proje, elektronik ve programlama becerilerinizi geliştirmenize yardımcı olurken, aynı zamanda günlük hayatınızda kullanabileceğiniz pratik bir araç sunar. Umarım bu blog yazısı size ilham vermiştir. Bir sonraki projede görüşmek üzere!

Etiketler: Arduino, geri sayım sayacı, sınav, egzersiz, timer, proje, kod, elektronik, DIY, zamanlayıcı, lcd ekran, buzzer

```

Arduino ile Basit Bir Hırsız Alarmı Sistemi: PIR Sensörlü Arduino Güvenliği

Arduino ile Basit Bir Hırsız Alarmı Sistemi: PIR Sensörlü Arduino Güvenliği

Arduino ile Basit Bir Hırsız Alarmı Sistemi: PIR Sensörlü Arduino Güvenliği

Merhaba sevgili Arduino severler!

Bu yazımızda, Arduino kullanarak basit ama etkili bir hırsız alarmı sistemi nasıl kuracağımızı öğreneceğiz. Bu proje hem yeni başlayanlar için uygun, hem de Arduino'nun potansiyelini anlamak için harika bir fırsat.

Neden Bu Proje?

Ev veya ofis güvenliğini artırmak, pahalı güvenlik sistemlerine bağımlı kalmadan da mümkün. Bu proje sayesinde, hareket algılayan bir PIR (Passive Infrared) sensörü kullanarak, istenmeyen bir hareket algılandığında uyarı veren bir alarm sistemi oluşturabileceksiniz. Üstelik bu sistemi kişisel ihtiyaçlarınıza göre kolayca özelleştirebilirsiniz.

Gerekli Malzemeler

  • Arduino Uno (veya benzeri bir Arduino kartı)
  • PIR Hareket Sensörü
  • Buzzer (sesli uyarı için)
  • Jumper kablolar
  • 1 adet 220 ohm direnç (buzzer için)
  • Breadboard (isteğe bağlı, bağlantıları kolaylaştırmak için)

Bağlantı Şeması

Şimdi de malzemeleri nasıl bağlayacağımıza bakalım. Dikkatlice uygulayın, yanlış bağlantılar donanımınıza zarar verebilir!

  • PIR Sensörü VCC pini -> Arduino 5V pinine
  • PIR Sensörü GND pini -> Arduino GND pinine
  • PIR Sensörü OUT pini -> Arduino Dijital 2 pinine
  • Buzzer (+) pini -> 220 ohm direnç üzerinden Arduino Dijital 8 pinine
  • Buzzer (-) pini -> Arduino GND pinine

Arduino Kodu

Bağlantıları tamamladıktan sonra, sıra geldi Arduino kodunu yüklemeye. Aşağıdaki kodu Arduino IDE'sine kopyalayın ve Arduino kartınıza yükleyin.


const int pirPin = 2;    // PIR sensörünün bağlı olduğu pin
const int buzzerPin = 8; // Buzzer'ın bağlı olduğu pin

void setup() {
  pinMode(pirPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
  Serial.begin(9600); // Seri port iletişimi başlatılıyor (debug için)
}

void loop() {
  int pirDegeri = digitalRead(pirPin);

  if (pirDegeri == HIGH) {
    // Hareket algılandı!
    Serial.println("Hareket Algılandı!");
    digitalWrite(buzzerPin, HIGH); // Buzzer'ı çal
    delay(1000);                   // 1 saniye çal
    digitalWrite(buzzerPin, LOW);  // Buzzer'ı kapat
    delay(5000);                   // 5 saniye bekle
  } else {
    // Hareket yok
    digitalWrite(buzzerPin, LOW); // Buzzer'ı kapalı tut
  }
}

Kod Açıklaması:

  • pirPin ve buzzerPin değişkenleri, PIR sensörünün ve buzzer'ın hangi pinlere bağlı olduğunu belirtir.
  • setup() fonksiyonu, pin modlarını ayarlar (PIR sensörü giriş, buzzer çıkış).
  • loop() fonksiyonu sürekli olarak PIR sensöründen veri okur. Eğer hareket algılanırsa, buzzer çalınır.

Test Etme ve İyileştirmeler

Kodu yükledikten sonra sistemi test edebilirsiniz. PIR sensörünün önüne geçerek hareketi tetikleyin ve buzzer'ın çaldığını kontrol edin. Eğer her şey yolundaysa, tebrikler! Başarılı bir hırsız alarmı sistemi kurdunuz.

Bu projeyi daha da geliştirmek için aşağıdaki fikirleri deneyebilirsiniz:

  • LCD ekran ekleyerek uyarı mesajlarını görüntüleyebilirsiniz.
  • GSM modülü kullanarak SMS ile uyarı gönderebilirsiniz.
  • Farklı sensörler (örneğin, duman sensörü) ekleyerek sistemi daha kapsamlı hale getirebilirsiniz.

Umarım bu proje, Arduino dünyasına güzel bir giriş yapmanıza yardımcı olur. Sorularınız ve yorumlarınız için aşağıdaki bölümü kullanmaktan çekinmeyin.

Herkese keyifli projeler!

Etiketler: arduino, hırsız alarmı, pir sensör, güvenlik, proje, sensör, alarm sistemi, kolay kurulum, adım adım rehber, elektronik, diy, kendin yap

Arduino ile Sesle Kontrol Edilebilen Lamba Sistemi: Basit ve Eğlenceli Proje | Arduonik

Arduino ile Sesle Kontrol Edilebilen Lamba Sistemi: Basit ve Eğlenceli Proje

Arduino ile Sesle Kontrol Edilebilen Lamba Sistemi: Basit ve Eğlenceli Proje

Merhaba sevgili Arduino severler ve elektronik meraklıları!

Bu blog yazımızda, Arduino kullanarak nasıl sesle kontrol edilebilen bir lamba sistemi oluşturabileceğimizi adım adım inceleyeceğiz. Projemiz hem eğlenceli hem de oldukça basit, bu yüzden Arduino dünyasına yeni adım atanlar için harika bir başlangıç olacak. Hazırsanız, malzemelerimizi hazırlayalım ve kodlamaya başlayalım!

Gerekli Malzemeler

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

  • Arduino Uno (veya benzeri bir Arduino kartı)
  • KY-038 Ses Algılama Modülü (Ses Sensörü)
  • LED Lamba (veya bir röle modülü ile kontrol edebileceğiniz herhangi bir lamba)
  • 220 Ohm Direnç (LED için)
  • Jumper Kabloları
  • Breadboard (isteğe bağlı, devre kurulumunu kolaylaştırır)

Devre Şeması ve Bağlantılar

Devremizi kurarken dikkat etmemiz gereken bağlantılar şunlar:

  • Ses Sensörü VCC -> Arduino 5V (Ses sensörünün güç kaynağı bağlantısı)
  • Ses Sensörü GND -> Arduino GND (Ses sensörünün toprak bağlantısı)
  • Ses Sensörü D0 (Dijital Çıkış) -> Arduino Dijital Pin 2 (Ses algılandığında sinyal gönderecek)
  • LED'in Anot (+) -> 220 Ohm Direnç -> Arduino Dijital Pin 13 (LED'i kontrol pini)
  • LED'in Katot (-) -> Arduino GND (LED'in toprak bağlantısı)

Eğer röle modülü kullanıyorsanız, Arduino'nun bir dijital pini ile röleyi kontrol edip, röle üzerinden lambanıza güç verebilirsiniz. Röle bağlantıları, kullandığınız röle modülüne göre değişiklik gösterebilir, bu yüzden modülün datasheet'ini incelemeniz önemlidir.

Arduino Kodu

Şimdi de Arduino kodumuza göz atalım. Bu kod, ses sensöründen gelen sinyali dinleyecek ve bir ses algılandığında LED'i yakıp söndürecek:


const int sesSensoruPin = 2; // Ses sensörünün bağlı olduğu pin
const int ledPin = 13;       // LED'in bağlı olduğu pin
int ledDurumu = LOW;        // LED'in başlangıç durumu

void setup() {
  pinMode(sesSensoruPin, INPUT); // Ses sensörü girişi olarak ayarlandı
  pinMode(ledPin, OUTPUT);       // LED çıkış olarak ayarlandı
  Serial.begin(9600);          // Seri iletişim başlatıldı (debug için)
}

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

  if (sesDegeri == LOW) { // Ses algılandıysa (KY-038 LOW sinyali gönderir)
    Serial.println("Ses Algilandi!"); // Seri port ekranına yazdır
    delay(50); // Stabilizasyon için kısa bir bekleme

    // LED'in durumunu değiştir
    if (ledDurumu == LOW) {
      ledDurumu = HIGH;
    } else {
      ledDurumu = LOW;
    }

    digitalWrite(ledPin, ledDurumu); // LED'i yak veya söndür
    delay(500);                    // Kısa bir bekleme
  }
}

Bu kodu Arduino IDE'nize kopyalayın ve Arduino kartınıza yükleyin. Seri port monitörünü açarak ses algılandığında "Ses Algilandi!" mesajını görüp görmediğinizi kontrol edebilirsiniz.

Projenin Çalışma Prensibi

Projemiz, ses sensörünün çevredeki sesleri algılaması ve bu bilgiyi Arduino'ya iletmesi prensibiyle çalışır. Ses sensörü, belirli bir eşik değerinin üzerinde bir ses algıladığında Arduino'ya düşük seviyede (LOW) bir sinyal gönderir. Arduino, bu sinyali aldığında LED'in durumunu değiştirir; eğer LED kapalıysa açar, açıksa kapatır.

Projenin Geliştirilmesi

Bu basit projeyi daha da geliştirmek için birçok farklı fikir deneyebilirsiniz:

  • Birden fazla lamba ekleyerek farklı ses komutlarıyla farklı lambaları kontrol edebilirsiniz.
  • Ses tanıma kütüphaneleri kullanarak daha karmaşık ses komutları tanımlayabilirsiniz.
  • Bir LCD ekran ekleyerek, hangi komutun algılandığını gösterebilirsiniz.
  • İnternete bağlanarak, lambayı uzaktan kontrol edebilirsiniz.

Sonuç

Bu yazımızda, Arduino ile sesle kontrol edilebilen basit bir lamba sisteminin nasıl oluşturulacağını adım adım öğrendik. Bu proje, hem Arduino'ya yeni başlayanlar için harika bir öğrenme fırsatı sunuyor, hem de elektronik projelerin ne kadar eğlenceli olabileceğini gösteriyor. Umarız siz de bu projeyi denemekten keyif alırsınız!

Herkese iyi kodlamalar!

Etiketler: arduino, sesle kontrol, lamba, ses sensörü, proje, elektronik, diy, hobby

```.

Arduino ile Deprem Alarmı Yapımı: Güvenliğiniz İçin İlk Adım

Arduino ile Deprem Alarmı Yapımı: Güvenliğiniz İçin İlk Adım

Arduino ile Deprem Alarmı Yapımı: Güvenliğiniz İçin İlk Adım

Merhaba sevgili okuyucular! Günümüzde depremlerin sıkça yaşandığı bir coğrafyada yaşıyoruz ve bu durum, güvenlik önlemlerini her zamankinden daha önemli hale getiriyor. Bu yazımızda, basit ama etkili bir çözüm olan Arduino ile deprem alarmı yapımını adım adım anlatacağız. Bu proje sayesinde, olası bir sarsıntıyı erkenden fark edip gerekli önlemleri alabilirsiniz.

Neden Arduino ile Deprem Alarmı Yapmalıyız?

Arduino, düşük maliyeti ve kolay programlanabilir yapısı sayesinde elektronik projeler için mükemmel bir platformdur. Evde basit bir sismik sensör kullanarak, profesyonel cihazlara yakın bir hassasiyetle deprem algılama sistemi kurabilirsiniz. Üstelik bu proje, elektronik bilgisi olmayanlar için bile kolayca uygulanabilir.

Gerekli Malzemeler

Bu projeyi hayata geçirmek için aşağıdaki malzemelere ihtiyacınız olacak:

  • Arduino Uno (veya benzeri bir Arduino kartı)
  • Titreşim Sensörü (SW-420 veya benzeri bir model)
  • Buzzer (Sesli alarm için)
  • Jumper kablolar
  • Breadboard (Opsiyonel, kolay bağlantı için)

Bağlantılar ve Devre Şeması

Şimdi malzemelerimizi hazırladığımıza göre, devre bağlantılarını yapalım:

  • Titreşim Sensörü VCC pini -> Arduino 5V pinine
  • Titreşim Sensörü GND pini -> Arduino GND pinine
  • Titreşim Sensörü DO (Digital Output) pini -> Arduino Dijital Pin 2'ye
  • Buzzer (+) pini -> Arduino Dijital Pin 8'e
  • Buzzer (-) pini -> Arduino GND pinine

Bu bağlantıları yaptıktan sonra, devremiz hazır hale gelecektir.

Arduino Kodu

Şimdi sıra geldi Arduino koduna. Aşağıdaki kodu Arduino IDE'sine kopyalayıp, Arduino kartınıza yükleyin:


// Define pin numbers
const int sensorPin = 2;     // Digital pin connected to sensor output
const int buzzerPin = 8;     // Digital pin connected to buzzer

// Variables
int sensorValue = 0;         // Variable to store the sensor value

void setup() {
  pinMode(sensorPin, INPUT);   // Set the sensor pin as input
  pinMode(buzzerPin, OUTPUT); // Set the buzzer pin as output
  Serial.begin(9600);        // Initialize serial communication for debugging
}

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

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

  // If the sensor detects vibration (LOW signal), activate the buzzer
  if (sensorValue == LOW) {
    digitalWrite(buzzerPin, HIGH); // Turn the buzzer ON
    delay(200);                     // Keep the buzzer on for 200 milliseconds
    digitalWrite(buzzerPin, LOW);  // Turn the buzzer OFF
    delay(200);                     // Wait for 200 milliseconds
  } else {
    digitalWrite(buzzerPin, LOW);  // Keep the buzzer OFF
  }

  delay(10); // Small delay to avoid reading too frequently
}

Bu kod, titreşim sensöründen gelen veriyi sürekli olarak okur. Sensör, titreşim algıladığında (LOW sinyali gönderdiğinde), buzzer'ı aktif hale getirir. Böylece bir sarsıntı olduğunda sesli bir uyarı almış olursunuz.

Kodu Açıklaması

  • sensorPin ve buzzerPin değişkenleri, sensör ve buzzer'ın bağlandığı Arduino pinlerini tanımlar.
  • setup() fonksiyonu, pinleri giriş veya çıkış olarak ayarlar ve seri iletişim başlatır.
  • loop() fonksiyonu, sensörden gelen değeri sürekli olarak okur ve buzzer'ı kontrol eder.
  • digitalRead(sensorPin) komutu, sensörden gelen dijital değeri okur.
  • digitalWrite(buzzerPin, HIGH) komutu, buzzer'ı aktif hale getirir.
  • delay() komutu, belirli bir süre beklemeyi sağlar.

Test ve Ayarlama

Kodu yükledikten sonra, sisteminizi test etme zamanı. Sensörü hafifçe sallayarak veya titreterek buzzer'ın çalıp çalmadığını kontrol edin. Eğer buzzer çalmıyorsa, bağlantılarınızı ve kodu tekrar kontrol edin. Sensörün hassasiyetini ayarlamak için, titreşim sensöründeki potansiyometreyi kullanabilirsiniz. Bu sayede, sisteminizi çevresel titreşimlerden etkilenmeyecek şekilde ayarlayabilirsiniz.

Öneriler ve İyileştirmeler

Bu projeyi daha da geliştirmek için aşağıdaki önerileri düşünebilirsiniz:

  • LCD ekran ekleyerek, sarsıntının şiddetini ve diğer bilgileri görsel olarak gösterebilirsiniz.
  • GSM modülü ekleyerek, sarsıntı algılandığında SMS yoluyla bildirim gönderebilirsiniz.
  • Daha hassas bir sismik sensör kullanarak, daha küçük sarsıntıları da algılayabilirsiniz.

Sonuç

Bu yazımızda, Arduino ile basit bir deprem alarmı yapımını adım adım anlattık. Umarım bu proje, sizin ve sevdiklerinizin güvenliği için faydalı olur. Unutmayın, güvenlik her zaman önceliğimiz olmalı. Bir sonraki projede görüşmek üzere!

Etiketler: Arduino, deprem alarmı, sismik sensör, güvenlik, proje, elektronik, diy, kendin yap, titreşim sensörü