Əsaslar · 14 dəq oxu

Arduino proqramlaşdırmanın əsasları: dəyişən, dövr və funksiya

Arduino proqramlaşdırma sıfırdan: setup və loop, int, long, byte və daşma, const, #define, if-else, switch-case, for, while, massiv, funksiya; LED və düymə nümunələri ilə.

Arduino proqramlaşdırma Arduino platasına nə edəcəyini C/C++ dili ilə izah etməkdir: hansı LED-in nə vaxt yanacağını, düyməyə basılanda nə olacağını, sensordan gələn ədədin necə şərh ediləcəyini sən yazırsan, plata isə bu təlimatları saniyədə minlərlə dəfə təkrarlayır. Yaxşı xəbər budur: LED yandırmaqdan robot maşına qədər gördüyün kodların demək olar ki, hamısı eyni on-on beş tikinti blokundan ibarətdir. Bunlar setup() və loop(), dəyişənlər, sabitlər, operatorlar, if-else, switch-case, for və while dövrləri, massivlər və funksiyalardır.

Bu bələdçidə bu tikinti bloklarını ardıcıllıqla, hər biri üçün real LED və ya düymə nümunəsi ilə öyrənəcəksən. Bütün nümunələr eyni sadə dövrədə işləyir və Arduino Uno üçün kompilyasiya edilib sınaqdan keçirilib. Yeni başlayanların ən çox ilişdiyi məqamlar, yəni dəyişənin daşması, = ilə == qarışıqlığı, unudulmuş break və hər turda sıfırlanan sayğac ayrıca izah olunur. Son bölmələrdə eyni məntiqin ESP32-də necə işlədiyini və Raspberry Pi Pico-da MicroPython qarşılıqlarını da görəcəksən.

Arduino Uno platası və rəqəmsal pinləri
Arduino Uno: bu yazıdakı nümunələrin hamısı D2 pininə qoşulmuş bir düymə və D8–D13 pinlərinə qoşulmuş altı LED ilə işləyir. D13-dəki daxili LED sayəsində ilk nümunələr üçün naqil belə lazım deyil.

Arduino proqramlaşdırma nədir, hansı dildən istifadə olunur?

Arduino kodu C++ dilinin üzərində qurulub; ayrıca "Arduino dili" yoxdur. Arduino nüvəsi C++-a pinMode(), digitalWrite() və delay() kimi hazır funksiyalar əlavə edir. Yazdığın fayla sketch deyilir və uzantısı .ino-dur. Verify düyməsinə basanda Arduino IDE faylın əvvəlinə Arduino.h başlıq faylını əlavə edir, funksiyaların bəyannamələrini özü yaradır, kompilyator isə kodu prosessorun başa düşdüyü maşın diline çevirir. Upload düyməsi bu nəticəni USB vasitəsilə platanın yükləyicisinə (bootloader) göndərir. IDE-ni hələ quraşdırmamısansa, Arduino IDE quraşdırılması yazısı ilə başlaya bilərsən.

Kod yazarkən riayət etməli olduğun bir neçə əsas qayda var. Onları əvvəldən öyrənmək ilk günlərdə görəcəyin kompilyasiya xətalarının yarısını aradan qaldırır:

QaydaDüzgün yazılışƏməl etməsən
Hər komanda nöqtəli vergüllə bitirdigitalWrite(13, HIGH);expected ';' before '}' token
Böyük-kiçik hərf fərq edirpinMode(13, OUTPUT);'pinmode' was not declared in this scope
Kod blokları fiqurlu mötərizə içindədirvoid loop() { ... }Açılan hər { üçün bir } lazımdır
Tək sətirlik şərh// bu sətir işləmirŞərhlər kompilyasiya olunmur, izah üçündür
Çoxsətirlik şərh/* ... */Bağlanmasa, altındakı hər şey şərh olur
Mətn cüt dırnaqda, tək simvol tək dırnaqda"Salam" və 'A'Dırnaq növü qarışsa səhv dəyər və ya xəta alınır

Nümunələrdə istifadə edəcəyimiz dövrə

Bütün nümunələr tək dövrədə işləyir. D8–D13 pinlərinə hərəsi bir 220 Ω rezistorla altı LED qoş; LED-lərin qısa ayağı (katod) GND-yə gedir. Rezistorun dəyərini öz LED-inə görə LED rezistoru hesablayıcısı ilə yoxlaya bilərsən. Düymənin bir ayağını D2-yə, çarpaz qarşısındakı ayağını GND-yə qoş. Kodda INPUT_PULLUP istifadə edəcəyimiz üçün xarici rezistora ehtiyac yoxdur: düymə buraxılanda pin HIGH, basılanda LOW oxunur. Ətraflı məlumat üçün Arduino-ya düymə necə qoşulur? və LED nədir? yazılarına baxa bilərsən.

HissəArduino UnoESP32Raspberry Pi Pico
6 LED (hər biri 220 Ω ilə, katod GND-yə)D8, D9, D10, D11, D12, D13GPIO 18, 19, 21, 22, 23, 25GP14, GP13, GP12, GP11, GP10, GP9
Düymə (digər ayağı GND-yə)D2GPIO 4GP2
Platadakı LEDD13 (L hərfli LED)GPIO 2 (əksər DevKit-lərdə)GP25 (Pico W-də "LED")
Serial port sürəti9600 baud115200 baudThonny Shell
LED-i rezistorsuz qoşma: həm LED, həm də Arduino-nun pini zədələnə bilər. Düyməni breadboard-a taxanda eyni tərəfdəki iki ayaqdan istifadə etsən, bu ayaqlar daxildə artıq birləşmiş ola bilər və düymə heç basılmamış kimi davranar; buna görə çarpaz ayaqlardan istifadə etmək ən etibarlı yoldur. Pin nömrələrini platanın üzərində Pinout alətində görə bilərsən.

setup() və loop(): hər proqramın skeleti

Hər Arduino proqramında iki məcburi funksiya var. setup() plata işə düşəndə və ya reset düyməsinə basılanda yalnız bir dəfə işləyir; pin ayarları və Serial.begin() kimi hazırlıqlar bura yazılır. loop() isə setup() bitdikdən sonra sonsuza qədər təkrarlanır. Arxa planda Arduino nüvəsinin gizli bir main() funksiyası var: əvvəlcə aparatı hazırlayır, sonra setup()-ı bir dəfə çağırır və loop()-u sonsuz dövr daxilində dönə-dönə çağırır. Bu iki funksiyanın xaricində, faylın ən yuxarısındakı sahə qlobal sahədir; sabitlər və hər yerdən əlçatan olacaq dəyişənlər burada təyin edilir.

