Arduino ile Trafik Işığı Simülasyonu: İki Yaya Butonlu ve Erişilebilir Tasarım

Arduino ile Trafik Işığı Simülasyonu: İki Yaya Butonlu ve Erişilebilir Tasarım

Arduino ile Trafik Işığı Simülasyonu: İki Yaya Butonlu ve Erişilebilir Tasarım

Merhaba sevgili Arduino dostları!

Bu yazımızda, Arduino kullanarak nasıl iki yaya butonlu ve erişilebilir bir trafik ışığı simülasyonu oluşturabileceğimizi adım adım inceleyeceğiz. Bu proje hem Arduino temellerini öğrenmek için harika bir başlangıç noktası, hem de gerçek hayattaki trafik sistemlerinin mantığını anlamamıza yardımcı olacak.

Günümüzde şehir planlamasında erişilebilirlik önemli bir konu. Bu nedenle projemize, yaşlı ve engelli vatandaşlarımız için düşünülmüş, daha uzun süreli yaya geçiş izni veren bir buton ekleyeceğiz. Hazırsanız, malzemelerimizi hazırlayalım ve kodlamaya başlayalım!

Gerekli Malzemeler

  • Arduino Uno (veya benzeri bir Arduino kartı)
  • Kırmızı, Sarı, Yeşil LED (3 adet)
  • Kırmızı, Yeşil LED (2 adet – Yaya Geçidi Işıkları için)
  • 2 adet Buton
  • 220 ohm direnç (8 adet)
  • Breadboard
  • Jumper kablolar

Devre Şeması

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

  • Kırmızı LED (Trafik): 13. pin -> 220 ohm direnç -> Arduino
  • Sarı LED (Trafik): 12. pin -> 220 ohm direnç -> Arduino
  • Yeşil LED (Trafik): 11. pin -> 220 ohm direnç -> Arduino
  • Kırmızı LED (Yaya): 9. pin -> 220 ohm direnç -> Arduino
  • Yeşil LED (Yaya): 8. pin -> 220 ohm direnç -> Arduino
  • 1. Buton (Normal Yaya): 2. pin -> Arduino, ayrıca 10k ohm direnç ile GND'ye çekilir
  • 2. Buton (Engelli/Yaşlı Yaya): 3. pin -> Arduino, ayrıca 10k ohm direnç ile GND'ye çekilir
  • Yaya geçidi LED'leri de aynı şekilde bağlanır (kırmızı ve yeşil), örneğin 7 ve 6. pinlere.

Not: Dirençler, LED'leri korumak için kullanılır. Arduino pinlerinden çıkan akımı sınırlandırarak LED'lerin yanmasını engellerler.

Arduino Kodu

Şimdi de Arduino kodumuza geçelim. Aşağıdaki kodu Arduino IDE'nize kopyalayıp yükleyebilirsiniz. Kod içerisinde gerekli açıklamalar bulunmaktadır.


// Pin tanımlamaları
const int kirmiziLed = 13;
const int sariLed = 12;
const int yesilLed = 11;
const int yayaKirmiziLed = 9;
const int yayaYesilLed = 8;
const int butonPin = 2;      // Normal Yaya Butonu
const int engelliButonPin = 3; // Engelli/Yaşlı Yaya Butonu

// Değişkenler
int butonDurumu = 0;
int engelliButonDurumu = 0;

