Desibel cinsinden ses seviyelerini ölçen arduino projesi
Bu Gürültü Seviyesi Monitörü ile Kendinizi Koruyun
10 Ekim 2019
Burada, desibel (dB) cinsinden ses seviyelerini ve LCD’de karşılık gelen voltaj seviyelerini gösteren Arduino tabanlı bir gürültü / ses seviyesi monitörü sunulmaktadır. Gürültü izleme sistemi sağlık, savunma, madencilik, robotik ve benzeri birçok uygulamada kullanılmaktadır.
Bu devre özellikle partiler ve evlilik işlevleri gibi halka açık yerlerde gürültü izleme için tasarlanmıştır. Bir kişinin işitme kapasitesi 80dB civarındadır – bunun üzerindeki sesler, yüksek ses seviyeleri veya ses seviyesi uzun süre çalınırsa işitme kaybına neden olabilir.
Devre ve Çalışma
Gürültü izleme sisteminin devre şeması Şekil 1’de gösterilmiştir. Arduino Uno kartı, 9V pil, 16 × 2 alfasayısal LCD (JHD162A), ses sensörü modülü ve diğer birkaç bileşen etrafında inşa edilmiştir .
1: Gürültü seviyesi monitörünün devre şeması
Ses sensörü modülündeki mikrofon tarafından ses algılandığında, ilgili voltaj ve ses seviyeleri LCD1’de dB’de görüntülenir. Ses sensörü çıkışı, Arduino’nun dahili analogdan dijitale dönüştürücüsü aracılığıyla dijitale dönüştürülen analog voltajdır. Analog voltaj 0V ile 5V arasında değişir ve karşılık gelen eşdeğer dijital değer 0 ila 1023 Arduino IDE’nin seri ekranında görüntülenir.
Ses sensörü modülü
Bu cihaz ses dalgalarını alır ve onları elektrik sinyallerine dönüştürür. Ortam atmosferindeki ses yoğunluğunu tespit eder. Bu projede kullanılan ses sensörü modülü Şekil 2’de gösterilmektedir. Sese duyarlı kapasitif bir mikrofonu vardır. Ses dalgaları kapasitansı değiştirir ve karşılık gelen voltaj değişir. Değişim oldukça zayıf olduğu için güçlendirilmesi gerekiyor.
Şekil 2: Ses sensörü modülü
LM393, modülde güç amplifikatörü olarak kullanılır. Analog çıkış piminin (OUT) hassasiyetini ayarlamak için yerleşik bir ön ayara sahiptir.
Ses sensörü modülünün OUT pinini (veya bazı durumlarda S pinini) Arduino Uno’nun analog giriş pinine bağlayın. LCD1’de olduğu gibi seri monitörde de ses yoğunluğunun değerini göreceksiniz.
LCD modülü
16 × 2 LCD modülü (LCD1), piyasada kolayca bulunabilen 16 pimli bir LCD’dir. Pim ayrıntılarını almak için veri sayfasına bakın. LCD ekranın kontrastını ayarlamak için bir ön ayar (VR1) kullanılır.
Arduino Uno
Arduino Uno R3, ATmega328 mikrodenetleyicisine (MCU) dayanmaktadır. On dört dijital giriş / çıkış pini, altı analog giriş pimi, 16MHz kristal osilatör, USB bağlantısı, güç girişi, ICSP başlığı ve sıfırlama düğmesi içerir.
Programlama Arduino IDE kullanılarak yapılır. A0 – A5 analog giriş pinleri Arduino Uno’da (Kart1) mevcuttur. Yazılım programı (Audio_meter.ino) bu giriş pinlerinde analog sinyaller algıladığında, ilgili sinyal PC’nin seri ekranında ve LCD1’de gösterilir.
İnşaat ve test
Gürültü seviyesi monitörünün bir PCB düzeni Şekil 3’te ve bileşen düzeni Şekil 4’te gösterilmiştir. Bileşenleri devre şemasına göre PCB’ye monte edin. Bu projede, ses sensörünün analog OUT pimi Arduino’nun A5 pinine, Vcc pinini 5V’ye ve GND pinini Arduino’nun toprak pinine (GND) bağlanır.
3: Gürültü seviyesi monitörünün PCB düzeni4: PCB için bileşen yerleşimi
Arduino’yu bir USB kablosu kullanarak bir bilgisayara bağlayın. Arduino IDE’den kaynak kodunu açın, Tools (Araçlar) menüsünden uygun COM portunu ve kartını seçin. Uygun COM bağlantı noktasını ve kartını seçtikten sonra, kaynak kodu derleyip karta yükleyin.
Kodu yükledikten sonra, USB kablosunu çıkarın ve bağımsız kullanım için güç kaynağı olarak 9V’luk bir pil bağlayın. Devreye 9V pil bağlandıktan sonra, LCD1’de Ses Ölçer’i göreceksiniz. Şimdi mikrofonun önünde konuşun. Tespit edilen ses, ilgili analog gerilime, dijital gerilime ve dB cinsinden ses seviyesine dönüştürülecek ve tüm bu değerler LCD1’de görüntülenecektir. Bu devreyi ölçüm cihazının çevresindeki gürültüyü yakalamak için kullanabilirsiniz.
Devre çeşitli durumlar için test edilmiştir ve iyi çalışır.
Arduino Kullanarak Otomatik Kayıt Sistemli Gürültü Dedektörü Yapımı
IoT ile
Ashwini kumar sinha
4 Kasım 2019
Gürültü kirliliği, hızlı nüfus artışı, kentleşme ve yeni teknolojiler sayesinde modern şehirlerde büyüyen bir sorundur. Dahası, zaman zaman gürültülü bir komşu veya iş arkadaşı sizi deli edebilir ve refahınızı etkileyebilir.
Yüksek sesle konuşmak ofis ortamında can sıkıcı bir alışkanlıktır. Yüksek bir iş arkadaşına sahip olmak bizi işimizden uzaklaştırabilir ve üretkenliğimize zarar verebilir. Bu sorunu çözmeye yardımcı olmak için bugün size otomatik kayıt sistemine sahip bir gürültü dedektörü sunuyoruz. Bu cihaz, yüksek ses algıladığında (ses belirli sınırları aştığında) kullanıcıları otomatik olarak sesi kaydeder ve kaydedilen sesi bir dosyaya kaydeder.
Bu Gürültü Dedektör Sistemi, gürültülü kişileri tanımlamak için kütüphane, ofis ve sınıf ortamlarında kullanılabilir, böylece onlara karşı gerekli önlemler alınabilir.
Bu cihazı oluşturmak için önce birkaç bileşen toplamamız gerekiyor.
Gerekli Bileşenler
Titreşim motoru / Buzzer
Bluetooth HC 05
Ses sensörü modülü
telleri
Arduino Nano
Kodlama
İlk olarak, değerleri ve pin numaralarını saklamak ve daha sonra Software Serial kütüphanesini dahil etmek için kodumuzdaki farklı değişkenleri başlatacağız. Bundan sonra, Arduino pinleri için Pin modlarını ve Bluetooth için baud hızını ayarlayacağız. Bunu takiben, gelen numarayı Bluetooth’tan kontrol eden bir ‘if koşulu’ oluşturacağımız bir döngü işlevi ayarlayacağız. Bu sayı, gürültü sensörü eşik seviyesini ayarlamak için kullanılır. Daha sonra döngü fonksiyonu, ortalama sensör verilerini toplayan başka bir işleve (yani sensör) atlar (Bkz. Şekil 1).
Şekil 1. Arduino Kodu ayar değişkenleriŞekil 2. Bluetooth’tan dizeleri okumak için Arduino kodu.
Sensör fonksiyonunda, for döngüsü bitene kadar (160 defaya kadar) sensör verilerini toplayan ve toplanan verilerin ortalamasını hesaplayan bir ‘for loop’ oluşturacağız. Bundan sonra bir ‘if koşulu’ ortalamayı kontrol eder, eğer ortalama değer eşik değerinden büyükse, değeri sonraki bölümde yapacağımız bir uygulamaya gönderir (Bakınız Şekil 3).
Şekil 3. Arduino kodu gürültü seviyesini hesaplama
Uygulama Yapımı
Uygulamamızı oluşturmak için MIT uygulama mucidini kullanacağız . İlk bölümde, bir düzen oluşturmamız ve aşağıdaki bileşenleri eklememiz gerekiyor
Bir liste seçici
Metin seviyesi
2 düğme
1 metin görünümü
Ses kaydedici
Küçük DB
Bluetooth istemcisi
Bundan sonra şekil 4’e göre kod bloklarını birleştirin.
Şekil 4. Uygulama DüzeniŞekil 5.MIT Uygulama kodu blokları
Bağ
Şimdi tüm bileşenleri aşağıda gösterildiği gibi bağlayın (Bkz. Şekil 6).
Arduino Nano
Bileşenler
Pim A7
Ses Sensörü Çıkışı
5v
VCC Bluetooth ve Ses sensörü
GND
GND Bluetooth ve Ses sensörü
D4
RX
D3
Teksas
D12
Buzzer VCC
GND
Buzzer GND
Şekil 6. Bağlantı
Test yapmak
Şimdi Arduino’ya güç verin ve Bluetooth’u uygulamanıza bağlayın. Başarılı bağlantıdan sonra, yüksek sesler çıkararak test edebilirsiniz. Ses seviyeniz eşik değerini geçtiğinde, Gürültü Dedektörü cihazı bunu bildirmek için vızıldayacak ve aynı zamanda uygulama sesi kaydetmeye başlayacak ve gürültü seviyesi eşik seviyesinin altına düşene kadar kayıt yapmaya devam edecektir. (Bakınız Şekil 7).
Arduino Uno Tabanlı Pencere Hırsız Alarmı Yapım devresi
Balasubramanian adlı geliştiriciden
9 Kasım 2019
Burada Arduino Uno panosuna dayanan bir pencere alarmı duyurusu sunulmaktadır. Bir uyarı, esas olarak proses tesislerinde, enerji santrallerinde ve endüstrilerde operatörleri anormal koşullar veya parametre sapmaları hakkında uyarmak için çeşitli tesis koşullarını izlemek için kullanılır. Güvenlik / yangın alarmı olarak da kullanılabilir. Yazarın prototipi Şekil 1’de gösterilmiştir.
1: Yazarın Pencere Alarmı Uyarı Tablosu için prototipi
Devre ve çalışma
Pencere alarmı uyarıcısının devre şeması Şekil 2’de gösterilmiştir. Arduino Uno kartı (kart1), yedi LED (LED1 ila LED7), üç dokunsal anahtar (S1 ila S3) ve birkaç ayrı bileşen etrafında inşa edilmiştir.
Şekil 2: Pencere alarmı uyarıcısının devre şeması
Bu bildirimde alarmı normalde açık (NO) kontaklar üzerinden başlatmak için CON1 – CON7 konnektörleri arasında bağlı yedi giriş vardır. Ayrıca test, onaylama ve sıfırlama için üç giriş anahtarı (S1 – S3) vardır. Zil için sekizinci çıkış sağlanırken, bunlardan yedisi LED’lere bağlı sekiz çıkış vardır. (Zil, ek devre kullanılarak bir hooter ile değiştirilebilir.)
Tüm alarm girişleri NO kontakları için tasarlanmıştır. Arduino’nun dijital pin 2 – pin 13’ünün yanı sıra, yedi farklı giriş koşulunu izlemek için dijital I / O pinleri olarak analog pin A0 – pin A5 de kullanılır.
Herhangi bir giriş alarm kontağı kapalıysa, ilgili çıkış LED’i hızlı bir şekilde yanıp söner / yanıp söner ve piezo zili, kullanıcının veya yakındaki kişilerin dikkatini çekmek için etkinleştirilir. Alarm, onay düğmesine (S2) basılarak durdurulabilir. Bu, piezo zilini devre dışı bırakır ve LED daha yavaş yanıp söner. Yani, alarm girişi kontağı açılırsa, alarm sesi durur ancak LED yavaş yanıp sönmeye devam eder. Sıfırlama düğmesine (S3) basıldığında LED tamamen söner.
Bir örnek ele alalım. Başlangıçta, tüm girişler açık olduğundan tüm LED’ler kapalıdır. İlk makinede sorun varsa, CON1’deki ilk giriş I / P1 kapanacak, LED1 hızlı bir şekilde yanıp sönecek ve PZ1 bir alarm sesi çıkaracaktır. S2’ye basıldığında, I / P1 kapalıyken PZ1 kapalı olacak, ancak LED1 açık kalacaktır. S2’ye basıldığında, I / P1 açıkken, PZ1 kapanır ve S3 anlık olarak basılana kadar LED1 yavaşça yanıp söner.
LED’leri ve sesli uyarıyı test etmek için test butonu S1 sağlanmıştır. S1 tuşuna basıldığında, tüm pencere alarm LED’leri sürekli yanar ve sesli uyarı etkinleştirilir. Bu, S1 serbest bırakılana kadar devam edecek.
Yazılım
Yazılım, Arduino programlama dilinde Arduino IDE 1.8.5 sürümü kullanılarak yazılmıştır. Verilen çizimi / programı Arduino Uno’ya yüklemeden önce, geçen Millis kütüphanesi işlevinin Arduino IDE’de (Çizim> Kütüphaneleri dahil et> Arduino kütüphaneleri) mevcut olduğundan emin olun. Değilse, source.efymag.com adresinden elapsedMillis-master klasörünü indirin. Ardından, aşağıdaki adımları izleyerek zip dosyasını ekleyin.
Çizim> Kitaplıkları dahil et> Ekle. ZIP Library…> ‘ye gidin ve geçen Millis dosyasının kaydedildiği konuma göz atın. Yukarıdaki kütüphane işlevini ekledikten sonra, kütüphane işlevleri listesinde göründüğünden emin olun. Şimdi, Annunciator.ino çizim dosyasını panoya yükleyin.
Pencere alarmı uyarıcısının PCB yerleşimi Şekil 3’te ve bileşen yerleşimi Şekil 4’te gösterilmiştir. Devreyi monte ettikten sonra, Arduino Uno ile birlikte uygun bir kutu içine alın. Tüm LED’leri kabinin bir tarafına, piezo zilini diğer tarafa sabitleyin. Devrenin güç kaynağı Arduino kartı üzerinden kullanılır ve dizüstü / masaüstü bilgisayarın USB portu üzerinden bağlanır.
Tüm girişler, I / P1 – I / P7, ortak bir topraklama rayı ile potansiyelsiz harici NO kontaklarıdır. Yani, cihazlardan / makinelerden gelen tüm girdiler NO olmalıdır. Bir veya daha fazla cihaz / makinenin yükünde aşırı yük veya kısa devre gibi sorunlar meydana geldiğinde giriş kontakları kapanmalıdır.
Kolay ve hızlı test için, devreyi verilen bağlantı şemasına göre bir breadboard üzerinde monte edin. Onay, test ve sıfırlama girişleri dahil olmak üzere tüm girişler, ilgili anahtarlara basılarak başlatılabilir.
Dikkat. 1
Ortak potansiyeli olan alarm kontakları (CON1 ila CON7) olarak yalnızca potansiyelsiz harici NO kontakları kullanılmalıdır. Aksi takdirde, devreye enjekte edilen harici voltaj Arduino Uno’ya zarar verir.
Alarm girişi için uzun kablolar kullanılıyorsa, sahte çalışmayı veya hasarı önlemek için EMI bastırma devreleri / optokuplör devreleri eklenmelidir.
Kendi Taşınabilir Yağmur ve Buhar Sensörünüzü Yapmak İster misiniz ?
Açıklama
Bu, bir devrede basit bir taşınabilir yağmur ve buhar dedektörüdür. Küçük boyutludur, 9V pil ile çalışır ve montajı kolaydır.
Devre ve çalışma
Taşınabilir yağmur ve buhar dedektörünün devre şeması Şekil 2’de gösterilmektedir. Transistör T1, piezo buzzer PZ1, 9V pil ve birkaç diğer bileşen etrafında inşa edilmiştir. Sensör bağlantı terminalleri devrede P1 ve P2 olarak işaretlenmiştir.
1: Yazarın prototipi Şekil 2: Yağmur ve buhar dedektörünün devre şeması
Yağmur veya buhar olmadığında, P1 ve P2 arasındaki empedans yüksektir. Bu nedenle, T1 yapmaz. Sensör yağmur tespit ettiğinde, P1 ve P2 arasındaki empedans düşüktür. T1, R1 direnci üzerinden taban akımı alır. T1, yağmur veya buharın algılandığını gösteren PZ1’i çalıştırır ve açar.
Zil sesini durdurmak için sensörün yüzeyindeki suyu veya buharı silin. Güç açma / kapama düğmesinin kullanımı devrede isteğe bağlıdır çünkü yağmur veya buhar olmadığında akım tahliyesi ihmal edilebilir veya sıfırdır.
İnşaat ve test
Bileşenleri bir breadboard veya veroboard üzerindeki devre şemasına göre monte edin . Güç kaynağı için 9V pil (6F22) bağlayın. Bu üniteyi uygun bir plastik kutuda da monte edebilirsiniz. Devreyi ve pili kutunun içine sabitleyin.
Sensörün yapısı Şekil 3’te gösterilmektedir. Yağmur ve buhar sensörü genel amaçlı bir PCB veya veroboarddan yapılmıştır. Yağmur sensörü olarak on üç parçalı 3.8cm x 5cm’lik bir veroboard kullanılır.
3: Yağmur sensörü kartı
Yedi iletken kablo (örneğin beyaz) alın ve bunları Şekil 3’te gösterildiği gibi Veroboard’un alternatif bakır raylarına lehimleyin. Yedi beyaz kablonun diğer uçlarını birleştirin, bağlantıyı uygun bir kabloya bağlayın ve P1’e uzatın.
Altı kablo daha (mesela mavi) alın ve bunları veroboard’a kalan alternatif pistlere lehimleyin. Benzer şekilde, altı kabloyu birleştirin ve başka bir kablo kullanarak P2’ye uzatın. Yağmur sensörünü devreye bağlamak için iki ila üç metrelik blendajlı kablolar kullanabilirsiniz. Yağmur algılama için sensörü dışarıda uygun bir yerde tutun.
Proje adı: 4WD akıllı robot araba nasıl yapılır Bölüm 4 – Bluetooth HC-05 HC-06, L298N H-Bridge
Etiketler: Arduino, 4WD akıllı robot araba, Arduino Uno R3, L298N H-Bridge motor sürücü modülü, LED, Bluetooth modülü HC-05, Bluetooth modülü HC-06, ZS-40, aktif piezo buzzer, yazılım seri
Ekler:
4WDcarBluetoothHC05ZS40ATcommandssketch
4WDcarBluetoothHC06ZS40ATcommandssketch
4WDcarBluetoothHC05sketch
4WDcarBluetoothHC06sketch
4WDcarBluetoothHC05softsketch
4WDcarBluetoothHC06softsketch
Bu projede, bu parçalar gerekli ( Değerli ziyaretçiler Sen parçaların linklere proje satın tıklayarak desteklemek ve onları satın ya da diri bu web sitesini tutmamıza bağış yapabilirsiniz teşekkür ederiz.. ):
1. Arduino Uno R3 (Arduino’nun diğer sürümünü de kullanabilirsiniz)
2. Bluetooth modülü HC-05, HC-06 2 adet
3.Arduino IDE (siz indirebilirsiniz burada )
4. Bağlantı kabloları MM, FM, FF
5. Breadboard 1 adet
6. Direnç 8 adet (1 adet 1 KOhm, 1 adet 2KOhm ve 6 adet 220 Ohm)
7.4WD akıllı robot araba seti 1 adet
8. L298N H-Köprü motor sürücü modülü (gördüğünüz gibi biraz farklı olabilir ama aynı çalışma prensibi var) 1 adet
9. 6 x 1.5 V AA Pil Kutusu Kasa Tutucu ile 6 adet 1.5 V AA piller veya şarj edilebilir 7.2 V Güç Kaynağı (6 x 1.2 V 1900 mAh) motor sürücü modülü kaynağı için 1 adet
10. Arduino kurulu güç kaynağı, +7 ila + 12 V DC (biz 9 V Pil Klip ve Namlu Jack ile 9 V pil kullanılan) veya 5 V + DC olabilir
veya
11. LED 6 adet (ön ışıklar için 2 adet beyaz, arka ışıklar için 2 adet kırmızı, sola dönüş için 1 adet sarı, sağa dönüş için 1 adet mavi)
12. Aktif Piezo buzzer 1 adet
13. güç anahtarı 1 adet
14. Havya
Genel
Farklı bileşenleri nasıl bağlayacağımızı ve Bluetooth kontrollü 4WD akıllı robot arabasını nasıl yapacağımızı öğreneceğiz. HC-05 ve HC-06 ZS-40 bluetooth modüllerini kullanacağız. Ayrıca kolay programlama için seri yazılım kullanacağız.
ROBOT NEDİR?
Robot, çevresine bir şekilde tepki verebilen ve belirli bir görevi yerine getirmek için otonom kararlar veya eylemler gerçekleştirebilen bir elektromekanik cihazdır.
Bir robot aşağıdaki bileşenlerden oluşur:
1. Yapı / Şasi
2. Aktüatör / Motor
3. Denetleyici
4. Girişler / Sensörler
5. Güç Kaynağı
Yapısı fiziksel bileşenden oluşur. Bir robotun görevi gerçekleştirmek için bir şekilde hareket eden bir veya daha fazla fiziksel bileşeni vardır. Bizim durumumuzda Şasi ve tekerlekler robotun yapısıdır.
“ Aktüatör ” enerjiyi (robotikte, bu enerjinin elektrik olma eğilimindedir) fiziksel harekete dönüştüren bir cihaz olarak tanımlanabilir. Aktüatörlerin çoğu dönme veya doğrusal hareket üretir. Bizim durumumuzda aktüatör DC dişli motorudur. Temel olarak, motorun hızını azaltmak ve torku arttırmak için çalışan bir şanzıman ile birleştirilmiş bir DC motordur. Örnek: 3000 rpm hız ve 0,002 Nm torka sahip bir DC motor. Şimdi buna dişli oranı 1:48 olan bir dişli ekliyoruz. Yeni hız bir faktör 48 azalır (sonuç olarak 3000/44 = 68 rpm) ve tork 48 faktör artırılır (sonuç 0.002 x 48 = 0.096 Nm).
Yapısı ve Aktüatörler olmadan Kontrolör şey ifade etmiyor. Robotunuz hala tek bir yerde oturacak. Hayatsız bir insan gibi. Bu yüzden robotu bir yerden bir yere taşımak için bir Kontrolörün (beyin) ihtiyacı vardı. Bir programı çalıştırabilen bir bilgi işlem cihazıdır ve tüm hesaplama, karar verme ve iletişimden sorumludur. Bizim durumumuzda Kontrolör olarak Arduino Uno mikrodenetleyici kullanıyoruz. Kontrolör girişi (sensörler, uzaktan kumanda vb.) Alır, işler ve ardından aktüatöre (motor) istenen görevi yerine getirmesi için bir komut verir.
İnsanlardan farklı olarak, robotlar sadece görme, ses, dokunma, koku ve tat ile sınırlı değildir. Robotlar , dış dünyayla etkileşim kurmak için farklı Sensörler kullanır. Sensör, fiziksel ortamdan bir tür girişi algılayan ve bunlara yanıt veren bir cihazdır. Spesifik girdi ışık, ısı, hareket, nem, basınç veya çok sayıda diğer çevresel olaydan herhangi biri olabilir. Girişler sensörler, IR uzaktan kumanda veya akıllı telefon / tablet / PC arasında olabilir. IR uzaktan kumandayı 4WD akıllı robot arabasını kontrol etmek için bir giriş cihazı olarak kullanacağız.
Bir robotun aktüatörleri (motorları) ve kontrol cihazını çalıştırmak için bir Güç kaynağına ihtiyacı vardır . Robotların çoğu pil ile çalışır. Pil hakkında konuştuğumuzda, birçok seçenek var:
• AA Alkalin Pil (Şarj Edilemez)
• AA NiMh veya NiCd Pil (Şarj Edilebilir)
• Li Ion Batarya
• LiPo Batarya
Yani gereksinime göre uygun olanı seçin. Bize göre her zaman şarj edilebilir ve yeterli kapasiteli bir pil seçin.
HC-05, HC-06 Bluetooth modüllerini anlama
Burada onlar hakkında daha fazla bilgi edinebilirsiniz .
Bileşenler hakkında faydalı bilgiler
1. nasıl 4WD akıllı robot araba montajı hakkında bilgi bulabilirsiniz 4WD akıllı robot araba Bölüm 1 nasıl inşa edilir .
2. L298N H-Bridge motor sürücü modülünü anlama
Daha fazla bilgiyi buradan okuyabilirsiniz .
3. DC motorunu anlama
Daha fazla bilgiyi buradan okuyabilirsiniz .
LED sinyalleri ve bağlantıları
LED’in çalışma voltajı 1.8V ve çalışma akımı 10mA-20mA’dır. Arduino Uno kartı 5V veya 3.3V güç sağlayabilir. Bu proje için 5V kullanacağız, bu nedenle akım sınırlama direncinin minimum direnci (5 V ila 1.8 V) / 20 = 160 Om olmalıdır. Kitte sunulan 220 Om uygundur ve ayrıca koşulu karşılayan diğer dirençleri de seçebilirsiniz. Direnç büyüdükçe LED sönükleşir.
Aktif piezo buzzer sinyalleri ve bağlantıları
(+) İşareti ile işaretlenmiş aktif piezo zil pimi, sinyal gönderen Arduino Uno kartı dijital pimine, aktif piezo zilinin diğer pimi Arduino Uno kartı GND’sine bağlanmalıdır.
HC-05, HC-06 Bluetooth modüllerinin sinyalleri ve bağlantıları
Bu projede HC-05 ZS-40 ve HC-06 ZS-40 Bluetooth modüllerini kullanacağız. Onlar ve Bluetooth modülleri HC-05 FC-114 ve HC-06 FC-114 hakkında daha fazla bilgiyi burada bulabilirsiniz .
Devreyi oluşturun
Aşağıdaki resimde Arduino Uno ile gerekli bağlantılar gösterilmektedir.
1. Kablolama donanım seri
2. Kablolama yazılımı seri
Adım Adım talimat
“Boş” taslak, Leonardo, Micro, Zero, vb.Gibi “yerel USB” tabanlı Arduinos için çalışmaz! Kullan
Bunun yerine Leo_passthru kroki!
1. 4WD robot araç şasisini (taban) monte edin. Bkz . 4WD akıllı robot araba nasıl yapılır Bölüm 1 (1’den 19’a kadar STEPS).
2. L298N H-Bridge motor sürücü modülünü, iki orta boy ve iki küçük boy cıvata kullanarak robot şasinin alt kısmına takın.
3.
4.
5.
6.
7. Hız kontrolü ile dört DC motor konfigürasyonu yapacağız. L298N H-Bridge motor sürücü modülü mantığı ve tüm DC motorlara 7.2V güç kaynağından güç verilecektir.
8. 5V_EN (5V) regülatör anahtarını ayarlayın, ENA üzerindeki jumper’ları ve motor sürücü kartındaki + 5V , ENB ve + 5V’yi çıkarın . Motor polaritesini akü takımına bağlayarak kontrol edebilirsiniz. İleri yönde dönerse (akünün eksi kutbu pozitif ve siyah kablo ile kırmızı kablo), bağlantı tamam demektir. Hız kontrolü için PWM pin kullanmanız gerektiğini unutmayın (3,5,6,9,10,11 olabilir) – ENA, ENB, PWM pinlerine bağlanmalıdır.
9.
10. Motor bağlantı kartının ENA, IN1, IN2, IN3, IN4, ENB pinlerine 6 jumper kablo FM takın.
11.
12.
13. Motor sürücü modülünün güç terminaline takın 1 adet pozitif bağlantı kablosu MM (erkekten erkeğe) ve 2 adet negatif (GND) bağlantı kablosu MM (erkekten erkeğe)
14.
15. Robot kasasının üst kısmını dört orta boy cıvata ile takın. Aktarma kablolarını çıkarın.
16.
17.
18. Arduino Uno kartını iki bakır yaka, iki orta boy cıvata ve iki küçük boy cıvata kullanarak robot şasisinin üst kısmına takın.
19.
20.
21.
22. Menekşe bağlantı kablosunu (ENA) Arduino Uno dijital pim 9’a, sarı bağlantı kablosunu (ENB) Arduino Uno dijital pim 6’ya, mavi bağlantı kablosunu (IN1) Arduino Uno dijital pim 7’ye, turuncu bağlantı kablosu (IN2) Arduino Uno dijital’e takın pin 10, Arduino Uno dijital pin 5’e sarı jumper kablosu (IN3), Arduino Uno dijital pin 4’e yeşil jumper kablosu (IN4), motor sürücü kartından Arduino Uno GND pinine bir negatif (GND) jumper kablosu.
23.
24. Motor sürücü kartı için güç kaynağını hazırlayın. Güç anahtarını ona takın.
25.
26. Güç kaynağını bant veya iki cıvata ve iki somun ile robot kasasının üstüne takın ve güç kaynağı atlama kablosu kablolarına bağlayın.
27.
28. Bluetooth modülü, LED’ler, orta boy kartta aktif piezo zili için kablolama yapın. 15 x jumper kablo MM, 8 direnç ve 4 x jumper kablo FM gerekir. Aşağıdaki resme bakın.
29.
30. Robot şasisinin üst kısmına orta boy breadboard takın. Bağlantı kablolarını Arduino Uno kartına bağlayın.
31.
32. PC’nizde / dizüstü bilgisayarınızda Arduino IDE’yi açın.
33. Adruino Uno kartınızı PC / dizüstü bilgisayarınıza takın ve doğru kartı ve com bağlantı noktasını seçin.
34.
35. 9V pili 9V Pil Klipsi ile robot şasisinin üstüne takın, ancak Arduino Jack’e bağlamayın.
36. Taslağı doğrulayın ve Adruino Uno kartınıza yükleyin. Yazılım seri kitaplığı (Arduino Uno kartının RX, TX (pim 0,1) ‘e bağlı bluetooth modülünüz) olmadan kroki kullanıyorsanız – çizimi yüklemeden önce jumper kablolarını Arduino’nun RX, TX (pim 0,1)’ den ayırmalısınız. Uno kurulu.
37. Adruino Uno kartınızı PC / dizüstü bilgisayarınızdan çıkarın.
38. 9V pili 9V Pil Klipsi ve Namlu Jakı ile Arduino Jakına bağlayın.
39.
40. Güç anahtarını (kırmızı anahtar) AÇIN.
41. Bluetooth kontrollü 4WD akıllı robot otomobiliniz hazır. Tebrikler!!! Akıllı telefonunuzu / tabletinizi şimdi hazırlamamız gerekiyor.
42.
43. Android Uygulamasını Android OS ile akıllı telefonunuza / tabletinize indirin ve yükleyin – Arduino Bluetooth RC Car , Play market veya buradan . Samsung Galaxy Tab A 2016’yı kullanacağız .
44.
45.
46. Anroid OS’li akıllı telefonunuzu / tabletinizi HC-05 veya HC-06 Bluetooth modülüne bağlamak için PIN KODU (ŞİFRE) 1234 veya 0000 girmeniz gerekir . Go Bluetooth> (ON) Enable -> Yakın Cihazlarla> Pair-> Enter şifre (pin kodu) ara akıllı telefon / tablet üzerinde. Bluetooth HC-05 modülü SLAVE moduna ayarlanmalıdır, aksi takdirde Android cihazınız görmez. Buna gitmek görmüyorsa burada AT gitmek konusunda daha fazla ayrıntı için modu comms – Eğer “Seri Monitör AT komutu kablolama, yükleme kroki ve türünü kontrol etmek gerekir + ROLE = 0 AT veya“” AT + ROLE0 ” Bluetooth modülü ürün yazılımınıza bağlı olarak.
47. Akıllı telefonunuzu / tabletinizi HC-05 veya HC-06 bluetooth modülü ile eşleştirdiğinizde Arduino Bluetooth RC Car uygulamasını açın.
48.
49. Sol üst köşede kırmızı ışığı görebilirsiniz. Bu, uygulamanızın Bluetooth modülüne bağlı olmadığı anlamına gelir. Bu yüzden Seçenekler’e gitmelisiniz .
50. Araca bağlan’ı seçin .
51.
52. Bluetooth modülünü seçin.
53.
54. Tebrikler, şimdi 4WD akıllı robot arabanızı kontrol edebilirsiniz.
55.
56. Orada ivmeölçer kontrol modu da mevcuttur. Seçenekler’e gidin ve ivmeölçer kontrolünü seçin .
57.
58. 4WD akıllı robot otomobilinizi akıllı telefonunuzla / tabletinizle sadece eğerek kontrol edebilirsiniz. Bunu yapmak için düğmelere gerek yok.
59.
60. Bu kadar. Google Play pazarında başka uygulamalar da var. Çizimi gönderilecek harflerle (bu uygulamalarda atanan) kolayca değiştirebilirsiniz.
61.
62. Robotun doğru çalışıp çalışmadığını test edin. Motor yanlış yöne dönerse – motor sürücü modülünün o / p gücünü değiştirin. Uyku durumunda L298N motor sürücü modülü – Arduino denetleyicisi ile motor sürücü modülü arasındaki GND bağlantısını kontrol edin.
özet
Farklı bileşenleri nasıl bağlayacağımızı ve Bluetooth kontrollü 4WD akıllı robot arabasını nasıl yapacağımızı öğrendik .
Kütüphane
• SoftwareSerial kütüphanesi Arduino IDE’ye dahildir. Kütüphanede aşağıdaki bilinen sınırlamalar vardır: Birden fazla yazılım seri bağlantı noktası kullanılıyorsa, aynı anda yalnızca bir tanesi veri alabilir. Mega ve Mega 2560 üzerindeki tüm pinler değişiklik kesintilerini desteklemez, bu nedenle RX için yalnızca aşağıdakiler kullanılabilir: 10, 11 , 12, 13, 14, 15, 50, 51, 52, 53, A8 (62), A9 (63), A10 (64), A11 (65), A12 (66), A13 (67), A14 (68 ), A15 (69). Leonardo ve Micro desteği üzerindeki tüm pinler değişiklik kesmez, bu nedenle RX için sadece aşağıdakiler kullanılabilir: 8, 9, 10, 11, 14 (MISO), 15 (SCK), 16 (MOSI Arduino veya Genuino 101’de mevcut maksimum RX hızı 57600bps’dir Arduino veya Genuino 101 RX’te Pin 13 üzerinde çalışmaz Kütüphane aşağıdaki bilinen sınırlamalara sahiptir: Birden fazla yazılım seri portu kullanılıyorsa, bir seferde yalnızca bir veri alabilir; Mega ve Mega 2560 üzerindeki tüm pinler değişiklik kesintilerini desteklemez, bu nedenle RX için sadece aşağıdakiler kullanılabilir: 10, 11, 12, 13, 14, 15, 50, 51, 52, 53, A8 (62), A9 (63), A10 (64), A11 (65), A12 (66), A13 (67), A14 (68), A15 (69); Leonardo ve Micro desteği üzerindeki tüm pimler kesintileri değiştirmez, bu nedenle RX için sadece aşağıdakiler kullanılabilir: 8, 9, 10, 11, 14 (MISO), 15 (SCK), 16 (MOSI); Arduino veya Genuino 101’de mevcut maksimum RX hızı 57600bps’dir; Arduino veya Genuino 101 RX’de Pin 13’te çalışmaz. Buradan okuyabilirsiniz.
kroki
• Bu projenin başlangıcındaki ekleri görün
Kristal toplar geleceği “tahmin etmeye” yardımcı olabilir. Her şeyi bilen topa bir soru sorarsınız ve bir cevabı ortaya çıkarmak için ters çevirirsiniz. Cevaplar önceden belirlenecektir, ancak istediğiniz her şeyi yazabilirsiniz. Toplam 8 yanıt arasından seçim yapmak için Arduino’nuzu kullanacaksınız. Kitinizdeki eğim anahtarı, cevaplar için topu sallayarak hareketin çoğaltılmasına yardımcı olacaktır. LCD, alfasayısal karakterleri görüntülemek için kullanılabilir. Kitinizdeki, toplam 32 karakter için 16 sütun ve 2 satır içerir. Kartta çok sayıda bağlantı var. Bu pimler güç ve iletişim için kullanılır, bu yüzden ekranda ne yazacağını bilir, ancak hepsini bağlamanız gerekmez. Bağlamanız gereken pimler için aşağıdaki resme bakın. LCD ekranda projede kullanılan pimler ve etiketler.
DEVRE
Devre aşırı karmaşık değil, ancak çok fazla kablo var. Doğru olduğundan emin olmak için her şeyi kablolarken dikkatli olun. Gücü ve toprağı breadboard’unuzun bir tarafına bağlayın. Eğim anahtarını breadboard üzerine yerleştirin ve bir ucu 5V’a takın. Diğer tarafı 10 kilohm’luk bir dirençle ve Arduino’nuzun pimine 6 bağlayın. Bunu, diğer birçok projede yaptığınız gibi, dijital bir giriş olarak bağlıyorsunuz. Kayıt seçme (RS) pimi, karakterlerin ekranda nerede görüneceğini kontrol eder. Okuma / yazma pimi (R / W) ekranı okuma veya yazma moduna geçirir. Bu projede yazma modunu kullanacaksınız. Enable (EN) LCD’ye bir komut alacağını bildirir. Veri pinleri (D0-D7) ekrana karakter verisi göndermek için kullanılır. Bunlardan yalnızca 4 tanesini kullanacaksınız (D4-D7). En sonunda, ekranın kontrastını ayarlamak için bir bağlantı var. Bunu kontrol etmek için bir potansiyometre kullanacaksınız. Arduino yazılımı ile birlikte gelen LiquidCrystal kütüphanesi, bu pinlerin tüm yazılarını işler ve karakterleri görüntülemek için yazılım yazma işlemini basitleştirir. LCD’nin iki dış piminin (Vss ve LED-) toprağa bağlanması gerekir. Ayrıca, R / W pimini toprağa bağlayın. Bu, ekranı yazma moduna geçirir. LCD güç kaynağı (Vcc) doğrudan 5V’a bağlanmalıdır. Ekrandaki LED + pim, 220 ohm’luk bir direnç üzerinden güce bağlanır. Bağlayın: Arduino Dijital pin 2 – LCD D7, Arduino Dijital pin 3 – LCD D6, Arduino Dijital pin 4 – LCD D5, Arduino Dijital pin 5 – LCD D4. Bunlar ekrana hangi karakterin görüntüleneceğini söyleyen veri iğneleridir. Ekrandaki EN’yi Arduino’nuzdaki 11 pinine bağlayın. LCD üzerindeki RS pim 12’ye bağlanır. Bu pim LCD’ye yazmayı sağlar. Potansiyometreyi bir uç pimini güce, diğerini de toprağa bağlayarak breadboard’a yerleştirin. Orta pim LCD’deki V0’a bağlanmalıdır. Bu, ekranın kontrastını değiştirmenize izin verecektir.
THE CODE
First, you’ll need to import the LiquidCrystal library. Next, you’ll initialize the library, somewhat similar to the way you did with the Servo library, telling it what pins it will be using to communicate
Now that you’ve set up the library, it’s time to create some variables and constants. Create a constant to hold the pin of the switch pin, a variable for the current state of the switch, a
variable for the previous state of the switch, and one more to choose which reply the screen will show. Set up the switch pin as an input with pinMode() in your setup(). Start the LCD library, and tell it how large the screen is. Now it’s time to write a small introductory screen welcoming you to the 8-ball. The print() function writes to the LCD screen. You’re going to write the words “Ask the” on the top line of the screen. The cursor is automatically at the beginning of the top line.
In order to write to the next line, you’ll have to tell the screen where to move the cursor. The coordinates of the first column on the second line are 0,1 (recall that computers are zero indexed.
0,0 is the first column of the first row). Use the function lcd. setCursor() to move the cursor to the proper place, and tell it to write “Crystal ball!”. Now, when you start the program, it will say “Ask the Crystal ball!” on your screen. In the loop(), you’re going to check the switch first, and put the value in the switchState variable. Use an if() statement to determine if the switch is in a different
position than it was previously. If it is different than it was before, and it is currently LOW, then it’s time to choose a random reply. The random() function returns a number based on the
argument you provide it. To start, you’ll have a total number of 8 different responses for the ball. Whenever the statement random(8) is called, it will give a number between 0-7. Store that
Clear the screen with the function lcd.clear(). This also moves the cursor back to location 0,0; the first column in the first row of the LCD. Print out the line “The ball says:” and move the cursor for the output.
The switch() statement executes different pieces of code depending on the value you give it. Each of these different pieces of code is called a case. switch() checks the value of the variable reply; whatever value reply holds will determine what named case statement is executed. Inside the case statements, the code will be the same, but the messages will be different. For example, in case 0 the code says lcd.print (“Yes”). Afer the lcd.print() function, there’s another command: break. It tells the Arduino where the end of the case is. When it hits break, it skips to the end of the switch statement. You’ll be creating a total of 8 case statements to start out. Four of the responses will be positive, 2 will be negative, and the final 2 will ask you to try again.
Loop () öğesinde yapılacak son şey, prevSwitchState değişkenine switchState değerini atamaktır. Bu, döngü bir sonraki çalıştırıldığında anahtardaki değişiklikleri izlemenizi sağlar.
KOD
İlk olarak, LiquidCrystal kütüphanesini içe aktarmanız gerekir . Daha sonra, Servo kütüphanesinde yaptığınız gibi, kütüphaneyi başlatmak için iletişim kurmak için hangi pinleri kullanacağını söyleyeceksiniz. Şimdi kitaplığı kurduğunuza göre, bazı değişkenler ve sabitler oluşturma zamanı. Anahtar piminin pimini tutmak için bir sabit, anahtarın mevcut durumu için bir değişken, anahtarın önceki durumu için değişken ve ekranın hangi cevabın gösterileceğini seçmek için bir tane daha oluşturun. İle girdi olarak anahtar pimini kurma pinMode () sizin içinde kurulum () . LCD kitaplığını başlatın ve ekranın ne kadar büyük olduğunu söyleyin. Şimdi sizi 8 topa davet eden küçük bir tanıtım ekranı yazmanın zamanı geldi. Baskı ()işlevi LCD ekrana yazar. Ekranın üst satırına “Sor” kelimesini yazacaksınız. İmleç otomatik olarak üst satırın başlangıcındadır.Sonraki satıra yazmak için ekrana imleci nereye hareket ettireceğini söylemeniz gerekir. İkinci satırdaki ilk sütunun koordinatları 0,1’dir (bilgisayarların sıfır indekslendiğini hatırlayın. 0,0 ilk satırın ilk sütunu). Lcd fonksiyonunu kullanın . setCursor () ile imleci doğru yere getirin ve “Crystal ball!” yazmasını söyleyin. Şimdi, programı başlattığınızda, ekranda “Kristal topa sorun!” Yazacaktır. In döngü () , önce anahtarı kontrol edin ve switchState değişkendeki değeri koymak için gidiyoruz. Bir if () kullanınanahtarın öncekinden farklı bir konumda olup olmadığını belirleme ifadesi. Öncekinden farklıysa ve şu anda DÜŞÜK ise, rastgele bir yanıt seçme zamanı gelmiştir. Rasgele () işlevi, bunu sağlamak theargument dayalı bir sayıyı döndürür. Başlamak için, top için toplam 8 farklı yanıtınız olacaktır. Random (8) ifadesi her çağrıldığında 0-7 arasında bir sayı verecektir. Bu sayıyı yanıt değişkeninizde saklayın.
Ekranı lcd.clear () işleviyle temizleyin . Bu ayrıca imleci 0,0 konumuna geri taşır; LCD’nin ilk satırındaki ilk sütun. “Top şöyle diyor:” satırını yazdırın ve çıktı için imleci hareket ettirin. Switch () ifadesi, verdiğiniz değere bağlı olarak farklı kod parçalarını çalıştırır. Bu farklı kod parçalarının her birine durum denir. switch () değişken cevabın değerini kontrol eder; yanıtın sahip olduğu her değer, adlandırılmış vaka ifadesinin yürütüleceğini belirler. Vaka ifadelerinin içinde kod aynı olacaktır, ancak mesajlar farklı olacaktır. Örneğin, 0 durumunda kod lcd.print (“Evet”) der . Afer lcd.print ()işlevinde başka bir komut daha vardır: break. Arduino’ya davanın sonunun nerede olduğunu söyler. Araya çarptığında, anahtar ifadesinin sonuna atlar. Başlamak için toplam 8 vaka ifadesi oluşturacaksınız. Yanıtların Dört 2 negatif olacaktır, pozitif olacak ve nihai 2 sizin yapmak again.The son şey denemek isteyecektir () döngü atamaktır switchState değişkene ‘ın değerini prevSwitchState . Bu, döngü bir sonraki çalıştırıldığında anahtardaki değişiklikleri izlemenizi sağlar.
BAŞLANGIÇ
Sihirli topu kullanmak için Arduino’ya güç ver. “Kristal topa sorun!” Yazdığından emin olmak için ekranı kontrol edin. Karakterleri göremiyorsanız, potansiyometreyi çevirmeyi deneyin. Ekranın kontrastını ayarlayacaktır. Kristal topunuzla ilgili bir soru sorun ve düğmeyi baş aşağı ve geriye yatırmayı deneyin. Sorunuza bir cevap almalısınız. Cevap size uygun değilse, tekrar sorun. Print () ifadelerine kendi sözlerinizi eklemeyi deneyin , ancak her satırda yalnızca 16 karakter kullanıldığına dikkat edin. Ayrıca daha fazla yanıt eklemeyi de deneyebilirsiniz. Ek anahtar durumları eklediğinizde, yanıt değişkenini rastgele dolduracak seçenek sayısını ayarladığınızdan emin olun.
LCD’ler, polarize cam arasına sıkıştırılmış bir sıvının elektriksel özelliklerini değiştirerek çalışır. Cam sadece belirli ışık türlerinin geçmesine izin verir. Cam arasındaki sıvı doldurulduğunda, yarı katı bir duruma dönüşmeye başlar. Bu yeni durum, polarize camdan farklı bir yönde ilerler, ışığın geçmesini engeller, böylece ekranda gördüğünüz karakterleri oluşturur.
LCD ekranın metnini değiştirmek için burada yer alan işlevler oldukça basittir. Nasıl çalıştığını ele aldığınızda, kütüphanenin sahip olduğu diğer bazı işlevlere bakın. Kaydırmak veya sürekli güncellemek için metin almayı deneyin. LiquidCrystal kütüphanesinin nasıl çalıştığı hakkında daha fazla bilgi için şu adresi ziyaret edin: http://arduino.cc/lcd .
LCD ekran, LiquidCrystal kütüphanesini kullanarak ekranda metin göstermenizi sağlar. Switch … case ifadeleri, bir değişkeni belirtilen değerlerle karşılaştırarak program akışını kontrol eder.
İLAVE
LCD 1602 I2C modülünüz varsa:
KOD :
#include <LCD.h>
#include <LiquidCrystal_I2C.h>
// initialise the LCD1602 I2C:
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
const int switchPin = 6;
int switchState = 0;
int prevSwitchState = 0;
int reply;
void setup() {
lcd.begin(16, 2);
pinMode(switchPin,INPUT);
lcd.print("Ask the");
lcd.setCursor(0, 1);
lcd.print("Crystal Ball!");
}
void loop() {
switchState = digitalRead(switchPin);
if (switchState != prevSwitchState) {
if (switchState == LOW) {
reply = random(8);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("The ball says:");
lcd.setCursor(0, 1);
switch(reply){
case 0:
lcd.print("Yes");
break;
case 1:
lcd.print("Most likely");
break;
case 2:
lcd.print("Certainly");
break;
case 3:
lcd.print("Outlook good");
break;
case 4:
lcd.print("Unsure");
break;
case 5:
lcd.print("Ask again");
break;
case 6:
lcd.print("Doubtful");
break;
case 7:
lcd.print("No");
break;
}
}
}
prevSwitchState = switchState;
}
Bu Uygulama ile Bir müzisyenin parmaklarını tuşlara dokunmadan yukarı aşağı hareket ettirerek bir müzik çalmasını öğreneceksiniz.
Bir theremin, bir müzisyenin ellerinin enstrüman etrafındaki hareketlerine dayanarak ses yapan bir enstrümandır. Muhtemelen birini korkutucu filmlerde duymuşsundur. Bu arada, antenlerin kapasitif değişimini okuyarak, performansçı ellerinin iki antene göre nerede olduğunu tespit eder. Bu antenler, sesi yaratan analog devrelere bağlanır. Bir anten sesin frekansını ve diğer ses seviyesini kontrol eder. Arduino bu enstrümandaki gizemli sesleri tam olarak çoğaltamasa da, tone () işlevini kullanarak bunları taklit etmek mümkündür . Aşağıdaki resim analogWrite () ve ton () tarafından yayılan darbeler arasındaki farkı göstermektedir. Bu, hoparlör veya piezo gibi bir dönüştürücünün farklı hızlarda ileri geri hareket etmesini sağlar. Arduino ile kapasitansı algılamak yerine, ışık miktarını tespit etmek için bir fotorezistör (fotosel) kullanacaksınız. Ellerinizi sensörün üzerinde hareket ettirerek, fotorezistörün yüzüne düşen ışık miktarını, Arduino Starter Kit Projesi 4’te olduğu gibi değiştireceksiniz. Analog pinteki voltajdaki değişiklik hangi frekans notunun çalınacağını belirleyecektir. Arduino Başlangıç Kiti Projesi 4’teki gibi bir voltaj bölücü devre kullanarak fotorezistörleri Arduino’ya bağlayacaksınız. Muhtemelen önceki projede analogRead () kullanarak bu devreyi okuduğunuzda fark etmişsinizdir.okumalarınız 0 ila 1023 arasında değişmedi. Toprağa bağlanan sabit direnç aralığın alt ucunu ve ışığınızın parlaklığı üst ucunu sınırlar. Sınırlı bir aralığa yerleşmek yerine, yüksek ve düşük değerleri alan sensör okumalarını kalibre edersiniz, bunları aralığınızdan olabildiğince fazla alan çıkarmak için map () işlevini kullanarak bunları ses frekanslarına eşleştirirsiniz . Bu, farklı ışık koşullarına sahip bir oda gibi, devrenizi yeni bir ortama taşıdığınızda sensör okumalarını ayarlama avantajına sahip olacaktır. Piezo, elektrik aldığında titreyen küçük bir elementtir. Hareket ettiğinde, etrafındaki havayı uzaklaştırır, ses dalgaları oluşturur.
DEVRE
Geleneksel bunlar, sesin frekansını ve sesini kontrol edebilir. Bu örnekte, yalnızca frekansı kontrol edebileceksiniz. Arduino üzerinden ses seviyesini kontrol edemeseniz de, hoparlöre gelen voltaj seviyesini manuel olarak değiştirmek mümkündür. Breadboard’unuzda dış bus hatlarını güç ve toprağa bağlayın. Piezo’nuzu alın ve bir ucu toprağa, diğerini Arduino’daki dijital pim 8’e bağlayın. Fotorezistörünüzü bir uçtan 5V’a bağlayarak breadboard’a yerleştirin. Diğer ucunu Arduino’nun analog IN 0 pimine bağlayın ve 10 kilometrelik bir dirençle topraklayın. Bu devre, Arduino Başlangıç Kiti Proje 4’teki voltaj bölücü devresi ile aynıdır.
KODCreate a variable to hold the analogRead() value from the photoresistor. Next, create variables for the high and low values. You are going to set the initial value in the sensorLow variable to 1023, and set the value of the sensorHigh variable to 0. When you first run the program, you will compare these numbers to the sensor’s readings to find the real maximum and minimum values. Create a constant named ledPin. You will use this as an indicator that your sensor has finished calibrating. For this project, use the on-board LED connected to pin 13. In the setup(), change the pinMode() of ledPin to OUTPUT, and turn the light on. The next steps will calibrate the sensor’s maximum and minimum values. You’ll use a while() statement to run a loop for 5 seconds. while() loops run until a certain condition is met. In this case you’re going to use the millis() function to check the current time. millis() reports how long the Arduino has been running since it was last powered on or reset.In the loop, you’ll read the value of the sensor; if the value is less than sensorLow (initially 1023), you’ll update that variable. If it is greater than sensorHigh (initially 0), that gets updated. When 5 seconds have passed, the while() loop will end. Turn off the LED attached to pin 13. You’ll use the sensor high and low values just recorded to scale the frequency in the main part of your program. In the loop(), read the value on A0 and store it in sensorValue. Create a variable named pitch. The value of pitch is going to be mapped from sensorValue. Use sensorLow and sensorHigh as the bounds for the incoming values. For starting values for output, try 50 to 4000. These numbers set the range of frequencies the Arduino will generate. Next, call the tone() function to play a sound. It takes three arguments: what pin to play the sound on (in this case pin 8), what frequency to play (determined by the pitch variable), and how long to play the note (try 20 milliseconds to start).Ardından, sese çalması için biraz zaman vermek üzere 10 milisaniye boyunca bir gecikme () arayın.
AnalogRead () değerini fotorezistörden tutmak için bir değişken oluşturun . Sonra, yüksek ve düşük değerler için değişkenler oluşturun. SensorLow değişkenindeki başlangıçdeğerini 1023 olarak ve sensörHigh değişkeninin değerini 0 olarak ayarlayacaksınız . Programı ilk çalıştırdığınızda, gerçek maksimum ve minimum değerleri bulmak için bu sayıları sensörün okumaları ile karşılaştıracaksınız. . LedPin adlı bir sabit oluşturun . Bunu, sensörünüzün kalibrasyonunun bittiğini gösteren bir gösterge olarak kullanacaksınız. Bu proje için, on-board olarak pim 13 bağlanmış LED kullanmak kurulum () , değiştirmek pinMode () ait ledPinÇIKIŞ’a gidin ve ışığı açın. Bir sonraki adımlar sensörün maksimum ve minimum değerlerini kalibre edecektir. 5 saniye boyunca bir döngü çalıştırmak için while () ifadesini kullanacaksınız. while () döngüler belirli bir koşul yerine getirilinceye kadar çalışır. Bu durumda , geçerli saati kontrol etmek için millis () işlevini kullanacaksınız. millis (), Arduino’nun ne zamandan beri çalıştırıldığından veya sıfırlandığından beri ne kadar süredir çalıştığını Döngüde, sensörün değerini okursunuz; değer sensorLow’dan düşükse (başlangıçta 1023), bu değişkeni güncelleyeceksiniz. SensorHigh değerinden büyükse (başlangıçta 0), bu güncellenir. 5 saniye geçtikten sonra , ()döngü sona erecek. Pim 13’e bağlı LED’i çevirin. Programın ana bölümündeki frekansı ölçeklemek için yeni kaydedilen yüksek ve düşük değerleri kullanın. Gelen döngü () , A0 değerini okumak ve sensorValue saklayın. Pitch adlı bir değişken oluşturun. Pitchin değeri sensorValue’dan eşlenecek . Gelen değerlerin sınırları olarak sensorLow ve sensorHigh kullanın . Çıkış için başlangıç değerleri için, 50 ila 4000’i deneyin. Bu sayılar, Arduino’nun üreteceği frekans aralığını belirler. Sonra, tonu arayın ()Bir ses çalmak için Bu üç argüman alır: Sesi çalmak için hangi pin (bu durumda pin 8), hangi frekansı çalmak (adım değişkeni tarafından belirlenir) ve notun ne kadar süre çalınacağını (başlamak için 20 milisaniye deneyin). Sesi çalması için bir süre vermek üzere 10 milisaniye boyunca bir gecikme () .BAŞLANGIÇ
Arduino’yu ilk açtığınızda, sensörü kalibre etmeniz için 5 saniyelik bir pencere vardır. Bunu yapmak için, elinize ulaşan ışık miktarını değiştirerek elinizi fotorezistör üzerinde yukarı ve aşağı hareket ettirin. Enstrümanı çalarken kullanmak istediğiniz hareketleri ne kadar yaklaştırırsanız kalibrasyon o kadar iyi olacaktır. 5 saniye sonra kalibrasyon tamamlanacak ve Arduino’daki LED sönecektir. Bu olduğunda, piezodan gelen bir ses duymalısınız! Sensöre düşen ışık miktarı değiştikçe, piezonun çaldığı frekans da olmalıdır.ÖZETAralık haritası () perde belirler fonksiyonu oldukça geniştir, müzikal stil için doğru bir uyum olanları bulmaya frekansları değiştirmeyi deneyin. Ton () işlevi çok PWM gibi çalışır analogWrite () fakat anlamlı bir di ff eden farkla. Gelen analogWrite () frekansı sabittir; Bu periyottaki bakliyat oranını görev döngüsünü değiştirmek için değiştirirsiniz. İle tonu () hala darbeleri göndererek, ancak bunların frekansı değişiyor. tone () her zaman% 50 görev döngüsünde darbeler (pimin yüksek olduğu zamanın yarısı, düşük olduğu zamanın yarısı). Tonu ()fonksiyonu, bir hoparlörü veya piezoyu attığında farklı frekanslar üretme yeteneği verir. Sensörleri bir voltaj bölücü devresinde kullanırken, muhtemelen 0 – 1023 arasında tam bir değer aralığı elde edemezsiniz. Sensörleri kalibre ederek, girişlerinizi kullanılabilir bir aralıkla eşleştirmek mümkündür.Bu konuda Youtube’daki filmlerden birini izleyin – buraya tıklayın
Bir dizi anlık anahtarı, farklı tonların anahtarına dijital girişlere bağlamanız mümkün olsa da, bu projede direnç merdiveni adı verilen bir şey yaparsınız. Bu, analog girişi kullanarak bir dizi anahtarı okumanın bir yoludur. Kendinizi dijital girişlerde kısa bulursanız yararlı bir tekniktir. Paralelde paralel bağlanmış bir dizi anahtarı 0’da bağlarsınız. Bunların çoğu bir direnç üzerinden güce bağlanır. Her düğmeye bastığınızda, farklı bir voltaj seviyesi giriş pimine geçecektir. Aynı anda iki düğmeye basarsanız, paralel olarak iki direnç arasındaki ilişkiye göre benzersiz bir giriş elde edersiniz.
DEVRE
Breadboard’unuzu önceki projelerdeki gibi güç ve toprakla bağlayın. Piezonun bir ucunu toprağa bağlayın. Diğer ucunu Arduino’nuzdaki 8 no’lu pime bağlayın. Anahtarlarınızı devre üzerinde gösterildiği gibi ekmek tahtasına yerleştirin. Dirençlerin ve analog giriş besleyen anahtarların düzenlenmesine direnç merdiveni denir. İlki doğrudan güce bağlayın. İkinci, üçüncü ve dördüncü anahtarları sırasıyla 220 ohm, 10 Koh ve 1 Moh motor dirençleriyle bağlayın. Tüm anahtarların çıkışlarını tek bir kavşakta birbirine bağlayın. Bu bağlantıyı 10-Kohm’luk bir dirençle toprağa bağlayın ve ayrıca Analog In 0’a bağlayın. Bunların her biri bir voltaj bölücü görevi görür.
KOD
Bu çizimde, düğmelerinizin her birine bastığınızda oynatmak istediğiniz frekansların bir listesini tutmanız gerekir. Orta C, D, E ve F (262Hz, 294Hz, 330Hz ve 349Hz) için frekanslarla başlayabilirsiniz. Bunu yapmak için, dizi adı verilen yeni bir değişkene ihtiyacınız vardır . Dizi, müzikal bir ölçekte frekanslar gibi, birbiriyle ilişkili farklı değerleri yalnızca bir ad kullanarak kaydetmenin bir yoludur. Bilgiye hızlı ve verimli bir şekilde erişebilmeniz için kullanışlı bir araçtır. Bir dizi bildirmek için, bir değişkenle yaptığınız gibi başlayın, ancak adı bir çift köşeli ayraçla izleyin: [].Eşittir işaretinden sonra, öğelerinizi küme parantez içine alırsınız. Dizinin öğelerini okumak veya değiştirmek için, dizinin adını ve sonra adreslemek istediğiniz öğenin dizinini kullanarak tek tek öğeye başvurursunuz. Dizin, dizi oluşturulduğunda öğelerin göründüğü sırayı ifade eder. Dizideki ilk öğe 0, ikincisi de 1’dir. Yukarıda listelenen frekansları kullanarak dört nota içeren bir dizi ayarlayın. Bu diziyi setup () işleminden önce bildirerek global bir değişken yapın . Senin içinde kurulum (), bilgisayar ile seri iletişim başlar. Gelen döngü (),A0 piminde okunan değeri tutmak için yerel bir değişken tanımlayın. Her anahtarın güç kaynağına bağlanan farklı bir direnç değeri olduğundan, her birinin kendisiyle ilişkili farklı bir değeri olacaktır. Değerleri görmek için Seri satırını ekleyin . bilgisayara göndermek için println (keyVal) . Kullanılması Bir if (…) Başka deyimi, bir di ff Erent tonuna her değer atayabilirsiniz. Bu projede yer alan değerler, bu direnç ebatları için basketbol rakamlarıdır. Tüm dirençler hataya karşı tolerans gösterdiğinden, bunlar tam size göre çalışmayabilir. Gerektiği gibi ayarlamak için seri monitördeki bilgileri kullanın. Her if () ifadesinden sonra , tonu () çağırınişlevi. Program, hangi frekansın oynatılacağını belirlemek için diziye başvurur. A0’ın değeri if ifadelerinizden biriyle eşleşiyorsa, Arduino’ya bir ton çalmasını söyleyebilirsiniz. Devreniz biraz “gürültülü” olabilir ve bir düğmeye basarken değerler biraz düşebilir. Bu değişime uyum sağlamak için, kontrol edilmesi gereken küçük bir değer aralığına sahip olmak iyi bir fikirdir. ” && ” karşılaştırmasını kullanırsanız, doğru olup olmadıklarını görmek için birden fazla ifadeyi kontrol edebilirsiniz. İlk düğmeye basarsanız, [0] notaları çalınır. İkinciye basarsanız, [1] notaları çalınır ve üçüncü basarsanız, notalar [2]oynayacak. Bu, diziler gerçekten kullanışlı hale geldiğinde olur. Herhangi bir zamanda yalnızca bir frekans pin üzerinde çalabilir, böylece birden fazla tuşa basarsanız, yalnızca bir ses duyarsınız. Hiçbir tuşa basılmadığında nota çalmayı durdurmak için, noTone () işlevini çağırın, böylece sesi çalmayı durdurmak için pin numarası verin.
BAŞLANGIÇ
Eğer dirençleriniz bu projedeki değerlere yakınsa, düğmelere bastığınızda piezodan bazı sesler duymalısınız. Değilse, düğmelerin her birinin if () … else ifadesindeki notlara karşılık gelen bir aralıkta olduğundan emin olmak için seri monitörünü kontrol edin . Kekeme gibi görünen bir ses duyarsanız, aralığı biraz arttırmayı deneyin. Aynı anda birden fazla düğmeye basın ve seri monitörde ne tür değerler elde ettiğinizi görün. Daha fazla ses tetiklemek için bu yeni değerleri kullanın. Müzik çıktınızı genişletmek için farklı frekanslarla deneyler yapın. Notaların sıklıklarını bu sayfada bulabilirsiniz: arduino.cc/frequencies. Anahtarları ve direnç merdivenini analog sensörlerle değiştirirseniz, daha dinamik bir araç oluşturmak için size verdikleri ek bilgileri kullanabilirsiniz. Bir notun süresini değiştirmek için değeri kullanabilir veya Arduino Başlangıç Seti Theremin Projesi’nde olduğu gibi kayan bir ses ölçeği oluşturabilirsiniz.
ÖZET
Ton () fonksiyonu sesleri üretmek için eğlenceli, ama birkaç kısıtları var. Sinüs dalgalarını veya üçgenleri değil, sadece kare dalgaları yaratabilir. Kare dalgalar, dalgalara hiç benzemiyor. Daha önce tarif edilen Arduino Başlangıç Seti Proje 6’da gördüğünüz gibi, bir dizi açık ve darbeli. Sadece bir ton bir zaman ve oynayabilir: Eğer bant başladığınızda, akılda bazı şeyleri tutmak tonu () müdahale edecek analogWrite () pimleri 3 ve 11. Dizileri üzerinde birlikte benzer bilgi türlerini gruplandırmak için yararlıdır; bireysel öğelere atıfta bulunan indeks numaralarıyla erişilirler. Direnç merdivenleri, bir analog girişe takarak bir sisteme daha fazla dijital giriş almanın kolay bir yoludur.
Youtube’daki filmlerden birini görmek için buraya tıklayın .
// declare constant
const int switchPin = 8;
// declare variables
int switchState = 0;
int prevSwitchState = 0;
unsigned long previousTime = 0;// positive variable 32 bit, can count up to 4,294,967,295. will hold the time the LED was last changed
int led =2 ;// will be used to count which LED is the next one to be turned on. start out with pin 2
long interval = 1000;// interval between each LED turning on
//*************************************************************************
void setup() {
Serial.begin(9600);// open serial port, 9600 bits per second
for (int x = 2; x < 8; x++) {// LEDs connected to digital 2 - 7
pinMode(x, OUTPUT);// declare LED pins as OUTPUT
}
pinMode(switchPin, INPUT);// declare Switch pin as an INPUT
}//************************************************************************
void loop() {
unsigned long currentTime = millis();// get the amount of time the Arduino has been running and store it in a local variable
if (currentTime - previousTime > interval) {
previousTime = currentTime;
digitalWrite(led, HIGH);
led++;
if (led == 7) {// to check if the LED on pin 7 is turned on
}
}
switchState = digitalRead(switchPin);// read the switch value into the switchState variable
Serial.println(switchState);// print the switchState variable
if (switchState != prevSwitchState) {// checks to see if switchState does not equal prevSwitchState
for (int x = 2; x < 8; x++) {
digitalWrite(x, LOW);// if they are different, turn the all LEDs off
}
led = 2;// return the led variable to the first pin
previousTime = currentTime;// reset the timer for the LEDs by seting previousTime to currentTime
}
prevSwitchState = switchState;// save the switch state in prevSwitchState , so you can compare it to the value you get for switchState in the next loop()
}
Arduino ile belirli bir zaman aralığında bir şey olmasını istediğinizde, delay () yöntemini kullandınız . Arduino delay () işlevini çağırdığında, gecikme süresi boyunca mevcut durumunu dondurur. Bu, beklerken başka bir girdi veya çıktı olamayacağı anlamına gelir. Gecikmeler ayrıca zamanı takip etmek için çok da yardımcı değildir. Her 10 saniyede bir şeyler yapmak isteseydiniz, 10 saniyelik bir gecikmeye sahip olmak oldukça hantal olurdu. Millis () fonksiyonu bu sorunları çözmek için yardımcı olur. Arduino’nuzun milisaniye cinsinden çalıştığı süreyi izler. Daha önce kalibrasyon için bir zamanlayıcı oluşturduğunuzda Arduino Başlangıç Kiti Proje 6’da kullandınız. Şimdiye kadar değişkenleri int olarak bildirdiniz . Bir int (tam sayı)16 bit bir sayıdır, değerleri -32,768 ve 32,767 arasında tutar. Bunlar çok büyük sayılar olabilir, ancak Arduino millis () ile saniyede 1000 kez sayıyorsa , bir dakikadan daha az bir sürede alanınız tükenir . Uzun veri türü 32 bitlik bir sayı tutar (-2,147,483,648 ve 2,147,483,647 arasında). Negatif sayıları almak için geriye doğru zaman çalıştıramadığınız için, millis () zamanını saklamak için değişkene imzasız bir uzun denir . Bir veri türü işaretsiz olarak adlandırıldığında , yalnızca pozitif olur. Bu, daha da yüksek saymanıza izin verir. Bir imzasız uzun 4,294,967,295 kadar sayabilir. Milislerin () neredeyse 50 gün boyunca zaman depolaması için yeterli alan . Mevcut millis () ‘i karşılaştırarakbelirli bir değere belli bir süre geçip geçmediğini görebilirsiniz. Kum saatinizi ters çevirdiğinizde, bir tilt düğmesi durumunu değiştirecek ve bu da LED’lerin yanmasını sağlayacak. Eğme anahtarı, açık / kapalı bir sensör olması gibi normal bir anahtar gibi çalışır. Burada dijital giriş olarak kullanacaksınız. Eğim anahtarlarını benzersiz yapan şey, yönlendirmeyi algılamalarıdır. Tipik olarak, içinde metal bilyeli olan mahfazanın içinde küçük bir boşluk bulunur. Doğru şekilde yatırıldığında, top boşluğun bir tarafına yuvarlanır ve breadboard’unuzdaki iki kabloyu birleştirerek düğmeyi kapatır. Altı LED ile kum saatiniz adından da anlaşılacağı gibi bir saat boyunca çalışır.
DEVRE
Breadboard’unuza güç ve toprak bağlayın. Altı LED’in anotunu (uzun bacak) 2-7 numaralı dijital pinlere bağlayın. LED’leri toprağa 220-ohm dirençlerle bağlayın. Eğim anahtarının bir kablosunu 5V’a bağlayın. Diğerini 10 kilometrelik bir direnç ile toprağa bağlayın. Buluştukları kavşağı dijital pim 8’e bağlayın. Bunun çalışması için Arduino’nuzu bilgisayara bağlamanıza gerek yoktur. Karton veya strafor içeren bir stand inşa etmeyi deneyin ve taşınabilir bir sürüm elde etmek için Arduino’yu bir batarya ile güçlendirin. Işıkların yanında bazı sayısal göstergelerle bir kapak oluşturabilirsiniz. Eğim anahtarları, bir şeyin yönünü belirlemek için harika, ucuz araçlardır. Akselerometreler başka tür bir eğim sensörüdür, ancak daha fazla bilgi verirler. Ayrıca çok daha pahalıdırlar.
KOD
Her şeyin çalışabilmesi için eskizinizde çok sayıda global değişkene ihtiyacınız var. Başlamak için, switchPin adlı bir sabit oluşturun . Bu, eğim anahtarınızın açık olduğu pimin adı olacaktır. İmzasız uzun tip bir değişken oluşturun , Bu, bir LED’in en son değiştirildiği süreyi koruyacaktır. Anahtar durumu için bir değişken ve önceki anahtar durumunu tutmak için başka bir değişken oluşturun. Bu ikisini, anahtarın konumunu bir döngüden diğerine karşılaştırmak için kullanırsınız. Led adlı bir değişken oluşturun. Bu, bir sonraki açılacak LED’in hangisi olduğunu saymak için kullanılacaktır. Pim 2 ile başlayın. Oluşturduğunuz son değişken, her bir LED’in açılması arasındaki aralıktır. Bu uzun sürecekveri tipi. 10 dakika içinde (her bir LED’in yanması arasındaki süre) 600.000 milisaniye geçer. Işıklar arasındaki gecikmenin daha uzun veya daha kısa olmasını istiyorsanız, değiştirdiğiniz sayı budur. Kurulumunuzda (), LED pinlerini 2-7 çıkış olarak bildirmeniz gerekir. Bir for () döngüsü, altı tanesinin tümünü yalnızca 3 satırlık bir kod satırı ile OUTPUT olarak bildirir. Ayrıca switchPin’i bir INPUT (GİRİŞ) olarak bildirmeniz gerekir. Ne zaman döngü () başlar, sen Arduino ile çalışmakta olduğu süreyi alacağız milisaniye () ve CurrentTime adında yerel bir değişkende saklayın. Bir if () ifadesi kullanarak , bir LED’i açmak için yeterli zamanın geçtiğini kontrol etmiş olursunuz. Çıkar CurrentTime gelen previousTimeve aralık değişkeninden daha büyük olup olmadığını kontrol edin. 600.000 milisaniye geçtiğinde (10 dakika), öncekiTime değişkenini currentTime değerine ayarlarsınız. priorTime bir LED’in en son ne zaman açıldığını gösterir. Eğer belirledikten sonra previousTime , LED açın ve led şekilde arttıracaktır. Zaman aralığını bir sonraki geçiinizde bir sonraki LED yanacaktır. Pim 7’deki LED’in açık olup olmadığını kontrol etmek için programdaki ifadeyi bir tane daha ekleyin. Bununla henüz bir şey yapma. Bir saat sonra ne olacağına siz karar verin. Şimdi saati kontrol ettikten sonra, anahtarın durumunu değiştirip değiştirmediğini görmek istersiniz. Switch değerini, switchState değişkenine okuyun . Bir if () ileAnahtarın daha önce olduğundan farklı bir konumda olup olmadığını kontrol edin. ! = SwitchState eşit prevSwitchState yapar değilse değerlendirme denetler. Farklıysa, LED’leri turn çevirin, led değişkenini ilk pime getirin ve LED’lerin zamanlayıcısını, öncekiTime’yi currentTime olarak ayarlayarak sıfırlayın. Döngünün sonunda () , anahtar durumunu prevSwitchState konumuna kaydedin , böylece bir sonraki döngüde () switchState için aldığınız değerle karşılaştırabilirsiniz .
BAŞLANGIÇ
Tahtayı programladıktan sonra, bir saatteki zamanı kontrol edin. 10 dakika geçtikten sonra, ilk LED açık olmalıdır. Bundan sonra her 10 dakikada bir, yeni bir ışık yanacaktır. Bir saatin sonunda, altı ışığın tümü açık olmalıdır. Devreyi çevirdiğinizde ve yatırma anahtarının durumunu değiştirmesine neden olduğunuzda, ışıklar sönecek ve zamanlayıcı tekrar başlayacaktır. Saat bir saate ulaştığında ve altı ışığın hepsi yandığında, sadece yanarlar. Sesler veya ışıkların yakılması, saat dolduğunda dikkatinizi çekmenin iyi bir göstergesidir. Tüm değişkenlerin açık olup olmadığını görmek için led değişkeni kontrol edilebilir, bu birinin dikkatini çekmeyi kontrol etmek için iyi bir yer. Kumla doldurulmuş bir kum saatinden farklı olarak, ışıklar anahtarın yönüne bağlı olarak yukarı ya da aşağı gider. SwitchState’i kullanabilirsiniz Bunu yapmak için değişken.
ÖZET
Olaylar arasındaki süreyi ölçmek için millis () işlevini kullanın. Ürettiği sayılar bir int içinde saklayabildiğinizden daha büyük olduğundan, değerlerini saklamak için uzun süre işaretsiz veri türünü kullanmanız gerekir.
Youtube’daki filmlerden birini görmek için buraya tıklayın .
Arduino ile 74HC595 – Seriden Paralel Kaymaya Çıkış
Kodlar:
//**************************************************************//
// Name : shiftOutCode, Hello World
// Author : Carlyn Maw,Tom Igoe, David A. Mellis
// Date : 25 Oct, 2006
// Modified: 23 Mar 2010
// Version : 2.0
// Notes : Code for using a 74HC595 Shift Register //
// : to count from 0 to 255
//****************************************************************
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
void setup() {
//set pins to output so you can control the shift register
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}
void loop() {
// count from 0 to 255 and display the number
// on the LEDs
for (int numberToDisplay = 0; numberToDisplay < 256; numberToDisplay++) {
// take the latchPin low so
// the LEDs don't change while you're sending in bits:
digitalWrite(latchPin, LOW);
// shift out the bits:
shiftOut(dataPin, clockPin, MSBFIRST, numberToDisplay);
//take the latch pin high so the LEDs will light up:
digitalWrite(latchPin, HIGH);
// pause before next value:
delay(500);
}
}
/*
Shift Register Example
for 74HC595 shift register
This sketch turns reads serial input and uses it to set the pins
of a 74HC595 shift register.
Hardware:
* 74HC595 shift register attached to pins 8, 12, and 11 of the Arduino,
as detailed below.
* LEDs attached to each of the outputs of the shift register.
Created 22 May 2009
Created 23 Mar 2010
by Tom Igoe
*/
//Pin connected to latch pin (ST_CP) of 74HC595
const int latchPin = 8;
//Pin connected to clock pin (SH_CP) of 74HC595
const int clockPin = 12;
////Pin connected to Data in (DS) of 74HC595
const int dataPin = 11;
void setup() {
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
Serial.begin(9600);
Serial.println("reset");
}
void loop() {
if (Serial.available() > 0) {
// ASCII '0' through '9' characters are
// represented by the values 48 through 57.
// so if the user types a number from 0 through 9 in ASCII,
// you can subtract 48 to get the actual value:
int bitToSet = Serial.read() - 48;
// write to the shift register with the correct bit set high:
registerWrite(bitToSet, HIGH);
}
}
// This method sends bits to the shift register:
void registerWrite(int whichPin, int whichState) {
// the bits you want to send
byte bitsToSend = 0;
// turn off the output so the pins don't light up
// while you're shifting bits:
digitalWrite(latchPin, LOW);
// turn on the next highest bit in bitsToSend:
bitWrite(bitsToSend, whichPin, whichState);
// shift the bits out:
shiftOut(dataPin, clockPin, MSBFIRST, bitsToSend);
// turn on the output so the LEDs can light up:
digitalWrite(latchPin, HIGH);
}
/*
Shift Register Example
Turning on the outputs of a 74HC595 using an array
Hardware:
* 74HC595 shift register
* LEDs attached to each of the outputs of the shift register
*/
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
//holders for infromation you're going to pass to shifting function
byte data;
byte dataArray[10];
void setup() {
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
Serial.begin(9600);
//Binary notation as comment
dataArray[0] = 0xFF; //0b11111111
dataArray[1] = 0xFE; //0b11111110
dataArray[2] = 0xFC; //0b11111100
dataArray[3] = 0xF8; //0b11111000
dataArray[4] = 0xF0; //0b11110000
dataArray[5] = 0xE0; //0b11100000
dataArray[6] = 0xC0; //0b11000000
dataArray[7] = 0x80; //0b10000000
dataArray[8] = 0x00; //0b00000000
dataArray[9] = 0xE0; //0b11100000
//function that blinks all the LEDs
//gets passed the number of blinks and the pause time
blinkAll_2Bytes(2,500);
}
void loop() {
for (int j = 0; j < 10; j++) {
//load the light sequence you want from array
data = dataArray[j];
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//move 'em out
shiftOut(dataPin, clockPin, data);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(300);
}
}
// the heart of the program
void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {
// This shifts 8 bits out MSB first,
//on the rising edge of the clock,
//clock idles low
//internal function setup
int i=0;
int pinState;
pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, OUTPUT);
//clear everything out just in case to
//prepare shift register for bit shifting
digitalWrite(myDataPin, 0);
digitalWrite(myClockPin, 0);
//for each bit in the byte myDataOut�
//NOTICE THAT WE ARE COUNTING DOWN in our for loop
//This means that %00000001 or "1" will go through such
//that it will be pin Q0 that lights.
for (i=7; i>=0; i--) {
digitalWrite(myClockPin, 0);
//if the value passed to myDataOut and a bitmask result
// true then... so if we are at i=6 and our value is
// %11010100 it would the code compares it to %01000000
// and proceeds to set pinState to 1.
if ( myDataOut & (1<<i) ) {
pinState= 1;
}
else {
pinState= 0;
}
//Sets the pin to HIGH or LOW depending on pinState
digitalWrite(myDataPin, pinState);
//register shifts bits on upstroke of clock pin
digitalWrite(myClockPin, 1);
//zero the data pin after shift to prevent bleed through
digitalWrite(myDataPin, 0);
}
//stop shifting
digitalWrite(myClockPin, 0);
}
//blinks the whole register based on the number of times you want to
//blink "n" and the pause between them "d"
//starts with a moment of darkness to make sure the first blink
//has its full visual effect.
void blinkAll_2Bytes(int n, int d) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(200);
for (int x = 0; x < n; x++) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 255);
shiftOut(dataPin, clockPin, 255);
digitalWrite(latchPin, 1);
delay(d);
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(d);
}
}
//**************************************************************//
// Name : shiftOutCode, Dual Binary Counters //
// Author : Carlyn Maw, Tom Igoe //
// Date : 25 Oct, 2006 //
// Version : 1.0 //
// Notes : Code for using a 74HC595 Shift Register //
// : to count from 0 to 255 //
//**************************************************************//
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
void setup() {
//Start Serial for debuging purposes
Serial.begin(9600);
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
}
void loop() {
//count up routine
for (int j = 0; j < 256; j++) {
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//count up on GREEN LEDs
shiftOut(dataPin, clockPin, j);
//count down on RED LEDs
shiftOut(dataPin, clockPin, 255-j);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(1000);
}
}
void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {
// This shifts 8 bits out MSB first,
//on the rising edge of the clock,
//clock idles low
..//internal function setup
int i=0;
int pinState;
pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, OUTPUT);
. //clear everything out just in case to
. //prepare shift register for bit shifting
digitalWrite(myDataPin, 0);
digitalWrite(myClockPin, 0);
//for each bit in the byte myDataOut�
//NOTICE THAT WE ARE COUNTING DOWN in our for loop
//This means that %00000001 or "1" will go through such
//that it will be pin Q0 that lights.
for (i=7; i>=0; i--) {
digitalWrite(myClockPin, 0);
//if the value passed to myDataOut and a bitmask result
// true then... so if we are at i=6 and our value is
// %11010100 it would the code compares it to %01000000
// and proceeds to set pinState to 1.
if ( myDataOut & (1<<i) ) {
pinState= 1;
}
else {
pinState= 0;
}
//Sets the pin to HIGH or LOW depending on pinState
digitalWrite(myDataPin, pinState);
//register shifts bits on upstroke of clock pin
digitalWrite(myClockPin, 1);
//zero the data pin after shift to prevent bleed through
digitalWrite(myDataPin, 0);
}
//stop shifting
digitalWrite(myClockPin, 0);
}
//**************************************************************//
// Name : shiftOutCode, Dual One By One //
// Author : Carlyn Maw, Tom Igoe //
// Date : 25 Oct, 2006 //
// Version : 1.0 //
// Notes : Code for using a 74HC595 Shift Register //
// : to count from 0 to 255 //
//**************************************************************//
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
//holder for infromation you're going to pass to shifting function
byte data = 0;
void setup() {
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
}
void loop() {
//function that blinks all the LEDs
//gets passed the number of blinks and the pause time
blinkAll_2Bytes(1,500);
// light each pin one by one using a function A
for (int j = 0; j < 8; j++) {
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//red LEDs
lightShiftPinA(7-j);
//green LEDs
lightShiftPinA(j);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(1000);
}
// light each pin one by one using a function A
for (int j = 0; j < 8; j++) {
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//red LEDs
lightShiftPinB(j);
//green LEDs
lightShiftPinB(7-j);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(1000);
}
}
//This function uses bitwise math to move the pins up
void lightShiftPinA(int p) {
//defines a local variable
int pin;
//this is line uses a bitwise operator
//shifting a bit left using << is the same
//as multiplying the decimal number by two.
pin = 1<< p;
//move 'em out
shiftOut(dataPin, clockPin, pin);
}
//This function uses that fact that each bit in a byte
//is 2 times greater than the one before it to
//shift the bits higher
void lightShiftPinB(int p) {
//defines a local variable
int pin;
//start with the pin = 1 so that if 0 is passed to this
//function pin 0 will light.
pin = 1;
for (int x = 0; x < p; x++) {
pin = pin * 2;
}
//move 'em out
shiftOut(dataPin, clockPin, pin);
}
// the heart of the program
void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {
// This shifts 8 bits out MSB first,
//on the rising edge of the clock,
//clock idles low
//internal function setup
int i=0;
int pinState;
pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, OUTPUT);
//clear everything out just in case to
//prepare shift register for bit shifting
digitalWrite(myDataPin, 0);
digitalWrite(myClockPin, 0);
//for each bit in the byte myDataOut�
//NOTICE THAT WE ARE COUNTING DOWN in our for loop
//This means that %00000001 or "1" will go through such
//that it will be pin Q0 that lights.
for (i=7; i>=0; i--) {
digitalWrite(myClockPin, 0);
//if the value passed to myDataOut and a bitmask result
// true then... so if we are at i=6 and our value is
// %11010100 it would the code compares it to %01000000
// and proceeds to set pinState to 1.
if ( myDataOut & (1<<i) ) {
pinState= 1;
}
else {
pinState= 0;
}
//Sets the pin to HIGH or LOW depending on pinState
digitalWrite(myDataPin, pinState);
//register shifts bits on upstroke of clock pin
digitalWrite(myClockPin, 1);
//zero the data pin after shift to prevent bleed through
digitalWrite(myDataPin, 0);
}
//stop shifting
digitalWrite(myClockPin, 0);
}
//blinks both registers based on the number of times you want to
//blink "n" and the pause between them "d"
//starts with a moment of darkness to make sure the first blink
//has its full visual effect.
void blinkAll_2Bytes(int n, int d) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(200);
for (int x = 0; x < n; x++) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 255);
shiftOut(dataPin, clockPin, 255);
digitalWrite(latchPin, 1);
delay(d);
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(d);
}
}
//**************************************************************//
// Name : shiftOutCode, Predefined Dual Array Style //
// Author : Carlyn Maw, Tom Igoe //
// Date : 25 Oct, 2006 //
// Version : 1.0 //
// Notes : Code for using a 74HC595 Shift Register //
// : to count from 0 to 255 //
//****************************************************************
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
//holders for infromation you're going to pass to shifting function
byte dataRED;
byte dataGREEN;
byte dataArrayRED[10];
byte dataArrayGREEN[10];
void setup() {
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
Serial.begin(9600);
//Arduino doesn't seem to have a way to write binary straight into the code
//so these values are in HEX. Decimal would have been fine, too.
dataArrayRED[0] = 0xFF; //11111111
dataArrayRED[1] = 0xFE; //11111110
dataArrayRED[2] = 0xFC; //11111100
dataArrayRED[3] = 0xF8; //11111000
dataArrayRED[4] = 0xF0; //11110000
dataArrayRED[5] = 0xE0; //11100000
dataArrayRED[6] = 0xC0; //11000000
dataArrayRED[7] = 0x80; //10000000
dataArrayRED[8] = 0x00; //00000000
dataArrayRED[9] = 0xE0; //11100000
//Arduino doesn't seem to have a way to write binary straight into the code
//so these values are in HEX. Decimal would have been fine, too.
dataArrayGREEN[0] = 0xFF; //11111111
dataArrayGREEN[1] = 0x7F; //01111111
dataArrayGREEN[2] = 0x3F; //00111111
dataArrayGREEN[3] = 0x1F; //00011111
dataArrayGREEN[4] = 0x0F; //00001111
dataArrayGREEN[5] = 0x07; //00000111
dataArrayGREEN[6] = 0x03; //00000011
dataArrayGREEN[7] = 0x01; //00000001
dataArrayGREEN[8] = 0x00; //00000000
dataArrayGREEN[9] = 0x07; //00000111
//function that blinks all the LEDs
//gets passed the number of blinks and the pause time
blinkAll_2Bytes(2,500);
}
void loop() {
for (int j = 0; j < 10; j++) {
//load the light sequence you want from array
dataRED = dataArrayRED[j];
dataGREEN = dataArrayGREEN[j];
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//move 'em out
shiftOut(dataPin, clockPin, dataGREEN);
shiftOut(dataPin, clockPin, dataRED);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(300);
}
}
// the heart of the program
void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {
// This shifts 8 bits out MSB first,
//on the rising edge of the clock,
//clock idles low
//internal function setup
int i=0;
int pinState;
pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, OUTPUT);
//clear everything out just in case to
//prepare shift register for bit shifting
digitalWrite(myDataPin, 0);
digitalWrite(myClockPin, 0);
//for each bit in the byte myDataOut�
//NOTICE THAT WE ARE COUNTING DOWN in our for loop
//This means that %00000001 or "1" will go through such
//that it will be pin Q0 that lights.
for (i=7; i>=0; i--) {
digitalWrite(myClockPin, 0);
//if the value passed to myDataOut and a bitmask result
// true then... so if we are at i=6 and our value is
// %11010100 it would the code compares it to %01000000
// and proceeds to set pinState to 1.
if ( myDataOut & (1<<i) ) {
pinState= 1;
}
else {
pinState= 0;
}
//Sets the pin to HIGH or LOW depending on pinState
digitalWrite(myDataPin, pinState);
//register shifts bits on upstroke of clock pin
digitalWrite(myClockPin, 1);
//zero the data pin after shift to prevent bleed through
digitalWrite(myDataPin, 0);
}
//stop shifting
digitalWrite(myClockPin, 0);
}
//blinks the whole register based on the number of times you want to
//blink "n" and the pause between them "d"
//starts with a moment of darkness to make sure the first blink
//has its full visual effect.
void blinkAll_2Bytes(int n, int d) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(200);
for (int x = 0; x < n; x++) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 255);
shiftOut(dataPin, clockPin, 255);
digitalWrite(latchPin, 1);
delay(d);
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(d);
}
}
Bu projede bir veya iki 74HC595’i Arduino kartına nasıl bağlayacağımızı öğreneceğiz .
74HC595’i Anlamak
74HC595, 8 bitlik kaydırma yazmacı ve üç durumlu paralel çıkışlara sahip bir depolama yazmacından oluşur. Seri girişi paralel çıkışa dönüştürür, böylece bir MCU’nun IO portlarını kaydedebilirsiniz. MR (pin10) yüksek ve OE (pin13) düşük seviyedeyken, veri SHcp’nin yükselen kenarına girer ve bellek kaydına gider. SHcp’nin yükselen kenarı. İki saat birbirine bağlanırsa, kaydırma yazmacı her zaman bellek yazmacından bir atım daha erken olur. Bellek kaydında bir seri kaydırma giriş pimi (Ds), bir seri çıkış pimi (Q) ve bir asenkron sıfırlama düğmesi (düşük seviye) bulunmaktadır. Bellek kaydı, paralel bir 8-bit ve üç durumda bir Veri Yolu çıkışı verir. OE etkinleştirildiğinde (düşük seviye), hafıza kaydındaki veriler veri yoluna gönderilir. Bir süre veya bir süre sonra Arduino kartınızdaki pimler tükenebilir ve vardiya kayıtlarıyla genişletmeniz gerekir. Bu proje 74HC595’e dayanmaktadır. Veri sayfası 74HC595’i “Çıkış mandallı 8 bit seri giriş, seri veya paralel çıkış kaydırma yazmacı; 3-durumu. “Başka bir deyişle, bir seferde 8 çıkışı kontrol etmek için kullanabilirsiniz, ancak mikrodenetleyicinizde yalnızca birkaç pimi çeker. Çıktınızı daha da uzatmak için birden fazla kaydı birbirine bağlayabilirsiniz. (Kullanıcılar ayrıca başka bir sürücü de bulmak isteyebilir. parça numaralarında “595” veya “596” olan yongalar, çok sayıda var. Örneğin STP16C596, 16 LED’i sürecek ve dahili sabit akım kaynaklarına sahip seri dirençleri ortadan kaldıracak.) Tüm bunlar nasıl işler “denilen bir şeyden geçer. senkronize seri haberleşme“, yani bir pimi yukarı ve aşağı atabilir ve böylece bir veri baytını kayıt defterine bit bit olarak iletebilirsiniz. Bu, ikinci pimi, saat pimini, bitler arasında tanımladığınız zaman darbesiyle. Bu” asenkron seri iletişimi kullanmanın tersine ” Seri.begin () ‘inBelirlenen veri hızına kararlaştırılan vericiye bağımsız olarak ayarlanacak gönderici ve alıcıya dayanan işlev. Tüm bayt kayıt defterine iletildiğinde, her bir bitte tutulan YÜKSEK veya DÜŞÜK mesajlar, her bir çıkış pimine ayrıştırılır. Bu, “paralel çıktı” kısmıdır, tüm pimlerin hepsini bir defada yapmalarını istediğiniz şeyi yapmalarıdır. Bu bileşenin “seri çıkışı” kısmı, mikrodenetleyiciden alınan seri bilgisini tekrar değiştirmeden iletebilen ekstra piminden gelir. Bu, 16 bit’i arka arkaya (2 bayt) aktarabileceğiniz anlamına gelir ve ilk 8 ilk yazmacın içinden ikinci yazmacın içine akar ve burada ifade edilir. Bunu ikinci örnekten yapmayı öğrenebilirsin. “3 durum”, çıkış pimlerini yüksek, düşük veya “olarak ayarlayabileceğiniz anlamına gelir” yüksek empedans. “YÜKSEK ve DÜŞÜK durumların aksine, pinleri ayrı ayrı yüksek empedans durumlarına ayarlayamazsınız. Tüm yongayı sadece bir araya getirebilirsiniz. Bu yapılacak oldukça özel bir şey. Projenize özgü bir mod ayarına bağlı olarak tamamen farklı bir mikrodenetleyici tarafından kontrol edilmesi gerekebilecek bir LED dizisi düşünün. Her iki örnek de bu özellikten faydalanmaz ve genellikle sahip olduğu bir fişi almak için endişelenmenize gerek yoktur.
Q0-Q7: 8-bit paralel veri çıkış pinleri, 8 LED’i veya 7 pinli ekranın 8 pinini doğrudan kontrol edebilen.
Q7 ‘: Birden fazla 74HC595’i seri bağlamak için başka bir 74HC595’in DS’sine bağlı seri çıkış pimi
MR: Pimi sıfırla, düşük seviyede aktif; burada doğrudan 5V’a bağlanır.
SHcp: Vardiya kaydının zaman sırası girişi. Yükselen kenarında, kaydırma yazmacındaki veriler art arda bir bit, yani Q1’deki veriler Q2’ye vb. Taşınır. Düşen kenardayken, kaydırma yazmacındaki veriler değişmeden kalır.
STcp: Depolama kaydının zaman sırası girişi. Yükselen kenarda, vardiya kaydındaki veriler hafıza kaydına taşınır.
OE: Düşük seviye aktif çıkış pimi. İşte GND’ye bağlı.
DS: Seri veri giriş pimi
VCC: Pozitif besleme gerilimi
GND: Toprak
Sen yonganın şartname kontrol edebilirsiniz 74HC595 burada .
Devreyi kur
1. İlk adım Arduino’nuzu bir vardiya kaydında genişletmek.
1. Açma.
Aşağıdaki bağlantıları yapın:
GND (pin 8) yere,
Vcc (pin 16) ila 5V
OE (pim 13) toprağa
MR (pim 10) ila 5V
Bu ayar, tüm çıkış pinlerinin her zaman aktif ve adreslenebilir olmasını sağlar. Bu kurulumun bir kusuru, ışıklar çalışmaya başladıktan önce devreyi ilk açışınızda, son durumlarına veya isteğe bağlı olarak yanan bir şeye neden olmanızdır. Arduino kartınızdan MR ve OE pimlerini de kontrol ederek bu sorunu çözebilirsiniz, ancak bu şekilde çalışır ve sizi daha açık pimlerle bırakır.
Bundan sonra, bunlar sırasıyla dataPin, clockPin ve latchPin olarak adlandırılacaktır. LatchPin’deki 0.1 uf kapasitöre dikkat edin, mandal pimi darbeye girdiğinde biraz titriyorsanız, eşitlemek için bir kapasitör kullanabilirsiniz.
3. 8 LED ekleyin.
Bu durumda, her LED’in katodunu (kısa pim) ortak bir toprağa ve her LED’in anotunu (uzun pim) ilgili kaydırma yazmacı çıkış pimine bağlamalısınız. Bu şekilde güç sağlamak için vardiya kaydının kullanılması kaynak akımı olarak adlandırılır. Bazı vardiya kayıtları akım besleyemez, yalnızca batan akım denilen şeyi yapabilirler. Bunlardan birine sahipseniz, anotları doğrudan güce ve katotları (topraklama pimleri) vites değiştirme yazıcısının çıkışlarına yerleştirerek, LED’lerin yönünü çevirmeniz gerekeceği anlamına gelir. 595 serisi bir yonga kullanmıyorsanız, kendi veri sayfanızı kontrol etmelisiniz. LED’lerin aşırı yüklenmesini önlemek için seri olarak 220 ohm’luk bir direnç eklemeyi unutmayın.
2. İkinci adım, Arduino’nuzu bir tane daha vardiya kaydıyla genişletmektir.1. İkinci bir vardiya kaydı ekleyin.Önceki örnekten başlayarak, tahtaya ikinci bir vardiya kaydı koymalısınız. Aynı elektriğe güç ve toprak vermelidir.
1. İlk vardiya yazıcısını ve 8 kırmızı LED’i Arduino’nuza daha önce anlatıldığı gibi bağlayın.
2. İkinci bir vardiya kaydı ekleyin. Önceki örnekten başlayarak, tahtaya ikinci bir vardiya kaydı koymalısınız. Aynı elektriğe güç ve toprak vermelidir.
3. 2 kaydı bağlayın.
Bu bağlantılardan ikisi Arduino’dan ikinci kaydırma yazmacına (sarı ve yeşil teller) aynı saat ve mandallama sinyalini uzatır. Mavi kablo, ilk kaydırma yazmacının seri çıkış piminden (pim 9) ikinci yazıcının seri veri girişine (pim 14) geçmektedir.4. İkinci bir LED seti ekleyin.Bu durumda yeşil olanları ekledim, bu yüzden kodu okurken hangi baytın hangi LED’lere gideceği açıktır.
KOD (BİR ÜSTKRK KAYIT)
Kod, veri sayfasındaki iki bilgiye dayanmaktadır: zamanlama diyagramı ve mantık tablosu.
Mantık tablosu, temelde önemli olan her şeyin bir atışta gerçekleştiğini söyleyen şeydir. Ne zaman clockPin alçaktan yükseğe doğru gider, kaydırma yazmacı veri pimi durumunu okur. Veriler kaydıkça dahili bir hafıza kaydına kaydedilir. Ne zaman latchPin alçaktan yükseğe doğru gider gönderileceği ile veri LED’leri aydınlatma, çıkış pimleri içine vardiya kayıtları yukarıda belirtilen bellek kasadan başına taşınır.
Adım adım talimat
Adruino Uno tahtanızı PC’nize takın ve doğru tahtayı ve bağlantı noktasını seçin
Seri monitörü açın ve baudunuzu 9600 baud’a ayarlayın
Taslağı doğrulayın ve Adruino Uno panonuza yükleyin
KOD (İKİ ÜSTKRK KAYIT KAYDI)
Merak ediyorsanız, sadece ne olduğunu görmek için bu devreyi kurmuş olan ilk örnekten örnekleri denemek isteyebilirsiniz.
Sketch 4 İkili İkili Sayıcılar
Eskiz 1’deki ilk kod örneğiyle karşılaştırıldığında yalnızca bir ekstra kod satırı var. İkinci bir bayt gönderir. Bu, doğrudan Arduino’ya bağlı olan ilk kaydırma yazmacını, yeşil LED’leri aydınlatmak için gönderilen ikinci byte’dan geçen ilk baytı geçmeye zorlar. İkinci bayt daha sonra kırmızı LED’lerde görünecektir.
5 Bayt Teker Teker Eskiz
Bu kodu Sketch 1 ‘deki benzer kodla karşılaştırarak, biraz daha fazlasının değişmesi gerektiğini görürsünüz. BlinkAll () işlevi, şu anda kontrol edilecek 16 LED bulunduğunu yansıtmak için blinkAll_2Bytes () işlevine değiştirildi. Ayrıca, 1. versiyonda, latchPin’in darbeleri, lightShiftPinA ve lightShiftPinB () alt fonksiyonlarının içine yerleştirilmiştir. Burada, her bir alt işlevi arka arkaya iki kez, yeşil LED’ler için bir kez ve kırmızı olanlar için bir kez çalıştırmak zorunda kalmaları için ana döngüye geri taşınmaları gerekir.
Çizim 6 – İkili Tanımlanmış Diziler
Çizim 5 gibi, Çizim 6 da yeni blinkAll_2bytes () işlevinden faydalanır. Eskiz 6’nın Eskiz 3’teki büyük farkı, yalnızca “data” adı verilen tek bir değişken ve “dataArray” adlı tek bir dizinin yerine, yukarıda tanımlanmış bir dataRED, dataGREEN, dataArrayRED, dataArrayGREEN’e sahip olmanız gerektiğidir. Bu, bu çizgiyi ifade eder
data = dataArray [j];
olur
dataRED = dataArrayRED [j];
dataGREEN = dataArrayGREEN [j];
ve
shiftOut (dataPin, clockPin, veri);
olur
shiftOut (dataPin, clockPin, dataGREEN);
shiftOut (dataPin, clockPin, dataRED);özet
Bir veya iki 74HC595’i Arduino kartına nasıl bağlayacağımızı öğrendik
Kütüphane:
Bu proje için kütüphaneye gerek yok
Skeçler:
Bu proje açıklamasının başlangıcındaki eklere bakınız.
Çizim 1 ila Çizim 3. Birincisi, sadece 0 ile 255 arasında bir byte değeri veren sadece bir “merhaba dünya” kodudur. İkinci çizim bir seferde bir LED yanar. Üçüncü dizi boyunca döner.