C++ (Arduino IDE)
1// 1) Global alan: sabitler ve değişkenler / Global area: constants and variables
2const int LED_PIN = 13;        // dahili LED / built-in LED
3unsigned long passCount = 0;   // loop() kaç kez döndü / how many times loop() has run
4
5// 2) setup(): açılışta bir kez çalışır / runs once at power-up or reset
6void setup() {
7  pinMode(LED_PIN, OUTPUT);
8  Serial.begin(9600);
9  Serial.println("setup() bitti / setup() done");
10}
11
12// 3) loop(): sonsuza kadar tekrar eder / repeats forever
13void loop() {
14  passCount++;                       // her turda 1 artır / add 1 on every pass
15  Serial.print("Tur / Pass: ");
16  Serial.println(passCount);
17
18  digitalWrite(LED_PIN, HIGH);       // LED'i yak / LED on
19  delay(500);                        // 500 ms bekle / wait 500 ms
20  digitalWrite(LED_PIN, LOW);        // LED'i söndür / LED off
21  delay(500);
22}

Kodu yükləyib Serial Monitor-u 9600 baud sürətində açanda əvvəlcə bir dəfə "setup() bitti" yazısını (setup() bitdi), ardınca hər saniyə artan tur nömrəsini görürsən; daxili LED də eyni ritmdə yanıb-sönür. loop() daxilindəki iki delay(500) hər turu təxminən bir saniyəyə uzadır; heç bir gözləmə və serial çap olmayan loop() isə Uno-da saniyədə yüz minlərlə dəfə dönə bilər. Serial Monitor-dan səmərəli istifadə üçün Arduino Serial Monitor yazısına nəzər sala bilərsən.

Dəyişənlər və verilənlər tipləri: int, long, float, bool, byte

Dəyişən dəyəri saxlamaq üçün yaddaşda açılan və adı olan qutudur. Təyin edəndə əvvəlcə tipini, sonra adını yazırsan, istəsən başlanğıc dəyər də verirsən: int sayac = 0; kimi. Tip qutunun neçə bayt yer tutacağını və hansı aralıqdakı ədədləri saxlaya biləcəyini müəyyən edir. Arduino Uno-da cəmi 2 KB RAM olduğu üçün düzgün tip seçmək vacibdir. Dəyişən adları hərflə və ya alt xəttlə başlayır; içində boşluq və ç, ğ, ı, ö, ş, ü, ə kimi hərflər ola bilməz.

TipUno-da ölçüDəyər aralığıTipik istifadə
bool1 bayttrue və ya falseLED yanıqdır, düyməyə basılıb
byte1 bayt0 – 255Pin nömrəsi, PWM parlaqlığı
char1 bayt-128 – 127Tək simvol: 'A'
int2 bayt-32.768 – 32.767Sayğaclar, analogRead() nəticəsi
unsigned int2 bayt0 – 65.535Yalnız müsbət ədədlər
long4 bayt-2.147.483.648 – 2.147.483.647Böyük tam ədədlər
unsigned long4 bayt0 – 4.294.967.295millis() ilə vaxt ölçümü
float4 baytTəxminən ±3,4 × 10^38, 6–7 rəqəm dəqiqlikTemperatur, gərginlik, orta dəyər
double4 bayt (Uno-da float ilə eyni)float ilə eyniESP32-də 8 baytdır

Bir neçə praktik qayda səni çoxlu əziyyətdən qurtarır. analogRead() 0–1023 arası ədəd qaytarır, ona görə int kifayətdir. millis() isə unsigned long qaytarır; vaxtı int dəyişəndə saxlasan, 32,7 saniyədən sonra dəyər daşır və vaxt hesablaman pozulur. Uno-da float əməliyyatları proqram yolu ilə aparıldığı üçün tam ədəd əməliyyatlarından yavaşdır və 6–7 rəqəmdən sonrası etibarlı deyil; buna görə iki float ədədi == ilə müqayisə etmə. Hansı platada olursan ol, ölçüsü dəyişməyən tip istəyirsənsə, uint8_t, int16_t və uint32_t kimi ölçüsü adında yazılan tiplərdən istifadə edə bilərsən.

Daşma (overflow): dəyişən həddi aşanda nə olur?

Dəyişənə tipinin ala biləcəyindən böyük ədəd yazmağa çalışsan, Arduino xəta vermir; ədəd avtomobilin kilometr sayğacı kimi başa qayıdır. Uno-da int ən çox 32.767 saxlaya bilir, ona 1 əlavə etsən -32.768 olur. byte 255-dən sonra 0-a qayıdır. Daha hiyləgər tələ isə sabitlərlə hesablamadır: 60 * 1000 kimi əməliyyat, nəticə long dəyişənə yazılsa belə, əvvəlcə int kimi hesablanır və daşır. Aşağıdakı kod bu halların hamısını Serial Monitor-a yazır, loop() hissəsi isə byte daşmasını LED üzərində göstərir:

C++ (Arduino IDE)
1const int LED_PIN = 9;        // PWM destekli pin (~9) / PWM-capable pin (~9)
2byte brightness = 0;          // byte: 0-255
3
4void setup() {
5  pinMode(LED_PIN, OUTPUT);
6  Serial.begin(9600);
7
8  int a = 32767;              // Uno'da int'in en büyük değeri / largest int on an Uno
9  a = a + 1;                  // taşma: -32768 olur / overflow: becomes -32768
10  Serial.println(a);
11
12  long wrong = 60 * 1000;     // int ile hesaplanır, taşar: -5536 / computed as int, overflows: -5536
13  long right = 60 * 1000L;    // L eki hesabı long yapar: 60000 / the L suffix makes it long math: 60000
14  Serial.println(wrong);
15  Serial.println(right);
16
17  float half = 5 / 2;         // tam sayı bölmesi: 2.00 / integer division: 2.00
18  float half2 = 5 / 2.0;      // ondalıklı bölme: 2.50 / floating-point division: 2.50
19  Serial.println(half);
20  Serial.println(half2);
21}
22
23void loop() {
24  analogWrite(LED_PIN, brightness);   // parlaklığı uygula / apply the brightness
25  brightness++;                       // 255'ten sonra 0'a döner / wraps to 0 after 255
26  delay(10);
27}
Kod sətriUno-da nəticəESP32 və Pico-da nəticəNiyə?
a = 32767 + 1-3276832768Uno-da int 2 bayt, digərlərində 4 baytdır
60 * 1000-553660000Sabitlər əvvəlcə int kimi hesablanır
60 * 1000L6000060000L şəkilçisi əməliyyatı long edir
5 / 22.002.00İki tam ədədin bölməsi tam ədəddir
5 / 2.02.502.50Ədədlərdən biri onluq kəsrli olanda nəticə də onluq kəsrli olur

D9-a qoşulmuş LED-ə bax: parlaqlıq 0-dan 255-ə qədər yavaş-yavaş artır, sonra brightness++ sətri dəyəri 256 əvəzinə 0 edir və LED qəfildən sönür. Daşmanı gözlə görməyin ən asan yolu budur. D9 Uno-da ~ ilə işarələnmiş PWM pinlərindən biri olduğu üçün analogWrite() burada işləyir; PWM-in təfərrüatları PWM nədir? yazısındadır. millis() dəyərinin təxminən 49,7 gündə sıfırlanması da daşmadır və düzgün yazılmış kodda problem yaratmır; necə yazılacağını millis() və delay() yazısında tapa bilərsən.

