Kodlama Projeleri 86650 TR

Kodlama BloğuTM modülü (U1) bir Arduino Nano devre kartı içerir. Bazı görevleri gerçekleştirmek üzere programlanabilen mini bir bilgisayardır.

Kodlama BloğuTM, USB kablosu kullanılarak bilgisayara bağlanır ve bir açma/kapama anahtarına sahip değildir. Kapatmak için USB kablosunu bilgisayarınızdan çıkarmalısınız.

U1 Kodlama BloğuTM bağlantıları:
(+) - güç
(-) - güç
A0, A4, A5 - Analog girişler
D2, D3, D7, D8, D9 - Dijital girişler/çıkışlar

Kodlama BloğuTM'unu diğer projeleriniz için de kullanabilirsiniz.

USB kablosu, Kodlama BloğuTM (U1) ile programlamak ve iletişim kurmak için kullanılır.

Kodlama BloğuTM modülünü diğer uygulamalarda kullanmak için notlar:

Güç kaynağı: Kodlama BloğuTM, yalnızca bir USB kablosu ve sette bulunan 9V pil tutucu kullanılarak çalıştırılmalıdır. Kodlama BloğuTM asla diğer Blok Devreler® setlerinde kullanılan veya harici güç kaynakları ile birlikte kullanılmamalıdır.

Analog girişler: Bunlar, voltajı 10 bit doğrulukla (1024 seviye) ölçebilir. Ayrıca ek dijital girişler/çıkışlar olarak işlev görecek şekilde yapılandırılabilirler.

Dijital girişler/çıkışlar: Bu girişler yapılandırıldığında, voltajların yüksek olması için güç kaynağı voltajının %80'inin üzerinde veya altında olması için güç kaynağı voltajının %20'sinin altında olması gerekir. Çıkışlar olarak yapılandırıldığında, her biri 20 mA'ya kadar akım sağlayabilir veya alabilir; bu bir LED'i yakmak için yeterlidir, ancak bir motoru veya hoparlörü kontrol ederken bir arabirim transistörüne ihtiyaç duyulabilir. Bunlar (D3 ve D9), Darbe Genişlik Modülasyonu (PWM) kullanılarak analog çıkışları simüle edecek şekilde yapılandırılabilir.

Proje 1 devresini kurun. Programı yükledikten sonra Kodlama BloğuTM'nuzu çalıştırmak için usb kablosuna ihtiyacınız yoktur. USB kablosunu yeniden bağlayın ve anahtarı açın. Şimdi 9V pilinizi kullanın ve devrede gösterildiği gibi bağlayın. 9V pil tutucusuna bir 9V pil takın, bunu Kodlama BloğuTM modülü (U1) üzerindeki konektöre takın ve anahtar bloğundaki (S1) anahtarını açın. Alternatif olarak devreye 9V pil yerine USB kablosu kullanarak güç verebilirsiniz.
Anahtar başlığını (S1) kaydırın ve mavi LED (L2) yanar.

Bu proje, Kodlama BloğuTM modülünü (U1) programlama prosedürünü açıklar. Mikrodenetleyici kullanılan herhangi bir devrede programlama kablosu takılarak yeniden programlanabilir. Yeni bir program indirme işlemi başlattığınızda, mikrodenetleyicide çalışmakta olan herhangi bir program kesintiye uğrar. Yeni bir program indirme işlemi tamamlandığında, yeni program çalışmaya başlayacaktır.

Mikrodenetleyiciye yeni programlar indirmek ve bazı programların bilgisayar ekranına veya bilgisayar ekranından karta bilgi aktarmasına izin vermek için USB kablosu gereklidir. USB ayrıca devrelerinize güç sağlar, bu nedenle bir USB cihazına bağlıyken 9V pil konektörü yok sayılır. Kodlama BloğuTM programlanmıştır, USB kablosunu çıkartabilir ve devreyi 9V pil konektörü kullanarak çalıştırabilirsiniz.

