Arduino döngüleri. Arduino'da FOR ve WHILE döngüleri Continue ve break ifadeleri
Arduino IDE'de for, while ve do while döngü operatörlerinin nasıl çalıştığına, çizimlerde döngülerin doğru şekilde nasıl kullanılacağına ve hangi hatalardan kaçınılması gerektiğine bakalım. Basit örnekler kullanarak bir 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 kez veya sonsuz sayıda tekrarlanan bir eylemdir. Arduino mikrodenetleyicisi için tek bir program döngü olmadan tamamlanmaz; örneğin, sonsuz bir döngüde geçersiz bir döngü çağrılır. Üç tür döngü operatörü vardır: for, while ve do while - hadi her operatöre bakalım ve örnekler kullanarak nasıl çalıştıklarına bakalım.
for ve while'ın çalışma prensibi aşağıdaki basit örneklerle açıklanabilir. For döngüsü sınırlı sayıda çalıştırı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ü, örneğin Arduino'daki LED'in sensörden gelen veriler değişene kadar yanıp sönmesi gibi sonsuz bir şekilde çalışabilir.
Arduino'daki for döngüsünün bir örnekle açıklaması
Arduino'daki for yapısı şu şekilde tanımlanır:
for (başlatma; koşul; değişiklik)( )Kıvrımlı parantez içindeki belirli komutları tekrarlamak için for döngüsü kullanılır. Bu döngü, tekrarlanan eylemlerin gerçekleştirilmesi için uygundur.
Şu tarihte: başlatma bir değişken yaratılır ve bir başlangıç değeri atanır.
İÇİNDE durum döngünün yürütüleceği değişkenin değeri kaydedilir.
İÇİNDE değiştirmek değişkenin döngünün her adımında nasıl değişeceğini gösterir.
Örnek çizimde başlangıç değeri olan bir değişken ayarlanmıştır ben=0 koşul, değişken beşe eşit veya daha büyük olana kadar döngünün çalışacağını belirtir Ben<=5 . Değişiklik, değişkenin döngünün her adımında 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ü bitmeden LED beş kez yanıp söner.
Değişken adım (değişim) herhangi bir şey olabilir. Bir değişkenin aynı anda iki birim artırılması gerekiyorsa sayaçtaki değişim şu şekilde yazılmalıdır: ben=i+2. For döngüsü, geçersiz kurulum prosedürünün içinde, örneğin aynı anda birden fazla pinin çalışma modunu belirtmek için kullanılabilir. Ve ayrıca geçersiz döngü prosedüründe, örneğin Arduino'daki LED'leri sırayla açma programında.
Arduino programının for ve while döngüleriyle açıklaması Bir örnekle Arduino while döngüsünün açıklaması
Arduino'daki while yapısı şu şekilde tanımlanır:
while (koşul)( // tekrarlanacak komutlar }While döngüsü parantez içindeki koşul doğru olduğu sürece sürekli ve sonsuz olarak çalışacaktır. While koşulundaki değişken değiştiğinde döngü çıkışına ulaşılacaktır, bu nedenle bir şeyin değerini değiştirmesi gerekir. Bir değişkenin değiştirilmesi, bir döngü içindeki program kodunda veya herhangi bir sensörden, örneğin bir ultrasonik telemetre HC-SR04'ten değerler okunurken meydana gelebilir.
bayt i=0; // döngüden önce bir değişken oluşturmamız gerekiyor bu arada (ben<5){ // i değeri 5'ten küçük olduğu sürece döngü çalışır digitalWrite(13, YÜKSEK); gecikme(500); digitalWrite(13, DÜŞÜK); gecikme(500); i++; // değişkeni değiştir }While fonksiyonunu kullanırken değişkenin döngü başlamadan önce oluşturulması gerekir. Örnek çizimde LED, döngü sona ermeden önce beş kez yanıp sönecektir. Kıvrımlı parantezlerin içindeki değişkeni değiştirmezseniz i++, o zaman döngü sonsuza kadar tekrarlanacaktır. Arduino Uno'nun while döngüsünden çıkmanın ikinci yolu, sensörden veri okumak ve değişkeni değiştirmek için if ifadesini kullanmaktır.
Arduino IDE'de kullanılabilecek bir diğer döngü ise sonkoşul döngüsüdür. yaparken. Bu yapıyı kullanırken, döngü gövdesi yürütüldükten 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 LED, sensör okumalarından bağımsız olarak yanacak ve ancak bundan sonra sonkoşulu kontrol edecektir.
dahili su; // döngüden önce bir değişken oluşturuyoruz do ( digitalWrite (13, YÜKSEK ); su = analogRead (AO); ) while (su<5) // sensörü kontrol et digitalWrite(13, DÜŞÜK);
Bir süre veya döngüden nasıl çıkılır
Belirtilen koşullardan bağımsız olarak döngünün 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 ifadesi yalnızca döngüden çıkmanıza değil, aynı zamanda etiket boyunca istediğiniz noktadan programı yürütmeye devam etmenize de olanak tanır; örneğin, Arduino'da başka bir döngüye gidebilirsiniz.
İfadeleri kullanan döngüler için Ve sırasında Arduino'nun temelini oluşturan C++ dilinin en önemli yapılarından biridir. Bilmeseniz bile kesinlikle her eskizde bulunurlar. Bu makalede döngülere daha yakından bakacağız, for ve while arasındaki farkın ne olduğunu, döngülerin yardımıyla program yazmayı nasıl basitleştirebileceğinizi ve hangi hatalardan kaçınılması gerektiğini öğreneceğiz.
Hala acemi bir programcıysanız ve döngünün ne olduğunu ve neden gerekli olduğunu anlamak istiyorsanız, bu makalenin ayrıntılı bir açıklama içeren sonraki bölümüne bakın.
WHILE operatörü, C++ ve Arduino'da aynı komutları isteğe bağlı sayıda tekrarlamak için kullanılır. FOR döngüsüyle karşılaştırıldığında WHILE döngüsü daha basit görünür; genellikle bir değişkendeki yinelemelerin sayısını saymamızın gerekmediği, ancak bir şey değişene veya bir olay oluşana kadar kodu tekrarlamamız gereken durumlarda kullanılır.
WHILE sözdizimi
sırasında(<условие или список условий>)
{
<программный блок, который будет повторяться>
}
Boolean değeri döndüren herhangi bir dil yapısı koşul olarak kullanılabilir. Koşullar karşılaştırma işlemleri, işlevler, sabitler, değişkenler olabilir. Arduino'daki diğer mantıksal işlemlerde olduğu gibi sıfır dışındaki herhangi bir değer doğru, sıfır – yanlış olarak algılanacaktır.
// Sonsuz bir döngü while(true)( Serial.println("Bekliyor..."); ) // checkSignal() fonksiyonunun değeri değişene kadar çalışan bir döngü while(!checkSignal())( Serial.println ("Beklemek..."); )
While ifadesinin bloğu küme parantezleriyle engellemeden kullanılabileceğini unutmayın; bu durumda döngüden sonra karşılaşılan ilk komut tekrarlanacaktır. Küme parantezleri olmadan kullanılması kesinlikle tavsiye edilmez, çünkü bu durumda hata yapmak çok kolaydır. Örnek:
While(true) Serial.print("Kesinti bekleniyor"); gecikme(1000);
Bu durumda, gecikme(1000) komutu tekrarlanmayacağından yazı, duraklamalar olmadan sonsuz bir döngüde görüntülenecektir. Bu tür hataları yakalamak için çok zaman harcayabilirsiniz; küme parantezi kullanmak çok daha kolaydır.
Bir süre döngüsü kullanma örneği
Çoğu zaman while bir olayı beklemek için kullanılır. Örneğin, Seri nesnesinin çalışmaya hazır olması.
Seri.begin(9600); while (!Serial) ( ; // Bazı Arduino kartları seri port boşalana kadar beklemenizi gerektirir)
UART aracılığıyla harici cihazlardan bir karakterin gelmesini beklemeye bir örnek:
While(Serial.available())( int byteInput = Seria.read(); // Diğer bazı eylemler)
Bu durumda Serial.available() sıfır dışında bir değer döndürdüğü sürece değerleri okuyacağız. Tampondaki tüm veriler bittiğinde döngü duracaktır.
Arduino'da FOR döngüsü
FOR döngüsünde sadece sınır koşullarını ayarlamakla kalmayıp aynı zamanda sayaç için hemen bir değişken tanımlama ve değerlerinin her yinelemede nasıl değişeceğini belirtme fırsatına da sahibiz.
FOR döngüsü sözdizimi
Burada tasarım 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 ve her döngü sonunda sayaç değerinin bir artması gerektiğini belirttik. İşte bu kadar; artık döngünün içindeki değişkeni kullanabilirsiniz.
Değişken adım farklı olabilir. İşte örnekler:
- for(int i=0; i<10; i=i+2) // Шаг 2
- for(int i=0; i<10; i+=2) // Аналогичен предыдущему
- for(int i=10; i>0; i–) // Geriye dön – 10'dan 1'e
while döngüsünde yap
Bazı durumlarda döngüyü, bloğun talimatları en az bir kez yürütülecek ve ardından kontrol gerçekleştirilecek şekilde düzenlememiz gerekir. Bu tür algoritmalar için do while yapısını kullanabilirsiniz. Örnek:
Do ( Serial.println("Çalışıyor"); ) while (checkSomething());
Döngünün bu versiyonu herhangi bir zorluk yaratmaz - biz basitçe bloğu koşullar aşağı gelecek şekilde hareket ettirdik, böylece do operatöründen sonra küme parantezlerinin içindeki tüm içerik ilk kontrolden önce yürütülecektir.
Devam etme ve kesme ifadeleri
Durum kontrol bloğuna geçmeyi 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; ))
Eğer sadece mevcut yinelemenin ilerlemesini durdurmak istiyorsak, ancak döngüden çıkmak istemiyorsak ve durum kontrol bloğuna gitmek istiyorsak, o zaman operatörü kullanmalıyız. devam etmek:
While (true) ( if (checkSomething()) ( devam et; ))
Continue ve break ifadeleri FOR ve WHILE döngülerinin tüm çeşitleriyle kullanılabilir.
Arduino'da iç içe döngüler
Döngülerin herhangi bir çeşidi birbiriyle kolayca birleştirilebilir ve iç içe yapılar oluşturulabilir. “Üstteki” döngünün bloğunda tanımlanan değişkenler içteki döngüde mevcut olacaktır. Bu tür bir döngünün en yaygın örneği iki boyutlu dizilerin üzerinden geçilmesidir. Aşağıdaki örnekte çift döngü kullanıyoruz: birincisi satırlar (i değişkeni) boyunca yinelenecek, iç içe geçmiş olan ikincisi ise arr değişkeninde tanımladığımız dizinin sütunları (j değişkeni) boyunca döngü yapacak.
Dahili konum; void setup() ( for (int i = 0; i< 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, hadi 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 asıl görevi aynı dil yapılarını birkaç kez tekrarlamaktır. Bu ihtiyaç hemen hemen her programda ortaya çıkar ve kesinlikle tek bir Arduino taslağı döngü olmadan yapamaz - loop() işlevi aynı zamanda sonsuz döngüde de çağrılır.
Aşağıdaki örneğe bakalım. Arduino kartına bağlı 5'ten 9'a kadar olan pinlerden 5 LED'e 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 konusunu göz ardı edelim, çünkü bu kadar çok sayıda LED'in aynı anda dahil edilmesi, 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 rakam farklı olan beş satırlık kod oluşturmuş olmamızdır. Bu yaklaşımın aşağıdaki dezavantajları vardır:
- Herhangi bir değişiklikte aynı anda birçok satırda değişiklik yapmanız gerekecektir. Örneğin LED'leri 2'den 6'ya kadar olan pinlere geçirmemiz veya voltajı açmak yerine kapatmamız gerekirse kodda 5 değişiklik yapmamız gerekecek. Daha fazla talimat ve değişiklik varsa ne olur?
- Çok sayıda benzer talimat içeren büyük kodun okunması zahmetli ve rahatsız edicidir. Beş özdeş çizgi çok korkutucu değil. Ancak kirli kod alışkanlığı, sonuçta listede onlarca ve yüzlerce ekstra sayfanın oluşmasına yol açacak ve bu da hem sizi hem de meslektaşlarınızı umutsuzluğa düşürecektir.
- Neredeyse aynı talimatları "kopyala-yapıştır" sürecinde, örneğin pin numarasını değiştirmeyi unutmak gibi kolayca hata yapabilirsiniz: digitalWrite(5, HIGH); digitalWrite(5, YÜKSEK);
- Herhangi bir normal yazılım şirketindeki görüşmeyi yapan kişiye bu kodu göstererek kolayca başarısız olabilirsiniz.
Bütün bunlardan, aynı dizelerin tekrar tekrar kullanılmasından hemen hemen her zaman kaçınılması ve bunların yerine döngülerin kullanılması gerektiği sonucuna varabiliriz. Üstelik çoğu durumda döngüler olmadan yapmak imkansızdır; hiçbir şey bunların yerini alamaz. Program çalışırken kodun tekrarlanma sayısını değiştiremezsiniz. Örneğin, her bir öğeyi işlemeniz gerekiyor veri dizisi, harici cihazlardan alındı. Ne kadar veri olacağını, işlemin kaç kez tekrarlanacağını asla tahmin edemeyeceksiniz ve bu nedenle makaleyi yazarken gerekli sayıda talimatı ekleyemeyeceksiniz.
Ve burada döngüler yardımımıza koşuyor.
Sözdizimi kuralları
Arduino'da döngü programın yürütülmesi sırasında belirli sayıda çağrılacak özel bir program bloğudur. Bu blok içerisinde çağrılacak komutları ve denetleyicinin bu komutların kaç kez çağrılması gerektiğini belirleyeceği kuralları açıklıyoruz.
Yukarıdaki örneğimizde denetleyiciye şunları söyleyebiliriz:
Komutu tekrarla digitalWrite 5 kez
Robot programcılarının olduğu ideal bir dünyada bu muhtemelen yeterli olacaktır, ancak bilgisayarla C++ dilinde konuştuğumuz için bu cümleyi şu dile çevirmemiz gerekiyor:
Komutu tekrarla – denetleyiciye while veya for döngüleriyle ilginç bir şeyin başlamak üzere olduğunu söyleyen özel talimatlar kullanmanız gerekir
dijitalYazma – olduğu gibi bırakın, ancak bir kez yazın ve küme parantezlerinin içine alın. Pin numaralarıyla ne yapmalı - hemen aşağıda.
5 kere – bunun için her tekrarda artacak bir sayaç kullanın. Bir bloğun başında (veya sonunda), bir karşılaştırma işlemi kullanarak bu sayacın değerini bir sınır değerle (bu durumda 5) karşılaştırabilirsiniz.
Böyle bir "çevrilmiş" döngü komutunun bir örneğine while ifadesi ile bakalım:
Dahili sayaç = 0; // Sayaç değerini saklayacak bir değişken // İşlemciden süslü parantez içindeki yapıyı parantez içindeki koşul doğru dönene kadar tekrarlamasını istiyoruz. // Bizim durumumuzda counter bizim sayacımızdır, 5 limit değeridir, şart sayıcı değerinin 5'ten küçük olmasıdır. // Ama tamamen farklı mantıksal operatörler belirtebiliriz while (counter< 5) { digitaWrite(5, HIGH); // Будем включать светодиод counter++; // Увеличиваем значение счетчика } // Дойдя до сюда, исполняющий процессор переместится в начало блока и опять займется проверкой условий. Если условия вернут истину, команды в блоке между { и } выполнятся еще раз. Если условие не выполнится - процессор переместится к концу блока и пойдет дальше. Этот цикл больше его не заинтересует.
Verilen kodda hata fark edenler için beş verip döngü bloğunu farklı yazıyoruz:
While(sayaç< 5) { // Вот теперь мы будем включать разные светодиоды, с 5 (0+5) по 9 (4+5) digitalWrite(counter + 5, HIGH); counter++; }
Aynı sonuca FOR döngüsü kullanılarak da ulaşılabilir:
For(int counter =0; counter<5; counter ++){ digitalWrite(counter+5, HIGH); }
Gördüğünüz gibi, bu durumda sayaçla gerekli tüm işlemleri derhal tek bir FOR talimatına yerleştiriyoruz - gerekli miktarı saymanız gerekiyorsa bu çok daha uygundur.
Döngü kullanımına ilişkin kurallar hakkında detaylı bilgiye bu makalenin ilgili bölümlerinden ulaşabilirsiniz.
Çözüm
Bu yazıda Arduino dilinin çok önemli yapılarına baktık: FOR ve WHILE döngüleri. Bu operatörleri hemen hemen her türlü karmaşık çizimde bulabilirsiniz, çünkü döngüler olmasaydı veriler üzerinde birçok işlem imkansız olurdu. Döngülerin sözdiziminde karmaşık hiçbir şey yoktur; bunlara kolayca alışabilir ve projelerinizde aktif olarak kullanabilirsiniz.
", denetleyicinin çalışmasını düzenlemek için "for" döngüsünün nasıl kullanılacağını öğrendik. Bu tür döngü her yerde kullanılır ve "döngü işlemlerine duyulan ihtiyacı" fazlasıyla kapsar. Ancak başka bir döngü türü daha var - "while". For döngüsünden daha iyi değil, sadece farklı ilkeler kullanıyor.
Çoğu durumda iki tür döngüden hangisinin kullanılacağını seçebilirsiniz. Kullanıcı gerekli verileri girene kadar programı duraklatmak için "while" ifadesini kullandık. Bu dersimizde örnek olarak Arduino platformunu kullanarak bu döngünün nasıl çalıştığına daha yakından bakacağız.
2 LED’den oluşan devre ile çalışmaya devam edelim.
Ayrıca 14. derste sonlandırdığımız kodla çalışmaya devam edeceğiz.
Geçmişe dönüş: denetleyici kullanıcıdan veri ister, girişi bekler ve ardından elde edilen değerleri değişkenlere atar göz kırpmaNumaraYeşil Ve göz kırpmaNumaraKırmızı. Bu, kullanıcının 2 LED'in her birinin yanıp sönme sayısını kontrol etmesine olanak tanır.
Bir programcının dünya görüşünü genişletmek için, aynı görevleri yerine getirmek için iki tür döngü kullanmayı öğrenmeye değer ve gelecekte bir veya başka bir türe sempati gösterebilirsiniz.
Nasıl çalıştığını anlayalım:
int z= 1; // bir değişken tanımlayıp ona 1 değerini atayın
sırasında (z<=10) { //запускаем цикл sırasında
Seri. baskı(z); //değişkenin geçerli değerini çıktı olarak alıyoruzz seri port aracılığıyla
z= z+1 // değişkenin değerini arttırz1'e kadar
) // döngüyü sonlandır
While döngüsü, parantez içinde açıklanan “koşul” doğru olduğu sürece komutları yürütmeye devam edecektir. Yukarıdaki örnekte, z 10'dan küçük veya ona eşit olduğu sürece döngü komutları yürütmeye devam edecektir. Döngünün gövdesi 2 komutu yürütür:
- Bir değişkenin değerinin seri port üzerinden çıkışı;
- Bir değişkenin değerini 1 birim artırmak (bilimsel olarak artırma olarak adlandırılır).
Değişkenin değeri artırıldığında program sonunda döngüden çıkacaktır. Bir an bu satırı belirtmeyi unuttuğumuzu veya bir tür arıza oluştuğunu hayal edersek, program mutlu bir şekilde bir döngüye girecektir (başka bir deyişle donacaktır).
Döngü, koşulun doğruluğunu kontrol ederek çalışmaya başlar. Eğer z 10'dan küçük veya ona eşitse program döngüyü çalıştırır. Daha sonra durum tekrar kontrol edilir vb. Değişkenin değeri z = 11'e ulaştığında koşul artık doğru olmayacaktır. Program döngüyü çalıştırmayacak ve döngü küme parantezinin hemen ardından bir sonraki satıra geçecektir.
Bu kadar teori yeter, hadi pratiğe geçelim. Kaynak kodundaki for döngülerini while döngüleriyle değiştirelim.
FOR döngüsü tarafından gerçekleştirilen flaşör:
for (int i = 1; i<= blinkNumberGreen; i++) // öğle yemeği döngüiçin
{
Seri. Yazdır("Yeşil yanıp söndü");
Seri.println(i);
digitalWrite(yeşilLed, YÜKSEK); //aç yeşil Işık yayan diyot
gecikme(timeOnGreenLed); //bekleriz
digitalWrite(yeşilLed, DÜŞÜK); //kapamak yeşil Işık yayan diyot
gecikme(timeOffGreenLed); //bekleriz
}
WHILE döngüsünde flaşör:
int Ben=1; //bir değişken tanımlayıp ona 1 değerini atadık
bu arada (ben<= blinkNumberGreen)
{ // öğle yemeği döngüsırasında
Seri.print("Yeşil göz kırptı «);
Seri.println(i);
digitalWrite(yeşilLed,YÜKSEK); //aç yeşil Işık yayan diyot
gecikme(timeOnGreenLed); //bekleriz
digitalWrite(yeşilLed,DÜŞÜK); //kapamak yeşil Işık yayan diyot
gecikme(timeOffGreenLed); //bekleriz
Ben= Ben+1 //değişkenin değerini 1 artır
}
Programı kaydedin ve ürün yazılımını denetleyiciye yükleyin. Sonuca bakalım.
Her programlama dilinde, aynı kodu tekrar tekrar çalıştırmanıza (bir döngü), uygun bir kod parçası seçmenize (koşullar) ve geçerli kod parçasından çıkmanıza olanak tanıyan bir dizi kontrol talimatı bulunur.
Arduino IDE gerekli kontrollerin çoğunu C/C++'dan ödünç alır. Sözdizimleri C ile aynıdır. Aşağıda sözdizimlerini kısaca açıklayacağız.
if ifadesi
If ifadesi, belirli bir koşulu kontrol etmenin sonucuna bağlı olarak programın belirli bir parçasını çalıştırmanıza olanak tanır. Koşul karşılanırsa program kodu yürütülür, koşul karşılanmazsa program kodu atlanır. if komutunun sözdizimi aşağıdaki gibidir:
If(koşul) (talimat1; talimat2; )
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. Bir if koşulunun ana kriteri, cevabın her zaman doğru ya da yanlış olması gerektiğidir. Bir if ifadesi için koşullara örnekler:
If(a!=2) ( ) if(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şareti kullanarak eşitleme hatasına düşerler. Böyle bir gösterim, değişken bir değerin atandığını açıkça gösterir ve bu nedenle koşul her zaman "doğru" olacaktır, yani karşılanacaktır. Bir değişkenin belirli bir değere eşit olup olmadığının test edilmesi her zaman çift eşittir işaretiyle (==) gösterilir.
İşlev durumunu bir koşul olarak kullanabilirsiniz, örneğin:
If(init()) ( Serial.print("ok"); )
Yukarıdaki örnek şu şekilde yürütülecektir: İlk adımda init() işlevi çağrılı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ı gelecek veya hiçbir şey gönderilmeyecektir.
If…else ifadesi
Genişletilmiş if ifadesi if….else ifadesidir. Bir koşul doğru (doğru) olduğunda bir kod parçasının yürütülmesini ve koşul karşılanmadığında (yanlış) ikinci bir kod parçasının yürütülmesini sağlar. f if….else ifadesinin sözdizimi aşağıdaki gibidir:
If (koşul) ( // komut A ) else ( // komut B )
"A" komutları yalnızca koşul karşılandığında yürütülür, "B" komutu koşul karşı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("tamam"); ) else ( Serial.print("error"); )
Bu sayede fonksiyonun doğru yürütüldüğünü kontrol edebilir ve kullanıcıyı bu konuda bilgilendirebilirsiniz.
Yaygın bir uygulama, durumu inkar etmektir. Bunun nedeni, doğru şekilde yürütülen bir işlevin 0 değerini döndürmesi ve herhangi bir nedenle yanlış yürütülen 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 şekilde yürütülürse, ihtiyacımız olan tek bilgi budur. Bir hata durumunda bazen neyin yanlış gittiğini ve işlevin neden doğru şekilde yerine getirilmediğini anlamak faydalı olabilir. Ve burada sıfır dışındaki sayılar kurtarmaya geliyor, yani. dijital kodları kullanarak hatanın türünü belirleyebiliriz. Örneğin, 1 - bazı değerlerin okunmasında sorun var, 2 - bellekte veya diskte yer yok vb.
Son değiştirilen örnek, doğru çalıştırıldığında sıfır döndüren bir fonksiyonun nasıl çağrılacağını gösterir:
If (!init()) ( Serial.print("tamam"); ) else ( Serial.print("error"); )
Switch case bildirimi
If ifadesi yalnızca bir koşulu test etmenize olanak tanır. Bazen döndürülen veya okunan değere bağlı olarak işlemlerden birinin gerçekleştirilmesi gerekebilir. Anahtar çoktan seçmeli operatörü bunun için idealdir. Switch komutunun sözdizimi aşağıda gösterilmiştir:
Anahtar (var) ( durum 1: //var=1 sonu için talimat; durum 2: //var=2 için talimat break; varsayılan: //varsayılan talimat (eğer var 1 ve 2'den farklıysa) )
Var değişkeninin değerine bağlı olarak belirli bloklardaki talimatlar yürütülür. Durum etiketi, belirtilen değer için bir bloğun başlangıcını gösterir. Örneğin, durum 1: bu bloğun var'ın bire eşit değeri için yürütüleceği anlamına gelir.
Her blok bir break komutuyla sonlandırılmalıdır. Switch ifadesinin daha fazla yürütülmesini kesintiye uğratır. Break komutu atlanırsa, talimatlar break komutundan önce sonraki bloklarda yürütülecektir. Varsayılan etiket, if ifadesinde olduğu gibi isteğe bağlıdır. Varsayılan blokta bulunan talimatlar yalnızca var değişkeninin değeri herhangi bir kalıpla eşleşmediğinde yürütülür.
Çoğu zaman aynı talimatların birden fazla değerden biri için yürütülmesi gerektiği görülür. Bu şu şekilde başarılabilir:
Anahtar (x) ( durum 1: //x=1 kesme talimatı; durum 2: durum 3: durum 5: //x=2 veya 3 veya 4 kesme talimatı; durum 4: //x=4 kesme talimatı ; durum 6: // x=6 için talimat break default: // varsayılan talimat (eğer x 1,2,3,4,5,6'dan farklıysa)
X değişkeninin değerine bağlı olarak karşılık gelen talimat bloğu yürütülecektir. Tekrarlanan durum 2: durum 3: durum 5: 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.
beyan 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ı yürütmek gerekir. Bunun için for döngüsü idealdir. Komutun sözdizimi aşağıdaki gibidir:
Dahili ben; for(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. Döngü koşul sağlandığı sürece çalışır. Son öğe, değişkenin değerindeki değişikliktir. Çoğu zaman değerini artırır veya azaltırız (gerektiğinde). Bu örnekte döngünün içerdiği talimatlar i=0...9'da yürütülecektir.
Genellikle bir döngüde kullanılan bir değişken burada bildirilir:
For(int i=0;i<10;i++) { // инструкции для выполнения в цикле }
Döngünün sonraki adımlarını saymak için kullanılan bir değişken, uygun parametrelerle bir işlevi çağırmak için döngü içinde 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ü, sayım yapmak istediğimiz yerde idealdir. Tahmin edilemeyen bir olayın sonucu olarak belirli eylemleri gerçekleştirmemiz gereken bir durumda (örneğin, bir düğmeye basılmasını bekliyoruz), o zaman deyim bloğunu şu şekilde çalıştıran while deyimini kullanabiliriz: koşul sağlandığı sürece. while ifadesinin sözdizimi aşağıdaki gibidir:
While(koşul) ( // yürütülecek talimat bloğu)
Durum kontrolünün döngünün başında yapılması önemlidir. While döngüsünün içindeki talimatlar hiçbir zaman yürütülmeyebilir. Sonsuz döngü oluşturmak da mümkündür. İki örneğe bakalım:
Dahilix=2; while(x>5) ( Seri.print(x); ) —————————————- int y=5; while(y>0) ( Seri.print(y); )
While içerisinde yer alan 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üyle uğraşıyoruz. “y” değişkeni 5, yani sıfırdan büyük bir değere sahiptir. Döngü içindeki "y" değişkeninde herhangi bir değişiklik olmadığından döngü hiçbir zaman tamamlanmayacaktır.
Döngünün sonlanmasına neden olan bir parametreyi değiştirmeyi unuttuğumuzda bu yaygın bir hatadır. Aşağıda while döngüsünü kullanmanın iki doğru örneği verilmiştir:
Dahilix=0; iken(x<10) { //блок инструкций x++; } —————————————- while(true) { if(условие) break; // блок инструкций }
İlk örnekte koşulda kontrol edilen değişkenin değerini değiştirmeye özen gösterdik. Sonuç olarak döngü sonunda sona erecektir. İkinci örnekte bilinçli olarak sonsuz bir döngü oluşturuldu. Bu döngü, Arduino IDE'deki loop() fonksiyonuna eşdeğerdir. Ek olarak, döngünün içine bir durum kontrolü eklenmiştir ve bunun ardından döngü, break komutuyla sonlandırılır.
do...while ifadesi
While döngüsünün bir varyasyonu do...while döngüsüdür. Sözdiziminin yanı sıra koşulun kontrol edildiği yere göre de farklılık gösterir. Do...while durumunda, talimat bloğu yürütüldükten sonra durum kontrol edilir. Bu, döngünün gövdesindeki talimat bloğunun en az bir kez yürütüleceği anlamına gelir. Aşağıda do...while komutunun sözdizimi verilmiştir:
( // talimat bloğunu) while(koşul) yapın
while operatörü hakkında yazılan her şey aynı zamanda do...while için de geçerlidir. Aşağıda do...while döngüsünün kullanımına bir örnek verilmiştir:
Dahilix=10; do ( // talimat bloğu x—; ) while(x>0); —————————————- do ( // talimat bloğu if (condition) break; ) while(true);
mola ifadesi
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ünün 0'dan 9'a kadar olan sayılar için yürütülmesi gerekir, ancak 5 sayısı için break ifadesini tetikleyen bir koşul karşılanır. Bu döngüden çıkılmasını sağlayacaktır. Sonuç olarak seri porta (Serial.print) sadece 0,1,2,3,4 sayıları gönderilecektir.
Operatöre devam et
Continue operatörü, döngü talimatlarının (do...while, for, while) geçerli değer için yürütülmesini durdurmasına ve bir sonraki döngü adımına geçmesine neden olur. Aşağıdaki örnek, devam ifadesinin nasıl çalıştığını gösterir:
için(i=0;i<10;i++) { if(i==5) continue; Serial.print(i); }
Fark edilmesi zor olmadığı için döngü 0'dan 9'a kadar olan değerler için yürütülecektir. 5 değeri için devam komutu yürütülecek, bunun sonucunda bu komuttan sonraki talimatlar yürütülmeyecektir. Sonuç olarak seri porta (Serial.print) 0,1,2,3,4,6,7,8,9 sayıları gönderilecektir.
dönüş bildirimi
Return ifadesi, çağrılan işlevin yürütülmesini sonlandırır ve belirli türde bir değer döndürür. Komut parametresi olarak bir sayıyı, bir sembolü veya belirli bir türdeki değişkeni belirtebilirsiniz. Dönen değerin bildirilen işlevin türüyle eşleşmesi önemlidir. Aşağıdaki örnek, return ifadesinin nasıl kullanılacağını gösterir:
Int checkSensor())( if (analogRead(0) > 400) ( // analog giriş okunduğunda 1 döndürülür; // 400'den büyük değerler için 1 döndürülür, else( return 0; // diğerleri için 0 döndürülür iade) )
Gördüğünüz gibi, bir fonksiyonda birden fazla return ifadesi kullanabilirsiniz, ancak bunlardan yalnızca biri her zaman çalışacaktır. Dönüş operatörünün parametresiz kullanılması kabul edilebilir. Bu, herhangi bir değer döndürmeyen bir işlevi zamanından önce sonlandırmanıza olanak tanır.
Void işlev_adı() ( talimat1; if(x==0) return; talimat2; talimat3; )
Yukarıdaki örnekte, fonksiyon her çağrıldığında talimat1 yürütülecektir. Talimat2 ve talimat3'ün yürütülmesi if komutunun sonucuna bağlıdır. Koşul doğruysa (true), dönüş komutu yürütülecek ve işlevden çıkılacaktır.
Koşulun karşılanmaması durumunda, dönüş komutu da yürütülmez, ancak talimat2 ve talimat3 talimatları yürütülür ve bundan sonra fonksiyon işini tamamlar.
ifadeye git
İdeolojik nedenlerden dolayı bu açıklamayı atlamak gerekiyor... Goto ifadesi normal programlamada kullanılmaması gereken bir komuttur. Kodun karmaşıklığına neden olur ve kötü bir programlama alışkanlığıdır. Programlarınızda bu komutu kullanmamanızı önemle tavsiye ederiz. Goto, arduino.cc web sitesindeki resmi belgelerde yer aldığından, burada onun kısa bir açıklamasını bulacaksınız. git komut sözdizimi:
…. metka'ya git; // 'metka' etiketli satıra gidin ..... .... …. metka: // programın çalışmaya devam edeceği etiket...
Komut, belirlenen işarete, yani programdaki bir yere gitmenizi sağlar.