Arduino IDE-də File > Preferences menyusundan Compiler warnings ayarını "More" və ya "All" et. Beləliklə, 60 * 1000 kimi daşan əməliyyat yazanda kompilyator integer overflow in expression xəbərdarlığı verir və xətanı kod plataya getməmiş tutursan.

const və #define: dəyişməyən dəyərlər

Pin nömrələri və hədd dəyərləri kimi proqram boyu dəyişməyəcək ədədlərə ad vermənin iki yolu var. const ilə təyin edilən sabitin tipi olur, görünmə dairəsi qaydalarına tabe olur və səhvən dəyişməyə çalışsan, kompilyator səni assignment of read-only variable 'LED_PIN' xətası ilə dayandırır. #define isə preprosessor komandasıdır: kompilyasiya başlamazdan əvvəl koddakı hər BUTTON_PIN yazısını 2 ilə əvəz edir. Tipi yoxdur, sətrin sonunda nöqtəli vergül və bərabərlik işarəsi işlədilmir. Sadə ədədlər üçün hər ikisi RAM sərf etmir, çünki kompilyator dəyəri birbaşa koda yerləşdirir. Bu gün const üstün tutulur; sabit adlarını BÖYÜK_HƏRFLƏ yazmaq da geniş yayılmış vərdişdir. Aşağıdakı nümunədə ikisi birlikdə istifadə olunur: düymə basılı olanda LED yanır.

C++ (Arduino IDE)
1#define BUTTON_PIN 2          // önişlemci: derlemeden önce metin değişimi / preprocessor: text swap before compiling
2const int LED_PIN = 13;       // tipi olan, salt okunur sabit / typed, read-only constant
3
4void setup() {
5  pinMode(LED_PIN, OUTPUT);
6  pinMode(BUTTON_PIN, INPUT_PULLUP);   // dahili pull-up: basılınca LOW / internal pull-up: LOW when pressed
7}
8
9void loop() {
10  if (digitalRead(BUTTON_PIN) == LOW) {   // buton basılı mı? / is the button pressed?
11    digitalWrite(LED_PIN, HIGH);          // evet: LED yanar / yes: LED on
12  } else {
13    digitalWrite(LED_PIN, LOW);           // hayır: LED söner / no: LED off
14  }
15}
#define LED_PIN 13; yazsan, nöqtəli vergül də dəyərin hissəsi olur və pinMode(LED_PIN, OUTPUT) sətri pinMode(13;, OUTPUT) halına gəlir. Kompilyator expected ')' before ';' token xətası verir; altındakı in expansion of macro 'LED_PIN' qeydi problemin sabitin işlədildiyi sətirdə üzə çıxdığını göstərir, amma düzəltməli olduğun yer #define sətridir. #define LED_PIN = 13 yazılışı da expected primary-expression before '=' token xətası verir.

Operatorlar: arifmetik, müqayisə və məntiq

Operatorlar dəyişənlərlə hesablamağa, onları müqayisə etməyə və şərtləri birləşdirməyə imkan verir. Gündəlik layihələrdə istifadə edəcəyin operatorların demək olar ki, hamısı bu cədvəldədir:

QrupOperatorMənasıNümunə
Arifmetik+ - * /Dörd əməlx = a * 2;
Qalıq%Bölmədən qalıq (yalnız tam ədədlərdə)7 % 3 nəticəsi 1
Mənimsətmə= += -= *= /=Dəyər ver, üstünə əlavə et, çıx…toplam += 5;
Artırma, azaltma++ --1 artır və ya 1 azalti++;
Müqayisə== != < > <= >=Nəticə true və ya falseif (x >= 10)
Məntiq&& || !VƏ, VƏ YA, DEYİLif (a && !b)
Şərt? :Qısa if-elsex > 0 ? HIGH : LOW
Bit& | ^ ~ << >>Ədədin bitləri üzərində əməliyyat1 << 3 nəticəsi 8

Ən çox qarışdırılan iki cüt = ilə == və & ilə &&-dir. Tək bərabərlik dəyər mənimsədir, cüt bərabərlik müqayisə edir. Tək & ədədlərin bitlərinə baxır, cüt && isə iki şərtin hər ikisinin düzgün olub-olmadığını soruşur. VƏ, VƏ YA və DEYİL əməliyyatlarının doğruluq cədvəllərini Məntiq elementləri alətində yoxlaya bilərsən. Bit operatorlarının təfərrüatı isə say sistemləri və bit əməliyyatları yazısındadır. Aşağıdakı nümunə düyməyə neçə dəfə basıldığını sayır və tək sayda basışda LED-i yandırır:

C++ (Arduino IDE)
1const int LED_PIN = 13;
2const int BUTTON_PIN = 2;
3
4int presses = 0;               // toplam basış sayısı / total number of presses
5bool lastPressed = false;      // önceki turdaki durum / state on the previous pass
6
7void setup() {
8  pinMode(LED_PIN, OUTPUT);
9  pinMode(BUTTON_PIN, INPUT_PULLUP);
10  Serial.begin(9600);
11}
12
13void loop() {
14  bool pressed = (digitalRead(BUTTON_PIN) == LOW);   // karşılaştırma: true ya da false / comparison: true or false
15
16  if (pressed && !lastPressed) {     // şimdi basılı VE önceden değildi: yeni basış / pressed now AND not before: new press
17    presses++;                       // 1 artır / increment by 1
18    Serial.print("Basış / Presses: ");
19    Serial.println(presses);
20    delay(50);                       // basit debounce / simple debounce
21  }
22  lastPressed = pressed;
23
24  // Kalan (%) ile tek mi çift mi? / odd or even using the remainder (%)
25  digitalWrite(LED_PIN, (presses % 2 == 1) ? HIGH : LOW);
26}

Buradakı əsas məqam pressed && !lastPressed şərtidir: "indi basılıdır VƏ əvvəlki turda basılı deyildi" mənasını verir. Beləliklə, düyməni basılı saxladığın müddətdə say artmır, hər basış yalnız bir dəfə sayılır. presses % 2 əməliyyatı ədədin 2-yə bölünməsindən qalığı verir: tək ədədlərdə 1, cütlərdə 0. Son sətirdəki ? : operatoru da bu nəticəyə görə HIGH və ya LOW seçir.

if, else if və else: qərar vermək

if mötərizə içindəki şərt düzgündürsə, fiqurlu mötərizədəki kodu işlədir. Şərt səhvdirsə, varsa else bloku işləyir. Bir neçə seçim lazım olanda arada else if əlavə edilir. Şərtlər yuxarıdan aşağıya yoxlanılır və ilk düzgün olanın bloku işlədikdən sonra qalanlara baxılmır. C++-da sıfır olmayan hər dəyər düzgün hesab edilir; buna görə if (sayac) yazılışı "sayğac sıfır deyilsə" mənasını verir. Sadə if-else nümunəsini const bölməsində gördük. İndi qısa və uzun basışı ayıran nümunə yazaq:

C++ (Arduino IDE)
1const int LED_PIN = 13;
2const int BUTTON_PIN = 2;
3
4void setup() {
5  pinMode(LED_PIN, OUTPUT);
6  pinMode(BUTTON_PIN, INPUT_PULLUP);
7  Serial.begin(9600);
8}
9
10void loop() {
11  if (digitalRead(BUTTON_PIN) == LOW) {             // basıldı / pressed
12    unsigned long start = millis();
13    while (digitalRead(BUTTON_PIN) == LOW) {         // bırakılana kadar bekle / wait until released
14    }
15    unsigned long held = millis() - start;          // basılı kalma süresi (ms) / hold time (ms)
16
17    if (held < 50) {
18      return;                                       // 50 ms'den kısa: parazit, yok say / under 50 ms: bounce, ignore
19    } else if (held < 1000) {
20      digitalWrite(LED_PIN, HIGH);                  // kısa basış: LED yak / short press: LED on
21      Serial.println("Kısa basış / Short press");
22    } else {
23      digitalWrite(LED_PIN, LOW);                   // uzun basış: LED söndür / long press: LED off
24      Serial.println("Uzun basış / Long press");
25    }
26  }
27}

Kod, düymə basıldığı anda millis() ilə vaxtı qeyd edir, while dövrü ilə düymə buraxılanadək gözləyir və aradakı müddəti hesablayır. 50 ms-dən qısa basışlar düymənin mexaniki titrəyişindən (bounce) gələn pozuntu sayılır və return ilə loop()-un həmin turu vaxtından əvvəl bitirilir. 1 saniyədən qısa basış LED-i yandırır, daha uzun basış söndürür. Şərtlərin ardıcıllığı vacibdir: held < 1000 yoxlamasını ən başa yazsaydın, 30 ms-lik pozuntu da "qısa basış" sayılardı.

if (mode = 2) yazmaq ən klassik xətadır: bu sətir müqayisə etmir, mode dəyişəninə 2 mənimsədir və nəticə sıfır olmadığı üçün şərt həmişə düzgün çıxır. Başqa bir hiyləgər xəta if (x == 5); şəklində mötərizədən sonra qoyulan nöqtəli vergüldür; if boş komandayla bitir və aşağıdakı blok şərtdən asılı olmayaraq hər dəfə işləyir.

switch-case: bir neçə hal arasından seçmək

Dəyişənin dəyərinə görə bir çox müxtəlif iş görəcəksənsə, uzun else if zənciri əvəzinə switch-case daha oxunaqlıdır. switch mötərizəsindəki dəyəri hər case etiketi ilə müqayisə edir və uyğun gələn yerdən işləməyə başlayır. Hər case-in sonuna break qoymalısan; əks halda proqram növbəti case-in kodunu da işlədir. Heç bir case uyğun gəlməsə, default bloku işləyir. switch yalnız int, byte, char və enum kimi tam ədəd tipləri ilə işləyir; String, float və ya "10 ilə 20 arası" kimi aralıqlar üçün if istifadə etməlisən. Aşağıdakı nümunədə hər basış lampanı növbəti rejimə keçirir: söndürülmüş, yanıq, yavaş yanıb-sönmə, sürətli yanıb-sönmə.

C++ (Arduino IDE)
1const int LED_PIN = 13;
2const int BUTTON_PIN = 2;
3
4byte mode = 0;                 // 0 kapalı, 1 açık, 2 yavaş, 3 hızlı / 0 off, 1 on, 2 slow, 3 fast
5bool lastPressed = false;
6
7void setup() {
8  pinMode(LED_PIN, OUTPUT);
9  pinMode(BUTTON_PIN, INPUT_PULLUP);
10}
11
12void loop() {
13  bool pressed = (digitalRead(BUTTON_PIN) == LOW);
14  if (pressed && !lastPressed) {
15    mode = (mode + 1) % 4;      // 0 → 1 → 2 → 3 → 0
16    delay(50);                  // basit debounce / simple debounce
17  }
18  lastPressed = pressed;
19
20  switch (mode) {
21    case 0:                                        // kapalı / off
22      digitalWrite(LED_PIN, LOW);
23      break;
24    case 1:                                        // sürekli açık / always on
25      digitalWrite(LED_PIN, HIGH);
26      break;
27    case 2:                                        // 500 ms'de bir değiş / toggle every 500 ms
28      digitalWrite(LED_PIN, (millis() / 500) % 2 ? HIGH : LOW);
29      break;
30    case 3:                                        // 100 ms'de bir değiş / toggle every 100 ms
31      digitalWrite(LED_PIN, (millis() / 100) % 2 ? HIGH : LOW);
32      break;
33    default:                                       // beklenmeyen değer: başa dön / unexpected value: reset
34      mode = 0;
35      break;
36  }
37}

mode = (mode + 1) % 4 sətri rejimi 0, 1, 2, 3 kimi artırır və 4-ə çatanda % operatoru sayəsində yenidən 0 edir. Yanıb-sönmə üçün delay() istifadə etmədiyimizə diqqət et: (millis() / 500) % 2 ifadəsi hər 500 ms-dən bir 0 ilə 1 arasında dəyişir, beləliklə LED yanıb-sönərkən düymə də hər an basışa cavab verir. Bu "rejim" yanaşmasının böyüdülmüş formasına vəziyyət maşını deyilir; svetofor və menyu kimi layihələrdə necə istifadə olunduğunu Arduino-da vəziyyət maşını yazısında görə bilərsən.

Bir case-in içində dəyişən təyin edəcəksənsə, həmin case-in kodunu fiqurlu mötərizə içinə al: case 1: { byte step = 3; ... break; }. Mötərizəsiz Uno bunu yalnız xəbərdarlıqla kompilyasiya edir, amma ESP32 jump to case label xətası verir və kod heç kompilyasiya olunmur.

for, while və do-while dövrləri

Dövrlər kod blokunu dönə-dönə işlədir. for dövrünün mötərizəsində üç hissə var: başlanğıc (int i = 0), davam şərti (i < 6) və hər turdan sonra görüləcək əməliyyat (i++). Təkrar sayı bəlli olanda for idealdır. while şərt düzgün olduğu müddətdə dönür və şərti hər turdan əvvəl yoxlayır; nə qədər çəkəcəyi bəlli olmayan gözləmələr üçün uyğundur. do-while isə şərti sonda yoxladığı üçün ən azı bir dəfə işləyir. Dövrün içində break dövrdən dərhal çıxır, continue həmin turun qalanını atlayıb növbəti tura keçir. loop() onsuz da sonsuz dövr olduğu üçün içinə ayrıca while (true) yazmağa adətən ehtiyac yoxdur.

