Arduino'da bir düğme programlama. Arduino'ya bir düğme bağlama. Bir çekme direnci devresi kullanarak bir düğmenin bağlanması

Elektronikte çok sık kullanılır. İlk bakışta onlarla çalışmak sürprizlerle dolu değil ama burada da tuzaklar var.

Düğmenin dört ayağı olmasına rağmen aslında üstte kapanan iki devre parçası olarak düşünülebilir. Devrenin doğru olması için bağlantının doğru olduğundan emin olun.

Kumanda kullanmadan, üzerinden akım geçirerek butonu bağlayalım. 5V. Butona bastığınızda devre kapanacak ve LED yanacaktır. Beklenmedik bir şey yok.

Gerçekte butondan gelen sinyali okumamız ve ona yanıt vermemiz gerekiyor. Bu nedenle şemayı değiştirmeye çalışalım. Butonun bir pinini powera ve kart üzerindeki pin 3’e bağlayalım. Pim 3'ten bilgiyi okuyacağız: mantıksal sıfır veya mantıksal bir. Butona bastığınızda devre kapanır, pin 3 mantıksal olur ve LED'i yakarız.

Int butonuPin = 12; int ledPin = 3; void setup() ( pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT); ) void loop() ( bool val = digitalRead(buttonPin); digitalWrite(ledPin, val); )

Düğmeye tıklandığında kod düzgün çalışıyor. Ve düğmeyi bırakıp devrede bir kesinti yarattığımızda bir sorun ortaya çıkıyor. Pim 12 serbest kalır ve modda süresiz olarak asılı kalır GİRİŞ(dijital çıkışlarla ilgili dersi hatırlayın). Sonuç olarak rastgele değerler elde ediyoruz ve parazit nedeniyle LED açılıp kapanıyor.

Bu sorunu önlemek için 10 ila 100 kOhm'luk bir direnç ekleyip toprağa basabilirsiniz. Bu durumda buton bırakılsa dahi devre kapanacaktır. Bu durumda direnç aşağı çekme olarak adlandırılır. Bu müfredatta kullanılabilecek bir çalışma şemasıdır.

Aşağı çekme dirençli çalışma devresine rağmen karmaşık bir projeyle çalışırken sorun yaşıyoruz. Gerçek şu ki devredeki birçok cihazın farklı güç değerleri kullanması mümkündür. Ve sonra cihazın her düğmesine kendi ayrı aşağı çekme direncini sağlamanız gerekecektir. Uygulamada, güç kaynağına değil, her zaman aynı ve 0'a eşit olan toprağa bağlanmak gelenekseldir. Bu durumda, direncin kendisi güç kaynağına bağlanmalı - yukarı çekilmelidir. Bu durumda direnç bir yukarı çekmedir. Ancak başka bir sorun ortaya çıkıyor - LED'in davranışı ters yönde değişti - basıldığında LED kapanıyor ve bırakıldığında açılıyor. Sorun sadece bir kod satırını değiştirerek çözülebilir.

DigitalWrite(ledPin, !val);

Değişkenin değerini tam tersine değiştiriyoruz. Bu, bir düğmeyle çalışırken standart yaklaşımdır. Artık Arduino IDE'deki örnekleri anlamanız daha kolay olacaktır.

Arduino kartının pinlerinin zaten yerleşik çekme dirençlerine sahip olduğunu (pim 13 hariç) ve harici direnci çıkarabileceğimizi belirtmekte fayda var. Ancak o zaman bu direncin kullanımını parametreyle kod aracılığıyla açıkça belirtmeniz gerekir. INPUT_PULLUP.

Int butonuPin = 12; int ledPin = 3; void setup() ( pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT_PULLUP); ) void loop() ( bool val = digitalRead(buttonPin); digitalWrite(ledPin, !val); gecikme(100); )

01.Temel Bilgiler: DigitalReadSerial

Bir örnek üzerinde çalışalım DigitalReadSerial itibaren Dosya | Örnekler | 01.Temel Bilgiler.

Bir düğmeyi doğru şekilde nasıl bağlayacağımızı öğrendik ve yerleşik örnekleri inceleyebiliriz. Butona bastığımızda dijital çıkıştan gelen sinyali okuyacağız.

Kabaca birleştirilmiş bir diyagram şöyle görünebilir:

Bu şemayı kısaca kelimelerle anlatacağım. Devre tahtası oluğunun eşleştirilmiş bacaklar arasından geçmesi için devre tahtasının ortasına bir düğme yerleştiriyoruz. Ardından güç kaynağını atlama telleriyle bağlayın 5V ve arazi GND Breadboard'da raylar bulunan bir Arduino'da. Daha sonra Arduino üzerinde bulunan 2 numaralı dijital pini jumper ile breadboard üzerindeki butonun bir ayağına bağlıyoruz. Düğmenin aynı ayağını bağlarız, ancak diğer tarafa rolünü oynayan bir dirençle bağlanırız. aşağı çekme direnci. Bundan sonra direncin kendisini toprağa bağlarız. Düğmenin üçüncü ayağını devre tahtası üzerindeki pozitif raya bağlıyoruz. Geriye kalan tek şey yan rayları devre tahtası üzerinde birbirine bağlamaktır ve artık yeni bir örnek çalışmaya hazırız.

Düğme çok önemli bir işlevi yerine getirir - basıldığında devreyi kapatır. Butona basılmadığı zaman butonun bacakları arasından akım geçmediği için 2 numaralı dijital pinten sinyali yakalayamayız. Bu nedenle pinin durumu sistem tarafından şu şekilde belirlenir: DÜŞÜK veya 0. Düğmeye basıldığında, iki ayağı birbirine bağlanarak akımın güç kaynağından dijital pin 2'ye akmasına izin verilir ve sistem, geçen sinyali şu şekilde okur: YÜKSEK veya 1.

Kodu parça parça parçalayalım

// İkinci pin butonla ilişkilidir int PushButton = 2; void setup() ( Serial.begin(9600); pinMode(pushButton, INPUT); ) void loop() ( int ButtonState = digitalRead(pushButton); Serial.println(buttonState); gecikme(1); // kararlılık için gecikme )

İşlevde kurmak() Arduino'dan bilgisayarınıza 9600 bps hızında veri okumak için port ile iletişim kuruyoruz: Seri.begin(9600).

İkinci satır bize zaten tanıdık geliyor ancak parametre artık burada kullanılıyor GİRİŞ- ikinci dijital çıkışı butondan gelen verileri okuyacak şekilde ayarladık: pinMode(Buton, GİRİŞ);

Döngüde gelen bilgiyi okuyoruz. Öncelikle yeni bir değişkene ihtiyacımız var düğme durumu fonksiyondan gelen 0 veya 1 değerlerini içerecektir dijitalOku().

Gelen bilgileri görebilmemiz için elde edilen sonuçları Serial Monitor penceresinde komutu kullanarak görüntülememiz gerekmektedir. println().

Verileri okurken daha fazla kararlılık sağlamak için minimum gecikmeyi ayarlayacağız.

Programı şimdi çalıştırırsanız ve ayrıca pencereyi açarsanız Seri Monitör(Menü Araçlar | Seri Monitör), o zaman ekranda sonsuz sıfırlar göreceksiniz. Program sürekli olarak yapımızın durumunu yokluyor ve sonucu gösteriyor - akım yok. Butona basıp basılı tutarsanız sayıların 0'dan 1'e değiştiğini göreceksiniz. Bu da devremizde akım oluştuğu ve bilgilerin değiştiği anlamına gelir.

02.Dijital: Düğme