void setup() {
  // Pinleri çıkış olarak ayarla
  pinMode(kirmiziLed, OUTPUT);
  pinMode(sariLed, OUTPUT);
  pinMode(yesilLed, OUTPUT);
  pinMode(yayaKirmiziLed, OUTPUT);
  pinMode(yayaYesilLed, OUTPUT);
  pinMode(butonPin, INPUT_PULLUP); // Dahili pull-up direnci kullanılır
  pinMode(engelliButonPin, INPUT_PULLUP); // Dahili pull-up direnci kullanılır

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

void loop() {
  // Buton durumunu oku
  butonDurumu = digitalRead(butonPin);
  engelliButonDurumu = digitalRead(engelliButonPin);

  // Normal yaya geçidi isteği
  if (butonDurumu == LOW) {
    Serial.println("Normal Yaya Geçidi İsteği Alındı");
    trafikIsiklariYayaGecidi(10000); // 10 saniye yaya geçişi
  }
  // Engelli/Yaşlı yaya geçidi isteği
  else if (engelliButonDurumu == LOW) {
    Serial.println("Engelli/Yaşlı Yaya Geçidi İsteği Alındı");
    trafikIsiklariYayaGecidi(20000); // 20 saniye yaya geçişi (daha uzun süre)
  } else {
    // Normal trafik akışı
    normalTrafikAkisi();
  }
}

void normalTrafikAkisi() {
  // Yeşil ışık yanar
  digitalWrite(yesilLed, HIGH);
  digitalWrite(kirmiziLed, LOW);
  delay(5000);

  // Sarı ışık yanar
  digitalWrite(yesilLed, LOW);
  digitalWrite(sariLed, HIGH);
  delay(2000);

  // Kırmızı ışık yanar
  digitalWrite(sariLed, LOW);
  digitalWrite(kirmiziLed, HIGH);
  delay(5000);
}

void trafikIsiklariYayaGecidi(int yayaGecisSuresi) {
  // Kırmızı ışık yanarken yayalara yeşil ışık yak
  digitalWrite(kirmiziLed, HIGH);
  digitalWrite(yesilLed, LOW);
  digitalWrite(sariLed, LOW);

  digitalWrite(yayaKirmiziLed, LOW);
  digitalWrite(yayaYesilLed, HIGH);

  delay(yayaGecisSuresi); // Yaya geçiş süresi (milisaniye cinsinden)

  // Yaya ışığı kırmızıya döner
  digitalWrite(yayaYesilLed, LOW);
  digitalWrite(yayaKirmiziLed, HIGH);
  delay(2000);

  // Normal trafik akışına geri dön
  digitalWrite(yayaKirmiziLed, LOW);
  digitalWrite(kirmiziLed, LOW); // Kırmızı ışığı kapat
}

Kodun Açıklaması

  • Pin Tanımlamaları: LED'lerin ve butonların hangi pinlere bağlandığını belirtiyoruz.
  • Değişkenler: Buton durumunu saklamak için değişkenler tanımlıyoruz.
  • setup() Fonksiyonu: Pinleri giriş veya çıkış olarak ayarlıyoruz. INPUT_PULLUP, butonun bağlı olmadığı durumda pinin HIGH seviyesinde kalmasını sağlar.
  • loop() Fonksiyonu: Sürekli olarak buton durumunu okuyup, gerekli işlemleri yapıyoruz.
  • normalTrafikAkisi() Fonksiyonu: Normal trafik ışığı döngüsünü simüle ediyor.
  • trafikIsiklariYayaGecidi() Fonksiyonu: Butona basıldığında yaya geçidini aktif hale getiriyor.

Sonuç

Tebrikler! Arduino ile iki yaya butonlu ve erişilebilir bir trafik ışığı simülasyonu başarıyla oluşturdunuz. Bu proje, Arduino'nun temel kavramlarını anlamanız ve gerçek dünya uygulamalarına yönelik projeler geliştirmeniz için harika bir başlangıç noktasıdır.

Projenizi daha da geliştirmek isterseniz, sensörler (örneğin, ışık sensörü) ekleyerek trafik ışıklarının günün saatine göre otomatik olarak ayarlanmasını sağlayabilirsiniz. Yaratıcılığınızı kullanarak projeyi daha da ileriye taşıyabilirsiniz!

Umarım bu yazı sizin için faydalı olmuştur. Bir sonraki projede görüşmek üzere!

Etiketler: Arduino, Trafik Işığı, Simülasyon, Yaya Geçidi, Buton, Erişilebilirlik, LED, Proje, Elektronik, Kodlama

```

0 yorum:

Arduino ile Dijital Zar (LED ve Buton ile)

Arduino ile Dijital Zar (LED ve Buton ile)

Arduino ile Dijital Zar: LED ve Buton ile Eğlenceli Bir Proje

Merhaba Arduino severler! Bu blog yazımızda, basit ama eğlenceli bir projeye odaklanacağız: Arduino ile dijital zar yapımı! Bu proje, Arduino'nun temel prensiplerini anlamak için harika bir başlangıç noktasıdır ve hem öğrenciler hem de hobi olarak elektronik ile ilgilenenler için uygundur. Projemizde, bir buton ve 7 adet LED kullanarak, zar atma işlemini simüle edeceğiz. Hazırsanız, malzemelerimizi toplayalım ve başlayalım!

Gerekli Malzemeler

  • Arduino Uno (veya benzeri bir Arduino kartı)
  • 7 adet LED (Tercihen aynı renk)
  • 7 adet 220 Ohm direnç (LED'ler için akım sınırlayıcı)
  • 1 adet Buton
  • 1 adet 10k Ohm direnç (Buton için pull-down direnci)
  • Breadboard (Devreyi kurmak için)
  • Jumper kablolar (Bağlantıları yapmak için)

Devre Şeması ve Bağlantılar

Şimdi, malzemelerimizi topladığımıza göre, devremizi kuralım. Aşağıdaki listede bağlantıları adım adım görebilirsiniz:

  • LED'ler: Her bir LED'in anot ucunu (uzun bacak) bir 220 Ohm direnç ile bağlayın. Bu dirençlerin diğer uçlarını sırasıyla Arduino'nun dijital pinlerine bağlayın (Örneğin: 2, 3, 4, 5, 6, 7 ve 8 numaralı pinler). LED'lerin katot uçlarını (kısa bacak) ise breadboard üzerindeki bir hat üzerinden GND'ye (toprak) bağlayın.
  • Buton: Butonun bir bacağını Arduino'nun 9 numaralı dijital pinine bağlayın. Aynı bacağı, 10k Ohm'luk bir direnç üzerinden GND'ye bağlayın (pull-down direnci). Butonun diğer bacağını ise Arduino'nun 5V pinine bağlayın.

Arduino Kodu

Devremizi kurduktan sonra, sıra geldi Arduino kodunu yazmaya. Aşağıdaki kodu Arduino IDE'sine kopyalayın ve Arduino kartınıza yükleyin.


 // LED'lerin bağlı olduğu pinler
 const int ledPins[] = {2, 3, 4, 5, 6, 7, 8};
 const int numberOfLeds = 7;

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

 // Değişkenler
 int buttonState = 0;
 int diceValue = 0;

 void setup() {
  // LED pinlerini çıkış olarak ayarla
  for (int i = 0; i < numberOfLeds; i++) {
   pinMode(ledPins[i], OUTPUT);
  }

  // Buton pinini giriş olarak ayarla ve pull-up direncini etkinleştir
  pinMode(buttonPin, INPUT_PULLUP); //Dahili pull-up direnci kullanılıyor.
  //Serial.begin(9600);
  randomSeed(analogRead(0)); //Rastgele sayı üretimi için seed
 }

 void loop() {
  // Butonun durumunu oku
  buttonState = digitalRead(buttonPin);

  // Butona basıldıysa
  if (buttonState == LOW) { // Dahili pull-up direnci kullandığımız için LOW değerini kontrol ediyoruz.
   //Zar at ve değeri kaydet
   diceValue = random(1, 7); // 1 ile 6 arasında rastgele bir sayı üret

   // LED'leri yak
   lightUpDice(diceValue);

   // Kısa bir süre bekle
   delay(1000);

   // Tüm LED'leri söndür
   clearLeds();

   //Buton serbest bırakılana kadar bekle
   while(digitalRead(buttonPin) == LOW){
    //Bekle
   }
  }

 }

 // Zar değerine göre LED'leri yakan fonksiyon
 void lightUpDice(int value) {
  switch (value) {
   case 1:
    digitalWrite(ledPins[3], HIGH); // Ortadaki LED
    break;
   case 2:
    digitalWrite(ledPins[0], HIGH); // Sol üst
    digitalWrite(ledPins[6], HIGH); // Sağ alt
    break;
   case 3:
    digitalWrite(ledPins[0], HIGH); // Sol üst
    digitalWrite(ledPins[3], HIGH); // Orta
    digitalWrite(ledPins[6], HIGH); // Sağ alt
    break;
   case 4:
    digitalWrite(ledPins[0], HIGH); // Sol üst
    digitalWrite(ledPins[2], HIGH); // Sağ üst
    digitalWrite(ledPins[4], HIGH); // Sol alt
    digitalWrite(ledPins[6], HIGH); // Sağ alt
    break;
   case 5:
    digitalWrite(ledPins[0], HIGH); // Sol üst
    digitalWrite(ledPins[2], HIGH); // Sağ üst
    digitalWrite(ledPins[3], HIGH); // Orta
    digitalWrite(ledPins[4], HIGH); // Sol alt
    digitalWrite(ledPins[6], HIGH); // Sağ alt
    break;
   case 6:
    digitalWrite(ledPins[0], HIGH); // Sol üst
    digitalWrite(ledPins[1], HIGH); // Orta üst
    digitalWrite(ledPins[2], HIGH); // Sağ üst
    digitalWrite(ledPins[4], HIGH); // Sol alt
    digitalWrite(ledPins[5], HIGH); // Orta alt
    digitalWrite(ledPins[6], HIGH); // Sağ alt
    break;
  }
 }

 // Tüm LED'leri söndüren fonksiyon
 void clearLeds() {
  for (int i = 0; i < numberOfLeds; i++) {
   digitalWrite(ledPins[i], LOW);
  }
 }
 

Kodun Açıklaması

  • ledPins[]: LED'lerin bağlı olduğu pin numaralarını tutan bir dizi.
  • buttonPin: Butonun bağlı olduğu pin numarası.
  • setup(): Arduino'nun başlangıç ayarlarının yapıldığı fonksiyon. Bu fonksiyonda, LED pinleri çıkış olarak, buton pini ise giriş olarak ayarlanır. Ayrıca randomSeed fonksiyonu ile rastgele sayı üretimi için bir başlangıç değeri atanır.
  • loop(): Arduino'nun sürekli olarak çalıştığı fonksiyon. Bu fonksiyonda, butonun durumu kontrol edilir ve butona basıldığında zar atılır ve LED'ler yakılır.
  • lightUpDice(int value): Zar değerine göre LED'leri yakan fonksiyon. Bu fonksiyon, switch-case yapısı kullanarak, her bir zar değerine karşılık gelen LED'leri yakar.
  • clearLeds(): Tüm LED'leri söndüren fonksiyon.
  • INPUT_PULLUP: Arduino'nun dahili pull-up direncini kullanmak için kullanılan parametre. Bu sayede harici bir direnç kullanmak zorunda kalmayız. Butona basılmadığı zaman pini HIGH seviyesinde tutar ve butona basıldığında pini LOW seviyesine çeker.
  • randomSeed(analogRead(0)): Analog pininden rastgele bir değer okuyarak, rastgele sayı üretecinin başlangıç değerini ayarlar. Bu, her seferinde farklı rastgele sayılar elde etmemizi sağlar.

Çalışma Prensibi

Proje, bir butona basıldığında 1 ile 6 arasında rastgele bir sayı üretir ve bu sayıya karşılık gelen LED'leri yakar. LED'lerin konumu, klasik bir zar üzerindeki noktaların yerleşimini taklit eder. Butona basılmadığı sürece LED'ler sönük kalır.

Ek Öneriler

  • Farklı renklerde LED'ler kullanarak projeyi daha görsel hale getirebilirsiniz.
  • Zar atma hızını değiştirmek için delay() fonksiyonunun değerini değiştirebilirsiniz.
  • Serial Monitor üzerinden zar değerini görüntüleyebilirsiniz. (Kodda yorum satırı olarak bırakılan Serial.begin() satırını aktifleştirmeniz gerekir.)
  • Daha gelişmiş bir proje için, bir LCD ekran kullanarak zar değerini sayısal olarak da görüntüleyebilirsiniz.

Umarım bu proje size Arduino dünyasına harika bir giriş yapmanıza yardımcı olur. İyi eğlenceler!

Etiketler: arduino, dijital zar, led, buton, proje, elektronik, hobi, öğrenme, kodlama

```

0 yorum:

Arduino ile Geri Sayım Sayacı ile Bomba Oyunu (Butonla Durdur)

Arduino ile Geri Sayım Sayacı ile Bomba Oyunu (Butonla Durdur)

Arduino ile Geri Sayım Sayacı ile Bomba Oyunu (Butonla Durdur)

Merhaba Arduino severler!

Bu yazımızda, Arduino ile eğlenceli bir proje geliştireceğiz: Geri Sayım Sayacı ile Bomba Oyunu! Bu projede, bir geri sayım sayacı kullanacak, butona basarak geri sayımı durdurmaya çalışacak ve eğer zamanında durduramazsak, buzzer ile bir "patlama" sesi duyacağız. Projemiz, millis() fonksiyonu ile zaman takibi, if/else koşulları, tone() fonksiyonu ve bir buzzer kullanarak Arduino'nun temel özelliklerini bir araya getiriyor.

Projenin Amacı

Bu projenin amacı, Arduino'nun temel özelliklerini kullanarak interaktif ve eğlenceli bir uygulama geliştirmektir. Öğrenciler ve hobi amaçlı elektronik meraklıları için, bu proje hem Arduino programlamayı öğrenmek hem de elektronik devreleri anlamak için harika bir başlangıç noktasıdır.

Gerekli Malzemeler

  • Arduino Uno (veya benzeri bir Arduino kartı)
  • Bir adet buton
  • Bir adet buzzer
  • 220 ohm direnç (Buton için)
  • Jumper kablolar
  • Breadboard (isteğe bağlı)

Devre Şeması

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

  • Buzzer:
    • Buzzer'ın pozitif (+) bacağı Arduino'nun 8 numaralı pinine
    • Buzzer'ın negatif (-) bacağı Arduino'nun GND pinine
  • Buton:
    • Butonun bir bacağı Arduino'nun 2 numaralı pinine (dijital giriş pini)
    • Butonun diğer bacağı 220 ohm direnç üzerinden GND'ye
    • Aynı bacaktan (Arduino'nun 2 numaralı pinine bağlanan) Arduino'nun 5V pinine bir kablo çekerek "pull-up" direncini taklit edebiliriz (veya dahili pull-up direncini kullanabiliriz, kodda anlatacağım).

Arduino Kodu

Şimdi de projemizin Arduino koduna geçelim:


 // Pin tanımlamaları
 const int buttonPin = 2;   // Butonun bağlı olduğu pin
 const int buzzerPin = 8;   // Buzzer'ın bağlı olduğu pin

 // Zaman ayarları
 const unsigned long countdownTime = 10000; // Geri sayım süresi (10 saniye - milisaniye cinsinden)
 unsigned long startTime;  // Geri sayımın başladığı zaman

 // Durum değişkenleri
 bool bombActive = false; // Bomba aktif mi?
 bool bombDefused = false; // Bomba etkisiz hale getirildi mi?

 void setup() {
  Serial.begin(9600); // Seri haberleşmeyi başlat
  pinMode(buttonPin, INPUT_PULLUP); // Buton pinini giriş olarak ayarla ve dahili pull-up direncini etkinleştir
  pinMode(buzzerPin, OUTPUT); // Buzzer pinini çıkış olarak ayarla
 }

 void loop() {
  // Eğer bomba aktif değilse ve buton basılıyorsa, geri sayımı başlat
  if (!bombActive && digitalRead(buttonPin) == LOW) {
   startBomb();
  }

  // Eğer bomba aktifse ve henüz etkisiz hale getirilmediyse, geri sayımı kontrol et
  if (bombActive && !bombDefused) {
   checkCountdown();
  }

  // Bomba etkisiz hale getirildiyse veya patladıysa, hiçbir şey yapma
  delay(10); // Döngü hızını yavaşlatmak için kısa bir gecikme
 }

 // Bomba geri sayımını başlatır
 void startBomb() {
  Serial.println("Bomba Aktif!");
  bombActive = true;
  bombDefused = false;
  startTime = millis(); // Geri sayımın başlangıç zamanını kaydet
  Serial.print("Kalan Sure: ");
  Serial.print(countdownTime / 1000);
  Serial.println(" Saniye");

 }

 // Geri sayımı kontrol eder
 void checkCountdown() {
  unsigned long currentTime = millis(); // Şu anki zamanı al
  unsigned long elapsedTime = currentTime - startTime; // Geçen süreyi hesapla

  // Eğer geri sayım süresi dolduysa, bombayı patlat
  if (elapsedTime >= countdownTime) {
   explodeBomb();
  }

  // Eğer buton basıldıysa, bombayı etkisiz hale getir
  if (digitalRead(buttonPin) == LOW) {
   defuseBomb();
  }
 }

 // Bombayı patlatır (buzzer ile ses çıkarır)
 void explodeBomb() {
  Serial.println("BOOM!");
  bombActive = false;
  bombDefused = true;
  tone(buzzerPin, 1000); // Buzzer ile 1kHz frekansında ses çıkar
  delay(2000); // 2 saniye boyunca sesi çal
  noTone(buzzerPin); // Buzzer'ı kapat
 }

 // Bombayı etkisiz hale getirir
 void defuseBomb() {
  Serial.println("Bomba Etkisiz Hale Getirildi!");
  bombActive = false;
  bombDefused = true;
  // Buzzer'dan kısa bir "başarı" sesi çıkarılabilir
  tone(buzzerPin, 440, 200); // 440Hz (A notası) frekansında 200ms süreyle ses çal
  delay(300);
  noTone(buzzerPin);
 }
 

Kodun Açıklaması

  • Pin Tanımlamaları: Projede kullanılan pinlerin tanımlandığı kısım.
  • Zaman Ayarları: Geri sayım süresinin belirlendiği kısım.
  • Durum Değişkenleri: Bomba aktif mi, etkisiz hale getirildi mi gibi durumları takip etmek için kullanılan değişkenler.
  • setup() Fonksiyonu: Pin modlarını ayarlayan ve seri haberleşmeyi başlatan fonksiyon. INPUT_PULLUP modu butonu bağlarken harici direnç kullanma zorunluluğunu ortadan kaldırır.
  • loop() Fonksiyonu: Sürekli olarak çalışan ve bomba durumunu kontrol eden fonksiyon.
  • startBomb() Fonksiyonu: Bombayı aktif hale getiren ve geri sayımı başlatan fonksiyon.
  • checkCountdown() Fonksiyonu: Geri sayım süresini kontrol eden ve butona basılıp basılmadığını kontrol eden fonksiyon.
  • explodeBomb() Fonksiyonu: Bomba patladığında çalışacak olan fonksiyon (buzzer ile ses çıkarır).
  • defuseBomb() Fonksiyonu: Bomba etkisiz hale getirildiğinde çalışacak olan fonksiyon (buzzer ile kısa bir ses çıkarabilir).

Çalışma Prensibi

Arduino, sürekli olarak butonun durumunu kontrol eder. Butona basıldığında (digitalRead(buttonPin) == LOW), startBomb() fonksiyonu çağrılır ve geri sayım başlar. checkCountdown() fonksiyonu, geçen süreyi sürekli olarak kontrol eder. Eğer geri sayım süresi dolmadan butona tekrar basılırsa, defuseBomb() fonksiyonu çağrılır ve bomba etkisiz hale getirilir. Eğer geri sayım süresi dolarsa, explodeBomb() fonksiyonu çağrılır ve buzzer ile bir patlama sesi çıkarılır.

Geliştirme İpuçları

  • Geri sayım süresini değiştirerek oyunun zorluğunu ayarlayabilirsiniz.
  • Buzzer'dan farklı sesler çıkararak oyunu daha eğlenceli hale getirebilirsiniz (örneğin, farklı frekanslarda sesler).
  • LCD ekran kullanarak geri sayım süresini görsel olarak gösterebilirsiniz.
  • Oyuna farklı zorluk seviyeleri ekleyebilirsiniz (örneğin, daha kısa geri sayım süreleri veya birden fazla buton).

Umarım bu proje size Arduino ile eğlenceli bir deneyim yaşatır. İyi eğlenceler!

Etiketler: Arduino, Geri Sayım Sayacı, Bomba Oyunu, Buton, Buzzer, millis(), tone(), elektronik proje, arduino proje

```

0 yorum:

Arduino ile ChatGPT Entegrasyonu: Fiziksel Asistan Yapımı

Arduino ile ChatGPT Entegrasyonu: Fiziksel Asistan Yapımı

Arduino ile ChatGPT Entegrasyonu: Fiziksel Asistan Yapımı

Merhaba sevgili Arduino severler!

Bu yazımızda, hepimizin merakla takip ettiği ChatGPT yapay zeka modelini Arduino'ya entegre ederek kendi fiziksel asistanımızı nasıl yapabileceğimizi adım adım inceleyeceğiz. Bu proje ile Arduino'nuzu sesli komutlarla kontrol edebilir, ChatGPT'nin sunduğu sonsuz bilgi ve yeteneklerden faydalanabilirsiniz. Projemiz, OpenAI API'si üzerinden HTTP istekleri göndererek, bir mikrofon aracılığıyla aldığımız sesli komutları ChatGPT'ye iletip, hoparlör aracılığıyla yanıtları dinlememizi sağlayacak.

Gerekli Malzemeler

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

  • Arduino Uno (veya benzeri bir Arduino kartı)
  • ESP8266 WiFi Modülü (veya ESP32, WiFi bağlantısı için)
  • Mikrofon Modülü (Örneğin MAX9814 veya benzeri bir analog mikrofon)
  • Hoparlör (veya amplifikatörlü bir hoparlör)
  • Jumper kablolar
  • Breadboard (isteğe bağlı)

Donanım Bağlantıları

Şimdi, donanım bağlantılarını nasıl yapacağımıza bakalım:

  • ESP8266/ESP32 ve Arduino Bağlantıları:
    • ESP8266 VCC -> Arduino 3.3V
    • ESP8266 GND -> Arduino GND
    • ESP8266 TX -> Arduino Dijital Pin 2 (RX)
    • ESP8266 RX -> Arduino Dijital Pin 3 (TX)
  • Mikrofon Bağlantıları:
    • Mikrofon VCC -> Arduino 3.3V veya 5V (mikrofonun çalışma voltajına bağlı)
    • Mikrofon GND -> Arduino GND
    • Mikrofon OUT -> Arduino Analog Giriş A0
  • Hoparlör Bağlantıları:
    • Hoparlör direkt olarak Arduino'ya bağlanmamalıdır. Arduino pinlerinden bir PWM pini (örn. 9,10,11) aracılığıyla bir amplifikatör modülüne bağlayınız. Amplifikatör modülünden ise hoparlöre bağlantı yapınız.

Önemli Not: ESP8266/ESP32 modüllerinin bazılarında voltaj seviyesi farklılıkları olabileceğinden, Arduino ile ESP8266/ESP32 arasındaki bağlantılarda voltaj bölücü dirençler kullanmanız önerilir. Bu, Arduino'nun 5V sinyallerinin ESP8266/ESP32'ye zarar vermesini önleyecektir.

Yazılım Geliştirme

Şimdi gelelim yazılım kısmına. Aşağıdaki Arduino kodunu kullanarak projemizi hayata geçireceğiz.

Dikkat: Bu kod örneği, ChatGPT API'sine istek gönderme ve yanıt alma mantığını göstermektedir. Ses işleme (mikrofondan veri okuma ve işleme) ve metin-konuşma dönüştürme (ChatGPT yanıtını hoparlörden çalma) kısımları için ek kütüphaneler ve algoritmalar kullanmanız gerekecektir.


#include 
#include  // Arduino IDE'den kurmanız gereklidir.
#include  // Arduino IDE'den kurmanız gereklidir.

// WiFi Bilgileri
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";

// OpenAI API Anahtarı
const char* apiKey = "YOUR_OPENAI_API_KEY";

// SoftwareSerial Tanımlama (ESP8266 için)
SoftwareSerial espSerial(2, 3); // RX, TX

// Mikrofon Pini
const int microphonePin = A0;

// Hoparlör Pini (PWM)
const int speakerPin = 9;

void setup() {
  Serial.begin(115200);
  espSerial.begin(115200);

  // WiFi'ye bağlan
  connectWiFi();

  // Mikrofon ve hoparlör kurulumu (gerekli ise)
  pinMode(speakerPin, OUTPUT);
}

void loop() {
  // Sesli komutu al (basit bir örnek)
  String command = getVoiceCommand();

  // ChatGPT'ye gönder ve yanıtı al
  String response = getChatGPTResponse(command);

  // Yanıtı oynat (gerekli kütüphanelerle sesli hale getirilebilir)
  Serial.println("ChatGPT Yanıtı: " + response);
  // playResponse(response); // Sesli hale getirme fonksiyonu (yazılması gerekiyor)

  delay(5000); // 5 saniye bekle
}

// WiFi'ye bağlanma fonksiyonu
void connectWiFi() {
  Serial.print("WiFi'ye bağlanılıyor...");
  espSerial.println("AT+CWMODE=1"); // İstasyon Modu
  delay(1000);
  espSerial.print("AT+CWJAP=\"");
  espSerial.print(ssid);
  espSerial.print("\",\"");
  espSerial.print(password);
  espSerial.println("\"");
  delay(5000);

  if (espSerial.find("WIFI GOT IP")) {
    Serial.println("WiFi'ye bağlandı!");
  } else {
    Serial.println("WiFi'ye bağlanılamadı!");
    while (true); // Sonsuz döngü
  }
}

// Sesli komutu alma fonksiyonu (çok basit bir örnek)
String getVoiceCommand() {
  Serial.println("Sesli komut bekleniyor...");
  // Gerçek bir ses işleme için ek kütüphaneler kullanılmalıdır.
  // Bu örnek sadece analog değer okur ve basitleştirilmiş bir komut oluşturur.
  int sensorValue = analogRead(microphonePin);
  if (sensorValue > 500) {
    Serial.println("Komut algılandı!");
    return "Merhaba ChatGPT, nasılsın?"; // Örnek komut
  } else {
    return "";
  }
}

// ChatGPT'den yanıt alma fonksiyonu
String getChatGPTResponse(String prompt) {
  if (prompt == "") {
    return "Komut algılanamadı.";
  }

  WiFiClient client;
  HTTPClient http;

  String serverPath = "https://api.openai.com/v1/completions";

  http.begin(client, serverPath);

  http.addHeader("Content-Type", "application/json");
  http.addHeader("Authorization", "Bearer " + String(apiKey));

  String requestBody = "{\"model\": \"text-davinci-003\", \"prompt\": \"" + prompt + "\", \"max_tokens\": 150}";

  int httpResponseCode = http.POST(requestBody);

  String response = "";

  if (httpResponseCode > 0) {
    Serial.print("HTTP Yanıt Kodu: ");
    Serial.println(httpResponseCode);

    response = http.getString();
    Serial.println(response);

    // JSON ayrıştırma
    DynamicJsonDocument doc(2048);
    deserializeJson(doc, response);

    // ChatGPT yanıtını al
    response = doc["choices"][0]["text"].as();

  } else {
    Serial.print("HTTP İstek Hatası: ");
    Serial.println(httpResponseCode);
    response = "Bir hata oluştu. Lütfen bağlantınızı kontrol edin.";
  }

  http.end();

  return response;
}

// Yanıtı oynatma fonksiyonu (basit bir örnek)
void playResponse(String response) {
  // Gerçek bir metin-konuşma dönüştürme için ek kütüphaneler kullanılmalıdır.
  // Bu örnek sadece yanıtın uzunluğuna göre bir ton üretir.
  for (int i = 0; i < response.length(); i++) {
    tone(speakerPin, 500 + i * 10);
    delay(50);
    noTone(speakerPin);
    delay(10);
  }
}

Kod Açıklamaları:

  • Kütüphaneler: SoftwareSerial, HTTPClient ve ArduinoJson kütüphanelerini Arduino IDE'den kurmanız gerekmektedir.
  • WiFi Bilgileri: ssid ve password değişkenlerine kendi WiFi ağınızın bilgilerini girin.
  • OpenAI API Anahtarı: apiKey değişkenine OpenAI API anahtarınızı girin. OpenAI API'sine kayıt olarak bir anahtar alabilirsiniz.
  • ESP8266 Bağlantısı: ESP8266 ile Arduino arasındaki seri iletişim için SoftwareSerial kullanılır.
  • Sesli Komut: getVoiceCommand() fonksiyonu, mikrofondan alınan analog veriyi okuyarak basit bir komut algılar. Gerçek bir ses işleme için ek kütüphaneler ve algoritmalar kullanmanız gerekecektir.
  • ChatGPT İstek: getChatGPTResponse() fonksiyonu, ChatGPT API'sine HTTP POST isteği göndererek yanıtı alır.
  • JSON Ayrıştırma: ChatGPT'den gelen JSON formatındaki yanıtı ayrıştırmak için ArduinoJson kütüphanesi kullanılır.
  • Yanıtı Oynatma: playResponse() fonksiyonu, ChatGPT'den alınan yanıtı hoparlörden çalmak için kullanılır. Bu örnek sadece basit bir ton üretir. Gerçek bir metin-konuşma dönüştürme için ek kütüphaneler ve algoritmalar kullanmanız gerekecektir.

Ek Bilgiler ve İpuçları

  • Ses İşleme: Mikrofon sinyalini daha doğru bir şekilde işlemek için FFT (Fast Fourier Transform) gibi algoritmalar kullanabilirsiniz.
  • Metin-Konuşma Dönüştürme: ChatGPT yanıtını sesli hale getirmek için Google Text-to-Speech API'si veya ESP32'nin dahili ses sentezleme özelliklerini kullanabilirsiniz.
  • Güç Kaynağı: Arduino ve ESP8266/ESP32 için yeterli güç sağlayan bir güç kaynağı kullanmanız önemlidir.
  • Hata Ayıklama: Seri monitörü kullanarak kodunuzdaki hataları tespit edebilir ve düzeltebilirsiniz.

Sonuç

Bu yazımızda, Arduino ile ChatGPT'yi entegre ederek kendi fiziksel asistanımızı nasıl yapabileceğimizi öğrendik. Bu proje, yapay zeka ve donanım dünyasını bir araya getirerek yaratıcılığınızı konuşturabileceğiniz harika bir fırsat sunuyor. Umarız bu yazı, kendi projelerinizi geliştirmeniz için size ilham vermiştir. İyi eğlenceler!

Etiketler: Arduino, ChatGPT, OpenAI API, Fiziksel Asistan, Yapay Zeka, IoT, ESP8266, HTTP İstekleri, Mikrofon, Hoparlör

```

0 yorum:

Arduino ile Sesle Kontrol: Google Assistant + IFTTT ile Cihaz Aç/Kapat (ESP8266)

Arduino ile Sesle Kontrol: Google Assistant + IFTTT ile Cihaz Aç/Kapat (ESP8266)

Arduino ile Sesle Kontrol: Google Assistant + IFTTT ile Cihaz Aç/Kapat (ESP8266 ile)

Merhaba sevgili Arduino severler!

Bu yazımızda, günlük hayatımızı kolaylaştıracak süper bir projeye imza atıyoruz: Arduino ile sesle kontrol! Evet, yanlış duymadınız. Artık Google Assistant'ı kullanarak cihazlarınızı sesinizle açıp kapatabileceksiniz. Hem de karmaşık kodlara boğulmadan, kolayca anlaşılır adımlarla!

Projemizde kullanacağımız malzemeler oldukça basit:

  • Arduino (UNO, Nano vb.)
  • ESP8266 Wi-Fi Modülü (NodeMCU de olabilir)
  • Röle Modülü
  • Bağlantı Kabloları

Neden Bu Proje?

Akıllı ev sistemlerine giriş yapmak, projelerinizde farklı bir boyut yakalamak veya sadece "acaba yapabilir miyim?" sorusuna cevap bulmak istiyorsanız, bu proje tam size göre! Üstelik, IFTTT (If This Then That) ve Google Assistant'ı kullanarak projeyi hayata geçirmek, kodlama bilginiz ne seviyede olursa olsun, oldukça kolay.

Nasıl Çalışır?

Mantık aslında çok basit:

  1. Siz Google Assistant'a komut verirsiniz ("Lambayı aç").
  2. Google Assistant, IFTTT üzerinden tanımladığınız bir "Webhook" olayını tetikler.
  3. IFTTT, ESP8266'ya bir HTTP isteği gönderir.
  4. ESP8266, Arduino'ya sinyal gönderir.
  5. Arduino, röle modülünü kontrol ederek cihazı açar veya kapatır.

Gerekli Bağlantılar

Öncelikle, ESP8266 modülünü Arduino'ya bağlamamız gerekiyor. Bağlantıları aşağıdaki gibi yapıyoruz:

  • ESP8266 VCC pini -> Arduino 3.3V pinine
  • ESP8266 GND pini -> Arduino GND pinine
  • ESP8266 TX pini -> Arduino RX pinine (veya 10 numaralı dijital pin)
  • ESP8266 RX pini -> Arduino TX pinine (veya 11 numaralı dijital pin)

Ardından, röle modülünü Arduino'ya bağlıyoruz:

  • Röle Modülü VCC pini -> Arduino 5V pinine
  • Röle Modülü GND pini -> Arduino GND pinine
  • Röle Modülü SINYAL pini -> Arduino Dijital Pin 8 (veya istediğiniz bir dijital pin)

Bağlantı şeması ile daha rahat yapabilirsiniz. ESP8266 modülünün besleme voltajına dikkat etmelisiniz. Çoğu ESP8266 3.3V ile çalışır, bu nedenle Arduino'nun 3.3V pinini kullanmanız önemlidir.

Arduino Kodu

Aşağıdaki kodu Arduino'nuza yükleyin:


 #include <SoftwareSerial.h>

 SoftwareSerial esp8266(10, 11); // RX, TX

 const int relayPin = 8;  // Röle'nin bağlı olduğu pin

 String command;

 void setup() {
  Serial.begin(9600);
  esp8266.begin(9600);
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, HIGH); // Başlangıçta röle kapalı (genelde NC kontakt kullanılır)

  Serial.println("Arduino Hazir!");
 }

 void loop() {
  if (esp8266.available() > 0) {
    command = esp8266.readStringUntil('\n');
    command.trim(); // Baştaki ve sondaki boşlukları temizle
    Serial.print("Gelen Komut: ");
    Serial.println(command);

    if (command == "open") {
      digitalWrite(relayPin, LOW); // Röleyi aç (cihazı aç)
      Serial.println("Röle Acildi!");
    } else if (command == "close") {
      digitalWrite(relayPin, HIGH); // Röleyi kapat (cihazı kapat)
      Serial.println("Röle Kapatildi!");
    }
  }
 }
 

Açıklamalar:

  • `SoftwareSerial` kütüphanesi, ESP8266 ile iletişim kurmak için kullanılıyor. (Eğer NodeMCU kullanıyorsanız Serial.begin kullanabilirsiniz ve TX/RX pinlerini tanımlamanıza gerek kalmaz)
  • `relayPin`, röle modülünün bağlı olduğu pini temsil ediyor. İhtiyacınıza göre değiştirebilirsiniz.
  • `digitalWrite(relayPin, HIGH);` röleyi başlangıçta kapalı tutar. Genellikle röle modüllerinde "Normally Closed" (NC) kontakt kullanılır. Yani, enerji yokken devre kapalıdır.
  • `command` değişkeni, ESP8266'dan gelen komutu saklar.
  • `open` komutu gelirse röle açılır, `close` komutu gelirse röle kapanır.

IFTTT ve Google Assistant Ayarları

Şimdi de IFTTT ve Google Assistant'ı ayarlayalım:

  1. IFTTT Hesabı Oluşturun: Eğer bir IFTTT hesabınız yoksa, ifttt.com adresinden ücretsiz bir hesap oluşturun.
  2. "Create" Butonuna Tıklayın: IFTTT arayüzünde "Create" butonuna tıklayarak yeni bir "Applet" oluşturmaya başlayın.
  3. "If This" Kısmını Ayarlayın: "If This" kısmına tıklayın ve "Google Assistant" servisini arayıp seçin.
  4. Google Assistant Tetikleyicisini Seçin: "Say a simple phrase" tetikleyicisini seçin.
    • "What do you want to say?" kısmına "Lambayı aç" yazın.
    • "What do you want the Assistant to say in response?" kısmına "Lambayı açıyorum" yazın.
    • "Create trigger" butonuna tıklayın.
  5. "Then That" Kısmını Ayarlayın: "Then That" kısmına tıklayın ve "Webhooks" servisini arayıp seçin.
  6. Webhooks Ayarlarını Yapın: "Make a web request" seçeneğini seçin.
    • URL: ESP8266'nın IP adresini ve komutu girin. Örneğin: `http://192.168.1.100/open` (ESP8266'nın IP adresini kendi ağınıza göre değiştirin).
    • Method: GET
    • Content Type: application/json
    • Body: Boş bırakın.
  7. Create Action: "Create action" butonuna tıklayın.
  8. Finish: Applet'inize bir isim verin ve "Finish" butonuna tıklayın.
  9. Kapatmak İçin Tekrarla: Aynı adımları "Lambayı kapat" komutu için de tekrarlayın. Sadece URL'yi `http://192.168.1.100/close` olarak değiştirin.