DövrŞərt nə vaxt yoxlanılır?Nə vaxt istifadə olunur?Nümunə
forHər turdan əvvəlTəkrar sayı bəllidirsəfor (int i = 0; i < 6; i++)
whileHər turdan əvvəlNəsə baş verənə qədər gözləyəndəwhile (digitalRead(2) == HIGH)
do-whileHər turdan sonraƏn azı bir dəfə işləməlidirsədo { ... } while (x < 10);

Aşağıdakı nümunə altı LED ilə qaçan işıq (Knight Rider) effekti yaradır. setup() içindəki for dövrü altı pini tək sətirdə çıxış edir; loop() içindəki while dövrü düyməyə basılanadək gözləyir. Düyməni basılı saxladığın müddətdə işıq D8-dən D13-ə gedir və geri qayıdır:

C++ (Arduino IDE)
1const int FIRST_LED = 8;       // ilk LED pini / first LED pin
2const int LAST_LED = 13;       // son LED pini / last LED pin
3const int BUTTON_PIN = 2;
4
5void setup() {
6  for (int pin = FIRST_LED; pin <= LAST_LED; pin++) {
7    pinMode(pin, OUTPUT);      // 6 pini tek döngüyle çıkış yap / make 6 pins outputs with one loop
8  }
9  pinMode(BUTTON_PIN, INPUT_PULLUP);
10}
11
12void loop() {
13  while (digitalRead(BUTTON_PIN) == HIGH) {
14    // butona basılana kadar burada bekle / wait here until the button is pressed
15  }
16
17  for (int pin = FIRST_LED; pin <= LAST_LED; pin++) {      // ileri: 8 → 13 / forward: 8 → 13
18    digitalWrite(pin, HIGH);
19    delay(80);
20    digitalWrite(pin, LOW);
21  }
22  for (int pin = LAST_LED - 1; pin > FIRST_LED; pin--) {   // geri: 12 → 9 / back: 12 → 9
23    digitalWrite(pin, HIGH);
24    delay(80);
25    digitalWrite(pin, LOW);
26  }
27}

Geri qayıdış dövrünün LAST_LED - 1-dən başlayıb FIRST_LED-dən böyük olduğu müddətdə dönməsi şüurlu seçimdir: kənardakı LED-lər üst-üstə iki dəfə yanmır və hərəkət axıcı görünür. Sürət ayarı, dolan effekt və daha çox naxış üçün Arduino qaçan işıq və ardıcıl LED yazısına baxa bilərsən.

for (byte i = 0; i < 256; i++) dövrü heç bitmir: byte ən çox 255 saxlaya bildiyi üçün i, 256-ya çatmadan yenidən 0 olur və şərt həmişə düzgün qalır. Eyni qaydada heç baş verməyəcək şərti gözləyən while dövrü, məsələn, naqili qopmuş sensoru gözləmək, proqramı sonsuza qədər kilidləyir.

Massivlər (array): bir neçə dəyəri tək adda saxlamaq

Massiv eyni tipli bir neçə dəyəri tək ad altında ardıcıl saxlayır. const byte LEDS[] = {8, 9, 10, 11, 12, 13}; sətri altı elementli massiv yaradır. Elementlərə kvadrat mötərizə ilə çatılır və say 0-dan başlayır: LEDS[0] dəyəri 8, LEDS[5] dəyəri 13-dür. Massivin uzunluğu təyin edildikdən sonra dəyişmir. Element sayını əllə yazmaq əvəzinə sizeof(LEDS) / sizeof(LEDS[0]) ilə hesablatsan, massivə yeni pin əlavə edəndə dövrlər öz-özünə uyğunlaşır. Massivdən kənara çıxan indeks, məsələn, LEDS[6], xəta vermir; yaddaşdakı başqa dəyişəni oxuyur və ya pozur. Buna görə indeksin 0 ilə element sayından bir az arasında qaldığına əmin olmalısan. Aşağıdakı nümunə altı LED-i elektron zərə çevirir:

C++ (Arduino IDE)
1const byte LEDS[] = {8, 9, 10, 11, 12, 13};               // LED pinleri / LED pins
2const byte LED_COUNT = sizeof(LEDS) / sizeof(LEDS[0]);    // eleman sayısı: 6 / number of elements: 6
3const byte BUTTON_PIN = 2;
4
5void setup() {
6  for (byte i = 0; i < LED_COUNT; i++) {     // indeks 0'dan başlar / index starts at 0
7    pinMode(LEDS[i], OUTPUT);
8  }
9  pinMode(BUTTON_PIN, INPUT_PULLUP);
10  randomSeed(analogRead(A0));                // boştaki A0'ın gürültüsüyle tohumla / seed from noise on the unconnected A0
11}
12
13void loop() {
14  if (digitalRead(BUTTON_PIN) == LOW) {
15    byte dice = random(1, 7);                // 1 ile 6 arası / between 1 and 6
16    for (byte i = 0; i < LED_COUNT; i++) {
17      digitalWrite(LEDS[i], (i < dice) ? HIGH : LOW);   // ilk 'dice' kadar LED yanar / the first 'dice' LEDs light up
18    }
19    delay(300);                              // basılı tutarsan zar dönmeye devam eder / keeps rolling while held
20  }
21}

random(1, 7) ifadəsi 1 ilə 6 arasında ədəd yaradır, çünki yuxarı sərhəd nəticəyə daxil deyil. Gələn ədəd qədər LED yanır: zər 4 gəlsə, LEDS[0]-dan LEDS[3]-ə qədər dörd LED yanır. randomSeed(analogRead(A0)) sətri heç yerə qoşulmayan A0 pinindəki elektrik küyünü başlanğıc dəyər kimi istifadə edir. Bu sətir olmasaydı, plata hər işə düşəndə eyni ədəd ardıcıllığını yaradardı. Massivlərin bir gözəl cəhəti də budur: LED-ləri başqa pinlərə köçürsən, yalnız ilk sətri dəyişmək kifayətdir.

Funksiya yazmaq: kodu hissələrə bölmək

Eyni işi proqramın bir neçə yerində görürsənsə, o işi funksiyaya çevir. Funksiya qaytarma tipi, adı, mötərizə içindəki parametrləri və fiqurlu mötərizə içindəki gövdəsindən ibarətdir. Dəyər qaytarmayan funksiyaların tipi void-dir. Dəyər qaytaranlar nəticəni return ilə verir. Parametrlər surət kimi ötürülür, yəni funksiya içində parametri dəyişmək onu çağıran yerdəki dəyişəni dəyişmir. Arduino IDE .ino fayllarındakı funksiyaların bəyannamələrini özü yaratdığı üçün funksiyanı loop()-un altına da yaza bilərsən. Lakin .cpp fayllarında və ya PlatformIO-da funksiyanı istifadə etməzdən əvvəl bəyan etməlisən. Funksiyalara blinkLed və ya isPressed kimi nə etdiyini izah edən adlar ver.