void setup() { pinMode(2, OUTPUT); // We define the digital pin number 2 as an output to give electricity. } void loop() { digitalWrite(2, HIGH); // We provide electrical output from pin 2 with the HIGH command. delay(1000); // we are holding our code for 1000 milliseconds (1 second). digitalWrite(2, LOW); // We stop the electrical output with the LOW command from pin 2. delay(1000); // we are holding our code for 1000 milliseconds (1 second). } ------------------------- void setup() { pinMode(2, OUTPUT); // 2 numaralı digital pini elektrik verecek şekilde çıkış olarak tanımlıyoruz. } void loop() { digitalWrite(2, HIGH); // 2 numaralı pin den HIGH komutu ile elektrik çıkışı sağlıyoruz. delay(1000); // kodumuzu 1000 milisaniye (1 saniye) bekletiyoruz. digitalWrite(2, LOW); // 2 numaralı pin den LOW komutu ile elektrik çıkışını durduruyoruz. delay(1000); // kodumuzu 1000 milisaniye (1 saniye) bekletiyoruz. } LED1, LED2 and Buzzer

// LED pin tanımları const int whiteLED = 8; // Beyaz LED (L1) Arduino Nano'nun D8 pinine bağlı const int blueLED = 9; // Mavi LED (L2) Arduino Nano'nun D9 pinine bağlı void setup() { // LED pinlerini çıkış olarak ayarla pinMode(whiteLED, OUTPUT); pinMode(blueLED, OUTPUT); // LED'leri aç digitalWrite(whiteLED, HIGH); // Beyaz LED'i aç digitalWrite(blueLED, HIGH); // Mavi LED'i aç } void loop() { // Döngü içinde herhangi bir işlem yapılmıyor çünkü LED'ler sürekli açık kalacak }

Bu devreyi kurun. Programlama talimatını kullanarak "Geçiş ve Yanıp Sönen Işıklar"ı Kodlama Bloğuna TM yükleyin. Arduino, devredeki iki LED'i (beyaz ve mavi) kontrol eder ve yanıp sönmesini sağlayarak sırayla açıp kapatır.

Bu devrede kullanılacak sabit bir değer atamak için int komutunu (int tamsayının kısaltmasıdır) kullanır. Kullanılması gerekli değildir. Gecikme değerini düzenleyerek ve ardından bunu Kodlama BloğuTM'a yeniden yükleyerek yanıp sönme hızını değiştirebilirsiniz. Arduino Nano kartındaki mikro denetleyici, LED'leri, anahtarları veya diğer cihazları kullanarak yapılması zor işleri kontrol etmenizi sağlar.

Pin Tanımları:
- Beyaz LED (L2): Arduino Nano'nun D2 pinine bağlı.
- Kırmızı LED (L1): Arduino Nano'nun D3 pinine bağlı.
Gecikme Süresi:
- Kodda delayTime adlı bir değişken tanımlandı.
- Varsayılan değer 500 ms (yarım saniye). Yanıp sönme hızını artırmak veya azaltmak için bu değeri değiştirebilirsiniz.
setup() Fonksiyonu:
- LED pinlerini çıkış olarak ayarlar.
loop() Fonksiyonu:
- Beyaz LED'i yakar ve kırmızı LED'i kapatır, ardından gecikme süresi bekler.
- Daha sonra kırmızı LED'i yakar ve beyaz LED'i kapatır, yine gecikme süresi bekler.
- Bu işlem sürekli olarak tekrarlanır.

Yanıp Sönme Hızını Değiştirme:

Kodun başındaki delayTime değişkeninin değerini değiştirerek LED'lerin daha hızlı veya yavaş yanıp sönmesini sağlayabilirsiniz.
- Örneğin:
  - 100 ms: Daha hızlı yanıp sönme.
  - 1000 ms: Daha yavaş yanıp sönme.

Bu kodu yükleyerek devredeki LED'leri istediğiniz gibi kontrol edebilirsiniz!

// LED pin tanımları const int whiteLED = 2; // Beyaz LED, D2 pinine bağlı const int blueLED = 3; // Mavi LED, D3 pinine bağlı // Her LED için gecikme süreleri (milisaniye cinsinden) int whiteLEDDuration = 500; // Beyaz LED için yanıp sönme süresi int blueLEDDuration = 300; // Mavi LED için yanıp sönme süresi // Zamanlayıcı değişkenleri unsigned long previousMillisWhite = 0; // Beyaz LED için zamanlayıcı unsigned long previousMillisBlue = 0; // Mavi LED için zamanlayıcı // LED durumlarını tutmak için değişkenler bool whiteLEDState = LOW; // Beyaz LED'in başlangıç durumu bool blueLEDState = LOW; // Mavi LED'in başlangıç durumu void setup() { // LED pinlerini çıkış olarak ayarla pinMode(whiteLED, OUTPUT); pinMode(blueLED, OUTPUT); } void loop() { // Şu anki zamanı al unsigned long currentMillis = millis(); // Beyaz LED kontrolü if (currentMillis - previousMillisWhite >= whiteLEDDuration) { previousMillisWhite = currentMillis; // Zamanlayıcıyı güncelle whiteLEDState = !whiteLEDState; // LED durumunu değiştir digitalWrite(whiteLED, whiteLEDState); // Beyaz LED'i aç/kapat } // Mavi LED kontrolü if (currentMillis - previousMillisBlue >= blueLEDDuration) { previousMillisBlue = currentMillis; // Zamanlayıcıyı güncelle blueLEDState = !blueLEDState; // LED durumunu değiştir digitalWrite(blueLED, blueLEDState); // Mavi LED'i aç/kapat } }

Proje 5'i kurun ve buzzer modülünü (BZ1) gösterildiği gibi devreye ekleyin. Programlama talimatını kullanarak "Yanıp Sönen Işıklar ve Buzzer"ı Kodlama BloğuTM'na yükleyin. Arduino, devredeki LED'leri (beyaz ve mavi) ve Buzzer'ı kontrol eder. Yanıp sönerek/bip sesi çıkararak bunları açıp kapatır.

Gecikme değerini düzenleyerek ve ardından bunu Kodlama BloğuTM'na yeniden yükleyerek yanıp sönme hızını değiştirebilirsiniz. Arduino Nano kartındaki mikro denetleyici, LED'leri, anahtarları veya diğer cihazları kullanarak yapılması zor işleri kontrol etmenizi sağlar.

Bağımsız Kontrol:
- millis() fonksiyonu sayesinde LED'ler ve buzzer bağımsız olarak çalışır.
- Her bileşen için farklı zamanlayıcılar (previousMillisWhite, previousMillisBlue, previousMillisBuzzer) kullanılır.
Zaman Ayarları:
- whiteLEDDuration: Beyaz LED'in yanıp sönme süresi.
- blueLEDDuration: Mavi LED'in yanıp sönme süresi.
- buzzerDuration: Buzzer'ın bip süresi.
- Bu değerleri değiştirerek yanıp sönme ve bip hızlarını düzenleyebilirsiniz.
Buzzer Ayarları:
- Buzzer'ın bip aralığını artırmak için buzzerDuration * 2 değeri kullanılır.
- Daha sık bip sesi için bu süreyi azaltabilirsiniz.
Pin Durumları:
- LED'ler ve buzzer'ın durumları ters çevrilerek sırayla açılıp kapanması sağlanır.

Nasıl Çalışır?

Beyaz LED (D2), mavi LED (D3) ve buzzer (D7) sırayla bağımsız olarak çalışır.
Yanıp sönme ve bip hızlarını düzenlemek için yukarıdaki süre değerlerini değiştirebilirsiniz.

Bu kod, devredeki bileşenlerin bağımsız olarak çalışmasını sağlar.

// Pin tanımları const int whiteLED = 2; // Beyaz LED, D2 pinine bağlı const int blueLED = 3; // Mavi LED, D3 pinine bağlı const int buzzer = 7; // Buzzer, D7 pinine bağlı // LED ve buzzer süreleri (milisaniye cinsinden) int whiteLEDDuration = 500; // Beyaz LED için yanıp sönme süresi int blueLEDDuration = 300; // Mavi LED için yanıp sönme süresi int buzzerDuration = 100; // Buzzer için bip süresi // Zamanlayıcı değişkenleri unsigned long previousMillisWhite = 0; // Beyaz LED için zamanlayıcı unsigned long previousMillisBlue = 0; // Mavi LED için zamanlayıcı unsigned long previousMillisBuzzer = 0; // Buzzer için zamanlayıcı // LED ve buzzer durumları bool whiteLEDState = LOW; // Beyaz LED'in başlangıç durumu bool blueLEDState = LOW; // Mavi LED'in başlangıç durumu bool buzzerState = LOW; // Buzzer'ın başlangıç durumu void setup() { // Pinleri çıkış olarak ayarla pinMode(whiteLED, OUTPUT); pinMode(blueLED, OUTPUT); pinMode(buzzer, OUTPUT); } void loop() { // Şu anki zamanı al unsigned long currentMillis = millis(); // Beyaz LED kontrolü if (currentMillis - previousMillisWhite >= whiteLEDDuration) { previousMillisWhite = currentMillis; // Zamanlayıcıyı güncelle whiteLEDState = !whiteLEDState; // LED durumunu değiştir digitalWrite(whiteLED, whiteLEDState); // Beyaz LED'i aç/kapat } // Mavi LED kontrolü if (currentMillis - previousMillisBlue >= blueLEDDuration) { previousMillisBlue = currentMillis; // Zamanlayıcıyı güncelle blueLEDState = !blueLEDState; // LED durumunu değiştir digitalWrite(blueLED, blueLEDState); // Mavi LED'i aç/kapat } // Buzzer kontrolü if (currentMillis - previousMillisBuzzer >= (buzzerDuration * 2)) { // Bip aralığı previousMillisBuzzer = currentMillis; // Zamanlayıcıyı güncelle buzzerState = !buzzerState; // Buzzer durumunu değiştir digitalWrite(buzzer, buzzerState); // Buzzer'ı aç/kapat } }

Bu devreyi kurun. Seri Port ekranını açtığınızda ekrandan aşağı doğru akan sayılar göreceğiz. Fotodirenç (PR1) üzerine gelen ışık miktarını değiştirerek üzerinden geçen voltajın sayısal değeri de değişecektir. 330ohm direnç (R1), Fotodirençten (PR1) gelen aşırı elektrik voltajı kablo üzerinden boşaltılamadığından sürekli olarak yüksek bir değer verir. Fazla voltajı GND'ye (toprak) atarak daha doğru bir değer elde ederiz.

Bu projede PC'yi güç kaynağımız olarak kullanmaktayız.

Bağlantılar:
- LDR'nin bir ucu Arduino'nun A0 analog pinine, diğer ucu ise 330Ω dirençle GND'ye bağlı.
- Direnç ve LDR'nin ortak noktası da 5V'a bağlanmış.
Kod Çalışma Mantığı:
- analogRead fonksiyonu ile LDR'den gelen voltaj değeri okunur.
- Değer, 0 ile 1023 arasında bir sayı olacaktır. Bu değer, ışık miktarına göre değişir.
- Daha parlak ışık, daha düşük bir direnç ve daha yüksek bir voltaj okumasına yol açar.
Sonuç:
- Seri port ekranında sürekli olarak ışık seviyesiyle ilgili sayılar görünecektir.
- LDR üzerine ışık miktarını değiştirerek sonuçlardaki değişimi gözlemleyebilirsiniz.

Bu kodu Arduino IDE'ye yükleyip, "Seri Port Monitörü"nü açarak çalışmayı test edebilirsiniz.

// Notalar ve frekanslar const int c = 261, d = 294, e = 329, f = 349, g = 391, gS = 415, a = 440, aS = 455, b = 466; const int cH = 523, cSH = 554, dH = 587, dSH = 622, eH = 659, fH = 698, fSH = 740, gH = 784, gSH = 830, aH = 880; // Pin tanımları const int buzzerPin = 8; // Buzzer pin const int ledPin1 = 12; // LED1 pin const int ledPin2 = 13; // LED2 pin int counter = 0; // LED sırasını belirlemek için sayaç void setup() { pinMode(buzzerPin, OUTPUT); pinMode(ledPin1, OUTPUT); pinMode(ledPin2, OUTPUT); } void loop() { firstSection(); // Birinci melodi bölümü secondSection(); // İkinci melodi bölümü // Varyasyon 1 playVariant1(); delay(500); // İkinci bölümü tekrar et secondSection(); // Varyasyon 2 playVariant2(); delay(650); } // Beep fonksiyonu (Nota çalma ve LED kontrol) void beep(int note, int duration) { tone(buzzerPin, note, duration); if (counter % 2 == 0) { digitalWrite(ledPin1, HIGH); delay(duration); digitalWrite(ledPin1, LOW); } else { digitalWrite(ledPin2, HIGH); delay(duration); digitalWrite(ledPin2, LOW); } noTone(buzzerPin); // Buzzer'ı kapat delay(50); counter++; } // Birinci melodi bölümü void firstSection() { beep(a, 500); beep(a, 500); beep(a, 500); beep(f, 350); beep(cH, 150); beep(a, 500); beep(f, 350); beep(cH, 150); beep(a, 650); delay(500); beep(eH, 500); beep(eH, 500); beep(eH, 500); beep(fH, 350); beep(cH, 150); beep(gS, 500); beep(f, 350); beep(cH, 150); beep(a, 650); delay(500); } // İkinci melodi bölümü void secondSection() { beep(aH, 500); beep(a, 300); beep(a, 150); beep(aH, 500); beep(gSH, 325); beep(gH, 175); beep(fSH, 125); beep(fH, 125); beep(fSH, 250); delay(325); beep(aS, 250); beep(dSH, 500); beep(dH, 325); beep(cSH, 175); beep(cH, 125); beep(b, 125); beep(cH, 250); delay(350); } // Varyasyon 1 void playVariant1() { beep(f, 250); beep(gS, 500); beep(f, 350); beep(a, 125); beep(cH, 500); beep(a, 375); beep(cH, 125); beep(eH, 650); } // Varyasyon 2 void playVariant2() { beep(f, 250); beep(gS, 500); beep(f, 375); beep(cH, 125); beep(a, 500); beep(f, 375); beep(cH, 125); beep(a, 650); }

Bu devreyi kurun. Aşağıdaki programlama talimatlarını kullanarak Gece Lambasını Kodlama BloğunaTM yükleyin. Kırmızı LED'i (L1) açmak için fototransistörü (PR1) kapatın. Programlandıktan sonra devreye güç vermek için USB kablosu yerine 9V pil konektörünü kullanabilir, ardından devreyi karanlık bir odaya götürebilirsiniz. (Devreyi hareket ettirmeden önce düz bir plaka üzerine taşımayı unutmayın.)

Bu projede PC'yi güç kaynağınız olarak kullanmalısınız.

12 değerini daha yüksek veya daha düşük olarak değiştirerek hassasiyeti ayarlayabilirsiniz.

Bağlantılar:
- Fototransistör (PR1) bir ucunu LED üzerinden A0 pinine, diğer ucu ise 5V'a bağlı.
- Fototransistör ile GND arasına 330Ω direnç eklenmiş.
- Kırmızı LED'in uzun bacağı (anot) D3 pinine, kısa bacağı (katot) ise GND'ye bağlı.
Kod Çalışma Mantığı:
- analogRead ile fototransistörden okunan voltaj değeri alınır.
- Okunan değer, belirlenen eşiğin altında ise LED yanar (karanlık algılanır).
- Değer eşiğin üstünde ise LED söner (aydınlık algılanır).
Hassasiyet Ayarı:
- threshold değerini artırarak LED'in daha karanlıkta yanmasını, azaltarak daha az karanlıkta yanmasını sağlayabilirsiniz.
Alternatif Güç Kaynağı:
- USB kablosu yerine 9V pil ile devreyi beslemek için pil konektörünü kullanabilirsiniz.

Kodunuzu Arduino IDE'ye yükleyerek test edebilirsiniz. Ardından, devrenizi karanlık bir ortama taşıyıp gece lambası işlevini gözlemleyebilirsiniz.

// Gece Lambası Projesi int ldrPin = A0; // Fototransistörün bağlı olduğu analog pin int ledPin = D2; // LED'in bağlı olduğu dijital pin int threshold = 12; // Işık seviyesine göre hassasiyet eşiği int ldrValue = 0; // Fototransistörden okunan değer void setup() { pinMode(ledPin, OUTPUT); // LED pinini çıkış olarak ayarla Serial.begin(9600); // Seri iletişim başlat } void loop() { ldrValue = analogRead(ldrPin); // Fototransistörden analog veri oku Serial.println(ldrValue); // Okunan değeri seri port ekranına yazdır // Eğer ışık seviyesi belirlenen eşiğin altındaysa LED'i yak if (ldrValue < threshold) { digitalWrite(ledPin, HIGH); // LED'i aç } else { digitalWrite(ledPin, LOW); // LED'i kapat } delay(500); // 500 ms bekle }

Önceki devreyi kullanın, "Yanıp Sönen Işık" (Proje 3) kodlarını Kodlama BloğuTM'na yükleyin. Kırmızı LED (L1) karanlıkta yanıp sönecektir. Kodu aşağıda gösterildiği gibi verilen -değer- satırından sonra girin.

Yanıp Sönme Oranı:
- LED'in açık ve kapalı kalma süreleri delay(500) ile belirlenir. 500 ms değerini artırarak daha yavaş, azaltarak daha hızlı bir yanıp sönme elde edebilirsiniz.
Kod Çalışma Mantığı:
- Fototransistörden okunan değer threshold değerinin altına düştüğünde (karanlık algılandığında), LED yanıp sönmeye başlar.
- Aydınlık ortamda ise LED tamamen kapalı kalır.
Hassasiyet Ayarı:
- threshold değerini ayarlayarak karanlık/aydınlık algılama hassasiyetini değiştirebilirsiniz.

Bu kodu Arduino IDE'ye yükleyerek devreyi test edin. Karanlık bir ortamda LED'in yanıp sönmesi gerektiğini göreceksiniz. Yanıp sönme oranını ve hassasiyeti isteğinize göre düzenleyebilirsiniz.

// Yanıp Sönme Oranı Projesi int ldrPin = A0; // Fototransistörün bağlı olduğu analog pin int ledPin = D3; // LED'in bağlı olduğu dijital pin int threshold = 12; // Işık seviyesine göre hassasiyet eşiği int ldrValue = 0; // Fototransistörden okunan değer void setup() { pinMode(ledPin, OUTPUT); // LED pinini çıkış olarak ayarla Serial.begin(9600); // Seri iletişim başlat } void loop() { ldrValue = analogRead(ldrPin); // Fototransistörden analog veri oku Serial.println(ldrValue); // Okunan değeri seri port ekranına yazdır // Eğer ışık seviyesi belirlenen eşiğin altındaysa LED yanıp söner if (ldrValue < threshold) { digitalWrite(ledPin, HIGH); // LED'i aç delay(500); // 500 ms açık kal digitalWrite(ledPin, LOW); // LED'i kapat delay(500); // 500 ms kapalı kal } else { digitalWrite(ledPin, LOW); // LED'i kapalı tut } }

Proje 10 devresini oluşturun. Şimdi LED yerine buzzer kullanın. Aşağıdaki programlama talimatlarını kullanarak "Gece Sireni" kodlarını Kodlama BloğunaTM yükleyin. Buzzer (BZ1)'i açmak için fototransistörü (PR1) kapatın. Programlandıktan sonra devreye güç vermek için USB kablosu yerine 9V pil konektörünü kullanabilir, ardından devreyi karanlık bir odaya götürebilirsiniz. (Devreyi hareket ettirmeden önce düz bir plaka üzerine yerleştirmeyi unutmayın.)

Bu projede PC'yi güç kaynağınız olarak kullanmalısınız.

12 değerini daha yüksek veya daha düşük olarak değiştirerek hassasiyeti ayarlayabilirsiniz.

Buzzer Kullanımı:
- LED yerine buzzer bağlayın. (Rezistör üzerinden D3 pinine)
Kod Çalışma Mantığı:
- Fototransistörden okunan değer threshold değerinin altına düştüğünde (karanlık algılandığında), buzzer aktif hale gelir ve belirli bir aralıkla ses çıkarır.
- Aydınlık ortamda buzzer tamamen kapalı kalır.
Hassasiyet Ayarı:
- threshold değerini artırarak buzzer'ın daha karanlıkta çalışmasını veya azaltarak daha az karanlıkta çalışmasını sağlayabilirsiniz.
Alternatif Güç Kaynağı:
- USB yerine 9V pil ile devreyi çalıştırabilirsiniz.

Bu kodu Arduino IDE'ye yükleyerek devreyi test edebilirsiniz. Buzzer karanlık bir ortamda belirli aralıklarla ses çıkarmaya başlayacaktır. Ses çıkışının sıklığını delay(500) değerini değiştirerek ayarlayabilirsiniz.

// Gece Sireni Projesi int ldrPin = A0; // Fototransistörün bağlı olduğu analog pin int buzzerPin = D3; // Buzzer'ın bağlı olduğu dijital pin int threshold = 12; // Işık seviyesine göre hassasiyet eşiği int ldrValue = 0; // Fototransistörden okunan değer void setup() { pinMode(buzzerPin, OUTPUT); // Buzzer pinini çıkış olarak ayarla Serial.begin(9600); // Seri iletişim başlat } void loop() { ldrValue = analogRead(ldrPin); // Fototransistörden analog veri oku Serial.println(ldrValue); // Okunan değeri seri port ekranına yazdır // Eğer ışık seviyesi belirlenen eşiğin altındaysa buzzer aktif hale gelir if (ldrValue < threshold) { digitalWrite(buzzerPin, HIGH); // Buzzer'ı aç delay(500); // 500 ms aktif digitalWrite(buzzerPin, LOW); // Buzzer'ı kapat delay(500); // 500 ms kapalı } else { digitalWrite(buzzerPin, LOW); // Buzzer'ı kapalı tut } }

Önceki devreyi kullanın, ancak Yanıp Sönen Işık (Proje 3) kodlarını Kodlama BloğuTM'na yükleyin. Bu projede Buzzer (BZ1) karanlıkta çalışacaktır. Kodu aşağıda gösterildiği gibi verilen değer satırından sonra girin.

Buzzer Bağlantısı:
- Buzzer'ı bağlayın (Rezistör üzerinden D3 pinine).
- Buzzer'ın bir ucu dijital pin A0'ye, diğer ucu ise GND'ye bağlanmalıdır.
Çalışma Mantığı:
- Fototransistör karanlık bir ortam algıladığında (ldrValue < threshold), buzzer belirli aralıklarla çalışacaktır.
- Aydınlık bir ortamda buzzer tamamen kapalı kalır.
Hassasiyet Ayarı:
- threshold değerini ayarlayarak karanlık algılama hassasiyetini artırabilir veya azaltabilirsiniz.
Yanıp Sönme Davranışı:
- delay(500) değerlerini değiştirerek buzzer'ın açık ve kapalı kalma sürelerini ayarlayabilirsiniz. Örneğin, delay(1000) yaparak daha uzun süreli bir ses çıkarabilirsiniz.

Bu kodu yükledikten sonra devrenizi karanlık bir ortama götürerek buzzer'ın çalışmasını gözlemleyebilirsiniz.

// Karanlıkta Çalışan Siren Projesi int ldrPin = A0; // Fototransistörün bağlı olduğu analog pin int buzzerPin = D3; // Buzzer'ın bağlı olduğu dijital pin int threshold = 12; // Işık seviyesine göre hassasiyet eşiği int ldrValue = 0; // Fototransistörden okunan değer void setup() { pinMode(buzzerPin, OUTPUT); // Buzzer pinini çıkış olarak ayarla Serial.begin(9600); // Seri iletişim başlat } void loop() { ldrValue = analogRead(ldrPin); // Fototransistörden analog veri oku Serial.println(ldrValue); // Okunan değeri seri port ekranına yazdır // Eğer ışık seviyesi belirlenen eşiğin altındaysa buzzer aralıklarla çalışır if (ldrValue < threshold) { digitalWrite(buzzerPin, HIGH); // Buzzer'ı aç delay(500); // 500 ms açık kal digitalWrite(buzzerPin, LOW); // Buzzer'ı kapat delay(500); // 500 ms kapalı kal } else { digitalWrite(buzzerPin, LOW); // Buzzer'ı kapalı tut } }

Bu devrede, Kodlama BloğuTM modülündeki (U1) elektrik bağlantılarını test edeceğiz. Blok Devreler Kodlama Seti/Kodlama Kiti Kullanma Talimatı Sayfa A7 ve A8'deki Gelişmiş Sorun Giderme prosedürü tarafından referans alınır. Şimdilik kırmızı kablo terminalinin (T) boşta kalan ucunu herhangi bir yere bağlamadan devreyi gösterildiği gibi kurun. Aşağıdaki programlama kodunu kullanarak "Kodlama BloğuTM Testi" kodlarını Kodlama BloğuTM'na yükleyin.

Kırmızı kablo terminalinin (T) boştaki ucunu Kodlama BloğuTM modülündeki (U1) kullanılmayan pinlerin her birine sırayla dokundurun. (T) ucunun pinlere her temasında mavi LED (L2) yanıp sönmelidir.

USB kablosunu çıkarın, ardından 9V Pil (B3) ve Anahtar (S1) Bloğu'nu bağlayın ve anahtarı AÇIK konuma getirin; devre, USB kablosuyla aynı şekilde çalışmalıdır.

Kod Açıklamaları:

setup() Fonksiyonu:
- Tüm pinler çıkış olarak tanımlandı (pinMode komutları).
loop() Fonksiyonu:
- Tüm pinler sırayla HIGH (aktif) yapılıyor, ardından 250 ms bekleniyor.
- Daha sonra tüm pinler LOW (kapalı) yapılıyor, ardından yine 250 ms bekleniyor.
Delay Süresi:
- delay(250) komutları ile 250 ms süreyle yanıp sönme efekti sağlanıyor. Bunu ihtiyacınıza göre artırıp azaltabilirsiniz.

Kodunuzu doğrudan Arduino IDE'ye yapıştırarak çalıştırabilirsiniz.

// Coding Block Test void setup() { pinMode(A0, OUTPUT); // Tüm bağlantıları tanımlayın. pinMode(A4, OUTPUT); pinMode(A5, OUTPUT); pinMode(2, OUTPUT); pinMode(3, OUTPUT); pinMode(7, OUTPUT); pinMode(8, OUTPUT); pinMode(9, OUTPUT); } void loop() { digitalWrite(A0, HIGH); // Elektrik çıkışı YÜKSEK komutu veriyoruz. digitalWrite(A4, HIGH); digitalWrite(A5, HIGH); digitalWrite(2, HIGH); digitalWrite(3, HIGH); digitalWrite(7, HIGH); digitalWrite(8, HIGH); digitalWrite(9, HIGH); delay(250); // 250 ms bekle digitalWrite(A0, LOW); // Elektrik çıkışı DÜŞÜK komutu veriyoruz. digitalWrite(A4, LOW); digitalWrite(A5, LOW); digitalWrite(2, LOW); digitalWrite(3, LOW); digitalWrite(7, LOW); digitalWrite(8, LOW); digitalWrite(9, LOW); delay(250); // 250 ms bekle }

PWM özellikli pin, LED'in yanma şeklini kontrol eder. Şimdi, LED'in parlaklığını kademeli olarak değiştirmek için PWM değerini değiştirelim.

Aşağıda gösterildiği gibi bir program yazın.

Program, LED'i kademeli olarak daha parlak hale getirmek için PWM oranını loop() işlevinde kullanılan “i” değişkeninde saklar.

while işleme, i 255'e ulaşana kadar STEP tarafından belirtilen artışlarla değeri artırır. Artan değer, LED'in parlaklığını değiştirmek için analogWrite() içindeki değer tarafından verilir. Ayrıca her PWM çıkışı değiştirildiğinde WAITTIME ile belirtilen süre kadar beklemeye yönlendirilir.

PWM oranı 255'e ulaştığında, LED'i kademeli olarak karartmak için 0'a kadar düşürülür. WAITTIME veya STEP değerini değiştirerek yanıp sönme hızını değiştirebilirsiniz. Bu projede LED'in parlaklığını nasıl kontrol edeceğimizi öğrendik.

Kod Açıklaması:

PWM Kullanımı:
- analogWrite() fonksiyonu, PWM (Darbe Genişlik Modülasyonu) kullanarak LED'in parlaklığını kontrol eder.
LED Parlaklık Artışı ve Azalışı:
- İlk while döngüsü, LED parlaklığını sıfırdan 255'e kadar artırır.
- İkinci while döngüsü, LED parlaklığını 255'ten sıfıra kadar azaltır.
Hız Kontrolü:
- WAITTIME: LED'in parlaklığının değişmesi arasındaki gecikme süresidir. Bu değeri artırarak daha yavaş, azaltarak daha hızlı bir efekt elde edebilirsiniz.
- STEP: Parlaklık değişimindeki adım miktarıdır. Daha büyük bir değer kullanarak daha keskin geçişler sağlayabilirsiniz.
Donanım Bağlantısı:
- LED'in pozitif (anot) ucu dijital pin D3'e, negatif (katot) ucu ise bir direnç aracılığıyla GND'ye bağlanmalıdır.

Bu kodu yükleyerek LED'in parlaklık değişimini gözlemleyebilirsiniz.

// LED Parlaklığını Kademeli Olarak Değiştirme #define LED_PIN 3 // LED'in bağlı olduğu pin #define STEP 5 // PWM değerindeki artış/azalış miktarı #define WAITTIME 30 // Her adım arasında bekleme süresi (ms) void setup() { pinMode(LED_PIN, OUTPUT); // LED pinini çıkış olarak ayarla } void loop() { int brightness = 0; // LED parlaklığını saklamak için değişken // LED'in parlaklığını artır while (brightness <= 255) { analogWrite(LED_PIN, brightness); // PWM ile LED'in parlaklığını ayarla brightness += STEP; // Parlaklığı artır delay(WAITTIME); // Bekle } // LED'in parlaklığını azalt while (brightness >= 0) { analogWrite(LED_PIN, brightness); // PWM ile LED'in parlaklığını ayarla brightness -= STEP; // Parlaklığı azalt delay(WAITTIME); // Bekle } }

Proje 15'i oluşturun ve şimdi LED'i (L1) Buzzer (BZ1) ile değiştirin. Aynı işlevsellik bu proje için de geçerlidir.

Kod Açıklaması:

Buzzer Kullanımı:
- analogWrite() fonksiyonu, buzzer'ın ses seviyesini kontrol eder. PWM sinyali ile buzzer'ın ürettiği ses seviyesi artırılıp azaltılır.
Ses Seviyesi Artışı ve Azalışı:
- İlk while döngüsü, ses seviyesini sıfırdan 255'e kadar artırır.
- İkinci while döngüsü, ses seviyesini 255'ten sıfıra kadar azaltır.
Hız ve Geçiş Kontrolü:
- WAITTIME: Ses seviyesinin değişmesi arasındaki bekleme süresidir. Daha küçük bir değer kullanarak geçişleri hızlandırabilirsiniz.
- STEP: Her adımda ses seviyesinde yapılan artış veya azalış miktarıdır. Daha büyük bir değer kullanarak daha hızlı geçişler sağlayabilirsiniz.
Donanım Bağlantısı:
- Buzzer'ın pozitif ucu dijital pin D3'e, negatif ucu ise GND'ye bağlanmalıdır.

Notlar:

Buzzer sürekli çalıştığı için ses seviyesi sürekli olarak artacak ve azalacaktır.
Daha belirgin bir efekt için STEP ve WAITTIME değerlerini ihtiyacınıza göre ayarlayabilirsiniz.

Bu kod, PWM sinyali kullanarak buzzer ses seviyesini yumuşak bir şekilde değiştirmenizi sağlar.

// Ses Seviyesini Parabolik Değiştirme #define BUZZER_PIN 3 // Buzzer'ın bağlı olduğu pin #define STEP 5 // PWM değerindeki artış/azalış miktarı #define WAITTIME 30 // Her adım arasında bekleme süresi (ms) void setup() { pinMode(BUZZER_PIN, OUTPUT); // Buzzer pinini çıkış olarak ayarla } void loop() { int soundLevel = 0; // Ses seviyesini saklamak için değişken // Ses seviyesini artır while (soundLevel <= 255) { analogWrite(BUZZER_PIN, soundLevel); // PWM ile ses seviyesini ayarla soundLevel += STEP; // Ses seviyesini artır delay(WAITTIME); // Bekle } // Ses seviyesini azalt while (soundLevel >= 0) { analogWrite(BUZZER_PIN, soundLevel); // PWM ile ses seviyesini ayarla soundLevel -= STEP; // Ses seviyesini azalt delay(WAITTIME); // Bekle } }

Önceki devreyi kullanın, LED'i (L1) ve Buzzer'ı (BZ1) D3 pinine bağlayın. USB kablosunu gösterildiği gibi Kodlama BloğuTM'na ve PC'ye bağlayın. Programı Kodlama BloğunaTM yükleyin ve ne olduğunu görün. Her blok birlikte çalışır.

Kod Açıklaması:

LED ve Buzzer:
- Hem LED hem de Buzzer, pin D3'e bağlanır. Bu, PWM sinyali kullanılarak hem ışık hem de ses şiddetinin kontrol edilmesini sağlar.
Parabolik Şiddet Değişimi:
- while döngüleri, PWM sinyali değerini artırır ve azaltır, böylece LED'in parlaklığı ve buzzer'ın sesi kademeli olarak değişir.
Kontrol Parametreleri:
- STEP: Şiddet artış/azalış miktarını belirler. Daha büyük bir değer, daha hızlı geçiş sağlar.
- WAITTIME: Her adımda bekleme süresini belirler. Daha kısa bir süre, daha hızlı değişim sağlar.
Donanım Bağlantıları:
- LED ve Buzzer'ın pozitif uçları D3 pinine, negatif uçları ise GND'ye bağlanmalıdır.

Notlar:

Kod, hem ışık hem de ses şiddetini aynı anda kontrol eder.
STEP ve WAITTIME değerlerini değiştirerek efekt hızını ve hassasiyetini ayarlayabilirsiniz.

Bu projede, LED ve Buzzer, birbiriyle senkronize şekilde parabolik olarak parlaklık ve ses şiddeti değiştirir.

// Işık ve Ses Şiddetini Parabolik Değiştirme #define OUTPUT_PIN 3 // LED ve Buzzer'ın bağlı olduğu pin #define STEP 5 // PWM değerindeki artış/azalış miktarı #define WAITTIME 30 // Her adım arasında bekleme süresi (ms) void setup() { pinMode(OUTPUT_PIN, OUTPUT); // Pin D3'ü çıkış olarak ayarla } void loop() { int level = 0; // PWM seviyesini saklamak için değişken // Şiddeti artır while (level <= 255) { analogWrite(OUTPUT_PIN, level); // LED ve Buzzer şiddetini ayarla level += STEP; // Şiddeti artır delay(WAITTIME); // Bekle } // Şiddeti azalt while (level >= 0) { analogWrite(OUTPUT_PIN, level); // LED ve Buzzer şiddetini ayarla level -= STEP; // Şiddeti azalt delay(WAITTIME); // Bekle } }

Bu projede switch kullanmayı ve gerçekte nasıl çalıştığını öğrenebilirsiniz. Dijital çıkış pinini YÜKSEK (5V) ve DÜŞÜK (0V) olmak üzere iki durum arasında değiştirerek LED'i, motoru, buzzer'ı vb. kontrol etmenizi sağlar. Dijital çıkışları, elektronik bileşenleri kontrol etmek için de kullanabilirsiniz. Dijital çıkış pini, dijital girişe dönüştürülebilir. Bunu yaparak dijital girişli pine uygulanan voltajı “DÜŞÜK” ve “YÜKSEK” olmak üzere iki şekilde kontrol edebilirsiniz. Bu giriş değerleri diğer elektronik bileşenleri kontrol etmek için kullanılabilir. Örneğin, dijital giriş YÜKSEK olduğunda LED'i veya sesli uyarıyı çalıştırmak veya giriş DÜŞÜK olduğunda durdurmak isteyebilirsiniz.

Durum verisini kontrol etmek istediğinizde “serial monitörü” kullanın. USB kablosunu kullanarak verileri Arduino'dan PC'ye gönderebilirsiniz. Veri alışverişi için seri iletişim kullanılır.

Bu projede kullanılan pin 7'yi giriş moduna çevirmek için pinMode()'da “INPUT” belirtin. Artık pin durumunu programdan kontrol edebilirsiniz.

digitalRead() içinde belirtilen pin durumu alınır ve değer değişkeninde saklanır. 0V ise “0”, 5V ise “1” kaydedilir.

Kod Açıklaması:

Pin Tanımlama:
- SWITCH_PIN sabiti, anahtarın bağlandığı pini temsil eder.
setup() Fonksiyonu:
- pinMode(SWITCH_PIN, INPUT): Pin 7 giriş olarak ayarlanır.
- Serial.begin(9600): Seri monitör ile iletişim için hız ayarlanır.
loop() Fonksiyonu:
- digitalRead(SWITCH_PIN): Anahtarın durumunu okur.
- Eğer anahtar durumu HIGH ise, anahtarın açık olduğunu belirtir.
- Eğer anahtar durumu LOW ise, anahtarın kapalı olduğunu belirtir.
Seri Monitör:
- Anahtarın durumu 500 ms aralıklarla seri monitöre yazdırılır.

Devre Bağlantıları:

Anahtarın bir ucu D7 pinine, diğer ucu GND'ye bağlanır.
330Ω direnç, anahtarın VCC bağlantısı ile D7 arasına bağlanır.
USB kablosu, Arduino'yu PC'ye bağlamak ve veri iletişimi sağlamak için kullanılır.

Çalışma:

Serial monitörde sürekli olarak anahtarın açık veya kapalı olduğu bilgisi görüntülenir.
Bu veri, projelerde dijital giriş durumlarını izlemek ve diğer bileşenleri kontrol etmek için kullanılabilir.

Bu basit proje, dijital giriş pinleriyle çalışmayı anlamak için harika bir başlangıçtır.

#define SWITCH_PIN 7 // Anahtarın bağlı olduğu pin void setup() { pinMode(SWITCH_PIN, INPUT); // Anahtarı giriş olarak ayarla Serial.begin(9600); // Seri iletişimi başlat } void loop() { int switchState = digitalRead(SWITCH_PIN); // Anahtarın durumunu oku if (switchState == HIGH) { // Anahtar açık ise Serial.println("Anahtar DURUMU: AÇIK"); // Durumu seri monitöre yazdır } else { // Anahtar kapalı ise Serial.println("Anahtar DURUMU: KAPALI"); } delay(500); // Durumu güncellemeden önce biraz bekle }

Arduino üzerinde bulunan pinleri dijitalden analoğa çevirerek voltaj okumak mümkündür. Kodu Kodlama BloğuTM'na yükledikten sonra seri port ekranını açın. Arduino mikrodenetleyici 5V voltaj ile çalışmaktadır. Bu mikrodenetleyici 10-bit ADC, 2¹⁰ = 1024 doğruluk adımlarıyla 0V ile 5V arasındaki voltajları okuyabilir.

Kırmızı kablonun serbest ucunu "T" kullanın, Önce seri porttan voltaj değerini okuyun. Ardından, "T" ucunu "A" noktasına dokundurun ve değerleri tekrar okuyun. Son olarak, "T" ucuna "B" noktasına dokundurun ve voltaj farklılıklarını gözlemleyin.

Kod Açıklaması:

Pin Tanımlama:
- VOLTAGE_PIN sabiti, voltaj okumak için kullanılan A0 analog pinini temsil eder.
setup() Fonksiyonu:
- Serial.begin(9600): Seri monitör ile iletişim başlatılır.
loop() Fonksiyonu:
- analogRead(VOLTAGE_PIN): Analog pin üzerinden gelen değer okunur.
- Voltaja Çevirme:
  - Analog değer (0-1023) 5V ile ölçeklendirilerek gerçek voltaj hesaplanır.
  - Formül: (ADC Değeri * 5.0) / 1023.0
- Seri Monitör Çıktısı:
  - Voltaj değeri seri monitöre yazdırılır.
- Gecikme:
  - Ölçüm değerleri arasında 500ms bekleme eklenmiştir.

Devre Bağlantıları:

A Noktası: 330Ω direnç ve GND ile bağlantılı.
B Noktası: LED'in anod ucu (diyot sembolünün "+" tarafı).
T Ucu: Kırmızı kablonun serbest ucu, farklı noktalara (A ve B) dokundurulur.
A0 Pin: Arduino'nun analog giriş pini, "T" ucu üzerinden voltaj okumalarını yapar.

Çalışma:

Seri port ekranında ölçülen voltaj değerleri görüntülenir.
Deney Adımları:
1. "T" ucunu açıkta bırakın ve voltajı gözlemleyin.
2. "T" ucunu "A" noktasına dokundurun ve ölçüm yapın.
3. "T" ucunu "B" noktasına dokundurun ve farklı voltaj değerlerini gözlemleyin.

Bu proje, analog sinyallerle çalışma ve ADC'nin kullanımını anlamak için harika bir adımdır.

Flip Flop Işıklar; İki LED'in sırayla yanıp sönmesini sağlayan bir uygulamadır. LED'lerden biri yanarken diğeri söner ve LED'lerin açma-kapama sürelerini dilediğiniz gibi ayarlayabilirsiniz.

Bu devreyi kurun. Aşağıdaki programlama talimatlarını kullanarak Flip Flop Işıkları Kodlama BloğunaTM yükleyin.

Kodlama BloğuTM pin 2 ve pin 3'e bağlı LED'leri 1 saniye aralıklarla sırayla yanıp sönen ve bir döngüde devam eden programdır.

Lütfen Dikkat: BC-135 (SKU: 86600) Mechabau® Blok Devreler® Setiniz varsa, Sürgülü anahtar (S1) yerine Pres Anahtarını (S2) kullanabilirsiniz.

Kod Açıklaması:

Pin Tanımları:
- LED1: Beyaz LED, Arduino'nun dijital pin 2'sine bağlı.
- LED2: Mavi LED, Arduino'nun dijital pin 3'üne bağlı.
Yanıp Sönme Süresi:
- DELAY_TIME: LED'lerin ne kadar süreyle açık ve kapalı kalacağını belirler. 1000 ms = 1 saniye.
setup() Fonksiyonu:
- LED pinleri çıkış olarak ayarlanır.
loop() Fonksiyonu:
- İlk olarak, LED1 açılır ve LED2 kapatılır.
- Belirlenen süre kadar beklenir.
- Daha sonra, LED1 kapatılır ve LED2 açılır.
- Bu işlem döngüde devam eder.

Çalışma Prensibi:

LED1 ve LED2, sırayla yanar ve söner.
LED'lerin hangi pinlere bağlı olduğu ve yanma süreleri Arduino kodunda kolayca değiştirilebilir.

Devre Bağlantıları:

Beyaz LED (L1):
- Katot (-): GND'ye bağlı.
- Anot (+): 330Ω direnç üzerinden dijital pin 2'ye bağlanır.
Mavi LED (L2):
- Katot (-): GND'ye bağlı.
- Anot (+): Dijital pin 3'e bağlanır.
Güç Kaynağı:
- 9V batarya, devreyi beslemek için kullanılır.

Bu uygulama, Flip Flop ışıkların temel prensibini anlamanızı sağlar. Kodda DELAY_TIME değişkenini düzenleyerek LED'lerin hızını değiştirebilirsiniz.

#define LED1 2 // Beyaz LED için pin #define LED2 3 // Mavi LED için pin #define DELAY_TIME 1000 // Yanıp sönme süresi (ms) void setup() { pinMode(LED1, OUTPUT); // LED1 çıkış pini olarak ayarlanır pinMode(LED2, OUTPUT); // LED2 çıkış pini olarak ayarlanır } void loop() { digitalWrite(LED1, HIGH); // LED1 yanar digitalWrite(LED2, LOW); // LED2 söner delay(DELAY_TIME); // Bekleme süresi digitalWrite(LED1, LOW); // LED1 söner digitalWrite(LED2, HIGH); // LED2 yanar delay(DELAY_TIME); // Bekleme süresi }

Önceki devreyi kullanın ve LED'i (L1) buzzer (BZ1) ile değiştirin ve programı tekrar çalıştırın. LED (L2) açıkken Buzzer (BZ1) kapalıdır. LED (L2) kapalıyken Buzzer (BZ1) açıktır. Ayrıca LED'in ve buzzer'ın açma-kapama sürelerini de dilediğiniz gibi ayarlayabilirsiniz.

Dilerseniz pil bloğunu (B3) ve anahtar bloğunu (S1) kullanarak bilgisayardan bağımsız olarak çalıştırabilirsiniz.

Lütfen Dikkat: BC-135 (SKU: 86600) Mechabau® Blok Devreler® Setiniz varsa, sürgülü anahtar (S1) yerine Pres Anahtarını (S2) kullanabilirsiniz.

Kod Açıklaması:

Pin Tanımları:
- LED: Mavi LED, Arduino'nun dijital pin 3'üne bağlı.
- BUZZER: Buzzer, Arduino'nun dijital pin 2'sine bağlı.
Yanıp Sönme Süresi:
- DELAY_TIME: LED ve buzzer'ın açma-kapama sürelerini belirler. Varsayılan olarak 1 saniyedir.
setup() Fonksiyonu:
- LED ve buzzer çıkış pinleri olarak ayarlanır.
loop() Fonksiyonu:
- İlk olarak, LED açılır ve buzzer kapanır.
- Belirlenen süre kadar beklenir.
- Daha sonra, LED kapanır ve buzzer çalışır.
- Bu işlem döngüde devam eder.

Çalışma Prensibi:

LED yanarken buzzer kapanır.
LED sönerken buzzer aktif hale gelir ve ses çıkarır.
Süreler Arduino kodunda ayarlanabilir.

Devre Bağlantıları:

LED (L2):
- Katot (-): GND'ye bağlı.
- Anot (+): 330Ω direnç üzerinden dijital pin 3'e bağlanır.
Buzzer (BZ1):
- Katot (-): GND'ye bağlı.
- Anot (+): Dijital pin 2'ye bağlanır.
Güç Kaynağı:
- 9V batarya kullanarak devreyi bilgisayardan bağımsız çalıştırabilirsiniz.

Notlar:

DELAY_TIME değişkenini değiştirerek LED ve buzzer'ın açma-kapama hızını artırabilir veya azaltabilirsiniz.
Bilgisayardan Bağımsız Çalıştırma:
- Pil (B3) ve anahtar (S1) kullanarak devreyi bilgisayardan bağımsız hale getirebilirsiniz.

Bu proje, LED ve buzzer kullanımını entegre ederek Flip Flop sistemini bir adım daha ileri taşır.

#define LED 3 // Mavi LED için pin #define BUZZER 2 // Buzzer için pin #define DELAY_TIME 1000 // LED ve Buzzer'ın durum değiştirme süresi (ms) void setup() { pinMode(LED, OUTPUT); // LED pini çıkış olarak ayarlanır pinMode(BUZZER, OUTPUT); // Buzzer pini çıkış olarak ayarlanır } void loop() { digitalWrite(LED, HIGH); // LED yanar digitalWrite(BUZZER, LOW); // Buzzer kapanır delay(DELAY_TIME); // Bekleme süresi digitalWrite(LED, LOW); // LED kapanır digitalWrite(BUZZER, HIGH); // Buzzer çalışır delay(DELAY_TIME); // Bekleme süresi }

Devreyi kurun ve kodları yükleyin. Programlama talimatlarını kullanarak "Işık Parlaklığını Artımlı Değiştirme" ayarlarını Kodlama BloğundaTM değiştirin. Anahtar (S1) KAPALI olduğunda, LED (L1) maksimum parlaklıkta yanacaktır. Düğmeyi AÇIK konuma getirin, ışığın parlaklığı 4 adımda artar. Anahtarı (S1) kapatana kadar döngü tekrar etmeye devam eder.

LED parlaklığı, 0 ile 255 arasındaki değerleri kullanan digitalWrite() komutu kullanılarak ayarlanır, ancak artımlı artışlar, düşük sayılar arasında yüksek sayılar arasında olduğundan çok daha belirgin olacaktır. Bu nedenle, bu devre, LED parlaklığını 2'nin katlarına ayarlamak için bir dizi kullanır ve ardından minimuma sıfırlanır. Artımlı artışlar, son değere göre 85 puan artırıldığında çok daha belirgin olacaktır.

Lütfen Dikkat: BC-135 (SKU: 86600) Mechabau® Blok Devreler® Setiniz varsa, sürgülü anahtar (S1) yerine Pres Anahtarını (S2) kullanabilirsiniz.

Kod Açıklaması:

Pin Tanımları:
- LED: LED (L1), Arduino'nun dijital pin 3'üne bağlı.
- SWITCH: Anahtar (S1), Arduino'nun dijital pin 7'sine bağlı.
Parlaklık Artışı:
- brightness: LED'in parlaklık seviyesi (0-255).
- step: Parlaklık artış miktarı. 85 kullanılarak 4 eşit artım sağlanır (0, 85, 170, 255).
setup() Fonksiyonu:
- LED çıkış, anahtar giriş olarak ayarlanır.
loop() Fonksiyonu:
- Anahtar açık (HIGH) olduğunda, LED parlaklığı 85 birim artar.
- Parlaklık maksimum değeri (255) geçerse sıfırlanır.
- Anahtar kapalı (LOW) olduğunda, LED tam parlaklıkta yanar.
Bekleme Süresi:
- delay(500): LED'in parlaklık değişimi arasındaki bekleme süresi (500 ms).

Çalışma Prensibi:

Anahtar Kapalı: LED, maksimum parlaklıkta yanar.
Anahtar Açık: LED'in parlaklığı 4 adımda artar ve tekrar en düşük seviyeye sıfırlanır.

Devre Bağlantıları:

LED (L1):
- Katot (-): GND'ye bağlı.
- Anot (+): 330Ω direnç üzerinden dijital pin 3'e bağlanır.
Anahtar (S1):
- Bir ucu GND'ye, diğer ucu dijital pin 7'ye bağlanır.
Güç Kaynağı:
- Arduino, USB bağlantısı üzerinden veya batarya ile çalıştırılabilir.

Notlar:

Parlaklık Artışı:
- Eğer farklı bir artış miktarı istiyorsanız, step değişkenini değiştirin.
- Daha yumuşak bir artış için küçük bir step değeri kullanabilirsiniz.
Bilgisayardan Bağımsız Çalıştırma:
- Pil ve anahtar modülü kullanarak bağımsız çalıştırabilirsiniz.

Bu proje, LED parlaklığını kontrol etmeyi ve PWM sinyalinin nasıl kullanılacağını anlamak için harika bir uygulamadır.

#define LED 3 // LED için pin #define SWITCH 7 // Anahtar için pin int brightness = 0; // Başlangıç parlaklık değeri int step = 85; // Artış miktarı (0-255 aralığında) void setup() { pinMode(LED, OUTPUT); // LED pini çıkış olarak ayarlanır pinMode(SWITCH, INPUT); // Anahtar pini giriş olarak ayarlanır } void loop() { if (digitalRead(SWITCH) == HIGH) { // Anahtar açık (HIGH) olduğunda brightness += step; // Parlaklık değerini artır if (brightness > 255) { // Parlaklık sınırını aşarsa sıfırla brightness = 0; } analogWrite(LED, brightness); // LED'in parlaklık seviyesini ayarla delay(500); // Her adım arasında kısa bir bekleme } else { // Anahtar kapalı (LOW) olduğunda analogWrite(LED, 255); // LED tam parlaklıkta yanar } }

Bu projede, anahtarın her açılıp kapanmasında LED'in nasıl değiştirileceğini öğreneceğiz. Anahtarı (S1) birkaç kez açıp kapatmaya devam edin ve nasıl çalıştığını görün. LED'in durumundaki değişimi not edin.

Seri monitörü açın ve anahtarı (S1) her açtığınızda çıkan mesajları görün.

Lütfen Dikkat: BC-135 (SKU: 86600) Mechabau® Blok Devreler® Setiniz varsa, sürgülü anahtar (S1) yerine Pres Anahtarını (S2) kullanabilirsiniz.

Kod Açıklaması:

Pin Tanımları:
- LED: Dijital pin 3'e bağlanır.
- SWITCH: Dijital pin 7'ye bağlanır.
LED Durum Takibi:
- ledState: LED'in mevcut durumunu (true = açık, false = kapalı) tutar.
- prevSwitchState: Anahtarın önceki durumunu kontrol ederek değişiklik algılar.
Debounce Mekanizması:
- Bir fiziksel anahtar, mekanik titreşim nedeniyle birden fazla kez tetiklenebilir. delay(50) ile bu sorun azaltılır.
Seri Monitör Mesajları:
- LED her açıldığında: LED açıldı!
- LED her kapatıldığında: LED kapatıldı!

Çalışma Prensibi:

Anahtar Durum Değişikliği:
- Anahtar kapalıyken (LOW), açıldığında (HIGH), LED'in durumu değişir.
- LED açıkken kapanır, kapalıyken açılır.
Seri Monitör:
- Her geçişte, LED'in yeni durumu seri monitörde görüntülenir.

Devre Bağlantıları:

LED (L1):
- Katot (-): GND'ye bağlanır.
- Anot (+): 330Ω direnç üzerinden dijital pin 3'e bağlanır.
Anahtar (S1):
- Bir ucu GND'ye, diğer ucu dijital pin 7'ye bağlanır.

Notlar:

Bilgisayardan Bağımsız Çalıştırma:
- Pil ve anahtar modülü kullanarak bağımsız çalıştırabilirsiniz.
- Seri monitör olmadan çalıştırıldığında LED durumu gözlemlenebilir.
Pres Anahtar Kullanımı:
- Projede pres anahtar (S2) kullanılırsa, devre ve kod aynı şekilde çalışır.

Bu proje, bir anahtarın durumunu nasıl okuyacağınızı ve LED kontrolünü nasıl gerçekleştireceğinizi öğrenmek için idealdir.

#define LED 3 // LED için pin #define SWITCH 7 // Anahtar için pin bool ledState = false; // LED durumunu takip etmek için değişken bool prevSwitchState = LOW; // Anahtarın önceki durumu void setup() { pinMode(LED, OUTPUT); // LED pini çıkış olarak ayarlanır pinMode(SWITCH, INPUT); // Anahtar pini giriş olarak ayarlanır Serial.begin(9600); // Seri haberleşme başlatılır } void loop() { bool currentSwitchState = digitalRead(SWITCH); // Anahtarın mevcut durumu okunur // Eğer anahtar kapalıdan açığa geçerse (değişiklik algılanırsa) if (currentSwitchState == HIGH && prevSwitchState == LOW) { ledState = !ledState; // LED durumunu değiştir digitalWrite(LED, ledState ? HIGH : LOW); // LED'i aç veya kapat // Seri monitöre mesaj yazdır if (ledState) { Serial.println("LED açıldı!"); } else { Serial.println("LED kapatıldı!"); } delay(50); // Değişiklik sonrası bekleme (debounce için) } prevSwitchState = currentSwitchState; // Önceki durumu güncelle }

const int Switch_PIN = 7; // D7 switch pinine bağlı const int Buzzer_PIN = 3; // D3 Buzzer pinine bağlı // düzenlenebilir değişkenler: int BuzzerState = LOW; // Buzzer'ın mevcut durumu int lastSwitchState; // Switch'in önceki durumu int currentSwitchState; // Switch'in mevcut durumu void setup() { Serial.begin(9600); // seriali başlat pinMode(Switch_PIN, INPUT_PULLUP); // arduino pinini giriş çekme moduna ayarla pinMode(Buzzer_PIN, OUTPUT); // arduino pinini çıkış moduna ayarla currentSwitchState = digitalRead(Switch_PIN); } void loop() { lastSwitchState = currentSwitchState; // son durumu kaydet currentSwitchState = digitalRead(Switch_PIN); // yeni durumu oku if(lastSwitchState == HIGH && currentSwitchState == LOW) { Serial.println("Anahtar açık"); // Buzzer durumunu değiştir BuzzerState = !BuzzerState; // Buzzer'ı geçiş durumuna göre kontrol et digitalWrite(Buzzer_PIN, BuzzerState); } }

Anahtara basma ve bırakma arasındaki süreyi ölçüyoruz. Süre tanımlanan süreden daha kısa ise kısa basma olayı algılanır. SHORT_PRESS_TIME = 500 değerini istediğiniz gibi değiştirebilirsiniz. Süre ayarladığınız kadar uzun olduğunda seri monitörde herhangi bir tepki görmezsiniz.

Lütfen Dikkat: BC-135 (SKU: 86600) Mechabau® Blok Devreler® Setiniz varsa, sürgülü anahtar (S1) yerine Pres Anahtarını (S2) kullanabilirsiniz.

Kod Açıklaması:

SHORT_PRESS_TIME:
- Kısa basma için maksimum süreyi tanımlar. Örneğin, 500 ms kısa basma olarak algılanır.
- Bu değeri isteğinize göre artırıp azaltabilirsiniz.
Basılı Kalma Süresi:
- Anahtarın basılı kaldığı süre, millis() fonksiyonu ile hesaplanır.
- Anahtar bırakıldığında süre kontrol edilir ve kısa basma algılanır.
Debounce Sorunu:
- Kod, yalnızca basma bırakma arasındaki süreyi algılar. Daha hassas debounce kontrolü gerekirse, ek bir gecikme (ör. delay(50)) uygulanabilir.

Çalışma Prensibi:

Anahtar ilk kez basıldığında, basma başlangıç zamanı kaydedilir.
Anahtar bırakıldığında, geçen süre hesaplanır.
Eğer süre SHORT_PRESS_TIME değerinden küçükse, "Kısa basma algılandı!" mesajı seri monitöre yazdırılır.

Devre Bağlantıları:

Anahtar (S1):
- Bir ucu dijital pin 7'ye bağlanır.
- Diğer ucu GND'ye bağlanır.
GND ve USB Bağlantısı:
- Arduino'nun GND pini, anahtarın diğer ucuna bağlanmıştır.
- Arduino, USB üzerinden bilgisayara bağlıdır.

Notlar:

Pres Anahtar (S2): Eğer sürgülü anahtar yerine pres anahtar kullanıyorsanız, devre bağlantısı ve kod aynıdır.
Seri Monitör: Arduino IDE'deki seri monitör penceresini açarak kısa basma mesajlarını görüntüleyebilirsiniz.

Bu proje, fiziksel girişleri algılamak ve tepki vermek için oldukça faydalıdır!

#define SWITCH 7 // Anahtar için pin #define SHORT_PRESS_TIME 500 // Kısa basma için maksimum süre (ms) unsigned long pressStartTime = 0; // Basma başlangıç zamanını saklar bool isPressed = false; // Anahtarın basılı olup olmadığını takip eder void setup() { pinMode(SWITCH, INPUT); // Anahtar pini giriş olarak ayarlanır Serial.begin(9600); // Seri haberleşme başlatılır } void loop() { int switchState = digitalRead(SWITCH); // Anahtar durumu okunur if (switchState == HIGH && !isPressed) { // Anahtar ilk kez basıldı isPressed = true; pressStartTime = millis(); // Basma zamanını kaydet } else if (switchState == LOW && isPressed) { // Anahtar bırakıldığında süre hesaplanır unsigned long pressDuration = millis() - pressStartTime; if (pressDuration <= SHORT_PRESS_TIME) { // Kısa basma algılandı Serial.println("Kısa basma algılandı!"); } isPressed = false; // Basma durumunu sıfırla } }

const int Switch_PIN = 7; // Switch pin numarası const int LONG_PRESS_TIME = 1000; // 1000 milisaniye // Düzenlenebilir değişkenler: int lastState = LOW; // giriş pininden önceki durum int currentState; // giriş pininin mevcut durumu unsigned long pressedTime = 0; unsigned long releasedTime = 0; void setup() { Serial.begin(9600); pinMode(Switch_PIN, INPUT_PULLUP); } void loop() { // Anahtarın durumunu okuma: currentState = digitalRead(Switch_PIN); if(lastState == HIGH && currentState == LOW) // Anahtar açık pressedTime = millis(); else if(lastState == LOW && currentState == HIGH) { // Anahtar kapalı releasedTime = millis(); long pressDuration = releasedTime - pressedTime; if( pressDuration > LONG_PRESS_TIME ) Serial.println("Uzun basma algılandı"); } // son durumu kaydet lastState = currentState; }

Proje 25 ve 26'ya referanslıdır.

Neden "uzun basma" ve "kısa basma" tespiti gerekir? Basma sayısını kaydetmek için. Tek bir buton iki veya daha fazla işlevi yapabilir. Örneğin, çalışma modunu değiştirmek için kısa basma, cihazı kapatmak için uzun basma örnek olabilir. Yanlışlıkla kısa basma ile çalışacak cihazı engellemek için uzun basma kullanımı. Örneğin, bazı cihazları fabrika ayarlarına sıfırlama için buton kullanır. Butona yanlışlıkla basılması tehlikeli olabilir. Bunu önlemek için, cihaz yalnızca düğmeye uzun basıldığında (örn. 5 saniyeden fazla) fabrika ayarlarına sıfırlanacak şekilde ayarlanır.

Sonucu Seri Monitörde görün!

Lütfen Dikkat: BC-135 (SKU: 86600) Mechabau® Blok Devreler® Setiniz varsa, sürgülü anahtar (S1) yerine Pres Anahtarını (S2) kullanabilirsiniz.

Kod Açıklaması:

SHORT_PRESS_TIME:
- Kısa basma için maksimum süreyi tanımlar. 500 ms'den daha kısa süreli basmalar kısa basma olarak algılanır.
LONG_PRESS_TIME:
- Uzun basma için minimum süreyi tanımlar. 1000 ms'den daha uzun basmalar uzun basma olarak algılanır.
Süre Kontrolü:
- Eğer süre SHORT_PRESS_TIME değerinden küçükse kısa basma, LONG_PRESS_TIME değerinden büyükse uzun basma olarak kabul edilir.
Seri Monitör:
- Algılanan kısa veya uzun basmalar, seri monitöre mesaj olarak yazdırılır.

Çalışma Prensibi:

Anahtar basıldığında, millis() fonksiyonu ile başlangıç zamanı kaydedilir.
Anahtar bırakıldığında, geçen süre hesaplanır.
Süreye göre kısa veya uzun basma olarak sınıflandırılır.

Devre Bağlantıları:

Anahtar (S1):
- Bir ucu dijital pin 7'ye bağlanır.
- Diğer ucu GND'ye bağlanır.
Arduino ve PC:
- Arduino, USB kablosu ile bilgisayara bağlanır.

Kullanım Senaryoları:

Çalışma Modu Seçimi:
- Kısa basma ile cihaz modunu değiştirme.
Cihaz Kapatma:
- Uzun basma ile cihazı kapatma.
Fabrika Ayarlarına Sıfırlama:
- Yalnızca uzun basma ile fabrika ayarlarına sıfırlama işlemini etkinleştirme.

Notlar:

Pres Anahtar (S2): Eğer sürgülü anahtar yerine pres anahtar kullanıyorsanız, devre ve kodda bir değişiklik gerekmez.
Süre Ayarları:
- SHORT_PRESS_TIME ve LONG_PRESS_TIME değerlerini ihtiyaçlarınıza göre değiştirebilirsiniz.
Seri Monitör: Seri monitör penceresini açarak basma türlerini kontrol edebilirsiniz.

Bu proje, tek bir butonla çok işlevli cihaz kontrolü sağlamak için oldukça kullanışlıdır!

#define SWITCH 7 // Anahtar için pin #define SHORT_PRESS_TIME 500 // Kısa basma için maksimum süre (ms) #define LONG_PRESS_TIME 1000 // Uzun basma için minimum süre (ms) unsigned long pressStartTime = 0; // Basma başlangıç zamanını saklar bool isPressed = false; // Anahtarın basılı olup olmadığını takip eder void setup() { pinMode(SWITCH, INPUT); // Anahtar pini giriş olarak ayarlanır Serial.begin(9600); // Seri haberleşme başlatılır } void loop() { int switchState = digitalRead(SWITCH); // Anahtar durumu okunur if (switchState == HIGH && !isPressed) { // Anahtar ilk kez basıldı isPressed = true; pressStartTime = millis(); // Basma zamanını kaydet } else if (switchState == LOW && isPressed) { // Anahtar bırakıldığında süre hesaplanır unsigned long pressDuration = millis() - pressStartTime; if (pressDuration < SHORT_PRESS_TIME) { // Kısa basma algılandı Serial.println("Kısa basma algılandı!"); } else if (pressDuration >= LONG_PRESS_TIME) { // Uzun basma algılandı Serial.println("Uzun basma algılandı!"); } isPressed = false; // Basma durumunu sıfırla } }

Bu projede (S1) anahtarı açık ise ses çıkar. Aşağıdaki programı Kodlama BloğunaTM yükleyin. Devreyi kapatsanız bile melodi sonuna kadar çalacaktır.

Arduino IDE sekmelerini kullanarak, kodu Arduino Kodu Melodi Sekmesi adlı ilk bloktan kopyalayın.

pitches.h adlı programı kullanmak için ek bir kitaplığa/kütüphaneye ihtiyacınız var.

Ardından yeni bir sekme açın ve sekmeye şu adı verin: pitches.h ve ardından tamam düğmesine tıklayın.

Sekme şuna benziyor.

Arduino IDE sekmelerini kullanmak için, pitches.h Kütüphane Sekmesi adlı ikinci bloktan kodu kopyalayın ve kodu Kodlama BloğuTM'na yükleyin. Melodiyi dinlemek için anahtarı (S1) açın.

Lütfen Dikkat: BC-135 (SKU: 86600) Mechabau® Blok Devreler® Setiniz varsa, sürgülü anahtar (S1) yerine Pres Anahtarını (S2) kullanabilirsiniz.

Devre:
- Anahtar (S1): Buzzer'ın çalmasını başlatır.
- Buzzer (BZ1): Melodiyi çalar.
- Rezistör (R1): Gerekli direnç sağlar.
Arduino IDE Sekme Kullanımı:
- Yeni bir sekme açmak için: Sağ üst köşedeki küçük oka tıklayın ve 'Yeni Sekme' seçeneğini seçin.
- Açılan sekmeye pitches.h adını verin ve ilgili kodu yapıştırın.
Çalışma Prensibi:
- Anahtar açıldığında, ana kod melodiyi çalma fonksiyonunu çağırır.
- pitches.h dosyasındaki notalar kullanılarak buzzer'dan belirli bir melodi çalınır.

#include "pitches.h" #define BUZZER_PIN 9 #define SWITCH_PIN 7 int melody[] = {NOTE_C4, NOTE_G3, NOTE_A3, NOTE_B3, NOTE_C4}; int noteDurations[] = {4, 8, 8, 4, 4}; void setup() { pinMode(BUZZER_PIN, OUTPUT); pinMode(SWITCH_PIN, INPUT_PULLUP); } void loop() { if (digitalRead(SWITCH_PIN) == LOW) { // Anahtar açık playMelody(); } } void playMelody() { for (int thisNote = 0; thisNote < 5; thisNote++) { int noteDuration = 1000 / noteDurations[thisNote]; tone(BUZZER_PIN, melody[thisNote], noteDuration); delay(noteDuration * 1.30); noTone(BUZZER_PIN); } }

#define NOTE_B0 31 #define NOTE_C1 33 #define NOTE_CS1 35 #define NOTE_D1 37 #define NOTE_DS1 39 #define NOTE_E1 41 #define NOTE_F1 44 #define NOTE_FS1 46 #define NOTE_G1 49 #define NOTE_GS1 52 #define NOTE_A1 55 #define NOTE_AS1 58 #define NOTE_B1 62 #define NOTE_C2 65 #define NOTE_CS2 69 #define NOTE_D2 73 #define NOTE_DS2 78 #define NOTE_E2 82 #define NOTE_F2 87 #define NOTE_FS2 93 #define NOTE_G2 98 #define NOTE_GS2 104 #define NOTE_A2 110 #define NOTE_AS2 117 #define NOTE_B2 123 #define NOTE_C3 131 #define NOTE_CS3 139 #define NOTE_D3 147 #define NOTE_DS3 156 #define NOTE_E3 165 #define NOTE_F3 175 #define NOTE_FS3 185 #define NOTE_G3 196 #define NOTE_GS3 208 #define NOTE_A3 220 #define NOTE_AS3 233 #define NOTE_B3 247 #define NOTE_C4 262 #define NOTE_CS4 277 #define NOTE_D4 294 #define NOTE_DS4 311 #define NOTE_E4 330 #define NOTE_F4 349 #define NOTE_FS4 370 #define NOTE_G4 392 #define NOTE_GS4 415 #define NOTE_A4 440 #define NOTE_AS4 466 #define NOTE_B4 494 #define NOTE_C5 523 #define NOTE_CS5 554 #define NOTE_D5 587 #define NOTE_DS5 622 #define NOTE_E5 659 #define NOTE_F5 698 #define NOTE_FS5 740 #define NOTE_G5 784 #define NOTE_GS5 831 #define NOTE_A5 880 #define NOTE_AS5 932 #define NOTE_B5 988 #define NOTE_C6 1047 #define NOTE_CS6 1109 #define NOTE_D6 1175 #define NOTE_DS6 1245 #define NOTE_E6 1319 #define NOTE_F6 1397 #define NOTE_FS6 1480 #define NOTE_G6 1568 #define NOTE_GS6 1661 #define NOTE_A6 1760 #define NOTE_AS6 1865 #define NOTE_B6 1976 #define NOTE_C7 2093 #define NOTE_CS7 2217 #define NOTE_D7 2349 #define NOTE_DS7 2489 #define NOTE_E7 2637 #define NOTE_F7 2794 #define NOTE_FS7 2960 #define NOTE_G7 3136 #define NOTE_GS7 3322 #define NOTE_A7 3520 #define NOTE_AS7 3729 #define NOTE_B7 3951 #define NOTE_C8 4186 #define NOTE_CS8 4435 #define NOTE_D8 4699 #define NOTE_DS8 4978

Bu projede, LDR ve Buzzer ile deney yapmayı öğreneceğiz. Bu deneyin çıktısı, LDR/fotodirenç (PR1) üzerine düşen ışığa bağlı olarak üretilen farklı frekanslarda sestir. Şimdi devreyi oluşturun ve aşağıdaki kodu Kodlama BloğunaTM yükleyin. Anahtarı (S1) AÇIK konuma getirin ve elinizi LDR/fotorezistörün (PR1) üzerinde gezdirin. Ses frekansındaki değişime dikkat edin.

Kod Açıklaması:

Anahtar Kullanımı:
- Buzzer, anahtar üzerinden D9 pinine bağlanmıştır.
- Devredeki anahtar (S1), buzzer'a fiziksel olarak bağlanmış ve buzzer'ı açıp kapatmaya olanak tanımaktadır.
Kodun Çalışma Prensibi:
- LDR'den gelen değer okunur ve ışık yoğunluğuna bağlı olarak bir frekans üretilir.
- Üretilen frekans, buzzer üzerinden bir ton olarak duyulur.

Çalışma Prensibi:

Anahtar Açıkken (S1):
- LDR üzerine düşen ışığa göre buzzer'dan ses frekansı üretilir.
- Daha fazla ışık → Daha yüksek frekans.
Anahtar Kapalıyken (S1):
- Buzzer tamamen devre dışı kalır.

Notlar:

Frekans Aralığı:
- map() fonksiyonundaki minimum ve maksimum değerleri ihtiyaçlarınıza göre değiştirebilirsiniz.
LDR Hassasiyeti:
- LDR'nin ışığa karşı hassasiyetini artırmak için uygun bir direnç kullanabilirsiniz.

Bu projeyle ışığa duyarlı ses frekansları üreterek eğlenceli deneyler yapabilirsiniz!

#define LDR_PIN A0 // LDR'nin bağlı olduğu pin #define BUZZER_PIN 9 // Buzzer'ın bağlı olduğu pin void setup() { pinMode(LDR_PIN, INPUT); // LDR pini giriş olarak ayarlanır pinMode(BUZZER_PIN, OUTPUT); // Buzzer pini çıkış olarak ayarlanır Serial.begin(9600); // Seri haberleşme başlatılır } void loop() { int ldrValue = analogRead(LDR_PIN); // LDR değeri okunur int frequency = map(ldrValue, 0, 1023, 100, 1000); // LDR değerini frekansa dönüştür tone(BUZZER_PIN, frequency); // Buzzer'da tonu çal Serial.print("LDR Değeri: "); Serial.print(ldrValue); Serial.print(" - Frekans: "); Serial.println(frequency); }

Bu deneyde önceki projede olduğu gibi ışığa bağlı direnç (R1) olan bir sensör ile çalışacağız. Ancak bu dersimizde anahtarı (S1) AÇIK konuma getirerek buzzerın (BZ1) bipleme frekansını değiştireceğiz. Karanlık bir ortamda, fotorezistörün (PR1) direnci çok yüksek olacaktır. Işık, fotorezistör (PR1) üzerine düştüğünde direnç azalacaktır. Daha fazla ışıkta daha düşük bir dirence sahip olacaktır. Sensörden farklı değerler okuyarak aydınlık mı karanlık mı yoksa aralarında bir değer mi olduğunu tespit edebiliriz.

Anahtarı (S1) AÇIN ve telefon ışığınızı vb. LDR/fotodirenç (PR1) üzerine getirin. Bip frekansındaki değişikliğe dikkat edin.

Güncellenmiş Açıklamalar:

Projenin Amacı:
- Işığın yoğunluğuna bağlı olarak buzzer'ın bip frekansını değiştirmek.
- LDR üzerine düşen ışığın seviyesi, bip sesi frekansı ile temsil edilir.
Kodun Çalışma Prensibi:
- LDR'den analog değer okunur.
- Bu değer bir frekansa dönüştürülür. Daha fazla ışık → Daha yüksek frekanslı bip sesi.
- Buzzer, ışık yoğunluğuna göre düzenli bir şekilde bip sesi verir.
Anahtar Kullanımı (S1):
- Devredeki anahtar (S1), buzzer'ı tamamen devreye alır veya çıkarır.
Bipler Arası Bekleme:
- Buzzer, 200 ms boyunca sesi çalar, ardından 100 ms bekler. Bu sayede düzenli bir bip sesi elde edilir.

Çalışma Prensibi:

Anahtar Açıkken (S1):
- Karanlıkta: LDR'nin direnci yüksek → Daha düşük bir frekansta bip sesi.
- Işıkta: LDR'nin direnci düşük → Daha yüksek frekansta bip sesi.
Anahtar Kapalıyken (S1):
- Buzzer devre dışı kalır, hiçbir ses duyulmaz.

Bu proje, bir LDR (fotodirenç) kullanarak ışık yoğunluğuna bağlı olarak bir buzzer'dan çıkan ses frekansını değiştirmek için tasarlanmıştır.

#define LDR_PIN A0 // LDR'nin bağlı olduğu pin #define BUZZER_PIN 9 // Buzzer'ın bağlı olduğu pin void setup() { pinMode(LDR_PIN, INPUT); // LDR pini giriş olarak ayarlanır pinMode(BUZZER_PIN, OUTPUT); // Buzzer pini çıkış olarak ayarlanır Serial.begin(9600); // Seri haberleşme başlatılır } void loop() { int ldrValue = analogRead(LDR_PIN); // LDR değeri okunur int frequency = map(ldrValue, 0, 1023, 100, 2000); // LDR değerini frekansa dönüştür tone(BUZZER_PIN, frequency, 200); // Buzzer'da 200 ms boyunca tonu çal delay(300); // Bipler arasında 100 ms bekle Serial.print("LDR Değeri: "); Serial.print(ldrValue); Serial.print(" - Frekans: "); Serial.println(frequency); }

Mechabau® Kodlama BloğuTM (U1) Pin Tanımları

Kodlama BloğuTM U1

Proje 1 Devre Şeması (Mavi Işık)

Proje 1 Açıklama (Mavi Işık)

Proje 1 Kod (Mavi Işık)

Proje 2 (Harici Güç Ekleme)

Proje 2 Açıklama (Harici Güç Ekleme)

Proje 2 Kod (Harici Güç Ekleme)

Proje 3 Devre Şeması (Yanıp Sönen Işık)

Proje 3 Açıklama (Yanıp Sönen Işık)

Proje 3 Kod (Yanıp Sönen Işık)

Proje 4 Devre Şeması (Tüm Işıklar Açık)

Proje 4 Açıklama (Tüm Işıklar Açık)

Proje 4 Kod (Tüm Işıklar Açık)

Proje 5 Devre Şeması (Geçiş ve Yanıp Sönen Işıklar)

Proje 5 Açıklama (Geçiş ve Yanıp Sönen Işıklar)

Yanıp Sönme Hızını Değiştirme:

Proje 5 Kod (Geçiş ve Yanıp Sönen Işıklar)

Proje 6 Devre Şeması (Yanıp Sönen Işıklar ve Buzzer)

Proje 6 Açıklama (Yanıp Sönen Işıklar ve Buzzer)

Nasıl Çalışır?

Proje 6 Kod (Yanıp Sönen Işıklar ve Buzzer)

Proje 7 Devre Şeması (Butonlu Aydınlatma Ledi)

Proje 7 Açıklama (Butonlu Aydınlatma Ledi)

Proje 7 Kod (Butonlu Aydınlatma Ledi)

Proje 8 Devre Şeması (LDR’den Veri Okuma)

Proje 8 Açıklama (LDR'den Veri Okuma)

Proje 8 Kod (LDR’den Veri Okuma)

Proje 9 Devre Şeması (Yıldız Savaşları Tema Şarkısı)

Proje 9 Açıklama (Yıldız Savaşları Tema Şarkısı)

Proje 9 Kod (Yıldız Savaşları Tema Şarkısı)

Proje 10 Devre Şeması (Gece Lambası)

Proje 10 Açıklama (Gece Lambası)

Proje 10 Kod (Gece Lambası)

Proje 11 Devre Şeması (Yanıp Sönme Oranı)

Proje 11 Açıklama (Yanıp Sönme Oranı)

Proje 11 Kod (Yanıp Sönme Oranı)

Proje 12 Devre Şeması (Gece Sireni)

Proje 12 Açıklama (Gece Sireni)

Proje 12 Kod (Gece Sireni)

Proje 13 Devre Şeması (Karanlıkta Çalışan Siren)

Proje 13 Açıklama (Karanlıkta Çalışan Siren)

Proje 13 Kod (Karanlıkta Çalışan Siren)

Proje 14 Devre Şeması (Kodlama BloğuTM Testi)

Proje 14 Açıklama (Kodlama BloğuTM Testi)

Kod Açıklamaları:

Proje 14 Kod (Kodlama BloğuTM Testi)

Proje 15 Devre Şeması (LED Parlaklığını Kademeli Olarak Değiştirme)

Proje 15 Açıklama (LED Parlaklığını Kademeli Olarak Değiştirme)

Kod Açıklaması:

Proje 15 Kod (LED Parlaklığını Kademeli Olarak Değiştirme)

Proje 16 Devre Şeması (Ses Seviyesini Parabolik Değiştirme)

Proje 16 Açıklama (Ses Seviyesini Parabolik Değiştirme)

Kod Açıklaması:

Notlar:

Proje 16 Kod (Ses Seviyesini Parabolik Değiştirme)

Proje 17 Devre Şeması (Işık ve Ses Şiddetini Parabolik Değiştirme)

Proje 17 Açıklama (Işık ve Ses Şiddetini Parabolik Değiştirme)

Kod Açıklaması:

Notlar:

Proje 17 Kod (Işık ve Ses Şiddetini Parabolik Değiştirme)

Proje 18 Devre Şeması (Anahtar Durumlarını Okuma)

Proje 18 Açıklama (Anahtar Durumlarını Okuma)

Kod Açıklaması:

Devre Bağlantıları:

Çalışma:

Proje 18 Kod (Anahtar Durumlarını Okuma)

Proje 19 Devre Şeması (Voltaj Okuma)

Proje 19 Açıklama (Voltaj Okuma)

Kod Açıklaması:

Devre Bağlantıları:

Çalışma:

Proje 19 Kod (Voltaj Okuma)

Proje 20 Devre Şeması (Flip Flop Işıklar)

Proje 20 Açıklama (Flip Flop Işıklar)

Kod Açıklaması:

Çalışma Prensibi:

Devre Bağlantıları:

Proje 20 Kod (Flip Flop Işıklar)

Proje 21 Devre Şeması (Flip Flop Işık ve Ses)