Örnekte bir düğmeyle çalışmak da tartışılmıştır. Dosya | Örnekler | 02.Dijital | Düğme. Düğme pim 2'ye ve LED pim 13'e bağlanır. Düğme ayrıca 10K'lık bir direnç aracılığıyla güce ve toprağa bağlanmalıdır. Çalışma prensibinin kendisi değişmeden kalır. Ancak bu sefer ekranda düğmenin durumu hakkında bilgi göstermeyeceğiz, ancak LED'i açacağız. Bu seçenek daha görseldir. Düğmeye basıp bıraktığınızda yerleşik LED yanmalı veya sönmelidir.

Const int butonuPin = 2; // butonun çıktısı const int ledPin = 13; // LED için çıktı int butonuDurum = 0; // düğme durumu - basılan veya bırakılan void setup() ( // LED pinMode için çıkış modu(ledPin, OUTPUT); // düğme için giriş modu pinMode(buttonPin, INPUT); ) void loop() ( // oku butonun durumu butonDurumu = digitalRead(buttonPin); // eğer butona basıldıysa durumu HIGH: if (buttonState == HIGH) ( // digitalWrite LED'ini açın(ledPin, HIGH); ) else ( // aksi halde LED digitalWrite'ı kapatın(ledPin, LOW ); ) )

Diyelim ki davranışı değiştirmek istiyoruz - düğmeye basılmazsa LED yanar ve basıldığında LED yanmaz. Bir kod satırını değiştirmek yeterlidir.

Eğer (buttonState == DÜŞÜK)

Ve şimdi bilmece! Taslağın ilk versiyonunu panoya yüklediniz ve aniden bilgisayarınız çöktü. İkinci seçeneği kullanmak için çizimi düzenleyemezsiniz. Bu durumdan nasıl kurtulabilirsiniz?

Devrenin polaritesini değiştirmeniz gerekiyor! Dirençten toprağa giden telin 5V'a, 5V'tan düğmeye giden telin ise toprağa bağlanması gerekir. Açıldığında güç kaynağından pin 2'ye herhangi bir müdahale olmadan akım akacak ve değer elde edilecektir. YÜKSEK. Butona bastığınızda başka bir devre oluşturulacak ve pin 2 enerjisiz kalacaktır.

02.Dijital: Durum Değişikliği Tespiti

Örnekte Dosya | Örnekler | 02.Dijital | Durum Değişikliği Algılaması Düğme tıklamalarının sayısı ve düğmenin durumu (açık veya kapalı) vardır. Şema aynı kalıyor. Düğme pim 2'ye ve LED pim 13'e bağlanır (yerleşik olanı kullanabilirsiniz). Düğme ayrıca güce ve toprağa 10K'lık bir aşağı çekme direncine bağlanmalıdır.

Const int butonuPin = 2; // pin 2'deki düğme const int ledPin = 13; // Pin 13'teki LED int butonuPushCounter = 0; // butona basma sayacı int butonuDurum = 0; // butonun mevcut durumu int lastButtonState = 0; // butonun önceki durumu void setup() ( // butonun giriş modunu ayarlayın pinMode(buttonPin, INPUT); // LED pinMode için çıkış modunu ayarlayın(ledPin, OUTPUT); // seri veri aktarımını etkinleştirin Serial.begin(9600) ; ) void loop() ( // düğme çıkışından okunan değerleri okuyun ButtonState = digitalRead(buttonPin); // durumu önceki durumla karşılaştırın if (buttonState != lastButtonState) ( // if durum değişti, sayacı artırın if (buttonState == HIGH ) ( // eğer mevcut durum HIGH ise buton butonun üzerindedirPushCounter++; Serial.println("on"); Serial.print("düğmeye basılma sayısı: "); Serial.println(buttonPushCounter); ) else ( // mevcut durum DÜŞÜK ise, bu düğmenin kapalı olduğu anlamına gelir Serial.println("off"); ) // sıçrama efekti gecikmesini ortadan kaldırmak için küçük bir gecikme( 50); ) // mevcut durumu bir dahaki sefere son durum olarak kaydedin lastButtonState = butonuState; // her dördüncü basışta LED'i açın, basın sayacının geri kalanına göre bölümü kontrol edin if (buttonPushCounter % 4 == 0) ( digitalWrite(ledPin, YÜKSEK); ) else ( digitalWrite(ledPin, LOW); ))

02.Dijital: Geri Dönme

Düğmelerin “yanıp sönme” adı verilen bir etkisi vardır. Düğme plakaları arasında kapatıp açarken, birkaç milisaniye içinde bir düzine kadar anahtarı tetikleyen mikro kıvılcımlar ortaya çıkıyor. Bu fenomene sıçrama denir. “Tıklamaların” kaydedilmesi gerekiyorsa bu dikkate alınmalıdır. Bu nedenle birincil tanıklığa güvenilemez. Bu nedenle eskizlerde sıklıkla kısa bir gecikme yaparlar ve ancak ondan sonra okumaları okurlar. Normal durumda butona basmadığımızda veya butonu basılı tutmadığımızda herhangi bir sıçrama etkisi olmuyor. Bazen eğitimsel örneklerde bu amaçlar için işlev kullanılır. gecikme(), ancak pratikte işlevi kullanmalısınız milis(), örnekteki gibi Dosya | Örnekler | 02.Dijital | Geri dönme. Bağlantı şeması değişmeden kalır.

Const int butonuPin = 2; // pin 2'deki düğme const int ledPin = 13; // 13. pindeki LED int ledState = HIGH; // LED'in mevcut durumu int ButtonState; // butonun mevcut çıkış durumu int lastButtonState = LOW; // düğmenin önceki çıkış durumu // büyük sayıları kullanmak için imzasız türü kullanın unsigned long lastDebounceTime = 0; // yakın zamanda imzalanmamış long debounceDelay = 50; // gecikme, gerekirse artırın void setup() ( pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); digitalWrite(ledPin, ledState); ) void loop() ( // butonun durumunu okuyun int okuma = digitalRead(buttonPin); // butona basılırsa, // sonra sıçramayı ortadan kaldırmak için biraz bekleriz // eğer durum değiştiyse (bounce veya press) if (reading != lastButtonState) ( // zamanlayıcıyı sıfırla lastDebounceTime = millis(); ) if (( millis() - lastDebounceTime) > debounceDelay) ( // okuma ne olursa olsun, geri dönme // gecikmesinden daha uzun süredir oradadır, bu yüzden onu gerçek mevcut durum olarak kabul edin: / / eğer buton durumu değiştiyse if (reading != butonDurumu) ( butonDurumu = okunuyor; // yeni buton durumu HIGH ise LED'i değiştirin if (buttonState == HIGH) ( ledState = !ledState; ) ) ) // set LED digitalWrite(ledPin, ledState); // butonun durumunu kaydedin. Döngüde bir dahaki sefere bu, lastButtonState'in değeri olacaktır: lastButtonState = okuma; )

02.Dijital: DigitalInputPullup (Dahili pull-up direnci)

Dijital pinler, düğmelerle çalışırken pull-up olarak kullanılabilecek 20 kOhm'luk dirençlere zaten sahiptir. Bir örneğe bakalım Dosya | Örnekler | 02.Dijital | DigitalInputPulup.

Bağlantı şeması - düğmenin ilk pinini karttaki pin 2'ye ve düğmenin ikinci pinini pin'e bağlayın GND. Çizim çalışırken ikinci pinin okumalarını okuyacağız.

