Arduino döngüleri. Arduino'da FOR ve WHILE Döngüleri Arduino'da İç İçe Döngüler

• while(koşul) ()

• do () while(koşul);

• for(sayı değişkeni; koşul; sayım değişkenini artır) ()

Her programlama dili, aynı kodun (döngü) birden fazla yürütülmesini, uygun kod parçasının (koşulların) seçilmesini ve mevcut kod parçasından çıkmak için yönergeleri sağlayan bir dizi kontrol yönergesine sahiptir.

Arduino IDE, gerekli kontrollerin çoğunu C/C++'dan ödünç almıştır. Sözdizimleri C ile aynıdır. Aşağıda sözdizimlerini kısaca açıklıyoruz.

if ifadesi

if ifadesi, belirli bir koşulu kontrol etmenin sonucuna bağlı olarak belirli bir program parçasını yürütmenize izin verir. Koşul sağlanırsa program kodu yürütülür, koşul sağlanmazsa program kodu atlanır. if komutunun sözdizimi aşağıdaki gibidir:

If(koşul) ( ifade1; ifade2; )

Koşul, bir işlev tarafından döndürülen bir değişkenin veya değerin herhangi bir karşılaştırması olabilir. if koşulunun ana kriteri, cevabın her zaman doğru (doğru) veya yanlış (yanlış) olması gerektiğidir. Bir if ifadesi için koşul örnekleri:

Eğer(a!=2) ( ) eğer(x<10) { } if(znak==’B’) { }

Koşulun içine yazılan parantezlerin içinde kodu çalıştırabilirsiniz.

Programlamayı öğrenmeye başlayan kişiler, genellikle belirli bir değişkenin değerini tek bir "=" işaretiyle eşitleme hatasına düşerler. Böyle bir kayıt, bir değişkene bir değer atandığını açık bir şekilde gösterir ve bu nedenle koşul her zaman "doğru" olacaktır, yani yerine getirilecektir. Bir değişkenin belirli bir değere eşit olup olmadığını kontrol etmek her zaman çift eşittir işaretiyle (==) gösterilir.

Bir fonksiyonun durumunu koşul olarak kullanabilirsiniz, örneğin:

If(init()) ( Serial.print("ok"); )

Yukarıdaki örnek şu şekilde yürütülür: ilk adım init() işlevini çağırmaktır. Bu işlev, "doğru" veya "yanlış" olarak yorumlanacak bir değer döndürür. Karşılaştırma sonucuna göre "tamam" yazısı gönderilecek veya hiçbir şey gönderilmeyecektir.

if...else ifadesi

Genişletilmiş if ifadesi, if….else ifadesidir. Koşul doğru olduğunda (doğru) bir kod parçasının, koşul doğru olmadığında (yanlış) ikinci kod parçasının yürütülmesini sağlar. if….else ifadesinin sözdizimi aşağıdaki gibidir:

If (koşul) ( // komut A ) else ( // komut B )

"A" komutları yalnızca koşul sağlandığında, "B" komutu koşul sağlanmadığında yürütülür. "A" ve "B" komutunun aynı anda yürütülmesi mümkün değildir. Aşağıdaki örnek, if...else sözdiziminin nasıl kullanılacağını gösterir:

If (init()) ( Serial.print("ok"); ) else ( Serial.print("error"); )

Bu şekilde, işlevin doğru yürütülmesini kontrol edebilir ve kullanıcıyı bu konuda bilgilendirebilirsiniz.

Olağan uygulama, koşulu reddetmektir. Bunun nedeni, doğru çalışan bir işlevin 0 döndürmesi, herhangi bir nedenle başarısız olan bir işlevin sıfırdan farklı bir değer döndürmesidir.

Bu “hayatın karmaşıklığının” açıklaması basittir. İşlev doğru yürütülürse, ihtiyacımız olan tek bilgi budur. Bir hata durumunda, bazen neyin yanlış gittiğini, işlevin neden doğru yürütülmediğini anlamaya değer. Ve burada sıfırdan farklı sayılar kurtarmaya geliyor yani dijital kodlar yardımıyla hatanın türünü belirleyebiliyoruz. Örneğin, 1 - bazı değerleri okumada sorun, 2 - bellekte veya diskte yer yok, vb.

Son değiştirilen örnek, doğru yürütüldüğünde sıfır döndüren bir işlevin nasıl çağrılacağını gösterir:

If (!init()) ( Serial.print("ok"); ) else ( Serial.print("error"); )

büyük/küçük harf değiştirme bildirimi

if ifadesi, yalnızca bir koşulu kontrol etmenizi sağlar. Bazen döndürülen veya okunan değere bağlı olarak işlemlerden birini gerçekleştirmek gerekir. Çoktan seçmeli geçiş ifadesi bunun için idealdir. Switch komutunun sözdizimi aşağıda gösterilmiştir:

Switch (var) ( durum 1: // komut var=1 için kesme; durum 2: // var=2 için komut kesme; varsayılan: // komut varsayılan olarak (var 1 ve 2'den farklıysa) )

Var değişkeninin değerine bağlı olarak, komutlar belirli bloklarda yürütülür. Durum etiketi, belirtilen değer için bloğun başlangıcı anlamına gelir. Örneğin, durum 1: verilen bloğun var değişkeninin bire eşit değeri için yürütüleceği anlamına gelir.

Her blok break komutu ile sonlandırılmalıdır. Switch ifadesinin daha fazla yürütülmesini kesintiye uğratır. Break komutu atlanırsa, komutlar break komutuna kadar sonraki bloklarda yürütülür. Varsayılan etiket, if ifadesindeki else gibi isteğe bağlıdır. Varsayılan bloktaki talimatlar yalnızca var değişkeninin değeri herhangi bir modelle eşleşmediğinde yürütülür.

Çoğu zaman, birkaç değerden biri için aynı talimatların yürütülmesi gerekir. Bu şu şekilde elde edilebilir:

Anahtar (x) ( durum 1: // x=1 için ifade; durum 2: durum 3: durum 5: // x=2 veya 3 veya 4 için ifade; durum 4: // x=4 için ifade ; durum 6: // x=6 kesme komutu; varsayılan: // varsayılan komut (x, 1,2,3,4,5,6'dan farklıysa) )

x değişkeninin değerine bağlı olarak, karşılık gelen komut bloğu yürütülür. Durum 2: durum 3: durum 5:'in tekrarı, derleyiciye x değişkeninin 2 veya 3 veya 5 değerine sahip olması durumunda aynı kod parçasının yürütüleceğini bildirir.

açıklama için

For ifadesi, aynı kodu tekrar tekrar çalıştırmak için kullanılır. Çoğu zaman, yalnızca bazı değişkenlerin değerini değiştirerek aynı talimatları uygulamak gerekir. For döngüsü bunun için mükemmeldir. Komut sözdizimi aşağıdaki gibidir:

int ben; için(i=0;i<10;i++) { // инструкции для выполнения в цикле }

for ifadesinde verilen ilk parametre, değişkenin başlangıç ​​değeridir. Başka bir öğe, döngünün yürütülmesine devam etme koşulunu kontrol etmektir. Koşul sağlandığı sürece döngü yürütülür. Son öğe, değişkenin değerindeki değişikliktir. Çoğu zaman, değerini (gerektiği gibi) artırır veya azaltırız. Bu örnekte, döngüde yer alan komutlar i=0…9'da yürütülecektir.

Genellikle bir döngüde kullanılan bir değişken aynı yerde bildirilir:

For(int i=0;i<10;i++) { // инструкции для выполнения в цикле }

Sonraki döngü adımlarını saymak için kullanılan bir değişken, içinde uygun parametrelerle bir işlevi çağırmak için kullanılabilir.

For(int i=10;i>0;i—) ( Serial.print(i); // 10,9,8,7,6,5,4,3,2,1 sayıları gönderilecektir)

while ifadesi

For döngüsü saymayı yapmak istediğimiz yer için mükemmeldir. Öngörülemeyen bazı olayların sonucu olarak belirli eylemleri gerçekleştirmenin gerekli olduğu bir durumda (örneğin, bir düğmeye basılmasını bekliyoruz), o zaman ifade bloğunu yürüten while ifadesini kullanabiliriz. koşul sağlandığı sürece. While ifadesinin sözdizimi aşağıdaki gibidir:

While(koşul) ( // yürütülecek deyim bloğu )

Durum kontrolünün döngünün başında gerçekleşmesi önemlidir. While döngüsü içindeki ifadeler hiçbir zaman yürütülmeyebilir. Sonsuz bir döngü oluşturmak da mümkündür. İki örnek görelim:

intx=2; while(x>5) ( Serial.print(x); ) —————————————- int y=5; while(y>0) ( Serial.print(y); )

While içindeki ilk ifade bloğu hiçbir zaman çalıştırılmayacaktır. x değişkeninin değeri ikidir ve 5'ten büyük olmayacaktır. İkinci örnekte sonsuz bir döngü ile uğraşıyoruz. "y" değişkeninin değeri 5'tir, yani sıfırdan büyüktür. Döngünün içinde 'y' değişkeninde bir değişiklik olmadığı için döngü hiç bitmeyecek.

Döngünün sona ermesine neden olan parametreyi değiştirmeyi unuttuğumuz zaman bu yaygın bir hatadır. Aşağıda, bir while döngüsü kullanmanın iki geçerli örneği verilmiştir:

intx=0; iken(x<10) { //блок инструкций x++; } —————————————- while(true) { if(условие) break; // блок инструкций }

İlk örnekte koşulda kontrol edilen değişkenin değerini değiştirmeyi hallettik. Sonuç olarak, döngü sonunda sona erecektir. İkinci örnekte, kasıtlı olarak sonsuz bir döngü oluşturulmuştur. Bu döngü, Arduino IDE'deki loop() işlevine eşdeğerdir. Ek olarak, döngü içinde bir durum kontrolü başlatılır, ardından döngü break komutuyla sona erer.

do...while deyimi

While döngüsünün bir varyasyonu do...while döngüsüdür. Sözdizimine ek olarak, koşulun kontrol edildiği yerde farklılık gösterir. do...while durumunda, ifade bloğu yürütüldükten sonra koşul kontrol edilir. Bu, döngü gövdesindeki ifade bloğunun en az bir kez yürütüleceği anlamına gelir. do...while komutunun sözdizimi aşağıdadır:

Do ( // ifade bloğu ) while(koşul)

while deyimi hakkında yazılan her şey do...while için de geçerlidir. Aşağıda do...while döngüsünün kullanımına bir örnek verilmiştir:

intx=10; do ( // komut bloğu x—; ) while(x>0); —————————————- do ( // komut bloğu if(koşul) break; ) while(true);

ifadeyi kırmak

Break ifadesi, döngüden çıkmanıza (do...while, for, while) ve switch seçeneğinden çıkmanıza olanak tanır. Aşağıdaki örnekte, break komutunun yürütülmesini düşünün:

için(i=0;i<10;i++) { if(i==5) break; Serial.print(i); }

Döngü, 0'dan 9'a kadar olan sayılar için yürütülmelidir, ancak 5 sayısı için, break deyimini tetikleyen koşul karşılanır. Bu döngüden çıkacaktır. Sonuç olarak, seri bağlantı noktasına (Serial.print) yalnızca 0,1,2,3,4 sayıları gönderilecektir.

ifadeye devam et

Devam operatörü, döngü komutlarının (do...while, for, while) mevcut değer için yürütmeyi durdurmasına ve döngünün bir sonraki adımına geçmesine neden olur. Aşağıdaki örnek, devam deyiminin nasıl çalıştığını gösterir:

için(i=0;i<10;i++) { if(i==5) continue; Serial.print(i); }

Gördüğünüz gibi, döngü 0 ile 9 arasında bir değer için yürütülecektir. 5 değeri için, devam komutu yürütülecek ve bunun sonucunda bu komuttan sonraki komutlar yürütülmeyecektir. Sonuç olarak seri porta (Serial.print) 0,1,2,3,4,6,7,8,9 numaraları gönderilecektir.

iade beyanı

Return ifadesi, çağrılan işlevin yürütülmesini sonlandırır ve belirli bir türde bir değer döndürür. Bir komut parametresi olarak, belirli bir türde bir sayı, karakter veya değişken belirtebilirsiniz. Dönen değerin, bildirilen işlevin türüyle eşleşmesi önemlidir. Aşağıdaki örnek, dönüş ifadesinin nasıl kullanılacağını gösterir:

Int checkSensor()( if (analogRead(0) > 400) ( // analog girişi okuyarak 1 döndürür; // 400'den büyük değerler için 1 döndürülür, aksi takdirde( 0 döndürür; // diğerleri için 0 döndürülür) )

Gördüğünüz gibi, tek bir işlevde birden çok dönüş ifadesi kullanabilirsiniz, ancak bunlardan yalnızca biri her zaman çalışır. Dönüş ifadesinin parametresiz olarak kullanılmasına izin verilir. Bu, herhangi bir değer döndürmeyen bir işlevi zamanından önce sonlandırmanıza olanak tanır.

Geçersiz işlev_adı() ( ifade1; if(x==0) dönüş; ifade2; ifade3; )

Yukarıdaki örnekte, fonksiyon her çağrıldığında deyim1 çalışacaktır. Talimat2 ve talimat3'ün yürütülmesi, if komutunun sonucuna bağlıdır. Koşul karşılanırsa (doğru), dönüş komutu yürütülecek ve işlevden çıkılacaktır.

Koşulun sağlanmaması durumunda, dönüş komutu da yürütülmez, ancak talimat2 ve talimat3 komutları yürütülür ve bundan sonra fonksiyon işini bitirir.

ifadeye git

İdeolojik nedenlerle bu açıklama atlanmalıdır... Goto deyimi normal programlamada kullanılmaması gereken bir komuttur. Kod karmaşıklığına neden olur ve kötü bir programlama alışkanlığıdır. Bu komutu programlarınızda kullanmamanızı şiddetle tavsiye ederiz. arduino.cc sitesindeki resmi dökümantasyonda goto olduğu için kısaca anlatacağız. Goto komutunun sözdizimi şöyledir:

…. etikete git; // 'metka' etiketli satıra atla ….. …. …. metka: // programın çalışmaya devam edeceği etiket...

Komut, belirlenen etikete, yani programdaki konuma atlamayı sağlar.

İfadeleri kullanan döngüler için Ve sırasında Arduino'nun altında yatan C++ dilinin en önemli yapılarından biridir. Bilmeseniz bile kesinlikle her eskizde görünürler. Bu yazıda döngülere daha yakından bakacağız, for ve while arasındaki farkın ne olduğunu, bunların yardımıyla program yazmayı nasıl basitleştirebileceğinizi ve hangi hatalardan kaçınılması gerektiğini öğreneceğiz.

Hâlâ acemi bir programcıysanız ve bir döngünün ne olduğunu ve neden gerekli olduğunu anlamak istiyorsanız, ayrıntılı bir açıklama ile bu makalenin sonraki bölümüne bakın.

WHILE operatörü, C++ ve Arduino'da aynı komutları rasgele sayıda tekrarlamak için kullanılır. FOR ile karşılaştırıldığında, WHILE döngüsü daha basit görünür, genellikle bir değişkendeki yineleme sayısını saymamıza gerek olmadığı, ancak bir şeyler değişene, bir olay meydana gelene kadar kodu tekrarlamamız gereken yerlerde kullanılır.

sözdizimi WHILE

sırasında(<условие или список условий>)
{
<программный блок, который будет повторяться>
}

Boole değeri döndüren herhangi bir dil yapısı koşul olarak kullanılabilir. Koşullar karşılaştırma işlemleri, fonksiyonlar, sabitler, değişkenler olabilir. Arduino'daki diğer tüm mantıksal işlemlerde olduğu gibi, sıfır dışındaki herhangi bir değer doğru (doğru), sıfır - yanlış (yanlış) olarak algılanacaktır.

// Sonsuz döngü while(true)( Serial.println("Waiting…"); ) // checkSignal() işlevinin değeri değişene kadar çalışan döngü while(!checkSignal())( Serial.println("Waiting… "); )

while ifadesinin blok çevresinde kaşlı ayraçlar olmadan kullanılabileceğini, bu durumda döngüden sonra karşılaşılan ilk komutun tekrarlanacağını unutmayın. Kıvrımlı ayraçlar olmadan kullanmak kesinlikle önerilmez, çünkü bu durumda hata yapmak çok kolaydır. Örnek:

While(true) Serial.print("Kesinti bekleniyor"); gecikme(1000);

Bu durumda, delay(1000) komutu tekrarlanmayacağından yazı duraklama olmaksızın sonsuz bir döngüde görüntülenecektir. Bu tür hataları tespit etmek için çok zaman harcayabilirsiniz - kaşlı ayraç kullanmak çok daha kolaydır.

While döngüsü kullanımına bir örnek

Çoğu zaman while, bir olayı beklemek için kullanılır. Örneğin, Serial nesnesinin çalışmaya hazır olup olmadığı.

Serial.begin(9600); while (!Serial) ( ; // Bazı Arduino kartlarında seri port boşalana kadar beklemeniz gerekir )

Bir karakterin UART aracılığıyla harici cihazlardan gelmesini beklemeye bir örnek:

While(Serial.available())( int byteInput = Seria.read(); // Başka bir şey yap )

Bu durumda, Serial.available() null olmayan bir değer döndürene kadar değerleri okuyor olacağız. Tampondaki tüm veriler biter bitmez döngü duracaktır.

Arduino'da FOR döngüsü

FOR döngüsünde, yalnızca sınır koşullarını belirleme değil, aynı zamanda sayaç için hemen bir değişken tanımlama, her yinelemede değerinin nasıl değişeceğini gösterme fırsatına sahibiz.

FOR döngüsü sözdizimi

Burada inşaat biraz daha karmaşık olacak:
için (<начальное значение счетчика>;<условие продолжения выполнения цикла>;<изменение значения счетчика на каждом шаге>){
<список_команд>
}

En basit örnek:

For(int i=5;i<10;i++){ // Конструкция «3 в одном» pinMode(i, OUTPUT); }

Hemen bir değişken oluşturduk, onu başlattık, her döngünün sonunda sayaç değerinin bir artırılması gerektiğini belirttik. İşte bu kadar - artık değişkeni döngü içinde kullanabilirsiniz.

Değişken adım farklı olabilir. İşte bazı örnekler:

• for(int i=0; ben<10; i=i+2) // Шаг 2
• for(int i=0; ben<10; i+=2) // Аналогичен предыдущему
• for(int i=10; i>0; i–) // Geri git - 10'dan 1'e

while döngüsü yapmak

Bazı durumlarda, döngüyü, bloğun talimatları en az bir kez yürütülecek ve ardından kontrol zaten gerçekleştirilecek şekilde düzenlememiz gerekir. Bu tür algoritmalar için do while yapısını kullanabilirsiniz. Örnek:

Do ( Serial.println("Working"); ) while (checkSomething());

Döngünün bu sürümünde herhangi bir zorluk yoktur - bloğu koşulları aşağı kaydırdık, böylece do ifadesinden sonraki kaşlı parantez içindeki her şey ilk kontrolden önce yürütülür.

ifadeleri devam ettir ve kes

Koşul kontrol bloğuna atlamayı beklemeden, döngü bloğu içindeki döngünün yürütülmesini acilen kesmeniz gereken durumlar vardır. Bunu yapmak için operatörü kullanabilirsiniz. kırmak:

While (true) ( ​​​​if (checkSomething()) ( break; ) )

Sadece mevcut yinelemenin ilerlemesini durdurmak istiyorsak, ancak döngüden çıkmak istemiyorsak, ancak koşul kontrol bloğuna gitmek istiyorsak, o zaman operatörü kullanmalıyız. devam etmek:

while (true) ( ​​if (checkSomething()) ( devam; ) )

Continue ve break deyimleri tüm FOR ve WHILE döngülerinde kullanılabilir.

Arduino'da İç İçe Döngüler

Döngülerin herhangi bir varyantı, iç içe konstrüksiyonlar oluşturarak birbirleriyle kolayca birleştirilebilir. "Üstteki" döngü bloğunda tanımlanan değişkenler, iç döngüde mevcut olacaktır. Bu tür bir döngünün en yaygın örneği, iki boyutlu dizilerin geçişidir. Aşağıdaki örnekte, çift döngü kullanıyoruz: ilki, arr değişkeninde tanımladığımız dizinin satırları (i değişkeni), ikincisi iç içe, sütunları (j değişkeni) üzerinde yinelenecektir.

dahili dizi; geçersiz kurulum() ( (int i = 0; i için)< 10; i++) { for (int j = 0; j < 3; j++) { arr[i][j] = i * j; Serial.println(arr[i][j]); } } }

Döngüler hakkında daha fazla bilgi

Döngülerle hiç çalışmadıysanız, biraz teori dünyasına dalalım ve döngülerin ne olduğunu ve neden bu gizemli dil yapılarına ihtiyacımız olduğunu anlayalım.

Neden bir döngüye ihtiyacımız var?

Aslında, döngünün ana görevi aynı dil yapılarını birkaç kez tekrarlamaktır. Böyle bir ihtiyaç hemen hemen her programda ortaya çıkar ve kesinlikle tek bir Arduino taslağı döngü olmadan yapamaz - sonsuz döngüde döngü () işlevi de denir.

Aşağıdaki örneğe bakalım. Arduino kartına bağlı 5 led'e 5'ten 9'a kadar olan pinlerden aynı anda güç sağlamanız gerekir. Bunun için en belirgin seçenek, beş talimatı arka arkaya yerleştirmek olacaktır:

digitalWrite(5, YÜKSEK);

digitalWrite(6, YÜKSEK);

digitalWrite(7, YÜKSEK);

digitalWrite(8, YÜKSEK);

digitalWrite(9, YÜKSEK);

Şimdilik, böyle bir eylemin riskliliği sorusunu bir kenara bırakalım, çünkü bu kadar çok sayıda LED'in aynı anda açılması, kartın güç devresinde artan bir yük oluşturur. Şimdi bizim için asıl önemli olan, her biri diğerlerinden yalnızca bir basamak farklı olan beş satır kod oluşturmuş olmamızdır. Bu yaklaşımın aşağıdaki dezavantajları vardır:

• Herhangi bir değişiklik ile aynı anda birçok satırda değişiklik yapmanız gerekecektir. Örneğin, LED'leri 2 ila 6 pinlerine çevirmemiz veya açmamamız, ancak voltajı kapatmamız gerekirse, kodda 5 değişiklik yapmamız gerekecek. Ve daha fazla talimat ve değişiklik varsa?
• Aynı türde çok sayıda talimat içeren hantal kodun okunması zahmetli ve hoş değildir. Beş özdeş satır - çok korkutucu değil. Ancak kirli kod alışkanlığı, sonunda listede fazladan onlarca ve yüzlerce sayfaya yol açacak ve bu da sizi ve iş arkadaşlarınızı cesaretsizliğe sürükleyecektir.
• Neredeyse aynı talimatları "kopyala-yapıştır" sürecinde, örneğin pin sayısını değiştirmeyi unutmak gibi bir hata yapmak kolaydır: digitalWrite(5, HIGH); digitalWrite(5, YÜKSEK);
• Görüşmeciye böyle bir kod göstererek herhangi bir normal yazılım şirketindeki bir görüşmede kolayca başarısız olabilirsiniz.

Tüm bunlardan, aynı dizelerin tekrar tekrar kullanılmasından neredeyse her zaman kaçınılması ve döngülerle değiştirilmesi gerektiği sonucuna varabiliriz. Dahası, birçok durumda prensip olarak döngülerden vazgeçilemez, hiçbir şey onların yerini alamaz. Program çalışırken kod tekrar sayısını değiştiremezsiniz. Örneğin, her bir öğeyi işlemeniz gerekir. veri dizisi harici cihazlardan alınan Ne kadar veri olacağını, işlemin kaç kez tekrarlanacağını asla tahmin edemezsiniz ve bu nedenle makaleyi yazarken gerekli sayıda talimatı ekleyemezsiniz.

Döngülerin kurtarmaya geldiği yer burasıdır.

sözdizimi kuralları

Arduino'da Döngü- Bu, programın yürütülmesi sırasında belirli sayıda çağrılacak özel bir program bloğudur. Bu blok içinde, çağrılacak komutları ve denetleyicinin kaç kez çağrılmaları gerektiğini belirleyeceği kuralları açıklıyoruz.

Yukarıdaki örneğimizde, denetleyiciye şunları söyleyebiliriz:

Komutu tekrarla digitalWrite 5 kez

Programcı robotların olduğu ideal bir dünyada, bu muhtemelen yeterli olacaktır, ancak bir bilgisayarla C ++ ile konuştuğumuz için, bu ifadeyi bu dile çevirmemiz gerekiyor:

Komutu tekrarla - denetleyiciye while veya for döngüleriyle başlamak üzere ilginç bir şey olduğunu söyleyen özel yönergeler kullanmanız gerekir

dijital Yazma - olduğu gibi bırakın, ancak bir kez yazın ve süslü parantez içine alın. Pin numaralarıyla nasıl başa çıkılır - hemen aşağıda.

5 kere - bunun için her tekrarda artacak bir sayaç kullanın. Bloğun başında (veya sonunda), bir karşılaştırma işlemi kullanarak bu sayacın değerini sınır değerle (bu durumda 5) karşılaştırabilirsiniz.

Bir while ifadesiyle böyle bir "çevrilmiş" döngü komutu örneğine bakalım:

int sayacı = 0; // Sayacın değerini saklayacak değişken // İşlemciden yapıyı parantez içindeki koşul doğru olana kadar küme parantezleri içinde tekrarlamasını istiyoruz. // Bizim durumumuzda sayaç bizim sayacımız, 5 sınır değer, koşul ise sayaç değerinin 5'ten küçük olmasıdır. // Ancak (sayaç) yaparken tamamen farklı mantıksal operatörler belirtebiliriz< 5) { digitaWrite(5, HIGH); // Будем включать светодиод counter++; // Увеличиваем значение счетчика } // Дойдя до сюда, исполняющий процессор переместится в начало блока и опять займется проверкой условий. Если условия вернут истину, команды в блоке между { и } выполнятся еще раз. Если условие не выполнится - процессор переместится к концу блока и пойдет дальше. Этот цикл больше его не заинтересует.

Yukarıdaki kodda bir hata fark edenler için beş koyup farklı bir şekilde döngü bloğunu yazıyoruz:

iken (sayaç< 5) { // Вот теперь мы будем включать разные светодиоды, с 5 (0+5) по 9 (4+5) digitalWrite(counter + 5, HIGH); counter++; }

Aynı sonuç bir FOR döngüsü kullanılarak da elde edilebilir:

For(int sayaç =0; sayaç<5; counter ++){ digitalWrite(counter+5, HIGH); }

Gördüğünüz gibi, bu durumda, sayaçla gerekli tüm işlemleri hemen tek bir FOR komutuna koyduk - gerekli sayıyı saymanız gerekiyorsa bu çok daha uygundur.

Döngülerin kullanım kuralları hakkında detaylı bilgiye bu yazının ilgili bölümlerinden ulaşabilirsiniz.

Çözüm

Bu yazıda, çok önemli Arduino dil yapılarına baktık: FOR ve WHILE döngüleri. Bu işleçleri hemen hemen her türlü karmaşık taslakta karşılayabileceksiniz, çünkü döngüler olmadan birçok veri işlemi imkansız olurdu. Döngülerin sözdiziminde karmaşık hiçbir şey yoktur - bunlara kolayca alışabilir ve projelerinizde aktif olarak kullanabilirsiniz.

Arduino IDE'de for, while ve do while döngülerinin nasıl çalıştığına, eskizlerde döngülerin nasıl doğru şekilde kullanılacağına ve hangi hatalardan kaçınılacağına bir göz atalım. Basit örnekler kullanarak, döngüyü nasıl durdurabileceğinizi veya bir döngüden diğerine nasıl geçebileceğinizi göstereceğiz. Yazma döngülerinin doğruluğunu anlamak için öncelikle robotikteki algoritma türlerini ve özelliklerini incelemelisiniz.

Arduino IDE'de döngüler nasıl çalışır?

C++ ve Arduino programlama dilindeki herhangi bir döngü, birçok veya sonsuz sayıda tekrar eden bir eylemdir. Arduino mikrodenetleyicisi için tek bir program döngü olmadan yapamaz, örneğin sonsuz döngüde boşluk döngüsü denir. Üç tür döngü operatörü vardır: for, while ve do while - her bir operatör üzerinde duralım, örneklerle nasıl çalıştıklarını düşünelim.

Nasıl ve çalışma sırasında aşağıdaki basit örneklerle açıklanabilir. For döngüsü sınırlı sayıda yürütülür (operatör koşulunda belirtilir), örneğin program LED'in birkaç kez yanıp sönmesini gerektirdiğinde kullanılır. While döngüsü süresiz olarak yürütülebilir, örneğin Arduino üzerindeki LED sensörden gelen veriler değişene kadar yanıp söner.

Arduino'daki for döngüsünün bir örnekle açıklaması

Arduino'daki for yapısı şu şekilde tanımlanır:

For döngüsü, küme parantezleri içindeki belirli komutları tekrarlamak için kullanılır. Bu döngü, tekrarlayan eylemleri gerçekleştirmek için uygundur.
-de başlatma bir değişken oluşturulur ve bir başlangıç ​​değeri atanır.
İÇİNDE durum döngünün yürütüleceği değişkenin değeri yazılır.
İÇİNDE değiştirmek değişkenin döngünün her adımında nasıl değişeceğini belirtir.

Örnek çizimde başlangıç ​​değeri olan bir değişken var ben=0, koşul, değişken beşe eşit veya beşten büyük olana kadar döngünün yürütüleceğini belirtir. Ben<=5 . Değişiklik, döngünün her adımındaki değişkenin bir artırılacağını belirtir. Son olarak, değişken beşe eşit olduğunda for döngüsünden çıkılır, böylece döngü sona ermeden önce LED beş kez yanıp söner.

Değişken adım (değişim) herhangi bir şey olabilir. Değişkeni aynı anda iki birim artırmak gerekirse sayaç değişikliği aşağıdaki gibi yazılmalıdır: ben=i+2. For döngüsü, geçersiz kurulum prosedürü içinde, örneğin aynı anda birkaç pin için çalışma modunu belirlemek için kullanılabilir. Ve ayrıca geçersiz döngü prosedüründe, örneğin Arduino'daki LED'leri seri olarak açma programında.

Arduino'nun while döngüsünün bir örnekle açıklaması

Arduino'daki while yapısı şu şekilde tanımlanır:

Parantez içindeki koşul doğru olduğu sürece while döngüsü sürekli ve süresiz olarak çalışır. While koşulundaki değişken değiştiğinde döngüden çıkışa ulaşılacaktır, bu nedenle bir şeyin değerini değiştirmesi gerekir. Döngü içindeki program kodunda veya herhangi bir sensörden, örneğin bir ultrasonik telemetre HC-SR04'ten değerler okunurken değişken bir değişiklik meydana gelebilir.

while fonksiyonu kullanılırken, değişken döngü başlamadan önce yaratılmalıdır. Örnek çizimde, döngü sona ermeden önce LED beş kez yanıp sönecektir. Süslü parantez içindeki değişkeni değiştirmezseniz ben++, ardından döngü süresiz olarak tekrar eder. Arduino Uno'nun while döngüsünden çıkmanın ikinci yolu, sensörden gelen verileri okumak ve değişkeni değiştirmek için bir if ifadesi kullanmaktır.

Arduino IDE'de kullanılabilen bir diğer döngü de sonkoşul döngüsüdür. yaparken. Bu yapıyı kullanırken, döngü gövdesinin yürütülmesinden sonra koşul kontrol edildiğinden, koşuldan bağımsız olarak döngüdeki komutlar en az bir kez yürütülür. Aşağıdaki kod örneğinde, sensör okumasından bağımsız olarak LED yanacak ve ancak o zaman son durum kontrolü gerçekleştirilecektir.

Bir süre veya for döngüsünden nasıl çıkılır

Belirtilen koşullardan bağımsız olarak döngü gövdesinden çıkmak gerektiğinde operatör kullanılır. kırmak veya git. Break deyimi döngüden çıkmanızı sağlar ve program aşağıdaki komutları yürütmeye devam eder. Goto deyimi sadece döngüden çıkmanıza değil, aynı zamanda programın yürütülmesine etikette doğru yerden devam etmenize de olanak tanır, örneğin Arduino'da başka bir döngüye gidebilirsiniz.