ESP8266 Kodu

Son olarak, ESP8266 için gerekli kodu da paylaşalım:


 #include <ESP8266WiFi.h>
 #include <WiFiClient.h>
 #include <ESP8266WebServer.h>

 const char* ssid = "SizinWiFiAdiniz";       // WiFi ağ adınız
 const char* password = "SizinWiFiSifreniz"; // WiFi şifreniz

 ESP8266WebServer server(80);

 void handleOpen() {
  Serial.println("Open komutu alindi!");
  Serial.println("open\n");
  sendToArduino("open");
  server.send(200, "text/plain", "OK");
 }

 void handleClose() {
  Serial.println("Close komutu alindi!");
  Serial.println("close\n");
  sendToArduino("close");
  server.send(200, "text/plain", "OK");
 }

 void handleNotFound() {
  String message = "File Not Found\n\n";
  message += "URI: ";
  message += server.uri();
  message += "\nMethod: ";
  message += (server.method() == HTTP_GET) ? "GET" : "POST";
  message += "\nArguments: ";
  message += server.args();
  message += "\n";
  for (uint8_t i = 0; i < server.args(); i++) {
    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
  }
  server.send(404, "text/plain", message);
 }

 void sendToArduino(String command) {
  Serial.print("Arduino'ya gonderilen: ");
  Serial.println(command);
  Serial.println("\n");
  delay(100);
 }

 void setup() {
  Serial.begin(9600);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("WiFi'ye baglaniliyor...");
  }

  Serial.println("WiFi'ye baglandi!");
  Serial.print("IP adresi: ");
  Serial.println(WiFi.localIP());

  server.on("/open", handleOpen);
  server.on("/close", handleClose);
  server.onNotFound(handleNotFound);

  server.begin();
  Serial.println("Server baslatildi");
 }

 void loop() {
  server.handleClient();
 }
 

Açıklamalar:

  • `ssid` ve `password` değişkenlerini kendi WiFi ağ bilgilerinizle güncelleyin.
  • `server.on("/open", handleOpen);` ve `server.on("/close", handleClose);` komutları, gelen HTTP isteklerini ilgili fonksiyonlara yönlendirir.
  • `sendToArduino(String command);` fonksiyonu, komutları Arduino'ya göndermek için kullanılır.

Sonuç

Tebrikler! Artık Google Assistant'ı kullanarak cihazlarınızı sesinizle kontrol edebilirsiniz. Bu proje, akıllı ev otomasyonuna ilk adımınız olabilir. İlerleyen zamanlarda sensörler ekleyerek veya farklı cihazları kontrol ederek projeyi daha da geliştirebilirsiniz.

Umarım bu yazı size yardımcı olmuştur. Herkese keyifli kodlamalar!

Etiketler: arduino, google assistant, ifttt, esp8266, sesle kontrol, akıllı ev, otomasyon, röle, webhook, iot

```

0 yorum: