Bu eğitimde, örnek kodlar ve örnek programlar aracılığıyla temel Arduino programlamanın nasıl yapılacağını öğreniyoruz. Bu eğitim, temel bilgileri kolay ve anlaşılır bir dille kavramak isteyen tüm yeni başlayanlar için son derece değerli bir kurs olabilir.

Giriş

Göre wikipedia bir mikro denetleyici, kendi çekirdek işlemcisine, programlanabilir girişlerine, belleğine ve çıkış çevre birimlerine sahip tek bir IC yongası içine yerleştirilmiş bir mini bilgisayara eşdeğerdir.

Bir mikro denetleyici, kullanıcı tarafından istenen spesifikasyonlara göre kontrol edilebilen yerleşik bir işlemci, bellek ve giriş / çıkış portları (GPIO veya genel amaçlı giriş / çıkış pinleri olarak da adlandırılır) sunduğundan, kullanıcı için çok kullanışlı hale gelir.

“kombinasyonel ve sıralı devre arasındaki fark ”

Bu eğitimde, programları öğrenmek ve test etmek için bir Arduino Uno kartı ile çalışacağız. Donanım montajını test etmek ve entegre etmek için bir devre tahtası kullanacağız.

Şimdi hızlı hareket edelim ve Arduino programlamaya nasıl başlayacağımızı öğrenelim.

1.2 Yazılımın Kurulması (Windows)

Bunun için internete erişmeniz gerekecek, ki bu belli ki bilgisayarınızda olacak. Lütfen aşağıdaki bağlantıya gidin ve IDE yazılımını indirin:

Yönetici olmayan kurulum için Windows ZIP dosyası

İndirdikten sonra, indirme klasöründe aşağıdaki gibi görünen Arduino kurulum simgesini bulacaksınız:

Bunu aldıktan sonra, basitçe üzerine çift tıklayıp bilgisayarınıza Arduino the Integrated Development Environment (IDE) kurabilirsiniz. İşlemin tamamı aşağıdaki videoda görselleştirilebilir:

https://youtu.be/x7AMn1paCeU

1.4 İlk Devremizden Başlamak

Gerçek programlama tekniklerini öğrenmeye başlamadan önce, herhangi bir acemi için LED gibi temel bir bileşenle başlamak ve onu bir Arduino ile nasıl bağlayacağınızı anlamak faydalı olacaktır.

Bildiğimiz gibi bir LED, bir polariteye sahip olan ve doğru besleme kutuplarına bağlanmazsa yanmayacak olan ışık yayan bir diyottur.

LED'lerle ilgili diğer bir husus, bu cihazların düşük akımla çalışması ve uygun şekilde hesaplanan bir direncin pimlerinden biriyle seri olarak dahil edilmemesi durumunda anında hasar görebilmesidir.

Genel bir kural olarak, akımı gereken güvenli bir seviyeye sınırlamak için besleme girişindeki her 5V artış için 330 ohm 1/4 watt oldukça idealdir. Bu nedenle 5V için 330 ohm, 10V için 680 ohm ve benzeri olabilir.

Montaj için Breadboard Kullanma

Lütfen nasıl kullanılacağını bildiğinizden emin olun. devre tahtası Bu bölümde açıklanan öğreticiyi denemeden önce, çünkü buradaki tüm deneyler için bir breadboard kullanacağız.

Temel LED bağlantı kurulumuna aşağıda tanık olunabilir:

Yukarıda 3 temel bileşeni görebilirsiniz:

5 mm, 20mA LED
330 ohm 1/4 watt direnç
Bir Arduino Kurulu

Sistemi şemaya göre monte edin.

Ardından, bilgisayarın USB'sinden 5V'yi Arduino'ya takın. Bunu yaptığınız anda LED'in yandığını göreceksiniz.

Bunun oldukça basit olduğunu biliyorum, ancak sıfırdan başlamak her zaman iyidir. Biz ilerledikçe her şeyin daha ilginç olmaya başlayacağından emin olabilirsiniz.

1.5 Arduino ile LED Kontrolü

Şimdi bir Arduino programı ile bir LED'i nasıl kontrol edeceğimizi öğreneceğiz.

Bir program yazmak için her programda en az 2 fonksiyona sahip olmamız gerekir.

Bir işlev, aşağıda verildiği gibi, bir adla atanabilen bir dizi programlama ifadesi olarak anlaşılabilir:

kurulum() bu, programın başlangıcında çağrılır veya yürütülür.
döngü () bu, Arduino'nun tüm operasyonel süresi boyunca tekrar tekrar çağrılır veya yürütülür.

Bu nedenle, pratik bir işlevi olmasa da, teknik olarak en kısa yasal Arduino programı şu şekilde yazılabilir:

En Basit Program

void setup() { } void loop() { }

Pek çok programlama dilinde sistemin, ekranda basit bir 'Merhaba, Dünya' yazısı göstererek başladığını fark etmiş olabilirsiniz.

Mikrodenetleyici yorumlamasında bu cümlenin elektronik eşdeğeri, bir LED'i AÇIK ve KAPALI olarak yanıp sönmektir.

Bu, sistemin doğru bir şekilde işlediğini belirtmek için yazıp uygulayabileceğiniz en temel programdır.

Prosedürü aşağıdaki kod parçası aracılığıyla uygulamaya ve anlamaya çalışacağız:

Liste 1.2: led1 / led1.pde

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } void loop() { digitalWrite(kPinLed, HIGH) delay(500) digitalWrite(kPinLed, LOW) delay(500) }

Tamam, şimdi kodun her satırının ne anlama geldiğini ve işlevi yürütmek için nasıl çalıştığını anlayalım:

const int kPinLed = 13

Bu, ona karşı ayarlanan gerçek değeri kullanmaya gerek kalmadan tüm programlama kursu sırasında onu kullanmamızı sağlayan bir sabit gibi çalışır.

Standart kurallara göre, bu tür sabitler başlangıç harfiyle tanınır -e . Bu zorunlu olmasa da, kod ayrıntılarını gözden geçirmek istediğinizde işleri daha net ve kolay anlaşılır hale getirir.

void setup() { pinMode(kPinLed, OUTPUT) }

Bu kod, LED'imizin bağlı olduğu belirli pimi yapılandırır. Başka bir deyişle, kod, Arduino'ya bu pin üzerindeki 'yazma' yönünü 'okumak' yerine kontrol etmesini söyler.

void loop() { digitalWrite(kPinLed, HIGH) delay(500) digitalWrite(kPinLed, LOW) delay(500) }

Yukarıdaki satırlar, uygulamanın fiili yürütülmesini gösterir. Kod, ilgili LED bağlantısına bir HIGH yazıp LED'i AÇIK hale getirerek başlar.

Burada, YÜKSEK terimi basitçe Arduino'nun ilgili pinine + 5V almak anlamına gelir. Tamamlayıcı LOW terimi, belirlenen pim üzerinde basitçe sıfır veya 0V'yi gösterir.