C++ (Arduino IDE)
1const byte LED_PIN = 13;
2const byte BUTTON_PIN = 2;
3
4// Değer döndürmeyen (void) fonksiyon / function that returns nothing (void)
5void blinkLed(byte pin, byte times, int ms) {
6  for (byte i = 0; i < times; i++) {
7    digitalWrite(pin, HIGH);
8    delay(ms);
9    digitalWrite(pin, LOW);
10    delay(ms);
11  }
12}
13
14// bool döndüren fonksiyon / function that returns a bool
15bool isPressed(byte pin) {
16  return digitalRead(pin) == LOW;      // INPUT_PULLUP: basılı = LOW / pressed = LOW
17}
18
19void setup() {
20  pinMode(LED_PIN, OUTPUT);
21  pinMode(BUTTON_PIN, INPUT_PULLUP);
22  blinkLed(LED_PIN, 3, 100);           // açılışta 3 hızlı yanıp sönme / 3 quick blinks at start-up
23}
24
25void loop() {
26  if (isPressed(BUTTON_PIN)) {
27    blinkLed(LED_PIN, 2, 250);         // basınca 2 yavaş yanıp sönme / 2 slow blinks per press
28  }
29}

blinkLed() hansı pinin, neçə dəfə və hansı sürətlə yanıb-sönəcəyini parametr kimi alır. Buna görə eyni funksiyanı başqa LED və başqa sürət üçün də istifadə edə bilərsən. isPressed() isə bool qaytarır və INPUT_PULLUP-un "basılı = LOW" məntiqini tək yerdə saxlayır; gələcəkdə düyməni tərsinə qoşsan, yalnız bu sətri dəyişirsən. Funksiyanın içindəki delay() proqramı yenə dayandırır. Eyni anda bir neçə iş görən funksiyalar üçün millis() əsaslı vaxt hesablaması lazımdır.

Qlobal, lokal və static dəyişənlər

Dəyişənin harada görünə bildiyinə görünmə dairəsi (scope) deyilir. Funksiyalardan kənarda təyin edilən qlobal dəyişənlər proqram boyu yaşayır və hər yerdən oxunub dəyişdirilə bilər. Funksiyanın və ya fiqurlu mötərizə blokunun içində təyin edilən lokal dəyişənlər həmin blok hər işləyəndə yenidən yaranır, blok bitəndə yox olur. Yeni başlayanların ən çox şikayət etdiyi "sayğacım həmişə 1 qalır" problemi buradan çıxır. Lokal dəyişənin əvvəlinə static yazsan, başlanğıc dəyəri yalnız ilk dəfə alır və dəyərini turlar arasında qoruyur, amma yenə yalnız həmin funksiyanın içindən görünür.

C++ (Arduino IDE)
1const byte LED_PIN = 13;
2const byte BUTTON_PIN = 2;
3
4int globalCount = 0;            // global: her yerden görünür, değerini korur / global: visible everywhere, keeps its value
5
6void setup() {
7  pinMode(LED_PIN, OUTPUT);
8  pinMode(BUTTON_PIN, INPUT_PULLUP);
9  Serial.begin(9600);
10}
11
12void loop() {
13  int localCount = 0;           // yerel: her turda yeniden 0 olur / local: back to 0 on every pass
14  static int staticCount = 0;   // static yerel: değerini korur, yalnız burada görünür / static local: keeps its value, visible only here
15
16  if (digitalRead(BUTTON_PIN) == LOW) {
17    globalCount++;
18    localCount++;
19    staticCount++;
20    Serial.print(globalCount);
21    Serial.print(' ');
22    Serial.print(localCount);
23    Serial.print(' ');
24    Serial.println(staticCount);                   // 3. basışta: 3 1 3 / on the 3rd press: 3 1 3
25    digitalWrite(LED_PIN, (staticCount % 2) ? HIGH : LOW);
26    delay(300);
27  }
28}

Düyməyə üç dəfə basanda Serial Monitor-da 1 1 1, 2 1 2 və 3 1 3 sətirlərini görürsən: qlobal və static sayğaclar artmağa davam edir, lokal sayğac isə loop()-un hər turunda yenidən 0-dan başladığı üçün həmişə 1-də qalır. Qlobal dəyişənlə eyni adı daşıyan lokal dəyişən təyin etsən, lokal olan qlobalı kölgədə qoyur və funksiya içində qlobal dəyişənə heç toxunmursan. Kəsmə funksiyasının (ISR) dəyişdirdiyi qlobal dəyişənlər ayrıca volatile kimi təyin edilməlidir; bunu Arduino interrupt yazısında ətraflı tapa bilərsən.

Dəyişənləri mümkün qədər lokal saxla: yalnız bir funksiyanın ehtiyac duyduğu sayğaclar üçün static, bir neçə funksiyanın paylaşdığı dəyərlər üçün qlobal istifadə et. Kompilyasiyanın sonunda IDE-nin yazdığı Global variables use … bytes of dynamic memory sətri qlobal dəyişənlərin RAM-da tutduğu yeri göstərir. Uno-da bu nisbət 75%-i keçərsə, qeyri-sabit işləmə başlaya bilər; həllər Arduino yaddaş çatışmır yazısındadır.

ESP32-də Arduino proqramlaşdırma: eyni dil, fərqli ölçülər

ESP32-ni Arduino IDE ilə proqramlaşdıranda eyni C++ dilindən və eyni komandalardan istifadə edirsən, amma bir neçə fərq var. ESP32 32 bitlik prosessor olduğu üçün int 4 baytdır və -2.147.483.648 ilə 2.147.483.647 arasındakı dəyərləri saxlayır; buna görə daşma nümunəsindəki 32767 + 1 əməliyyatı 32768 nəticəsini verir. double 8 baytdır, analogRead() 0–4095 arası dəyər qaytarır və pinlər 3,3 V ilə işləyir. Serial.printf() ilə formatlı çap etmək olar. random() defolt olaraq aparat təsadüfi ədəd generatorundan istifadə etdiyi üçün randomSeed() sətrinə ehtiyac yoxdur. Aşağıdakı proqram yazıda öyrəndiyin hər şeyi birləşdirir: massiv, funksiya, switch-case və rejim dəyişən düymə. Platanın ümumi xüsusiyyətləri üçün ESP32 nədir? yazısına baxa bilərsən.