Void setup() ( Serial.begin(9600); // pin 2'yi giriş moduna ayarlayın ve yerleşik çekme direncini açın pinMode(2, INPUT_PULLUP); pinMode(13, OUTPUT); // LED ) void loop() ( // düğme okumalarını alın int sensörVal = digitalRead(2); // Seri Monitöre çıktı Serial.println(sensorVal); // Bir güç çekme direnci kullanıldığında düğme durumunun tersine çevrildiğini unutmayın / / Butona basılmadığında HIGH, basıldığında LOW değeri bulunur. // Butona bastığınızda ledi yakar, bıraktığınızda ise söner (sensorVal == HIGH) ( digitalWrite(13, DÜŞÜK); ) else ( digitalWrite(13, YÜKSEK); ) )

Çizimi çalıştırırsak monitörde 1 sayısının görüntülendiğini göreceğiz ( YÜKSEK). Butona bastığınızda değerler 0 ( DÜŞÜK).

VE arduino burada bir istisna yoktur, LED yanıp söndükten sonra düğmeyi bağlamaya ve onu bu LED'in yanıp sönmesini kontrol etmek için kullanmaya çalışır. Burada özellikle karmaşık bir şey yok, ancak "temas sıçraması" adı verilen bir nüans var. Bir düğmenin doğru şekilde nasıl bağlanacağı arduino“Temas sıçraması”nın ne olduğu, bu etkinin nasıl kendini gösterdiği ve bununla mücadele yöntemleri bugün tartışılacak.

Bir düğmeyi bir mikro denetleyiciye bağlamak için en basit şema şuna benzer:

Eğer anahtar S1 açıksa (düğme bırakılır), ardından dijital girişte D girişi mikrodenetleyicide mantıksal olana karşılık gelen 5V'luk bir voltaja sahip olacağız. Butona basıldığında giriş D girişi mantıksal sıfır seviyesine karşılık gelen toprağa bağlanır ve tüm voltaj direnç boyunca düşecektir R1 değeri, düğmeye basıldığında içinden çok fazla akım geçmemesi gerçeğine göre seçilir (genellikle yaklaşık 10÷100 kOhm).

Dijital giriş ile toprak arasına yalnızca bir düğme bağlarsanız (dirençsiz R1, +5V'ye bağlı) veya giriş ile +5V arasında, düğmeye basılmadığı konumda, mikro denetleyicinin dijital girişinde tanımlanmamış bir voltaj mevcut olacaktır (seviye 0'a veya belki 1'e karşılık gelebilir) ve rastgele durumları okurduk. Bu nedenle bir direnç kullanılır R1, düğme bırakıldığında girişi +5V'a "yukarı çektiği" söylenir.

Mikrodenetleyicinin dijital girişinin durumunu okuyarak düğmeye basılıp basılmadığını (mantıksal 0 durumu) belirleyebiliriz (girişte mantıksal bir tane alacağız).

Bir düğmenin bağlanması arduino

Mikrodenetleyiciler Atmel AVR ATmega(bu temele dayanarak inşa edilmiştir arduino) yerleşik yazılıma bağlı yük dirençlerine sahiptir Rn 20 kOhm ve bunları bağlantı şemasını basitleştirerek kullanabiliriz.

Dahili yük direnci, portun gerekli bitine mantıksal bir direnç yazılarak bağlanır.

Taslak örneği arduino, dahili bir yük direnci kullanarak ikinci pime bağlı düğmeye basılmasına veya bırakılmasına bağlı olarak pim 13'teki yerleşik LED'i açıp kapatan:

void setup() ( pinMode(13, OUTPUT); //pin 13'teki LED pinMode(2, INPUT); //2 pin giriş modunda. Buton toprağa bağlı. digitalWrite(2, HIGH); // çekme direncini bağlayın) void loop() ( digitalWrite(13, !digitalRead(2)); // düğme durumunu okuyun ve LED'i değiştirin)

Burada giriş portundan okunan değeri bir Boolean kullanarak tersine çeviriyoruz. OLUMSUZ, işlevden önce ünlem işaretiyle gösterilir dijitalOku, çünkü düğmeye basıldığında 0 okuruz ve LED'i bağlantı noktasına açmak için 1 göndermemiz gerekir.

Kişinin geri dönmesi

Mükemmel düğmelerin olduğu ideal bir dünyada yaşasaydık her şey güzel olurdu. Düğmelerde bulunan gerçek mekanik kontaklar asla anında kapanmaz veya açılmaz. Kısa bir süre boyunca, anahtarın (düğmenin) kontakları tekrar tekrar kapatılır ve açılır, bunun sonucunda mikro denetleyicinin girişinde tek bir voltaj düşüşü değil, tam bir paket darbe alınır. Bu olaya "temas sıçraması" denir.

Yukarıdaki örnekte, bir düğmeyi kullanarak LED'i basitçe açıp kapattığımızda bunu fark etmedik, çünkü LED'in "sıçrama" anında açılıp kapanması çok hızlı oldu ve bunu elimizde görmedik. gözler.

Bu kütüphane aşağıdaki yöntemleri içerir:

• sıçrama()— Bounce nesnesinin başlatılması
• geçersiz aralık (işaretsiz uzun aralık)— sıçrama önleme süresini milisaniye cinsinden ayarlar
• geçersiz ekleme (int pin)— düğmenin bağlı olduğu pimi ayarlar ve yerleşik çekme direncini bu pime bağlar
• int güncelleme()- Çünkü Sıçrama kullanmıyorsa, durumunu okumadan önce nesneyi "güncelliyorsunuz" ve bunun sürekli yapılması gerekiyor (örneğin, içeride) döngü). Yöntem güncelleme nesneyi günceller ve geri döner DOĞRU(1), pimin durumu değiştiyse (düğmeye basıldı veya tam tersi serbest bırakıldı) ve YANLIŞ(0) aksi halde. Bir Yöntemin Çağrılması güncelleme içeri döngü yalnızca bir kez yapılması gerekir.
• int okuma()— pinin güncellenmiş durumunu döndürür

Varsayılan olarak, Bounce kitaplığı bir stabilizasyon aralığı kullanır ( kararlı aralık) sıçrama önlemeyi uygulamak için. Bunu anlamak daha kolaydır ve sohbetin süresini bilme ihtiyacını ortadan kaldırır.

Parametre kararlı aralık Geri dönen kitaplıklar

Belirledikten sonra

#define BOUNCE_LOCK-OUT

dosyada Sıçrama.h Sohbetle başa çıkmanın alternatif bir yöntemini etkinleştirebilirsiniz. Bu yöntem, düğmenin durumundaki değişikliklere daha hızlı tepki vermenizi sağlar, ancak geri dönme süresinin ayarlanmasını gerektirir ve bu değer, yukarıda belirttiğim gibi zamanla artar, bu da düğmede değişiklik yapmanız gerekeceği anlamına gelir. kodunu girin veya kasıtlı olarak daha büyük bir değer ayarlayın.

İşte bu kütüphaneyi kullanmanın bir örneği:

#katmak Sıçrama fedaisi = Sıçrama(); void setup() ( pinMode(2 ,INPUT); // pin 2'deki buton digitalWrite(2 ,HIGH); fedai .attach(2); // buton fedaisini ayarlayın .interval(5); Serial.begin(9600) ; //Seri bağlantı noktasını 9600 bps'ye ayarlayın) void loop() ( if (bouncer.update()) ( //bir olay meydana gelirse if (bouncer.read()==0) ( //düğmeye basılırsa Serial .println("basıldı"); //basılmaya ilişkin bir mesaj görüntüle) else Serial.println("yayınlandı"); //bırakmaya ilişkin bir mesaj göster ) )

Ve pratik olarak faydalı bir küçük örnek daha. 2 saniyeden az basıldığında değişkeni değiştiren bir düğmemiz olsun geçerli_mode Bir cihazın mevcut çalışma modunu saklayan. Bu örnekte mod 0'dan 5'e değişecektir. Bir kez basıldığında mod 1 numaradır. Tekrar basıldığında - 2. Ve beşe kadar böyle devam eder. Beşten sonra, bir sonraki basışta, mevcut mod bir daire içinde ilk ve tekrar olur. Düğmeyi 2 saniyeden fazla basılı tutarsanız değişken geçerli_mode 0 değeri atanır.

#katmak #define press_long 2000 // uzun basma = 2 saniye #define num_modes 5 // maksimum mod numarası short int max_mode = num_modes + 1; // yardımcı değişken Bounce fedaisi = Bounce(); //Bounce sınıfının bir örneğini yaratın unsigned long pressed_moment; // butona basma anı int current_mode = 0; // mevcut mod void setup() ( pinMode(2 ,INPUT); // pin 2'deki buton digitalWrite(2 ,HIGH); // dahili çekme direnci korumasını bağlayın .attach(2); // kurun buton fedai .interval( 5); // parametre kararlı aralığını ayarlayın = 5 ms Serial.begin(9600); // Seri portun 9600 bps'ye ayarlanması) void loop() ( if (bouncer.update()) ( //eğer olay olmuşsa if (bouncer.read()==0) ( //eğer butona basılırsa basıldı_moment = millis(); // basılma zamanını hatırla ) else ( // buton bırakılır if(( millis() - basılan_moment)< pressed_long) { // если кнопка была нажата кратковременно current_mode++; // увеличиваем счетчик текушего режима current_mode %= max_mode; // остаток от целочисленного деления if (current_mode == 0) current_mode = 1; // режим меняется от 1 до num_modes } else { // кнопка удерживалась долго current_mode = 0; pressed_moment = 0; // обнуляем момент нажатия } Serial.println("Current mode:"); Serial.println(current_mode); // выводим сообщение о текущем режиме } } }

/*
* ArduinoKit deney seti
* 5 numaralı deney için program kodu: taslak 05
*
* DÜĞMELER
*
* http://site sitesi için yazılmıştır
*
*
* Arduino topluluğundan yardım.
* http://www.arduino.cc adresini ziyaret edin
*
* Program hakkında yazılan yorum
* 22 Ocak 2014
* özellikle http://site için
*/

DÜĞMELER.

Dijital girişlerdeki düğmeleri kullanma.

Daha önce veri girişi için analog portları (pimleri) kullanıyorduk, ancak şimdi dijital portların işleyişine bakacağız. Dijital bağlantı noktaları yalnızca iki sinyal seviyesini bildiğinden (yüksek "+5" ve düşük "0") yalnızca "Açık" ve "Kapalı" olmak üzere iki konumu olan düğmeler ve anahtarlarla etkileşim kurmak için idealdirler.

Düğmenin bir pinini tel ile toprağa, diğer pinini ise dijital porta bağlayacağız. Butona bastığınızda devre kapanacak ve toprak ucu “-” dijital porta bağlanacak ve dolayısıyla alınan sinyal Arduino tarafından “düşük” olarak değerlendirilecektir.

Ama bekleyin; düğmeye basılmadığında ne olur? Bu durumda portun her şeyle bağlantısı kesilir, yani havada asılı kalır ve biz bu anlaşılmaz duruma "tanımsız" veya yüzer diyoruz. Yani Arduino'nun böyle bir duruma nasıl tepki vereceğini kesin olarak söyleyemeyiz. Çeşitli çevresel koşullara bağlı olarak bu, kendisi tarafından YÜKSEK (“YÜKSEK” +5 Volt) veya DÜŞÜK (“DÜŞÜK” - mantıksal sıfır) olarak algılanabilir.

Herhangi bir tutarsızlığı önlemek ve mikrodenetleyicinin girişinde tam olarak ne olduğunu bilmesi için, ayrıca Arduino portunu bir sınırlayıcı direnç (1KOhm - 10KOhm derecesine sahip herhangi biri yapacaktır) aracılığıyla +5 Volt veriyoluna bağlayacağız. Bu "çekme", sabit bir YÜKSEK +5V sinyalinin varlığını garanti edecektir ve düğmeye bastığınızda devre Toprak - "0"a kapanacaktır, bu da Arduino için giriş sinyalinin YÜKSEK'ten DÜŞÜK'e değişeceği anlamına gelir. yani YÜKSEK +5V'den DÜŞÜK “0”a.

(Ek: Dirençlere alıştıktan ve onlara ne zaman ihtiyaç duyulduğunu öğrendikten sonra, ATmega işlemcinin kendisinde bulunan dahili çekme dirençlerini etkinleştirebilirsiniz. Bilgi için bkz. http://arduino.cc/en/Tutorial/ DijitalPinler).

Ekipman bağlantısı:

Butonların iki kontağı vardır; butona basıldığında kontak kapanır, basılmadığında kontak açılır.

Butonlarda hem ikili hem de dört kontak kullanacağız ancak şimdi kullanacağımız butonlarda iki kontağın paralel olduğunu da belirtelim.

Bir düğmeyi bağlamanın en kolay yolu, kabloları terminallere eğik (çapraz) olarak bağlamaktır.

Düğme 1'in herhangi bir pinini toprağa (GND) bağlayın.
Diğer düğme pinini dijital port 2'ye bağlayın.

Düğme 2'nin herhangi bir pinini toprağa (GND) bağlayın.
Diğer düğme pinini dijital bağlantı noktası 3'e bağlayın.

Dijital port 2,3'e giden düğmelerin ayaklarına 10K'lık (kahverengi/siyah/kırmızı) "pull-up" dirençlerini bağlayın ve bu dirençlerin ikinci terminallerini ortak "-" (GND) terminaline bağlayın. Bu dirençler girişin ya +5V (düğmeye basılmadan) ya da basıldığında “0” olmasını sağlar, başka bir şey yapmaz. (Ayrıca analog girişlerden farklı olarak dijital girişlerin yalnızca iki durumu olduğunu unutmayın: YÜKSEK ve DÜŞÜK.)

Işık yayan diyot:

UNO da dahil olmak üzere çoğu Arduino kartında, 13 numaralı bağlantı noktasına bağlı, akım sınırlayıcı dirençli bir LED zaten kuruludur. Ayrıca kendinizinkini kurmanıza da gerek yoktur.

Ancak daha fazla bilgi için kendinizinkini bağlamaya karar verirseniz durum daha da kötü olmayacaktır.

LED'in pozitif ucunu Arduino dijital bağlantı noktası #13'e bağlayın
LED'in negatif ucunu 330 ohm'luk bir dirence bağlayın.
Direncin diğer terminalini GND "-" ye bağlayın.

// İlk önce sabitler yaratacağız, yani. olacak butonlara isim verelim
// program kodunun sonuna kadar değişmeden kalır ve bu adları Arduino portlarına bağlar.
// Bu, program kodunu anlamayı ve onunla çalışmayı kolaylaştırır ve ayrıca
// porta ismiyle bakın.

const int düğme1Pin = 2; // 1 numaralı düğme - bağlantı noktası 2
const int butonu2Pin = 3; // 2 numaralı düğme - bağlantı noktası 3
const int ledPin = 13; // LED için bağlantı noktası 13

geçersiz kurulum ()
{
// Düğme bağlantı noktalarını gelen olarak ayarlayın:
pinMode(button1Pin, INPUT);
pinMode(button2Pin, INPUT);

// LED bağlantı noktasını giden olarak ayarlayın:
pinMode(ledPin, ÇIKIŞ);
}

geçersiz döngü ()
{
int düğme1Durum, düğme2Durum; // butonların durumunu kaydedecek değişkenler

// Düğmelerin yalnızca iki durumu olduğundan (basılı ve basılmamış)
// dijital giriş bağlantı noktalarını kullanarak onlarla çalışın. Okumak için
// bilgi için digitalRead() fonksiyonunu kullanacağız. Bu özellik şunları sağlar:
// dijital porttan bir parametre alın ve YÜKSEK (+5V),
// veya DÜŞÜK (“0”).

// Burada butonların güncel durumunu okuyup değerlerini koyuyoruz
// iki değişkene:

buton1Durum = digitalRead(button1Pin);
Button2State = digitalRead(button2Pin);

// Unutmayın, butona basıldığında port toprağa ("-") bağlanacaktır.
// Butona basılmazsa port bir pull-up direnci aracılığıyla +5 volta bağlanacaktır.

// Yani butona basıldığında port durumu LOW olacak,
// ve basılmadığında HIGH (yüksek).

// Şimdi LED'i kontrol etmek için portların durumunu kullanacağız.

// Ne yapmak istiyoruz, koşul:
// "Herhangi bir tuşa basıldığında LED yanar"
// “Fakat her iki butona da basılırsa LED yanmaz”
// Bunu koda çevirelim.

// Arduino'nun özel mantıksal operatörleri ve karşılaştırma operatörleri vardır,
// koşulları kontrol ederken sıklıkla kullanılırlar, özellikle:

// "==" (eşitlik) - Her iki taraf da aynıysa doğrudur
// Örnek:
// eğer (x == y) (
// gövdeyi koşullandırma
//}

// "&&" (mantıksal VE) - Yalnızca her iki koşul da karşılanırsa doğrudur
// Örnek:
// Her iki ifade de Doğru ise doğrudur
// eğer (x > 0 && x< 5) {
// gövdeyi koşullandırma
//}

// "!" (mantıksal DEĞİL)
// Operatör yanlışsa doğru
// Örnek:
//eğer (!x) (
// gövdeyi koşullandırma
//}

// "||" (mantıksal VEYA) - Koşullardan en az biri doğruysa doğrudur
// Örnek:
//if (x > 0 || y > 0) (
// gövdeyi koşullandırma
// }

// Bu durumda her şeyi tercüme etmek için “if” yapısını kullanacağız
// yukarıdakileri programın mantıksal zincirlerine aktarın.
// (Unutmayın, LOW butona basıldığı anlamına gelir)

// "Düğmelerden birine basıldığında LED yanar"
// ortaya çıkacak:
// if ((button1Durum == LOW) || (button2Durum == LOW)) // LED'i yak

// "Her iki tuşa da basılırsa LED yanmaz"
// ortaya çıkacak:
// if ((button1Durum == LOW) && (button2Durum == LOW)) // LED'i yakmayın

// Şimdi yukarıdaki işlevleri kullanalım ve bunları tek bir ifadede birleştirelim:

if (((button1State == LOW) || (button2State == LOW)) // butonlardan birine basılıp basılmadığını karşılaştırın
&& ! // Ve değilse
((button1State == LOW) && (button2State == LOW))) // her iki butona da basılıp basılmadığını karşılaştırın
// Daha sonra…
{
digitalWrite(ledPin, YÜKSEK); // LED'i aç
}
başka // aksi halde
{
digitalWrite(ledPin, DÜŞÜK); // LED'i kapat
}

// Fark ettiğiniz gibi operatörler birleştirilebilir
// karmaşık problemleri çözmek için

// Unutmayın: Değerleri karşılaştırırken "=" operatörünü kullanamazsınız.
// "==" çünkü "=" operatörü değişkenlere bir değer atar!
}

Bir sonraki yazımızda 5 numaralı dersin kodunu arşiv olarak yayınlayacağız.

Arduino programlamanın temellerinden bahsettik. Bugün Arduino GPIO ve PWM sinyallerinden bahsedeceğiz. Düğmeleri kullanacağız ve bir PWM sinyali kullanarak LED'in parlaklığını kontrol edeceğiz. Arduino programlama ortamındaki fonksiyonları da kullanacağız.

Öncelikle LED'i bir düğme kullanarak kontrol etmeye çalışalım.

İhtiyacımız olacak:

1. Direnç yaklaşık mezhep 100-400ohm. LED'den geçen akımı, onu yakmamak için sınırlandırmak.
2. Direnç yaklaşık mezhep 10 oda Arduino girişindeki mantık seviyelerini yükseltmek için. Eğer yüklemezseniz butonumuz çok kararsız çalışacaktır çünkü... Arduino girişinde yararlı bir sinyal yerine gürültü olacaktır.
3. Işık yayan diyot AL307 ya da hoşlandığın herhangi biri. Aslında onu yakacağız.
4. İncelik düğmesi IT-1102 veya herhangi bir başkası. LED'i kontrol etmek için kullanılacaktır.

Şimdi basit bir devre kurmanın zamanı geldi, bunu BreadBoard hata ayıklama kartını kullanarak veya bir havya ve teller kullanarak yapabilirsiniz.

Işık yayan diyot Arduino'nun 10 çıkışına 200 ohm'luk bir akım sınırlayıcı direnç aracılığıyla bağlanan direnç değeri 200 ohm - 500 ohm olarak ayarlanabilir, bu, LED'den akan akımı ve buna bağlı olarak parlaklığını değiştirecektir. Bir LED'i doğrudan bağlarsanız, sonu kötü olacak, LED'den büyük bir akım akacak ve bunun sonucunda LED'in kendisi veya Arduino çıkışı arızalanacaktır. Ayrıca LED'in bir diyot olduğunu, bir polariteye sahip olduğunu da hesaba katmak gerekir!

LED'i yanlış bağlarsanız, içinden hiçbir akım geçmeyeceği için yanmayacaktır (basitçe kapanacaktır). LED'in polaritesini belirlemek kolaydır; LED'in kısa bacağı negatiftir (yani sıfır veya GND), uzun bacağı ise +.

Düğmeöyle bir şekilde bağlanır ki, basıldığı anda Arduino'nun dijital girişinin mantıksal birimine karşılık gelen Arduino'nun 10 numaralı girişine +5 volt geçiş yapar. Butona basılmadığı anda 10 kohm'luk direncimiz Arduino girişini GND'ye (yani sıfıra) çekecek ve Arduino girişi sürekli olarak mantıksal sıfır olacaktır. Bu çekme direncini kullanmazsanız yanlış alarmların oluşması oldukça olasıdır, bunun nedeni Arduino girişinde çekme direnci olmaması ve buna bağlı olarak voltajın olmamasıdır. sıfır, düzensiz bir şekilde değişecektir, bu da Arduino girişinde yanlış mantığın ortaya çıkmasını gerektirir.

Artık Arduino için bir program yazmanın zamanı geldi. Öncelikle butona bastığımız sürece LED’i açık tutalım. Elbette böyle bir sorunu mikrodenetleyici olmadan çözmek çok kolay ama bir yerden başlamamız gerekiyor. Arduino programlama ortamını açın (Arduino'nun nasıl programlanacağı No. 1'de ayrıntılı olarak anlatılmıştır) ve Kodu yazmaya başlayalım:

/*

LED'i yakıyoruz.
Butona bastığımız sürece LED'i açık tutacağız.

*/

{


}

{
if (digitalRead(switchPin) == HIGH) // Butona basıldığında switchPin değişkenimiz HIGH (mantıksal 1) değerine sahip olacak ve aşağıdaki kod çalıştırılacaktır. astar
{
digitalWrite(ledPin, YÜKSEK); // Çıkış 13'te mantık 1'i (seviye YÜKSEK) ayarlayarak LED'i aydınlatın
}
else // Butona basılmazsa aşağıdaki kod çalıştırılacaktır.
{
digitalWrite(ledPin, DÜŞÜK); // LED'i kapat
}
}

Peki ne işe yarıyor? :)

Şimdi görevi karmaşıklaştıralım, düğmeye bastığınızda LED'in yandığından ve biz tekrar basana kadar açık kaldığından emin olun ve bu şekilde bir daire içinde devam edin.

Bu amaçlara yönelik kodumuz şu şekilde görünecektir:

/*
Ders 2. Arduino'da GPIO, Düğmeler ve PWM

Butona bastıktan sonra LED’i açacak, ikinci basışta ise kapatacağız.
Bu demo kodu www.site adresinden indirilmiştir.
*/

int switchPin = 10; // Kolaylık olması açısından pin 10 için “switchPin” adını ayarlayın
int ledPin = 13; // Kolaylık olması açısından pin 13 için “ledPin” adını ayarlayın


void setup() // “Setup” bloğu Arduino başladığında sadece 1 kez çalışır, başlatma için gereklidir.
{
pinMode(switchPin, INPUT); // Arduino pin 10'u giriş olarak yapılandırıyoruz. Çünkü butonun durumunu okuyacağız.
pinMode(ledPin, ÇIKIŞ); // Arduino pin 13'ü çıkış olarak yapılandırıyoruz. Bununla birlikte LED'i açacağız.
}

void loop() // “Döngü” bloğu bir döngüdür, yani. durmadan tekrar tekrar çalışan kod
{
if (digitalRead(switchPin) == HIGH && lastButton == LOW) // Eğer butona basılırsa ve son butonun durumu "basılı değil" ise aşağıdaki kodu çalıştırın
{

lastButton = YÜKSEK; // LastButton'un değerini mantıksal değere değiştir
}
başka
{
lastButton = digitalRead(switchPin); // lastButton değişkenini switchPin değişkeniyle aynı değere ayarlayın
}

}

Peki nasıl çalışıyor? Hımm... Tuhaf... Bazen bizim için her şey beklediğimiz gibi çalışıyor, bazen de olmuyor... Neden böyle olabilir ki? Her şey "temas sıçraması" etkisi ile ilgili:

Bu osilogramda gördüğünüz gibi aslında butonumuz kusursuz çalışmıyor... Ve eğer butonu yüksek frekansla yoklarsak, geçiş anında hem bir hem de sıfır sayabiliriz. Soruna donanımsal çözümler kullanmak daha iyi olurdu ama şimdi kodumuzdan bahsediyoruz. Bu tıkırtıyı önlemek için programı değiştirmemiz gerekecek ve basitçe girmek Zaman gecikmesi:

/*
Ders 2. Arduino'da GPIO, Düğmeler ve PWM
LED'i açın/kapatın.
Butona bastıktan sonra LED'i yakıp ikinci basışta söndürüp tuşların zıplamasını ortadan kaldıracağız.
Bu demo kodu www.site adresinden indirilmiştir.

int switchPin = 10; // Kolaylık olması açısından pin 10 için “switchPin” adını ayarlayın
int ledPin = 13; // Kolaylık olması açısından pin 13 için “ledPin” adını ayarlayın
boolean lastButton = DÜŞÜK; // Bu değişkende, döngümüzün önceki işlemi sırasında butonun durumunu saklayacağız ve ayrıca onu sıfıra ayarlayacağız.
boolean ledOn = false; // Bu değişkende LED'in durumunu saklayacağız, böylece onu değiştirebiliriz

void setup() // “Setup” bloğu Arduino başladığında sadece 1 kez çalışır, başlatma için gereklidir.
{
pinMode(switchPin, INPUT); // Arduino pin 10'u giriş olarak yapılandırıyoruz. Çünkü butonun durumunu okuyacağız.
pinMode(ledPin, ÇIKIŞ); // Arduino pin 13'ü çıkış olarak yapılandırıyoruz. Bununla birlikte LED'i açacağız.
}

{


{


}

}

void loop() // “Döngü” bloğu bir döngüdür, yani. durmadan tekrar tekrar çalışan kod

{


{
ledOn = !ledOn; // ledOn değerini tersine değiştir
}

digitalWrite(ledPin, ledOn); // Aslında bu satır LED'i açıp kapatacak
}

Sanırım artık her şey herkes için amaçlandığı gibi çalıştı;)

Şimdi programımızı değiştirmenin zamanı geldi, böylece her düğmeye bastıktan sonra LED'in parlaklığı değişecek, bunun için bir PWM sinyali veya PWM olarak da adlandırıldığı gibi kullanacağız. PWM hakkında daha fazla bilgi edinmek istiyorsanız WIKI'de okuyabilirsiniz. Ancak şu anda bizim için yalnızca 0 ve 1 mantıksal değerlerini belirli bir sırayla değiştirerek LED'in farklı şekilde parlamasını sağlayabileceğinizi bilmek yeterlidir, ancak özünde sadece farklı şekilde yanıp sönecektir, ancak yanıp sönme frekansı yüksekse, göze sadece parlaklığı değiştiriyormuş gibi görünecektir.

Ancak ne yazık ki tüm Arduino çıkışları PWM'yi desteklemiyor, PWM desteği Arduino serigrafi ekranındaki pin numarasının yanındaki ~ simgesiyle belirtiliyor. Bu pinlerden bir tanesi 11 numaralı pin olup mevcut 13 numaralı pinimiz PWM’yi desteklememektedir bu nedenle bağlantı şemasını şu şekilde değiştirmemiz gerekmektedir:

Ayrıca program kodunda da değişiklik yapın, yani iletişim numarasını değiştirmeniz gerekir ve PWM kullanımı ekle:

/*
Ders 2. Arduino'da GPIO, Düğmeler ve PWM
LED'in parlaklığını değiştirin.
Her tuşa bastıktan sonra LED'in parlaklığını değiştireceğiz.
Bu demo kodu www.site adresinden indirilmiştir.
*/

int switchPin = 10; // Kolaylık olması açısından pin 10 için “switchPin” adını ayarlayın
int ledPin = 11; // Kolaylık olması açısından pin 11 için “ledPin” adını ayarlayın
boolean lastButton = DÜŞÜK; // Bu değişkende, döngümüzün önceki işlemi sırasında butonun durumunu saklayacağız ve ayrıca onu sıfıra ayarlayacağız.
int ledSeviyesi = 0; // Bu değişkende LED'in parlaklığını saklayacağız, parlaklık 0 ila 255 arasında bir değere sahip olabilir, başlatma sırasında LED'in parlamaması için onu 0'a ayarlayacağız.
boolean currentButton = DÜŞÜK; // Geri dönme fonksiyonumuz için değişken

void setup() // “Setup” bloğu Arduino başladığında sadece 1 kez çalışır, başlatma için gereklidir.
{
pinMode(switchPin, INPUT); // Arduino pin 10'u giriş olarak yapılandırıyoruz. Çünkü butonun durumunu okuyacağız.
pinMode(ledPin, ÇIKIŞ); // Arduino pin 13'ü çıkış olarak yapılandırıyoruz. Bununla birlikte LED'i açacağız.
}

boolean debounce(boolean last) //düğme kontaklarını geri döndürme işlevi, önceki durumuna dönecektir
{
boole akımı = digitalRead(switchPin); // Butonun mevcut durumunu mevcut duruma yaz
if (son != geçerli) // Düğme durumunun değişip değişmediğini kontrol edin
{
gecikme(5); // Evetse, düğmenin "tıkırtısını" durdurmak için 5 milisaniyelik bir gecikme yaparız
akım = digitalRead(switchPin); // Bir duraklamadan sonra butonun değerini okuyun, artık sohbet geçmiş olmalı
}
dönüş akımı; // butonun kararlı değerini döndür
}

void loop() // “Döngü” bloğu bir döngüdür, yani. durmadan tekrar tekrar çalışan kod
{
currentButton = debounce(lastButton); // debounce fonksiyonunun sonucunu, kendisine iletilen düğme durumuyla birlikte currentButton'a iletin
if (lastButton == LOW && currentButton == HIGH) // Butona basılıp basılmadığını kontrol edin
{
ledSeviyesi = ledSeviyesi + 51; // Parlaklık değerini 51 olarak değiştir
}
sonDüğme = geçerliDüğme; // lastButton değişkenini currentButton değişkeniyle aynı değere ayarlayın

if (ledSeviyesi > 255) ledSeviyesi = 0; // Maksimumu sınırlayın. 255 değeri
analogWrite(ledPin, ledLevel); // Aslında bu satır LED'i gerekli parlaklıkta yakacaktır
}

Umarım her şey işinize yaramıştır. Bu dersin sonu.

Yorumlarda soru sorabilir ve tavsiye isteyebilirsiniz.

Bir düğme sensörünü Arduino'ya bağlamak belirli bilgi ve beceriler gerektirir. Bu yazıda incelik düğmesinin ne olduğu, düğme sekmesinin ne olduğu, çekme ve aşağı çekme direncine sahip bir düğmenin nasıl düzgün bir şekilde bağlanacağı, bir düğmeyi kullanarak LED'leri ve diğer cihazları nasıl kontrol edebileceğiniz hakkında konuşacağız.

Bir düğme (veya basmalı düğme anahtarı), tüm sensör türleri arasında en basit ve en erişilebilir olanıdır. Üzerine tıkladığınızda kontrol cihazına bir sinyal gönderirsiniz ve bu da daha sonra bazı eylemlere yol açar: LED'ler açılır, sesler çıkarılır, motorlar çalıştırılır. Hayatımızda sıklıkla farklı anahtarlarla karşılaşırız ve bu cihaza oldukça aşinayız.

Dokunma düğmeleri ve geçiş düğmeleri

Her zamanki gibi bölüme yalnızca yeni başlayanların ilgisini çekecek basit şeylerle başlıyoruz. Temelleri biliyorsanız ve bir düğmeyi Arduino'ya bağlamak için çeşitli seçenekler hakkında bilgi edinmek istiyorsanız bu paragrafı atlayabilirsiniz.

Düğme nedir? Aslında bu, elektrik ağını kapatan ve açan oldukça basit bir cihazdır. Konumunuzu sabitlerken veya sabitlemeden bu açma/kapama işlemini farklı modlarda gerçekleştirebilirsiniz. Buna göre tüm düğmeler iki büyük gruba ayrılabilir:

• Sabitlemeli düğmeleri değiştirin. Serbest bırakıldıktan sonra orijinal hallerine geri dönerler. Başlangıç ​​durumuna bağlı olarak normalde kapalı ve normalde açık düğmelere ayrılırlar.
• Anlık düğmeler (incelik düğmeleri). Sabitlenirler ve bırakıldığı pozisyonda kalırlar.

Farklı düğmeler için pek çok seçenek var; bu gerçekten en yaygın elektronik bileşen türlerinden biridir.

Basit projeler için Arduino düğmeleri

Projelerimizde hemen hemen her Arduino kitiyle birlikte gelen çok basit 4 ayaklı saat düğmeleriyle çalışacağız. Düğme, iki çift kontağa sahip bir anahtardır. Bir çiftteki kontaklar birbirine bağlıdır, bu nedenle devrede birden fazla anahtarın uygulanması mümkün olmayacaktır, ancak iki paralel segmenti aynı anda kontrol edebilirsiniz, bu yararlı olabilir.

Duruma bağlı olarak normalde kapalı ve normalde açık kontaklarla her iki devreyi de oluşturabilirsiniz; tek yapmanız gereken devredeki bağlantıları buna göre yapmaktır.

Kullanım kolaylığı açısından, incelik düğmesi genellikle renkli bir plastik kapakla birlikte gelir; düğmenin üzerine oldukça belirgin bir şekilde oturur ve projeye daha az hacker benzeri bir görünüm kazandırır.

Arduino butonunu bağlama

Bir düğmeyi kullanarak LED'i açma ve kapatma

Bir incelik düğmesini bağlamanın en basit yoluyla başlayalım. Güç kaynağı olarak Arduino, bir LED, 220 Ohm sınırlama direnci ve devreyi kapatacak ve açacak bir düğme içeren bir devre düşünün.

İki çift bacaklı bir düğmeyi bağlarken doğru NC kontaklarını seçmek önemlidir. Resme dikkatlice bakın: düğmenin yanlarında bir çift bacak bulunur. Düğmenin kendisi kare şeklindedir, ancak kontak çiftleri arasındaki mesafeler görsel olarak fark edilir: hemen bir tarafta iki, diğer tarafta iki seçebilirsiniz. Yani, anahtarın uygulanacağı taraftaki bir "çift" arasındadır. Devreye dahil olmak için, aralarında minimum mesafe bulunan bir kontağa ve diğer kontağa bağlanıyoruz. İkinci kontak çifti basitçe birinciyi kopyalar.

Farklı türde bir anahtarınız varsa, karşıt köşelerden kişileri güvenle seçebilirsiniz (bazı düğmelerde, eşleştirilmiş kişilerin hangi tarafta bulunduğunu belirleyebileceğiniz girinti şeklinde özel bir işaret vardır). Doğru bacakları belirlemenin en güvenilir yolu, kontakları bir test cihazıyla çalmaktır.

Bir düğme, LED ve Arduino denetleyicisi içeren devrenin kendisi herhangi bir özel açıklamaya ihtiyaç duymaz. Düğme devreyi kesiyor, LED yanmıyor. Basıldığında devre kapanır ve LED yanar. Kontakları karıştırırsanız (düğmeleri kapalı eşleştirilmiş kontaklar aracılığıyla açın), devre asla açılmayacağından düğme çalışmaz. Sadece kişileri değiştirin.

Pull-up direncine sahip bir düğmenin bağlanması

Şimdi butonu Arduino’ya bağlayalım ki çizimdeki durumunu okuyabilelim. Bunu yapmak için aşağıdaki şemayı kullanacağız.

Düğmeye bastıktan sonra yanıp sönen LED

LED'li önceki örnekte Arduino kartına bir düğme bağladık ve nasıl çalıştığını anladık. LED açılıp kapandı, ancak bunu tamamen pasif modda yaptı - kontrolörün kendisi burada kesinlikle gereksizdi, pillerle değiştirilebilirdi. Bu nedenle yeni projemizi daha “akıllı” hale getirelim: Bir düğmeye bastığınızda LED'in sürekli yanıp sönmesini sağlayacağız. Bunu bir ampul ve anahtardan oluşan geleneksel bir devre ile yapamazsınız - bunu çözmek için mikrodenetleyicimizin gücünü kullanacağız, ancak basit ama önemsiz bir görev değil.

LED'li devrenin bir parçası bize zaten tanıdık geliyor. LED'li ve sınırlayıcı dirençli normal bir işaret lambası monte ettik. Ancak ikinci bölümde tanıdık bir düğme ve başka bir direnç görüyoruz. Ayrıntılara girmesek de sadece devreyi kuracağız ve Arduino'ya basit bir çizim yükleyeceğiz. Devrenin tüm elemanları en basit Arduino başlangıç ​​kitleriyle birlikte gelir.

/* Tact butonu ve LED kullanarak bir devre taslağı çizin.Düğmeye basıldığında LED yanıp söner. Düğme yere çekilir, basıldığında */ const int PIN_BUTTON = 2 girişinde HIGH'a karşılık gelir; const int PIN_LED = 13; void setup() ( Serial.begin(9600); pinMode(PIN_LED, OUTPUT); ) void loop() ( // Düğme durumunu alın int ButtonState = digitalRead(PIN_BUTTON); Serial.println(buttonState); // Eğer butona basılmazsa hiçbir şey yapmayız if (!buttonState) ( gecikme(50); return; ) // Butona basıldığında bu kod bloğu çalıştırılacaktır // LED'i yakıp söndürün digitalWrite(PIN_LED, HIGH); gecikme(1000); digitalWrite(PIN_LED, DÜŞÜK); gecikme(1000); )

Basılı tutun - LED yanıp söner. Bırak gitsin - söner. Tam olarak istediğimiz şey. Sevinçle ellerimizi çırpıyoruz ve yaptıklarımızı analiz etmeye başlıyoruz.

Taslağa bakalım. Oldukça basit bir mantık görüyoruz bunda.

1. Düğmeye basılıp basılmadığını belirleyin.
2. Düğmeye basılmazsa, hiçbir şeyi açmadan veya değiştirmeden döngü yönteminden çıkarız.
3. Düğmeye basıldığında standart bir çizimin bir parçasını kullanarak yanıp söneriz:
   1. İstenilen bağlantı noktasına voltaj uygulayarak LED'i açın
   2. LED yandığında gerekli duraklamayı yaparız
   3. LED'i kapat
   4. LED kapalıyken gerekli duraklamayı yapıyoruz

Çizimdeki düğmenin davranışının arkasındaki mantık, çekme direnciyle bağlantı yöntemine bağlı olabilir. Bir sonraki yazımızda bunun hakkında konuşacağız.

Arduino butonu tıkırdıyor

Düğmelerle çalışırken düğme sıçraması adı verilen çok hoş olmayan bir olayla karşılaşabiliriz. Adından da anlaşılacağı gibi bu olay, basmalı düğme anahtarının içindeki kontakların takırdamasından kaynaklanmaktadır. Metal plakalar birbirine anında (gözlerimiz için çok hızlı da olsa) temas etmez, bu nedenle temas bölgesinde kısa süreli voltaj dalgalanmaları ve düşmeleri meydana gelir. Bu tür “çöp” sinyallerin ortaya çıkacağını öngörmezsek, onlara her zaman tepki veririz ve projemizi eve yönlendirebiliriz.

Sıçramayı ortadan kaldırmak için yazılım ve donanım çözümleri kullanılır. Kısaca, sohbeti bastırmanın ana yöntemlerinden bahsedeceğiz:

• Arduino pininden değerlerin toplanması arasına taslakta 10-50 milisaniyelik bir duraklama ekliyoruz.
• Kesintiler kullanırsak yazılım yöntemi kullanılamaz ve donanım koruması oluştururuz. Bunlardan en basiti kapasitörlü ve dirençli bir RC filtresidir.
• Daha doğru geri tepme için Schmidt tetikleyicisini kullanan bir donanım filtresi kullanılır. Bu seçenek, Arduino girişinde neredeyse ideal şekle sahip bir sinyal almanızı sağlayacaktır.

Gevezelikle başa çıkmanın yolları hakkında daha ayrıntılı bilgiyi burada bulabilirsiniz.

Bir düğmeyi kullanarak modları değiştirme

Bir düğmeye basılıp basılmadığını belirlemek için, basıldığı gerçeğini kaydetmeniz ve özelliği özel bir değişkende saklamanız yeterlidir.

DigitalRead() fonksiyonunu kullanarak basma gerçeğini belirliyoruz. Sonuç olarak butonun nasıl bağlandığına bağlı olarak YÜKSEK (1, DOĞRU) veya DÜŞÜK (0, YANLIŞ) elde edeceğiz. Düğmeyi dahili bir çekme direnci kullanarak bağlarsak, düğmeye basmak girişin 0 (YANLIŞ) seviyesine gelmesine neden olur.

Bir düğmeye tıklamayla ilgili bilgileri depolamak için bir boolean değişkeni kullanabilirsiniz:

boolean tuşuna basıldı = digitalRead(PIN_BUTTON)==LOW;

Neden bu yapıyı kullanıyoruz ve bunu şu şekilde yapmıyoruz:

boolean keyPressed = digitalRead(PIN_BUTTON);

Mesele şu ki, digitalRead() işlevi YÜKSEK değerini döndürebilir, ancak bir düğmeye basıldığını göstermez. Pull-up dirençli bir devre kullanılması durumunda YÜKSEK, aksine düğmeye basılmadığı anlamına gelecektir. İlk seçenekte (digitalRead(PIN_BUTTON)==LOW), girişi hemen ihtiyacımız olan değerle karşılaştırdık ve girişteki sinyal seviyesi artık düşük olmasına rağmen düğmeye basıldığını belirledik. Ve düğme durumunu bir değişkene kaydettim. Kodunuzu daha şeffaf hale getirmek ve gereksiz aptalca hatalardan kaçınmak için gerçekleştirdiğiniz tüm mantıksal işlemleri açıkça belirtmeye çalışın.

Bir düğmeye bastıktan sonra çalışma modları nasıl değiştirilir?

Çoğu zaman, düğmeleri kullanırken yalnızca düğmeye basmakla kalmayıp aynı zamanda düğmeyi bırakma gerçeğini de hesaba katmamız gereken bir durum ortaya çıkar. Örneğin bir düğmeye basıp bırakarak ışığı açabilir veya devrenin çalışma modunu değiştirebiliriz. Başka bir deyişle, düğmeye basıldığı gerçeğini bir şekilde koda kaydetmemiz ve düğmeye artık basılmasa bile bilgiyi gelecekte kullanmamız gerekiyor. Bunun nasıl yapılabileceğini görelim.

Programın mantığı çok basittir:

• Bir hizmet değişkenine tıklamanın gerçeğini hatırlıyoruz.
• Tıkırtıyla ilgili olayların geçmesini bekliyoruz.
• Düğmenin bırakılmasını bekliyoruz.
• Serbest bırakma gerçeğini hatırlıyoruz ve düğmeye tam olarak basıldığına dair işareti ayrı bir değişkene koyuyoruz.
• Hizmet değişkenini temizleyin.

Birden fazla düğmeye basılması nasıl tespit edilir?

İlgili değişkendeki veya Arduino dizisindeki her düğmenin durumunu hatırlamanız yeterlidir. Burada anlaşılması gereken en önemli şey, her yeni butonun bir meşgul pini olduğudur. Bu nedenle, çok sayıda düğmeniz varsa, ücretsiz kişi sıkıntısı yaşayabilirsiniz. Alternatif bir seçenek, dirençli bölücüye sahip bir devre kullanarak bir analog pime bağlı düğmeleri kullanmaktır. Bundan sonraki yazılarımızda bundan bahsedeceğiz.