Sonra delay() işlevi milisaniyeler (saniyenin 1 / 1000'i) ile bir gecikme yaratmaktır. 500 rakamı girildiğinden, uygulanan gecikme 1/2 saniye olacaktır.

Bu 1/2 saniye geçtikten hemen sonra, aynı pim üzerindeki DÜŞÜK terimiyle LED'i KAPALI konuma getiren bir sonraki satır yürütülür.

Sonraki satır, LED'in 1/2 saniye KAPALI kalmasına izin vermek için yine 1/2 saniyelik gecikmeyi üretir.

Ve bu süreç, Arduino enerjili kaldığı sürece kod satırlarının yürütülmesiyle sonsuza kadar devam eder.

Bir sonraki seviyeye geçmeden önce, lütfen yukarıdaki kodu programlamanızı ve LED AÇIK / KAPALI sırasını doğru uygulayıp uygulayamadığınızı kontrol etmenizi tavsiye ederim.

Arduino'daki varsayılan LED pin # 13 ile bağlandığından, yukarıdaki programa hemen yanıt vermeli ve yanıp sönmeye başlamalıdır. Bununla birlikte, harici LED'inizin yanıp sönmediğini fark ederseniz, LED'inizde bir bağlantı hatası olabilir, LED'inizin polaritesini tersine çevirmeyi deneyebilir ve umarız yanıp söndüğünü de görebilirsiniz.

Gecikme süresi ile '500' rakamını başka bir değere değiştirerek oynayabilir ve komutları 'dinlerken' LED'i bulabilir ve belirlenen gecikme değerlerine göre yanıp sönmesini sağlayabilirsiniz.

Ancak, gecikme süresi değişikliğiniz ne olursa olsun, LED'in sabit 1 saniyelik bir hızla yanıp sönmediğini görürseniz, bu, bazı hatalar nedeniyle kodun çalışmadığını gösterebilir. Çünkü varsayılan olarak Arduino, 1 saniyelik bir yanıp sönme oranı ile programlanacaktır. Bu nedenle, doğru çalıştığını teyit etmek için bu oran kodunuz tarafından değiştirilmelidir.

1.7 Yorumlar

Yukarıda anladığımız kod satırları özellikle bilgisayar yazılımı için yazılmıştır.

Bununla birlikte, kullanıcının satırların anlamlarına atıfta bulunmasını ve anlamasını sağlamak için, açıklamayı istenen kod satırlarının yanına yazmak çoğu zaman faydalı ve mantıklı olabilir.

Bunlara denir yorumlar yalnızca insan veya kullanıcı referansı için yazılmıştır ve bilgisayarların güvenli bir şekilde yok saymasını sağlamak için kodlanmıştır.

Bu yorumların dili birkaç formatta yazılmıştır:

Blok yorum stili, burada yorum açıklaması başlangıç sembolü / * ve bitiş sembolü * / altında yer alır.
Bu, bir satırda kısıtlanmak zorunda değildir, aşağıdaki örnekte gösterildiği gibi yorumun veya açıklamanın uzunluğuna bağlı olarak sonraki sonraki satırlara uzatılabilir:

/ * Bu bir yorumdur * /

/* Öyleyse bu */

/* Ve
* bu
* gibi
* iyi */

Bir yorum için hızlı tek satırlık açıklama yazmak için, başlangıçta iki eğik çizgi // simgesi yeterli olur. Bu, bilgisayara bu satırın gerçek kodla hiçbir ilgisi olmadığını ve göz ardı edilmesi gerektiğini söyler. Örneğin:

// Bu, bilgisayarların göz ardı edeceği bir yorumdur.

İşte referans için bir örnek:

/* * Program Name: Blink * Author: Alan Smith * Description: * Turns an LED on for one half second, then off for one half second repeatedly. */

/* Pin Definitions */ const int kPinLed = 13 /* * Function Name: setup * Purpose: Run once when the system powers up. */ void setup() { pinMode(kPinLed, OUTPUT) } /* * Function name: loop * Purpose: Runs over and over again, as long as the Arduino has power */ void loop() { digitalWrite(kPinLed, HIGH) delay(500) digitalWrite(kPinLed, LOW) delay(500) }

1.8 Sorun Giderme

Programınızın derleme sırasında bir 'hata' gösterdiğini veya başka bir sorunu tespit ederseniz, aşağıdaki ipuçları muhtemelen kodunuzu yeniden kontrol etmenize ve engelden kurtulmanıza yardımcı olacaktır.

Program diliniz büyük / küçük harfe duyarlı olacaktır. Örneğin ifade myVar olarak yazılamaz MyVar.
Klavye yazmanızla çalıştırılabilecek her türlü beyaz boşluk, sonuçta tek bir boşluk olarak işlenir ve yalnızca sizin tarafınızdan görülebilir veya anlaşılır, bilgisayar bunu dikkate almayacaktır. Basitçe söylemek gerekirse, herhangi bir tür boş alanın kod sonuçları üzerinde herhangi bir etkisi olmayacaktır.
Her bir kod bloğu sol ve sağ kıvrımlı parantez içine alınmalıdır, '{' ve '}'
Sayı haneleri virgülle ayrılmamalıdır. Örneğin 1000, 1.000 olarak yazılamaz.
Küme parantezleri arasında yer alan her kod satırı bir noktalı virgülle bitmelidir

Arduino ile İlginç LED Işık Dizisi Yaratmak

Önceki bölümümüzde, bir LED'in sabit bir gecikme oranıyla sürekli olarak nasıl AÇIK / KAPALI yanıp söneceğini öğrendik.

Şimdi program kodunu yükselterek aynı LED üzerinde farklı gecikme modellerinin nasıl yürütüleceğini öğreneceğiz.

Harici bir LED kullanmayacağız, bunun yerine 13 numaralı pimdeki Arduino kartına yerleşik varsayılan LED'i kullanacağız. Bu küçük SMD LED'i USB konektörünün hemen arkasında bulabilirsiniz.

2.2 IF İfadelerini Anlamak

Bu bölümde, kontrol yapılarının gerektiğinde ayrı kodları ve hatta bazen tekrar tekrar çalıştırmamızı nasıl sağladığını öğreneceğiz.

İfade Eğer 1. kontrol yapısı olur. Aşağıdaki uygulama nasıl kullanıldığını gösterir:

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } int delayTime = 1000 void loop() { delayTime = delayTime - 100 if(delayTime <= 0){ // If the delay time is zero or less, reset it. delayTime = 1000 } digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) }

Yukarıdaki kodu adım adım anlamaya çalışacağız ve bunun diğer benzer uygulamalar için nasıl kullanılabileceğini öğreneceğiz.

1. ve 7. satır arasındaki kodlar tam olarak ilk programımıza benzer.

İlk değişiklik aslında 8. satırda gerçekleşir.

int delayTime = 1000

Bunu 1. satırdaki koda benzer bulabilirsin, ancak terimin eksik olduğu gerçeğini const.

Bunun nedeni, bu kodun sabit olmamasıdır. Bunun yerine bu bir değişken , programlama sırasında değişken bir değer özelliğine sahiptir.

Yukarıdaki örnekte, bu değişkenin 1000 değeriyle ilişkilendirildiğini görebilirsiniz. Küme parantezleri içine alınan bu tür değişkenlerin kesinlikle sadece küme parantez çiftleri içinde yazılması gerektiğini ve 'yerel' değişkenler olarak adlandırıldığını unutmayın.

Alternatif olarak, küme parantezlerinin dışında olması gereken değişkenler, şu anda tartıştığımız gibi 'global' olarak kabul edilir ve bir program kodu içinde hemen hemen her yerde çalıştırılabilir.

Devam edersek, 9. ve 11. satırlar arasındaki kodların da ilk programa benzediğini görebilirsiniz, yine de 11. satırdan sonra işler ilginçleşmeye başlıyor. Bakalım nasıl!

delayTime = delayTime - 100

Bu kodda, varsayılan değerin gecikme süresi ondan 100 çıkarılarak değiştiriliyor.

Anlamı 100, 1000 olan başlangıç değerinden çıkarılır ve ona 900 yeni bir değer sağlar.

Aşağıdaki görüntü aracılığıyla Arduino dilinde kullanılan Math operatörlerinden birkaçını anlamaya çalışacağız.

Şimdi satır 13 ile 15 arasındaki kodları değerlendirelim.

if(delayTime <= 0){ // If the delay time is zero or less, reset it. delayTime = 1000 }

Yukarıdaki kod parçasının temel amacı, LED'in herhangi bir kesinti olmaksızın yanıp sönmeye devam etmesini sağlamaktır.

Orijinalden 100 adet çıkarıldığı için gecikme süresi LED'in yanıp sönmesinin sıfıra ulaşmasını engeller ve yanıp sönmenin sürekli devam etmesini sağlar.

Aşağıdaki resimde, kodlarımızda kullanacağımız birkaç karşılaştırma operatörü gösterilmektedir:

arduino kodları için karşılaştırma operatörü

Yukarıdaki kodumuzda, kodun if(delayTime == 0) olduğunu test edebilirdik.

Bununla birlikte, negatif figür olmak eşit derecede kötü olabileceğinden, bunun için gitmedik ve bu önerilen bir uygulamadır.

delayTime 'Den 100 yerine 300 düşmeye çalışsaydık sonuç ne olabilirdi?

Şimdi fark etmiş olabilirsiniz ki delayTime sıfırdan küçük veya sıfıra eşit olarak yazılırsa, gecikme süresi orijinal şekil 1000'e geri ayarlanacaktır.

digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime)

Yukarıda gösterildiği gibi kodun son 4 satırı, LED'in sürekli olarak AÇIK / KAPALI, AÇIK / KAPALI duruma getirilmesinden sorumludur.

Burada, bir dizi rakam kullanmak yerine, gecikme süresini atamak için bir değişken kullandığımızı açıkça fark edebilirsiniz, böylece kodun çalışma süresi boyunca onu istediğimiz gibi ayarlayabiliriz. Harika, değil mi?

2.3 ELSE İfadeleri

Burada neden ve nasıl olduğunu öğreneceğiz Eğer terim bir cümle içerebilir Başka böylece duruma karar verecek Eğer ifade yanlıştır.

Bu çok kafa karıştırıcı geliyorsa özür dilerim, merak etmeyin, aşağıdaki örnekle anlamaya çalışacağız:

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } int delayTime = 1000 void loop() { if(delayTime <= 100){ // If it is less than or equal to 100, reset it delayTime = 1000 } else{ delayTime = delayTime - 100 } digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) }

Yukarıda, 10. satırda kodun yalnızca delayTime 100'den küçük veya 100'e eşittir, değilse 13. satırdaki kod çalıştırılır, ancak ikisi birlikte asla gerçekleşemez, 10. satır veya 13. satır kodu uygulanmaz, hiçbir zaman ikisi birden uygulanmaz.

Bir önceki bölüm 2.2'de yaptığımızın aksine, burada 100 ile karşılaştırmak yerine 0 ile karşılaştırma yapmadığımızı fark etmiş olabilirsiniz. Bunun nedeni, bu örnekte 100'ü çıkarmadan ÖNCE karşılaştırdığımız, aksine bölüm 2.2'de ise, çıkarıldı. 100 yerine 0'ı karşılaştırsaydık neler olabileceğini söyleyebilir misin?

2.4 WHILE ifadeleri

KİME süre ifade oldukça benzer Eğer ifadesi, bir kod bloğunun (küme parantezleri arasında olabilir) çok uzun süre tekrar tekrar çalıştırılmasına neden olması dışında, koşullar geçerli olur ve bu, bir Başka Beyan.

Aşağıdaki örnek bunu daha iyi anlamanıza yardımcı olacaktır

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } int delayTime = 1000 void loop() { while(delayTime > 0){ // while delayTime is greater than 0 digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) delayTime = delayTime - 100 } while(delayTime <1000){ // while delayTime is less than 1000 delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0 digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) } }

Yukarıdaki kodun ne yapmak üzere programlandığını tahmin edebilir misiniz? LED'i daha hızlı ve sonra daha yavaş yanıp sönecek şekilde tasarlanmıştır.

2.5 Doğru ve yanlış olan nedir?

Programlama dilinde, yanlış sıfır (0) anlamına gelir. Aslında 'doğru' kullanılmaz, bunun yerine hiçbir şey yanlış olmadığında, içerilen her şeyin doğru olduğu varsayılır.

Biraz tuhaf görünüyor, ancak işi oldukça iyi yapıyor.

Durumu aşağıdaki örnekle anlamaya çalışacağız.

Bazen aşağıda verilen bir kodla karşılaşabilirsiniz:

while (1){ digitalWrite(kPinLed, HIGH) delay(100) digitalWrite(kPinLed, LOW) delay(100) }

Bu, uzun güç mevcut olduğu sürece, LED uygulaması sonsuza kadar döngüyü sürdürecek gibi kodlanmış görünüyor.

Ancak, kullanıcı yanlışlıkla == yerine a = uyguladığında bu tür kodun bir dezavantajı ortaya çıkabilir.

Eminim ki = bir atama anlamına gelir, yani bir değişkene seçilen bir değeri atamak için kullanılırken, değer aynıysa bir testi uygulamak için a == kullanılır.

Örneğin, bir LED'in sıralı olarak hızlanan ve tekrarlayan bir şekilde yanıp sönmesi gerektiğini, ancak yanlış bir şekilde == yerine bir = kullandığınızı varsayalım.

Kod daha sonra şu şekilde görünecektir:

int delayTime = 1000 void loop() { if(delayTime = 0){ // WRONG!!! the = should have been == delayTime = 1000 } digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) delayTime = delayTime - 100 }

Hata, 0'ı delayTime 'e atar ve Eğer 0'ın doğru olup olmadığını kontrol etmek için ifade. 0, yanlış anlamına geldiğinden, bunun doğru olmadığını düşünecek ve delayTime = 1000 yerine delayTime işlevinin uygulanmasını durduracaktır. döngü () sırasında 0'da tutulur.

Bu çok istenmeyen görünüyor !!

Bu nedenle, bu tür aptalca hatalar yapmadığınızdan emin olmak için her zaman programınızı iki kez kontrol edin.

2.6 Kombinasyonlar

Bazen birden fazla şeyi birlikte test etme ihtiyacı hissedebilirsiniz. Örneğin, bir değişkenin iki sayı arasında olup olmadığını incelemek isteyebilirsiniz. Bu, if ifadesi kullanılarak birden çok kez uygulanabilse de, daha iyi ve daha kolay okuma için mantıksal kombinasyonları kullanmak daha uygun olabilir.

Mantıksal terimlerde kombinasyonların uygulanması, aşağıdaki tabloda gösterildiği gibi 3 yöntemle yapılabilir:

Arduino kombinasyon yöntemlerini gösteren tablo

NOT operatörünün bir değişken için değiştirici olarak çalışabileceğini bilmek ilginç olacaktır, bu değişkenlerden biri doğru veya yanlış (veya DÜŞÜK veya YÜKSEK).

Aşağıdaki örnek durumu göstermektedir:

int ledState = LOW void loop() { ledState = !ledState // toggle value of ledState digitalWrite(kPinLed, ledState) delay(1000) }

İşte ledState DÜŞÜK olacak ve daha sonra ledState = !ledState olur olmaz, YÜKSEK olacak. Aşağıdaki döngü ledState ledState = !ledState olduğunda YÜKSEK olacak düşük.

2.7 FOR ifadeleri

Şimdi başka bir kontrol yapısını anlamaya çalışacağız. için döngü. Bu, bir şeyi birkaç kez uygulamak istediğinizde çok kullanışlı olabilir.

Bunu aşağıdaki örnekle anlayalım:

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } void loop() { for(int i = 0 i <4 i++){ digitalWrite(kPinLed, HIGH) delay(200) digitalWrite(kPinLed, LOW) delay(200) } delay(1000) // 1 second }

Sırasında benzersiz bir şey bulabilirsiniz için.

Bu kod i ++? . Bu, tembel olan ve uygun kısayollar aracılığıyla kodlama uygulamak isteyen programcılar için kullanışlıdır.

Yukarıdaki terim, bir atama operatörünü başka bir atama operatörüyle birleştirme işini yaptıkları için bileşik operatörler olarak bilinir. Bunlardan en popüler olanları aşağıdaki tabloda görselleştirilebilir:

Bir for ifadesinde 3 alt ifade olduğunu göreceksiniz. Aşağıda gösterildiği gibi yapılandırılmıştır:

for (statement1conditionstatement2){ // statements }

1 numaralı ifade, başlangıçta ve yalnızca bir kez gerçekleşir. Koşul, döngü boyunca her seferinde test edilir. Ne zaman olursa olsun doğru küme parantezlerinin içinde, sonraki 2 numaralı ifade zorlanır. Durumunda yanlış, sistem sonraki kod bloğuna atlar.

Daha Fazla LED Bağlama

Tamam, şimdi daha ilginç efektler elde etmek için daha fazla LEd'i nasıl bağlayabileceğimizi göreceğiz.

Lütfen LED'leri ve Arduino'yu aşağıda gösterildiği gibi bağlayın. Kırmızı kablo aslında gerekli değildir, ancak her iki besleme rayının devre tahtasına dahil edilmesi her zaman iyi bir fikir olduğundan kurulum mantıklıdır.

Şimdi donanımımızın doğru yapılandırılıp yapılandırılmadığını kontrol etmemizi sağlayacak bir programı düzeltelim.

İlgili donanımların doğru bağlanıp bağlanmadığını kontrol etmek için her zaman küçük program bitlerinin kodlanması ve çalıştırılması önerilir.

Bu, olası bir hatanın hızla giderilmesine yardımcı olur.

Aşağıdaki kod örneği, LED 2 ila 5'i döngüsel bir şekilde birbiri ardına çevirerek belirli bir model sağlar.

const int kPinLed1 = 2 const int kPinLed2 = 3 const int kPinLed3 = 4 const int kPinLed4 = 5 void setup() { pinMode(kPinLed1, OUTPUT) pinMode(kPinLed2, OUTPUT) pinMode(kPinLed3, OUTPUT) pinMode(kPinLed4, OUTPUT) } void loop() { // turn on each of the LEDs in order digitalWrite(kPinLed1, HIGH) delay(100) digitalWrite(kPinLed2, HIGH) delay(100) digitalWrite(kPinLed3, HIGH) delay(100) digitalWrite(kPinLed4, HIGH) delay(100) // turn off each of the LEDs in order digitalWrite(kPinLed1, LOW) delay(100) digitalWrite(kPinLed2, LOW) delay(100) digitalWrite(kPinLed3, LOW) delay(100) digitalWrite(kPinLed4, LOW) }

Fark edebileceğiniz gibi, uzun görünmesi ve dolayısıyla hatalara açık olması dışında, kodda yanlış bir şey yoktur.

Elbette yukarıdaki kodu yazmanın daha iyi yolları var, aşağıdaki bölüm onu ortaya çıkaracaktır.

2.9 Dizilerin Tanıtımı

Diziler, indeks numaraları ile indekslenebilen bir grup değişken olabilir. Aşağıdaki örnek, onu daha iyi anlamamıza yardımcı olacaktır.

const int k_numLEDs = 4 const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5 void setup() { for(int i = 0 i pinMode(kPinLeds[i], OUTPUT) } } void loop() { for(int i = 0 i digitalWrite(kPinLeds[i], HIGH) delay(100) } for(int i = k_numLEDs - 1 i >= 0 i--){ digitalWrite(kPinLeds[i], LOW) delay(100) } }

Tamam, şimdi her bölümden geçelim ve gerçekte nasıl çalıştıklarını anlayalım.

const int k_numLEDs = 4

Yukarıdaki kod, dizide kaç tane maksimum elemana sahip olacağımızı tanımlar. Bu kod, sonraki bölümlerde her şeyin bir dizi içinde yazıldığından ve dizi bittiğinde hiçbir şeyin olmadığından emin olmamıza yardımcı olur.

const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

Sonraki satırda dizi yapısını kuruyoruz. Köşeli ayraç içindeki sayılar, dizideki öğelerin sayısını gösterir. Gerçek miktar yazılabilir olsa da, sabitler olarak yazmak daha iyi sonuç verir. Değerler normalde köşeli parantez içinde virgülle görülebilir ve değerleri diziye atar.

0 sayısıyla indekslenmiş bir dizi bulduğunuzda, bu code: k_LEDPins is k_LEDPins[0] ile gösterildiği gibi dizideki ilk öğeyi gösterir.

Benzer şekilde, son eleman k_LEDPins[3] olarak gösterilecektir, çünkü 0'dan 3'e kadar olan sayı 4'tür.

void setup() { for(int i = 0 i pinMode(kPinLeds[i], OUTPUT) } }

Yukarıdaki kod, her dizi elemanında ilerlemek ve bunları ÇIKIŞLAR olarak ayarlamak için döngü kullanımını gösterir. Dizideki öğelerin her birine ulaşmak için dizinle birlikte köşeli parantezler uygularız.

Diziler olmadan pin # 2'yi pin # 5'e kullanmanın mümkün olup olmadığını merak ediyorsanız, cevap evet, mümkün. Ama bu örnekte, biz öyle yapmadığımız için yapılmadı. Aşağıdaki bölümlerde, seçilen çıkış pinleri aynı hizada değilse dizi yaklaşımını ortadan kaldırabilirsiniz.

İlerlerken, bir sonraki kod bloğunun ne yaptığını görelim:

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH) delay(100) }

Burada kod, LED'lerin her birini 100 milisaniyelik bir aralık veya gecikmeyle sırayla AÇIK duruma getirmek için ilerler.

for(int i = k_numLEDs - 1 i >= 0 i--){ digitalWrite(kPinLeds[i], LOW) delay(100) }

Yukarıdaki kodun kullanılması, döngü için döngü içinde ters sırada bile hareket etmek için kullanılabilir.

k_numLEDs - 1 İle başlar çünkü diziler sıfır dizinlidir. k_LEDPins[4] İle başlamayız çünkü bu, dizinin bitişini geçmeye neden olur.

Kod, 0 dizinindeki ilk elemanın gözden kaçmamasını veya yok sayılmamasını kontrol etmek için> = 0 kullanır.

Bölüm 3

Girdi nedir

Arduino'yu kullanarak işleri nasıl çalıştıracağımızı da öğrendik. Bu bölümde, harici parametrelerden gelen girdileri arayüzleyerek gerçek dünyayı nasıl algılayacağımızı tartışacağız.

3.1 Butonları Kullanma

Düğmenin ne olduğunu ve nasıl çalıştığını hepimiz biliyoruz. Basılmış durumdayken anlık olarak bir devre aşamasından diğerine bir sinyali bağlayan ve bırakıldığında sinyali kesen bir tür anahtar veya düğmedir.

3.1.1 Bir düğme ve bir LED

Yukarıda gösterilen detaylara göre Arduino'yu Arduino ile bir buton ile bağlayacağız ve kurulumun temel çalışmasını ve uygulamasını öğreneceğiz.

Mikro anahtar basma düğmesi olarak da adlandırılan belirtilen basma düğmesinin toplamda 4 pimi vardır (her iki tarafta 2 çift). İtildiğinde, her bir pim çifti dahili olarak birleştirilir ve bunlar arasında bir bağlantı veya iletim sağlar.

Bu örnekte, bu pimlerin veya kontakların yalnızca bir çiftini kullanıyoruz, diğer çift alakasızdır ve bu nedenle ihmal edilir.

Devam edelim aşağıdaki kodu uygulayıp çalıştığını kontrol edin!

const int kPinButton1 = 2 const int kPinLed = 9 void setup() { pinMode(kPinButton1, INPUT) digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor pinMode(kPinLed, OUTPUT) } void loop() { if(digitalRead(kPinButton1) == LOW){ digitalWrite(kPinLed, HIGH) } else{ digitalWrite(kPinLed, LOW) } }

Burada olağandışı görünen birkaç şey bulabilirsiniz. Onları adım adım çözelim.

void setup() { pinMode(kPinButton1, INPUT) digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor pinMode(kPinLed, OUTPUT) }

Yaptığımız ilk şey, buttonPin olarak GİRİŞ. Bu oldukça basit, biliyorum.

Sonra, atıyoruz YÜKSEK için GİRİŞ toplu iğne. Girişte herhangi bir şey yazmanın nasıl mümkün olabileceğini merak ediyorsunuz? Elbette, bu ilginç olabilir.

Aslında, bir Arduino girişine bir YÜKSEK atamak, dahili bir 20k Ohm çekme direncini AÇIK konuma getirir (bu pin üzerindeki DÜŞÜK onu KAPATIR).

Yapabileceğiniz başka bir soru da, kaldırma direncinin ne olduğudur. Çekme dirençleriyle ilgili kapsamlı bir yazıyı ele aldım. buradan öğren .

Tamam, devam edin, şimdi ana döngü koduna bakalım:

void loop() { if(digitalRead(kPinButton1) == LOW){ digitalWrite(kPinLed, HIGH) } else{ digitalWrite(kPinLed, LOW) } }

Basma düğmesine bastığınızda, kablolu pim toprağa bağlanır ve bu da DÜŞÜK o iğneye. Ve sıkıştırılmamış durumda iken, aynı pim, YÜKSEK veya 20K dahili kaldırma direnci üzerinden + 5V.

Burada, Arduino'nun basma düğmesine basıldığında (DÜŞÜK) LED'i yakmasını istiyoruz, bu nedenle basıldığında basma düğmesinden gelen her DÜŞÜK yanıtı için çıkış için YÜKSEK yazıyoruz.

3.1.2 İki düğme ve bir LED

Pekala, yukarıda gösterilen eylemin Arduino olmadan da yapılabileceğini merak edebilirsiniz. Anlıyorum, ancak bu basma düğmesinin Arduno ile nasıl kullanılabileceğini öğrenmek için dik bir taş.

Bu noktaya kadar, bir LED'i AÇIK (YÜKSEK) veya KAPALI (DÜŞÜK) anahtarlama için kod yazma üzerinde çalıştık.

Şimdi bir Arduino ile LED'in parlaklığının nasıl kontrol edilebileceğini görelim.

İki yöntem kullanılarak yapılabilir:

Akım miktarını LED ile sınırlayarak
Kullanarak PWM veya LED'e beslemenin istenen bir hızda çok hızlı bir şekilde AÇIK / KAPALI hale getirildiği ve yoğunluğu PWM'ye bağlı olan ortalama bir aydınlatma üreten darbe genişliği modülasyonu.

Bir Arduino kartında PWM desteği, 500 Hz'de (saniyede 500 kez) 3, 4,5,9,10 ve 11 numaralı pinler olan tilde (~) ile işaretlenmiş pinlerde mevcuttur. Kullanıcı, 0 ile 255 arasında herhangi bir değer sağlayabilir, burada 0, YÜKSEK veya + 5V yok anlamına gelir ve 255, Arduino'ya her zaman YÜKSEK veya + 5V almasını söyler. Bu komutları başlatmak için analogWrite () 'a istenen değerle erişmeniz gerekecektir.

PWM'nin x / 255 olduğunu varsayabilirsiniz, burada x, analogWrite() ile göndermek istediğiniz istenen değerdir.

Arduino ve diğer parametreleri yukarıda gösterildiği gibi ayarlayın.

const int kPinButton1 = 2 const int kPinButton2 = 3 const int kPinLed = 9 void setup() { pinMode(kPinButton1, INPUT) pinMode(kPinButton2, INPUT) pinMode(kPinLed, OUTPUT) digitalWrite(kPinButton1, HIGH) // turn on pullup resistor digitalWrite(kPinButton2, HIGH) // turn on pullup resistor } int ledBrightness = 128 void loop() { if(digitalRead(kPinButton1) == LOW){ ledBrightness-- } else if(digitalRead(kPinButton2) == LOW){ ledBrightness++ } ledBrightness = constrain(ledBrightness, 0, 255) analogWrite(kPinLed, ledBrightness) delay(20) }

Burada açıklamaya ihtiyaç duyan 3 satır bulabilirsiniz.

ledBrightness = constrain(ledBrightness, 0, 255) 25 analogWrite(kPinLed, ledBrightness) 26 delay(20)

Satır: ledBrightness = constrain(ledBrightness, 0, 255) Arduino'nun içinde constrain () olarak bilinen benzersiz bir işlevi gösterir.

Bu dahili işlev, aşağıdakilere benzer bir kod içerir:

int kısıtlama (int değeri, int min, int maks)
{ if(value > max){ value = max } if(value value = min } return value }

Bundan önce tartışılan tüm kodlar, geçersiz , bu hiçbir şeyi geri vermemek anlamına geliyordu (geçersiz). Yukarıdaki kod ise int , bir tamsayı döndürdüğünü gösterir. Daha sonraki bölümlerde daha fazlasını tartışacağız, şu anda bir tamsayının herhangi bir kesirli parçası olmadığını hatırlayın.

Doğru, bu şu kodu gerektirir: ledBrightness = constrain(ledBrightness, 0, 255) ledBrightness to be within the range of 0 and 255 atar.

Sonraki satırda analogWrite Arduino'ya PWM'yi seçilen pin üzerinde istenen değerle uygulaması için komut vermek.

Bir sonraki satır, 20 milisaniyelik bir gecikme yaratır, bu, hızı 50 Hz'den veya saniyede 50 kez daha hızlı ayarlamadığımızdan emin olmak içindir. Bunun nedeni, insanların bir Arduino'dan çok daha yavaş olabilmesidir. Bu nedenle, gecikme yapılmazsa, program bize birinci düğmeye basmanın LED'i KAPALI hale getirdiğini ve ikinci düğmeye basmanın onu AÇIK hale getirdiğini hissettirebilir (onaylamak için kendiniz deneyin).

3.2 Potansiyometreler

Devam edelim ve nasıl kullanılacağını öğrenelim Arduino ile potansiyometreler.

Potansiyometrenin veya bir tencerenin nasıl çalıştığını öğrenmek için bunu okuyabilirsiniz. makale .

Gösterilen parametreleri Arduino'nuza yukarıda gösterildiği gibi bağlayın.

Bir potun 3 terminali olacaktır. Orta terminal, Arduino'daki ANALOG IN 0 ile bağlanacaktır. Diğer iki dış terminal + 5V ve 0V besleme raylarına bağlanabilir.

Sonuçları programlayıp kontrol edelim:

const int kPinPot = A0 const int kPinLed = 9 void setup() { pinMode(kPinPot, INPUT) pinMode(kPinLed, OUTPUT) } void loop() { int ledBrightness int sensorValue = 0 sensorValue = analogRead(kPinPot) ledBrightness = map(sensorValue, 0, 1023, 0, 255) analogWrite(kPinLed, ledBrightness) }

Tamamen yeni görünen ve önceki kodlarımızın hiçbirine dahil edilmeyen birkaç şey bulacaksınız.

Sabiti kPinPot A0 olarak atanmıştır, burada A, analog pinlerden birini açıklamak için kısayoldur. Bununla birlikte, A0 aynı zamanda 14 numaralı pin, A1 ila 15 numaralı pin anlamına gelir ve bunlar, bir deney için pinlerin tükenmesi durumunda dijital girişler / çıkışlar olarak kullanılmanıza izin verir. Ancak dijital pinleri analog pinler olarak kullanamayacağınızı unutmayın.
Satır: ledBrightness = map(sensorValue, 0, 1023, 0, 255) Arduino olarak bilinen yeni bir iç işlev sunar harita(). Bu özellik, belirli bir aralıktan diğerine yeniden kalibre eder. map (değer, fromLow, fromHigh, toLow, toHigh). Bu, analogueRead 0-1023 aralığında bir değer verir, ancak analogWrite 0-255 arası bir değeri kabul edebilir.

Bir LED'in parlaklığını değişen bir dirençle kontrol etmek mümkün olduğundan, amaç için sadece bir potun yeterli olabileceğini düşünebilirsiniz, neden Arduino'nun kullanılması. Yine, bir potun bir Arduino ile nasıl yapılandırılabileceğini göstermek sadece temeldir.

Sorun yok, şimdi Arduino olmadan yapılamayacak bir şey yapacağız.

Bu deneyde, bir potun değişken direncinin bir LED'in yanıp sönme hızını veya oranını kontrol etmek için nasıl kullanılabileceğini göreceğiz.

İşte program:

const int kPinPot = A0 const int kPinLed = 9 void setup() { pinMode(kPinLed, OUTPUT) } void loop() { int sensorValue sensorValue = analogRead(kPinPot) digitalWrite(kPinLed, HIGH) delay(sensorValue) digitalWrite(kPinLed, LOW) delay(sensorValue) }

3.2.3 Gecikmeden kaçınma ()

Yukarıdaki kod iyi görünüyor, ancak LED her tam döngüden geçene kadar pot değerini kontrol edemiyor. Daha uzun gecikmeler için bu işlem uzar, kullanıcı hareket ederken pot yanıtını görmek için beklemek zorundadır. Bu gecikme, bazı akıllı programlama ile önlenebilir, böylece kullanıcının minimum gecikme olmadan değeri kontrol etmesine izin verir. İşte kod.

const int kPinPot = A0 const int kPinLed = 9 void setup() { pinMode(kPinLed, OUTPUT) } long lastTime = 0 int ledValue = LOW void loop() { int sensorValue sensorValue = analogRead(kPinPot) if(millis() > lastTime + sensorValue){ if(ledValue == LOW){ ledValue = HIGH } else{ ledValue = LOW } lastTime = millis() digitalWrite(kPinLed, ledValue) } }

Öyleyse yukarıdaki kodda farklı olan nedir? Farkı yaratan aşağıdaki satırdır.

long lastTime = 0

Bu bölüme kadar, int değişkeni hakkında tartıştık. Ancak, erişebileceğiniz çok sayıda daha fazla tür değişkeni olabilir. Liste aşağıda okunabilir:

Şimdilik, yalnızca büyük sayıları depolamak için bilmek çok önemli olabilir. int değişken, terimini kullanabilirsiniz uzun veya a long int.

Burada başka bir ilginç işlevi görebilirsiniz. milis ().

Bu, Arduino'nun başından beri çalıştığı zaman aralığını milisaniye cinsinden üretir (bu, her 50 günde bir 0'a sıfırlanacaktır). Burada uzun bir dönüyor çünkü dönerse int , uzun süreler için saymak mümkün olmayabilir. Tam olarak ne kadar süre cevap verebilir misin? Cevap 32.767 saniyedir.

Bu nedenle delay () kullanmak yerine, milis () 'yi kontrol ederiz ve belirli milisaniye sayısı geçer geçmez LED'i değiştiririz. Sonuç olarak, en son değiştirdiğimiz zamanı saklarız. son kez değişken, böylece istediğimiz zaman tekrar kontrol etmemize izin verir.

3.3 RGB LED'ler

Şimdiye kadar tek renkli LED ile oynadık. LED rengi başka bir renkle değiştirilerek LED rengi değiştirilebilir ancak RGB LED'leri kullanmaya ne dersiniz? LED renklerini değiştirmek için LED'leri değiştirmeden?

Bir RGB LED, temel olarak tek bir LED'e gömülü ve birleştirilmiş kırmızı, yeşil ve mavi LED'e sahip bir LED'dir. Toprağa veya 0V besleme rayına giden bir ortak ucu vardır, diğer 3 uç ise amaçlananın uygulanması için çeşitlendirilmiş PWM pozitif sinyalleri ile beslenir. renk karışımı .

Kurulumu aşağıda gösterildiği gibi bağlayabilirsiniz:

Biraz karmaşık görünebilir, ancak aslında PWM kullanan önceki LED kontrol tasarımımızın bir kopyasıdır.

İşte bir alıştırma programı kodu:

const int kPinPot1 = A0 const int kPinPot2 = A1 const int kPinPot3 = A2 const int kPinLed_R = 6 const int kPinLed_G = 10 const int kPinLed_B = 11 void setup() { pinMode(kPinLed_R, OUTPUT) pinMode(kPinLed_G, OUTPUT) pinMode(kPinLed_B, OUTPUT) } void loop() { int potValue int ledValue potValue = analogRead(kPinPot1) ledValue = map(potValue, 0, 1023, 0, 255) analogWrite(kPinLed_R, ledValue) potValue = analogRead(kPinPot2) ledValue = map(potValue, 0, 1023, 0, 255) analogWrite(kPinLed_G, ledValue) potValue = analogRead(kPinPot3) ledValue = map(potValue, 0, 1023, 0, 255) analogWrite(kPinLed_B, ledValue) }

Bu kodu yükledikten sonra, pot ayarlamalarının RGB üzerinde nasıl ilginç ışık efekti yarattığını görün, gerçekten eğlenceli olabilir.

Beyaz renk yerine 3 potun tamamı maksimum konuma getirildiğinde kırmızıyı göreceğinizi göreceksiniz. Bunun nedeni kırmızı rengin 3 renk arasında en öne çıkması ve bu nedenle bu durumda hakim olmasıdır. Ancak işlevi deneyebilirsiniz harita() , daha mantıklı bir denge oluşturmak için LED'in kırmızı kısmına uygulamadan önce.

Arduino ile ses

Bu bölümde Arduino kurulumuna temel ses ve müziği nasıl ekleyeceğimizi öğreneceğiz.

İstenilen frekansta bağlı bir hoparlöre sinyal nasıl değiştirileceğini göreceğiz.

Daha kesin olmak gerekirse, 440 Hz frekans notu olan bir orta A notası denenecektir.

Bunu yapmak için basitçe bir orta A notası çalacağız ve sinüs dalgası sinyalini kare dalga ile optimize edeceğiz.

Ayrıca, bir hoparlörün AÇIK kalabileceği süreyi aşağıdaki formüle dava ederek hesaplayacağız:

timeDelay = 1 saniye / 2 x toneFrequency.

timeDelay = 1 saniye / 2 x 440

timeDelay = 1136 mikrosaniye

4.1 Arduino Kartını Bağlayalım

4.2 Basit bir not eklemek

İşlev hakkında daha önce tartıştık gecikme () birim milisaniye (saniye / 1000) cinsindendir, ancak başka bir fonksiyon bulacaksınız delayMicroseconds() birim mikrosaniye cinsindendir (milisaniye / 1000).

Mevcut kurulum için, hoparlöre bağlı seçilen pim üzerinde saniyede 440 darbe hızında + 5V AÇIK / KAPALI konuma geçmek için bir kod programlıyoruz.

Hatırlayın, son tartışmada amaçlanan sesli not için 1136 mikrosaniye değerini belirledik.

İşte bunun için program, arduino'yu bağlı bir hoparlörle programladığınız anda 440 Hz'lik bir sesli notu duymanızı sağlayacak.

const int kPinSpeaker = 9 const int k_timeDelay = 1136 void setup() { pinMode(kPinSpeaker, OUTPUT) } void loop() { digitalWrite(kPinSpeaker, HIGH) delayMicroseconds(k_timeDelay) digitalWrite(kPinSpeaker, LOW) delayMicroseconds(k_timeDelay) }

“3 fazlı watt saat ölçer ”

Yukarıdaki uygulama ile sesli not almak mümkündür, bu da kendi seçimimize göre bir müzik oluşturabileceğimiz anlamına gelir.

Koddan, Arduino'nun müziğin yaratılmasına ek olarak katkıda bulunan birkaç entegre işlev içerdiğini anlıyoruz.

Birincisi ton () 2 öğe ile birlikte çalışan üçüncü bir isteğe bağlı öğe olan ton (pin, frekans, süre). veya ton (pin, frekans)

Her ikisi de sizin tarafınızdan atanan zaman dilimine göre uygulanmak üzere belirlenmiştir.

Bir sürenin olmaması durumunda, müzik çağrıya kadar çalmaya devam edecektir. ton () tekrar infaz edilir veya siz infaz edene kadar notone ().

Müzik çalmanın uyguladığınız tek temel şey olması durumunda, bunun bir gecikme işlevi kullanılarak yapılması gerekecektir.

Müziğin ne kadar süreyle çalınacağına dair bir zaman sağladığından, süre çok önemli olabilir, böylece başka şeyler yapmakta özgür olabilirsiniz. Süre biter bitmez müzik durur.

Sonraki işlev noTone () tek bir parametreyi işler ve seçilen tonu belirli bir atanmış pim üzerinde durdurur.

Tuhaf bir uyarı: Ne zaman istersen ton () işlevi uygulandığında, pim 3 ve 11'deki PWM işlevi çalışmayı durduracaktır.

Bu nedenle, programda bir hoparlör eki kullanıldığında, hoparlörler için belirtilen pimi kullanmadığınızdan emin olun, bunun yerine hoparlör eki için başka pimler deneyin.

Tamam, işte bir hoparlörde müzik uygulamak için bir program, ancak bu gerçek bir müzik değil, temel ölçekli bir C notası.

#define NOTE_C4 262 #define NOTE_D4 294 #define NOTE_E4 330 #define NOTE_F4 349 #define NOTE_G4 392 #define NOTE_A4 440 #define NOTE_B4 494 #define NOTE_C5 523 const int kPinSpeaker = 9 void setup() { pinMode(kPinSpeaker, OUTPUT) } void loop() { tone(kPinSpeaker, NOTE_C4, 500) delay(500) tone(kPinSpeaker, NOTE_D4, 500) delay(500) tone(kPinSpeaker, NOTE_E4, 500) delay(500) tone(kPinSpeaker, NOTE_F4, 500) delay(500) tone(kPinSpeaker, NOTE_G4, 500) delay(500) tone(kPinSpeaker, NOTE_A4, 500) delay(500) tone(kPinSpeaker, NOTE_B4, 500) delay(500) tone(kPinSpeaker, NOTE_C5, 500) delay(500) noTone(kPinSpeaker) delay(2000) }

Yukarıdaki kodda yeni bir şey fark etmiş olabilirsiniz ve bu #tanımlamak .

Bu terim, derleme yapılırken bilgisayar için bir ara ve değiştir komutu gibi çalışır.

Bir boşluktan önceki ilk şeyi bulduğunda, onu satırın kalan kısmıyla (makrolar olarak adlandırılır) değiştirir.

Bu örnekte, bilgisayar gördüğünde NOTE_E4 hızla 330 miktarı ile değiştirir.

Daha fazla not ve özelleştirme için USB belleğinizdeki adlı bir dosyaya bakabilirsiniz. pitches.h , tercihinize göre frekansların çoğunun bulunabileceği yer.

4.4 İşlevli müzik

Yukarıdaki kod iyi görünüyor, ancak çok sayıda tekrar var gibi görünüyor, bu tekrarları kısaltmak için bir yöntem olmalı, değil mi?

Şimdiye kadar Arduino'da bulunan iki temel işlevle çalıştık. Şimdi kendi işlevlerimizi yaratmanın zamanı gelmiş olabilir.

Her işlev, ilişkili olabileceği değişken türüyle başlamalıdır. Örneğin işlev geçersiz hiçbir şey döndürmeyen tür anlamına gelir, dolayısıyla adı void olur. Not, daha önceki bölümlerimizde bir değişken listesini tartışmıştık, bunlara başvurmak isteyebilirsiniz.

Sonuç olarak, belirli işlev adı açık bir parantez alır '(' ardından virgülle ayrılmış parametrelerin bir listesi gelir.

Parametrelerin her biri kendi türünü bir adla birlikte alır ve son olarak ')' parantez.

Bu parametreler fonksiyon içinde değişkenler şeklinde uygulanabilir.

Aşağıda adı verilen bir işlevi geliştirdiğimiz bir örnek görelim bizimTone () birleştirmek için tasarlanmış ton () ile gecikme () satırlar, nota tonu çalmayı bitirene kadar işlevin geri dönmesini durduracak şekilde.

Bu fonksiyonları önceki kodumuza uyguluyoruz ve aşağıdaki programı alıyoruz, son satırlara bakın:

Fonksiyonlar, bir programın anlaşılmasını kolaylaştırmak için son derece kullanışlı olabilir.

Aşağıdaki, iki dizi kullanarak çalmak istediğimiz ton seçimini belirleyebileceğimiz bir örnektir. Notaları tutmak için bir dizi, diğeri ritimleri korumak için.

#include 'pitches.h' int kPinSpeaker = 9 #define NUM_NOTES 15 const int notes[NUM_NOTES] = // a 0 represents a rest { NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4, NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4, NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4, NOTE_D4, NOTE_C4, 0 } const int beats[NUM_NOTES] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 } const int beat_length = 300 void setup() { pinMode(kPinSpeaker, OUTPUT) } void loop() { for (int i = 0 i if (notes[i] == 0) { delay(beats[i] * beat_length) // rest } else { ourTone(notes[i], beats[i] * beat_length) } // pause between notes noTone(kPinSpeaker) delay(beat_length / 2) } } void ourTone(int freq, int duration) { tone(kPinSpeaker, freq, duration) delay(duration) }

Girişini ilk satırda açıkça görebilirsiniz. #Dahil etmek Beyan. Bu ifadenin görevi, tüm dosyayı alıntılar arasında alıp, #Dahil etmek Beyan. Standart kurallara göre bunlar kesinlikle programın başlangıcına yerleştirilmiştir.

Bölüm 5

Sıcaklık Ölçümü

Hatırlamak için, büyük programları bir arada yazmak yerine, her zaman küçük kod parçalarını yazmak ve analiz etmek akıllıca olacaktır, bu da hataları hızlı bir şekilde takip etmeye yardımcı olur.

5.1 Seri Monitör

Şimdiye kadar, tartıştığımız kodlar, hızlı sorun gidermeyi etkinleştirmek o kadar kolay görünmüyor. Burada, olası bir sorunun izlenmesi ve daha kolay çözülmesi için işleri kolaylaştırmaya çalışacağız.

Arduino'nun bilgisayarla 'konuşmasını' sağlayan bir özelliği vardır. Pin0 ve pin1'in yan yana RX ve TX olarak işaretlendiğini görebilirsiniz. Bu pinler aslında Arduino içinde ayrı bir IC tarafından izlenir ve bu da onları bilgisayara takılıyken USB kablosunun üzerinden okunacak şekilde yükseltir.

Aşağıdaki bölüm tam teşekküllü bir programı gösterir, lütfen devam edin, daha sonra koddaki yeni girişleri öğreneceğiz. Bu kod, neyin kodlandığını belirlememize izin veren bazı ekstra veriler içermesi dışında, bölüm 2.2'de ifade edilen ile aynıdır.

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) Serial.begin(9600) } int delayTime = 1000 void loop() { delayTime = delayTime - 100 if(delayTime <= 0){ // If it would have been zero or less, reset it. delayTime = 1000 } Serial.print('delayTime = ') Serial.println(delayTime) digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) }

Burada iki yeni şeyi tanımlayabilirsiniz, yeni bir satır kurulum() işlevi.

Serial.begin(9600)

Bu satır, basitçe Seri1 9600 baud ile zorlamak için kod. (burada seri, bitler birbiri ardına gönderilir ve baud, gönderildiği hız anlamına gelir). Bu baud değeri ve seri monitörün içindeki değer (bunu daha sonra öğreneceğiz) eşit olmalıdır, aksi takdirde seri monitördeki veriler çöpleri gösterecektir. 9600'ün standart olması daha kullanışlı hale geliyor.

İkinci yeni giriş aşağıdaki gibidir

Serial.print('delayTime = ') Serial.println(delayTime)

Burada ikinci satır, seri bağlantı noktasından çıkan sonraki şeyin bir sonraki satırda başlayacağını gösteriyor. İkinci satırın ilk çizgiden farkı budur.

Görebileceğiniz bir şey daha tırnak işaretleri ('). Bu, burada yalnızca sabitler gibi kullanılacak bir dizge olarak bilinir, çünkü bu konu hakkında daha fazla tartışma çok ayrıntılı ve kapsamın ötesinde olabilir.

Tamam, şimdi yukarıdaki kodu Arduino'ya yükleyebilir ve ne olacağını görebiliriz.

Ne, oops hiçbir şey olmamış gibi görünüyor, Arduino pin # 13 LED'i yanıp söndü ve durdu, Tx LED'i yanıp sönmeye devam etti.

Bunun nedeni Seri Monitör penceresinin henüz düzeltilmemesidir.

Yukarıda gösterildiği gibi IDE'nizdeki Seri Monitör kutusuna tıklamanız gerekir. Sağ altta bulunan baud hızını kontrol etmeyi unutmayın, varsayılan olarak 9600 olmalıdır ve kodla eşleşecektir. 9600'ü seçtiğinizden emin olun.

Aşağıdaki video klip bunun nasıl yapıldığını açıklamaktadır.

https://youtu.be/ENg8CUyXm10

Şimdi ilerleyelim ve yukarıdaki Seri Monitör özelliğinin, Arduino kullanarak Sıcaklık ölçümü

IC TMP36'yı sıcaklık sensörü olarak -40 ila 150 santigrat derece aralığında kullanacağız.

Kurulum aşağıda görülebilir:

Aşağıdaki kod, çıktıyı TMP36 sensöründen okuyarak ve ID'nin seri monitörüne göndererek sıcaklık ölçümünü başlatacaktır.

const int kPinTemp = A0 void setup() { Serial.begin(9600) } void loop() { float temperatureC = getTemperatureC() Serial.print(temperatureC) Serial.println(' degrees C') // now convert to Fahrenheit float temperatureF = convertToF(temperatureC) Serial.print(temperatureF) Serial.println(' degrees F') delay(500) } float getTemperatureC() { int reading = analogRead(kPinTemp) float voltage = (reading * 5.0) / 1024 // convert from 10 mv per degree with 500mV offset // to degrees ((voltage - 500mV) * 100) return (voltage - 0.5) * 100 } float convertToF(float temperatureC) { return (temperatureC * 9.0 / 5.0) + 32.0 }

Kodu en baştan anlayalım.

float temperatureC = getTemperatureC()

Burada, değişken türünü dahil ettiğimizi görebilirsiniz. şamandıra.

Bu, tamsayı sayıları (ondalık veya kesirli kısımları olmayan sayılar) hariç her şeyi depolayan tek değişken türüdür.

Float değişkeninin doğruluğu 6 ila 7 haneye kadar olabilir.

Bitişik kod getTemperatureC() TMP36 sensöründen algılanan voltaj farkını matematiksel olarak hesaplayan ve Santigrat dereceye dönüştüren kendi fonksiyonumuzdur.

float getTemperatureC() { int reading = analogRead(kPinTemp) float voltage = (reading * 5.0) / 1024 // convert from 10 mv per degree with 500mV offset // to degrees ((voltage - 500mV) * 100) return (voltage - 0.5) * 100 }

Kodların bir sonraki bölümünde analogIn() teriminden beri 1 ile 1023 arasında bir rakam döndürmek için atanırsa, okumamızı 5 ile çarpıp ardından 1024'e bölerek sensörden gelen voltajı değerlendirmemiz mümkün hale gelir.

Sensör TMP36, 0 Santigrat derecede 0.5V üretecek şekilde belirlenmiştir ve daha sonra Santigrat derecesindeki her bir yükseliş için 10mV üretir.

Hesaplamalar yoluyla elde edebileceğimiz yaklaşık değer şu şekildedir:

Bir değer döndüren ilk işleviniz olarak düşünebilirsiniz (şu ana kadar kalan tüm işlevlerin türden olduklarından herhangi bir değer döndürmediğini unutmayın. geçersiz ).

Bir fonksiyondan bir değer elde etmek için basitçe eklemeniz gerektiğini anlayabilirsiniz. dönüş ardından geri dönmek istediğiniz numarayı girin.

Dediğimizde dönüş bu, işlevin her çağrıldığında bir değişkene uygulanabilecek bir yanıt veya yanıt döndürdüğü anlamına gelir.

Bu, Seri Monitöre gönderildiğinde, okuma, aracılığıyla Fahrenheit'e dönüştürülür. convertToF ().

float convertToF(float temperatureC) { return (temperatureC * 9.0 / 5.0) + 32.0 }

Bu işlev, Santigrat aralığını alır ve Fahrenheit'e dönüştürür.

Fahrenheit'i Celsius'a dönüştürmek için aşağıdaki formülü uyguluyoruz Fahrenheit = 9 / 5 (Santigrat) + 32.

5.3 Bir LCD'nin Arabirimi

Şimdi bir arayüz veya bağlantı kurmayı inceleyelim. LCD ekran Arduino ile gerekli çıktılar için görsel ekran elde edilir.

Uygulamamızda yatay olarak 84 piksel veya noktaya ve 48 piksel dikey çözünürlüğe sahip 84x48 grafik LCD kullanacağız. Özel bir kontrolör tüm LCD'ler için zorunlu hale geldiğinden, mevcut cihaz ayrıca PCD8544 kontrolör şeklinde bir kontrolör içerir.

Bu eğitimde, yukarıda belirtilen LCD modülünü Arduino ile bağlayacağız ve ekranda metin mesajları oluşturmak için belirli rutinler uygulayacağız.

Aşağıdaki şekilde, küçük bir LCD ekran ile birlikte LCD arayüzüne ilişkin ayrıntıları bulabilirsiniz. 3.3V voltaj regülatörü . Bu regülatör, LCD'nin 3,3V besleme ile çalışacağı belirtildiğinden gereklidir.

Ayrıca LCD modülünden 8 pin çıkışı görebilirsiniz, pin çıkışı özellikleri aşağıdaki tablodan incelenebilir:

Şimdi LCD'yi ve ilgili parametreleri Arduino'muz ile nasıl bağlayabileceğimizi görelim. Ayrıntılar, aşağıda gösterilen şekilde görselleştirilebilir:

5.4 LCD ile İletişim

Arduino'dan LCD ile etkileşim için ayrıntılı kodlar yazmak mümkün olsa da, kütüphaneleri kullanarak aynısını nasıl yapacağımızı öğrenmeyi tercih edeceğiz.

Kitaplıklar, seçilen bir Arduino programı için hızla uygulanabilen bir dizi kod içerir.

Bu, kullanıcının karmaşık kodlama işlerinden geçmesine gerek kalmadan bir işlevi zahmetsizce çağırmasını sağlar.

5.4.1 Kitaplık Nasıl Kurulur

Bunun için bilgisayarınızda Arduino IDE adlı kitaplıklar adlı bir dizin oluşturmanız gerekecektir. İşte

5.4.2 LCD İşlemlerinin Uygulanması

“güneş paneli ocak nasıl yapılır ”

Önceki yaklaşımımız gibi, önce tüm kodu kontrol edeceğiz ve sonra tek tek satırların ayrıntılarını anlamaya çalışacağız.

#include const int kPin_CLK = 5 const int kPin_DIN = 6 const int kPin_DC = 7 const int kPin_RESET = 8 PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET) void setup() { lcd.init() lcd.setCursor(0,0) lcd.print('Hello, World!') } void loop() { lcd.setCursor(0,1) lcd.print(millis()) }

Satır, #include kodunu içerir

#İnclude kodu, PC'ye belirtilen dosyayı alması ve programın derlenmesi sırasında #include öğesini dosya içeriğiyle değiştirmesi talimatını verir.

#İnclude öğesi, kütüphane dizininde aramayı gösteren açılı parantezlere sahip olabilir, alternatif olarak, programın bulunduğu aynı dizin içinde aramayı gösteren tırnaklara da sahip olabilir.

Sonraki kod satırları LCD pin çıkışlarını ifade eder ve sonra yeni bir değişken formu yazarız:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Burada, lcd adında PCD8544 tipine sahip bir değişkeni ifade ediyoruz ve PC'ye Arduino ile ilişkili pin çıkışlarını yeniden düzenleme talimatı veriyoruz.

Bu süreçte, pin clk, din, dc ve reset işlemlerinin Arduino ile nasıl arayüzlendiğini anlatarak değişkeni bilgisayara açıklıyoruz.

void setup() { lcd.init() lcd.setCursor(0,0) lcd.print('Hello, World!') }

lcd.init() LCD işlemini başlatır. Bu yürütüldüğünde, sonraki satır ekranın sol üst köşesine bir imleci zorlar. Ve sonraki satır, 'Merhaba Dünya' mesajını basmak için çaba gösteriyor.

Bu, seri monitör üzerinden mesaj gönderdiğimiz teknikle oldukça benzer görünüyor. Tek fark, lcd.print kodunun kullanılmasıdır. serial.print yerine.

Bir sonraki kod bloğu aslında tekrar tekrar adlandırılır.

void loop() { lcd.setCursor(0,1) lcd.print(millis()) }

Bu satırı kullanarak lcd.setCursor(0,1) imleci LCD ekranın üzerinde 1. satırın en solundaki 0. sütuna sabitliyoruz.

Sonraki satır bir kısayol kullanır: lcd.print(millis())

Hatırlarsanız millis() ile çalıştık. önceki kodlarımızda, aynı şeyi burada da kodlar aracılığıyla uygulayabilirdik:

long numMillis = millis() lcd.print(numMillis)

Bununla birlikte, burada milisaniye cinsinden hiçbir zaman periyodu bulunmadığından, bunu sadece millis() göndererek gerçekleştiriyoruz. işlev doğrudan lcd.print() .

5.5 Tüm Şeyi Birleştirmek

Tamam, şimdi LCD sıcaklık devresini yapmak için yukarıda öğrendiğimiz tüm kodları birleştirelim ve nasıl göründüğüne bakalım:

#include const int kPin_CLK = 5 const int kPin_DIN = 6 const int kPin_DC = 7 const int kPin_RESET = 8 const int kPin_Temp = A0 PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET) void setup() { lcd.init() lcd.setCursor(10,0) lcd.print('Temperature:') } void loop() { float temperatureC = getTemperatureC() // now convert to Fahrenheit float temperatureF = convertToF(temperatureC) lcd.setCursor(21,1) lcd.print(temperatureC) lcd.print(' C') lcd.setCursor(21,2) lcd.print(temperatureF) lcd.print(' F') delay(100) } float getTemperatureC() { int reading = analogRead(kPin_Temp) float voltage = (reading * 5.0) / 1024 // convert from 10 mv per degree with 500mV offset // to degrees ((voltage - 500mV) * 100) return (voltage - 0.5) * 100 } float convertToF(float temperatureC) { return (temperatureC * 9.0 / 5.0) + 32.0 }

Yukarıdaki programda, işlevin kullanımı dışında her şey standart görünüyor setCursor () . Bu, metni ekranın ortasına mümkün olduğunca hizalamak için kullanılır.

Harika! Ve tebrikler, Arduino'yu kullanarak kendi küçük LCD sıcaklık göstergenizi programladınız.

Pratik Arduino Uygulamaları

Bu noktada, çeşitli programlama tekniklerini ayrıntılı olarak kapsamlı bir şekilde ele aldığımız için, bunları birkaç yararlı pratik uygulama için uygulayarak bunları öğrenmenin zamanı geldi.

Sensörlerle başlayacağız ve birkaç örnek kod yürüterek sensör cihazlarının Arduino ile nasıl kullanılabileceğini göreceğiz.

7.1 Sensörlere Giriş

Bu eğitimde Arduino ile kullanılabilecek çok çeşitli sensörler hakkında bilgi edineceğiz. Bunlar, ışık sensörü LDR, manyetik salon etkisi sensörü, eğim sensörleri, titreşim sensörü, basınç sensörü vb.Gibi cihazları içerebilir.

Arayüzle başlayacağız ışık sensörü LDR Arduino ile aşağıdaki diyagramda gösterildiği gibi:

Hepimizin bildiği gibi, LDR, direnci ortam olayının yüzeyindeki yoğunluğuna bağlı olan ışığa bağlı bir direnç cihazıdır.

Işığın yoğunluğu, LDR'nin direnç okuması ile ters orantılıdır.

Burada yararlı bir uygulamayı yürütmek için bu özelliğin Arduino ile nasıl entegre edilebileceğini öğreneceğiz:

Tam program kodu aşağıda verildiği gibi görselleştirilebilir:

const int kPin_Photocell = A0 void setup() { Serial.begin(9600) } void loop() { int value = analogRead(kPin_Photocell) Serial.print('Analog Reading = ') Serial.print(value) if(value <200){ Serial.println(' - Dark') }else if(value <400){ Serial.println(' - Dim') } else if(value <600){ Serial.println(' - Light') } else if(value <800){ Serial.println(' - Bright') } else{ Serial.println(' - Very Bright') } delay(1000) }

Kodda kullanılan tüm parametreler şimdiye kadar öğrendiğimiz kursumuzda zaten tartışılmıştır. Hatları ilgili bölümlere bakarak kontrol edebilirsiniz.

Değerler rastgele seçildi, kendi tercihlerinize göre kolayca değiştirebilirsiniz.

Eğim Sensörü

Eğim sensörü, kurulduğu herhangi bir nesne üzerindeki eğim hareketini algılamak için kullanılabilen basit bir cihazdır. Cihazın içinde temel olarak metalik bir top bulunur ve bu, bir çift kontak üzerinde eğildiğinde bu kontaklar arasında bir iletime neden olur. Eğim anahtarının uçları olarak sonlandırılan bu kontaklar, bir eğim hareketi nedeniyle iletimi algılamak ve istenen çıkış uygulamasını etkinleştirmek için harici bir devre ile kullanılır.

Şimdi nasıl olduğunu görelim eğim sensörü cihaz bağlanabilir. Aşağıdaki resim bize tam konfigürasyonla ilgili bir fikir verir:

const int kPin_Tilt = 3 const int kPin_LED = 13 void setup() { pinMode(kPin_Tilt, INPUT) digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor pinMode(kPin_LED, OUTPUT) } void loop() { if(digitalRead(kPin_Tilt) == HIGH){ digitalWrite(kPin_LED, LOW) } else{ digitalWrite(kPin_LED, HIGH) } }

Bu örnekte varsayılan pin # 13 LED eğim göstergesi olarak kullanılmıştır.

Bölüm 3.1'de yaptığımıza oldukça benzer şekilde, kaldırma direncinin dahil edildiğini burada açıkça görebilirsiniz. Bu nedenle DÜŞÜK terimi, eğme işlevinin tetiklenmediğini gösterir.

7.4 Manyetik Anahtar Rölesi (Minyatür Mıknatıs Aktifleştirilmiş Röle)

Şimdi Arduino ile bir röle anahtarını veya manyetik alan sensörünü nasıl bağlayacağımızı görelim. Reed rölesi, yanına bir manyetik alan veya bir mıknatıs getirildiğinde harekete geçen veya ileten bir tür anahtardır. Temel olarak, minyatür bir cam muhafaza içinde, bir manyetik ona yakın olduğunda manyetik çekme nedeniyle birleşen veya temas eden bir çift ferromanyetik kontağa sahiptir. Bu olduğunda, kontakların terminalleri, kontakların kapanması nedeniyle iletim gösterir.

Burada da yanıtı göstermek için pin # 13 LED'i kullanıyoruz. Daha önceki açıklamalarımıza göre gerekirse bu pinden harici bir LED bağlayabilirsiniz.

const int kPinReedSwitch = 2 const int kPinLed = 13 void setup() pinMode(kPinReedSwitch, INPUT) digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor pinMode(kPinLed, OUTPUT) } void loop() { if(digitalRead(kPinReedSwitch) == LOW){ digitalWrite(kPinLed, HIGH) } else{ digitalWrite(kPinLed, LOW) } }

Kod terimleri aşina ve kendini açıklayıcı olmalıdır.

7.5 Piezo Dönüştürücü kullanan titreşim sensörü

Bir sonraki örnek programda, piezo dönüştürücü Arduino üzerinden bir LED'i aydınlatmak için titreşim sensörü olarak kullanılabilir.

Bir piezo elemanı aslında, terminallerine bir frekans uygulandığında titreşim veya salınım üreten bir cihazdır. Ancak aynı piezo, ters işlemde de kullanılabilir. elektrik darbeleri üretmek vücuduna uygulanan titreşime tepki olarak. Bu titreşim, piezo yüzeyine vurma veya çarpma şeklinde olabilir.

Aşağıdaki şekilde gösterildiği gibi Arduino ve bir piezo elemanını kurun

const int kPinSensor = A5 const int kPinLed = 13 const int k_threshold = 100 int ledState = LOW // variable used to store the last LED status, to toggle the light void setup() { pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT } void loop() { int val = analogRead(kPinSensor) if (val >= k_threshold) { ledState = !ledState // toggle the value of ledState digitalWrite(kPinLed, ledState) delay(20) // for debouncing } }

Eşik 100, Arduino'nun yalnızca gerçek titreşimlere vuruntular yoluyla yanıt verdiğinden ve yüksek sesler veya kornalar gibi diğer daha küçük titreşimlere yanıt vermediğinden emin olmak için tanıtılmıştır.

A5 pin seçimi zorunlu değildir, tercihinize göre ve program kodunda eşleştirerek diğer analog girişleri seçebilirsiniz.

Arduino ile Servo Motor Kullanımı

Servo motor, belirli bir uygulamanın talebine göre hassas açılara döndürülebilen bir DC motor türüdür. Motor üzerinde 180 derece aralığında doğru bir dönüş veya dönüş açısı üretmek için motorun ilgili girişlerine hesaplanan bir komut uygulanarak yapılabilir.

Tipik olarak bir servo motorun 3 kablosu veya girişi vardır. Pozitif kablolar normalde kırmızı renktedir, negatif veya topraklama kablosu siyahtır ve komut kablosu veya sinyal kablosu normalde beyaz veya sarı renktedir.

Arduino, servo motorlar için kontrolü çok uygun ve ideal hale getiren dahili destek dili aracılığıyla servo motor kontrolünü kolaylaştırır.

Aşağıdaki örnek bize Arduino aracılığıyla servo motor kontrolünü uygulamak için temel kurulum programını gösterecektir:

Kod aşağıda verilmiştir:

#include Servo servo1 const int kPinPot = A0 const int kPinServo1 = 9 void setup() { servo1.attach(kPinServo1) } void loop() { int val = analogRead(kPinPot) val = map(val, 0, 1023, 0, 180) servo1.write(val) delay(15) }

Burada birkaç yeni giriş görebiliriz. Servo'nun takılı teline hangi pime atandığını söyleyen. Diğeri ise, servo üzerindeki dönme açısını belirlemek için pime 0 ile 180 arasında bir değer sağlayan koddur.

Sonuç

Arduino konusu sonsuz uzunlukta olabilir ve bu nedenle bu makalenin kapsamı dışında olabilir. Bununla birlikte, umarım yukarıdaki eğitim, Arduino'nun temellerini öğrenmenize ve çeşitli örnek uygulama kodları aracılığıyla önemli parametreleri anlamanıza kesinlikle yardımcı olmuş olmalıdır.

Umarım burada zaman zaman daha fazla bilgi güncellenebilir.

Bu arada programlama kursunuzun keyfini çıkarın, Size Mutlu Arduino!

Önceki: MQ-3 Sensör Modülünü kullanan Alkol Dedektörü Ölçer Devresi Sonraki: Cep Telefonu Kontrollü Köpek Besleyici Devresi