C++ (Arduino IDE)
1// ESP32: aynı dil, farklı pinler / ESP32: same language, different pins
2const byte LEDS[] = {18, 19, 21, 22, 23, 25};            // güvenli GPIO'lar / safe GPIOs
3const byte LED_COUNT = sizeof(LEDS) / sizeof(LEDS[0]);
4const byte BUTTON_PIN = 4;                                // diğer bacağı GND'ye / other leg to GND
5
6byte mode = 0;                  // 0 kapalı, 1 yürüyen ışık, 2 hepsi yanıp söner / 0 off, 1 chaser, 2 all blink
7bool lastPressed = false;
8
9void setAll(bool on) {
10  for (byte i = 0; i < LED_COUNT; i++) {
11    digitalWrite(LEDS[i], on ? HIGH : LOW);
12  }
13}
14
15void setup() {
16  Serial.begin(115200);
17  for (byte i = 0; i < LED_COUNT; i++) {
18    pinMode(LEDS[i], OUTPUT);
19  }
20  pinMode(BUTTON_PIN, INPUT_PULLUP);
21  Serial.printf("int = %d bayt / bytes\n", (int)sizeof(int));   // ESP32'de 4 / 4 on the ESP32
22
23  int a = 32767;
24  a = a + 1;
25  Serial.println(a);                                          // ESP32'de 32768, taşma yok / 32768 on the ESP32, no overflow
26}
27
28void loop() {
29  bool pressed = (digitalRead(BUTTON_PIN) == LOW);
30  if (pressed && !lastPressed) {
31    mode = (mode + 1) % 3;      // 0 → 1 → 2 → 0
32    delay(50);
33  }
34  lastPressed = pressed;
35
36  switch (mode) {
37    case 0:
38      setAll(false);
39      break;
40    case 1: {                                                 // case içinde değişken için süslü parantez / braces for a variable inside a case
41      byte step = (millis() / 120) % LED_COUNT;               // sıradaki LED / LED whose turn it is
42      for (byte i = 0; i < LED_COUNT; i++) {
43        digitalWrite(LEDS[i], (i == step) ? HIGH : LOW);
44      }
45      break;
46    }
47    case 2:
48      setAll((millis() / 300) % 2);                           // 300 ms'de bir hepsi / all of them every 300 ms
49      break;
50  }
51}

Bu proqramı Uno-da işlətmək üçün LEDS massivini {8, 9, 10, 11, 12, 13}, BUTTON_PIN sabitini 2 etməyin və Uno-da olmayan Serial.printf() sətrini Serial.print() ilə əvəz etməyin kifayətdir. Pin nömrələrini əvvəldə sabit və massiv kimi təyin etməyin faydası məhz budur. case 1 blokunun fiqurlu mötərizə içində olduğuna da diqqət et; içində step dəyişəni təyin edildiyi üçün ESP32-də bu mötərizələr məcburidir.

Raspberry Pi Pico: eyni məntiq MicroPython ilə

Raspberry Pi Pico-nu Arduino IDE-yə RP2040 plata paketini əlavə edərək C++ ilə proqramlaşdıra bilərsən; bu halda yazıdakı kodlar pin nömrələrini dəyişməyin kifayət edəcəyi şəkildə işləyir və int yenə 4 baytdır. Pico-nun ən geniş istifadəsi isə MicroPython-dur. Python-da dəyişən tipi yazılmır, bloklar fiqurlu mötərizə əvəzinə girintiylə müəyyən edilir, sətrin sonunda nöqtəli vergül yoxdur və tam ədədlər daşmır, lazım olduğu qədər böyüyür. Aşağıdakı kod elektron zər nümunəsinin MicroPython qarşılığıdır. Quraşdırma üçün Raspberry Pi Pico nədir?, dilin təfərrüatları üçün MicroPython əsasları yazılarına baxa bilərsən.

MicroPython
1from machine import Pin
2import time, random
3
4leds = [Pin(n, Pin.OUT) for n in (14, 13, 12, 11, 10, 9)]   # liste = dizi / list = array
5button = Pin(2, Pin.IN, Pin.PULL_UP)                        # basılınca 0 / reads 0 when pressed
6
7def show(count):                                            # fonksiyon / function
8    for i, led in enumerate(leds):                          # for döngüsü / for loop
9        led.value(1 if i < count else 0)
10
11show(0)                                                     # setup() karşılığı: bir kez çalışır / like setup(): runs once
12while True:                                                 # loop() karşılığı / like loop()
13    if button.value() == 0:                                 # buton basılı mı? / is the button pressed?
14        show(random.randint(1, 6))                          # 1-6 arası zar at / roll a number from 1 to 6
15        time.sleep_ms(300)
AnlayışArduino (C++)MicroPython
Bir dəfə işləyən hissəsetup()while True: sətrindən əvvəlki kod
Daim təkrarlanan hissəloop()while True:
Dəyişənint x = 5;x = 5
Sabitconst int PIN = 2;PIN = const(2) (from micropython import const)
Şərtif / else if / elseif / elif / else
Çoxlu seçimswitch-caseif / elif zənciri
Sayma dövrüfor (int i = 0; i < 6; i++)for i in range(6):
Massivbyte a[] = {1, 2, 3};a = [1, 2, 3]
Funksiyavoid blink(int pin) { ... }def blink(pin):
Məntiq&& || !and or not
Şərh// şərh# şərh

Bu əsaslarla edə biləcəyin layihə ideyaları

  • Svetofor: const sabitləri, delay() və if ilə piyada düyməli kəsişmə qur; addım-addım izahı Arduino svetofor yazısındadır.
  • Qaçan işıq və ardıcıl LED: for dövrü və massivlə onlarla fərqli işıq naxışı yarat.
  • Elektron zər: Massiv, random() və funksiya ilə 6 LED-li zəri 7 seqmentli göstəriciyə köçür; bunun üçün 7 seqmentli displey yazısına bax.
  • Reaksiya testi: LED təsadüfi anda yansın, düyməyə nə qədər tez basdığını unsigned long və millis() ilə ölç.
  • Rejim seçimli lampa: switch-case ilə tək düymədən söndürülmüş, sabit, nəfəs və flaş rejimləri; rəngli versiyası üçün RGB LED-in istifadəsi yazısına nəzər sal.
  • Şifrəli kilid: Daxil edilən düymələri massivdə topla və yadda saxlanmış şifrə ilə müqayisə et; təfərrüatlar Keypad istifadəsi yazısındadır.

Tez-tez edilən səhvlər və həlləri

SəhvƏlamətHəll
Müqayisədə = istifadə etməkif bloku həmişə işləyirMüqayisədə == istifadə et
#define sətrinə ; və ya = qoymaqexpected ')' before ';' token#define LED_PIN 13 şəklində yaz
Komandanı yanlış hərflə yazmaq'pinmode' was not declared in this scopepinMode kimi böyük-kiçik hərfə diqqət et
Dəyişən adında Azərbaycan hərfi (ə, ş, ç…)stray '\303' in programAdlarda yalnız ingilis hərfləri, rəqəm və _ istifadə et
60 * 1000-i int ilə hesablamaqNəticə -5536 çıxır60 * 1000L və ya 60000UL yaz
millis() dəyərini int-də saxlamaqVaxt hesablaması 32 saniyədən sonra pozulurunsigned long istifadə et
Tam ədəd bölməsi5 / 2 nəticəsi 2 çıxır5 / 2.0 yaz və ya float-a çevir
case-in sonunda break unutmaqNövbəti case də işləyirHər case-i break ilə bitir
Massivdən kənara yazmaqTəsadüfi dəyərlər, donmaİndeksi 0 ilə element sayı - 1 arasında saxla
Sayğacı lokal təyin etməkSayğac həmişə 1 qalırQlobal və ya static et
Kompilyasiya xətası alanda yalnız ilk xəta sətrini oxu və onu düzəlt; sonrakı sətirlərdəki xətaların çoxu ilk xətanın yan təsiridir. Mesajların nə demək olduğunu Arduino kompilyasiya xətaları yazısında tapa bilərsən. Əlində plata yoxdursa, kodları Tinkercad simulyasiyasında da sınaya bilərsən.

Bu tikinti bloklarını öyrəndikdən sonra növbəti addım ən çox işlədilən komandaları tanımaqdır: Arduino komandaları və mənaları yazısı pinMode()-dan attachInterrupt()-a qədər hamısını nümunələrlə izah edir. BlueGrays tətbiqində də LED yandırma, düymə ilə LED idarəsi, qaçan işıq, svetofor və zər kimi layihələri dövrə sxemləri və hazır kodları ilə addım-addım tapa bilərsən; burada öyrəndiyin hər strukturu real dövrədə sınaya bilərsən.

Tez-tez verilən suallar

Arduino hansı proqramlaşdırma dili ilə yazılır?

Arduino kodu C++ dilinin üzərində qurulub. Arduino nüvəsi bu dilə pinMode(), digitalWrite() və delay() kimi hazır funksiyalar əlavə edir, kodlar da .ino uzantılı fayllara yazılır. ESP32 və Raspberry Pi Pico kimi platalar istəsən MicroPython ilə də proqramlaşdırıla bilər.

Arduino proqramlaşdırmaya haradan başlamalıyam?

Əvvəlcə Arduino IDE-ni quraşdır və daxili LED-i yandırıb-söndürən Blink nümunəsini yüklə. Ardınca ardıcıllıqla setup() və loop(), dəyişənlər, if-else, dövrlər, massivlər və funksiyalar mövzularını hərəsini bir LED və ya düymə dövrəsi ilə sına. Hər yeni mövzunu kiçik layihədə istifadə etmək yalnız oxumaqdan qat-qat davamlı öyrənməyini təmin edir.

Arduino-da int ilə long arasındakı fərq nədir?

Arduino Uno-da int 2 baytdır və -32.768 ilə 32.767 arasındakı ədədləri saxlayır. long isə 4 baytdır və təxminən ±2,1 milyarda qədər çatır. Bu həddi aşan ədəd xəta vermədən başa qayıdır, buna görə millis() kimi böyük dəyərlər üçün long və ya unsigned long istifadə olunur. ESP32 və Pico-da int də 4 baytdır.

Arduino-da const ilə #define arasındakı fərq nədir?

const ilə təyin edilən sabitin tipi var, görünmə dairəsi qaydalarına tabe olur və dəyişdirilməyə çalışılanda kompilyator xəta verir. #define isə kompilyasiyadan əvvəl edilən mətn əvəzləməsidir, tipi yoxdur və sonuna nöqtəli vergül qoyulsa gözlənilməz xətalara yol açır. Sadə ədədlər üçün hər ikisi RAM sərf etmir, lakin təhlükəsiz olduğu üçün adətən const üstün tutulur.

Arduino-da for ilə while dövrü arasındakı fərq nədir?

for dövrü başlanğıc, şərt və artırma hissələrini tək sətirdə toplayır və təkrar sayı bəlli olanda istifadə olunur; məsələn, altı LED-i ardıcıl yandırmaq üçün. while isə yalnız şərtə baxır və şərt düzgün olduğu müddətdə dönür; düyməyə basılmasını gözləmək kimi nə qədər çəkəcəyi bəlli olmayan hallara uyğundur.

Arduino Python ilə proqramlaşdırıla bilərmi?

Arduino Uno kimi 8 bitlik platalar Python işlədə bilmir, buna görə C++ ilə proqramlaşdırılır. ESP32 və Raspberry Pi Pico isə MicroPython ilə proqramlaşdırıla bilər. Bundan əlavə, kompüterdə işləyən Python proqramı serial port vasitəsilə Uno ilə əlaqə quraraq onu dolayı yolla idarə edə bilər.

Bütün layihələrə bax
LED yandırma
AR-1Başlanğıc

LED yandırma

Elektronikanın ilk salamı: tək bir LED-i yandırıb söndürmək. Arduino LED-i çox qısa fasilələrlə yandırıb söndürür, işıq sürətlə qırpılır.

4.6(200)
1246
Düymə ilə LED yandırma (Push)
AR-9Başlanğıc

Düymə ilə LED yandırma (Push)

Qapı zəngi kimi: bassan işıq yanır, buraxanda sönür. Arduino düyməni daim dinləyir; düymə basılı olanda LED-i yandırır, əlini çəkdiyin anda söndürür.

4.8(114)
253
Düymə ilə LED yandırma (On Off)
AR-10Başlanğıc

Düymə ilə LED yandırma (On Off)

Düyməyə bir dəfə basanda işıq yanır, bir daha basanda sönür; tam otağındakı lampa düyməsi kimi.

4.7(103)
177
Qaçan işıq LED
AR-6Orta

Qaçan işıq LED

Knight Rider işığı kimi tanınan effekt: işıq altı LED üzərində bir ucdan o biri uca sürüşür, sonra geri qayıdır.

4.8(107)
214
Svetofor
AR-3Başlanğıc

Svetofor

Hər gün yolda gördüyün svetoforun balaca nüsxəsi. Qırmızı iki saniyə yanır, sarı qısa an parlayır, yaşıl iki saniyə yanır, sonra yenə sarı üzərindən qırmızıya qayıdılır və dövr heç dayanmır.

4.8(137)
440
ESP32 ilə düymədən LED idarəsi (Push)
ES-2Başlanğıc

ESP32 ilə düymədən LED idarəsi (Push)

Düymə basılı saxlananda LED yanır, buraxılanda sönür. ESP32-nin rəqəmsal giriş pinindən və daxili pull-up rezistorundan necə istifadə olunduğunu göstərir. INPUT_PULLUP rejimi sayəsində xarici rezistor lazım deyil.

4.6(36)
57
Raspberry Pi Pico düymə ilə LED yandırma (Toggle)
PI-10Başlanğıc

Raspberry Pi Pico düymə ilə LED yandırma (Toggle)

Düymə ilə LED — bir səviyyə yuxarı! Burada düyməni basılı saxlamaq lazım deyil: bas və burax → LED yanır, yenidən bas və burax → LED sönür (toggle). Dövrə eynidir (LED GP14, Düymə GP2), amma kod fərqlidir. Öyrənəcəkların: edge detection (pinin 1-dən 0-a düşdüyü anı tutmaq), state tracking, debounce (düymənin mexaniki sıçrayışını süzmək). MicroPython-un led.toggle() metodu vəziyyəti tək sətirdə dəyişir.

10
Zər layihəsi
AR-79Orta
Premium

Zər layihəsi

Stolüstü oyunlarda itən zərlərə son: düyməyə hər basanda 7 seqmentli ekranda 1-dən 6-ya qədər təsadüfi bir rəqəm çıxır. Bir basışda bir nəticə gəlir və nəticə kompüter ekranına da yazılır.

5.0(48)
67