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 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:
| Qayda | Düzgün yazılış | Əməl etməsən |
|---|---|---|
| Hər komanda nöqtəli vergüllə bitir | digitalWrite(13, HIGH); | expected ';' before '}' token |
| Böyük-kiçik hərf fərq edir | pinMode(13, OUTPUT); | 'pinmode' was not declared in this scope |
| Kod blokları fiqurlu mötərizə içindədir | void 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 Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| 6 LED (hər biri 220 Ω ilə, katod GND-yə) | D8, D9, D10, D11, D12, D13 | GPIO 18, 19, 21, 22, 23, 25 | GP14, GP13, GP12, GP11, GP10, GP9 |
| Düymə (digər ayağı GND-yə) | D2 | GPIO 4 | GP2 |
| Platadakı LED | D13 (L hərfli LED) | GPIO 2 (əksər DevKit-lərdə) | GP25 (Pico W-də "LED") |
| Serial port sürəti | 9600 baud | 115200 baud | Thonny Shell |
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.
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.
| Tip | Uno-da ölçü | Dəyər aralığı | Tipik istifadə |
|---|---|---|---|
| bool | 1 bayt | true və ya false | LED yanıqdır, düyməyə basılıb |
| byte | 1 bayt | 0 – 255 | Pin nömrəsi, PWM parlaqlığı |
| char | 1 bayt | -128 – 127 | Tək simvol: 'A' |
| int | 2 bayt | -32.768 – 32.767 | Sayğaclar, analogRead() nəticəsi |
| unsigned int | 2 bayt | 0 – 65.535 | Yalnız müsbət ədədlər |
| long | 4 bayt | -2.147.483.648 – 2.147.483.647 | Böyük tam ədədlər |
| unsigned long | 4 bayt | 0 – 4.294.967.295 | millis() ilə vaxt ölçümü |
| float | 4 bayt | Təxminən ±3,4 × 10^38, 6–7 rəqəm dəqiqlik | Temperatur, gərginlik, orta dəyər |
| double | 4 bayt (Uno-da float ilə eyni) | float ilə eyni | ESP32-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:
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ətri | Uno-da nəticə | ESP32 və Pico-da nəticə | Niyə? |
|---|---|---|---|
| a = 32767 + 1 | -32768 | 32768 | Uno-da int 2 bayt, digərlərində 4 baytdır |
| 60 * 1000 | -5536 | 60000 | Sabitlər əvvəlcə int kimi hesablanır |
| 60 * 1000L | 60000 | 60000 | L şəkilçisi əməliyyatı long edir |
| 5 / 2 | 2.00 | 2.00 | İki tam ədədin bölməsi tam ədəddir |
| 5 / 2.0 | 2.50 | 2.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.
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.
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}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:
| Qrup | Operator | Mənası | Nümunə |
|---|---|---|---|
| Arifmetik | + - * / | Dörd əməl | x = 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 azalt | i++; |
| Müqayisə | == != < > <= >= | Nəticə true və ya false | if (x >= 10) |
| Məntiq | && || ! | VƏ, VƏ YA, DEYİL | if (a && !b) |
| Şərt | ? : | Qısa if-else | x > 0 ? HIGH : LOW |
| Bit | & | ^ ~ << >> | Ədədin bitləri üzərində əməliyyat | 1 << 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:
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:
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ı.
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ə.
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.
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ə |
|---|---|---|---|
| for | Hər turdan əvvəl | Təkrar sayı bəllidirsə | for (int i = 0; i < 6; i++) |
| while | Hər turdan əvvəl | Nəsə baş verənə qədər gözləyəndə | while (digitalRead(2) == HIGH) |
| do-while | Hə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:
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.
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:
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.
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.
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.
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.
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.
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şən | int x = 5; | x = 5 |
| Sabit | const int PIN = 2; | PIN = const(2) (from micropython import const) |
| Şərt | if / else if / else | if / elif / else |
| Çoxlu seçim | switch-case | if / elif zənciri |
| Sayma dövrü | for (int i = 0; i < 6; i++) | for i in range(6): |
| Massiv | byte a[] = {1, 2, 3}; | a = [1, 2, 3] |
| Funksiya | void 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ət | Həll |
|---|---|---|
| Müqayisədə = istifadə etmək | if bloku həmişə işləyir | Müqayisədə == istifadə et |
| #define sətrinə ; və ya = qoymaq | expected ')' before ';' token | #define LED_PIN 13 şəklində yaz |
| Komandanı yanlış hərflə yazmaq | 'pinmode' was not declared in this scope | pinMode kimi böyük-kiçik hərfə diqqət et |
| Dəyişən adında Azərbaycan hərfi (ə, ş, ç…) | stray '\303' in program | Adlarda yalnız ingilis hərfləri, rəqəm və _ istifadə et |
| 60 * 1000-i int ilə hesablamaq | Nəticə -5536 çıxır | 60 * 1000L və ya 60000UL yaz |
| millis() dəyərini int-də saxlamaq | Vaxt hesablaması 32 saniyədən sonra pozulur | unsigned long istifadə et |
| Tam ədəd bölməsi | 5 / 2 nəticəsi 2 çıxır | 5 / 2.0 yaz və ya float-a çevir |
| case-in sonunda break unutmaq | Növbəti case də işləyir | Hər case-i break ilə bitir |
| Massivdən kənara yazmaq | Təsadüfi dəyərlər, donma | İndeksi 0 ilə element sayı - 1 arasında saxla |
| Sayğacı lokal təyin etmək | Sayğac həmişə 1 qalır | Qlobal və ya static et |
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.
Bu yazıdan sonra edə biləcəyin layihələr
Bütün layihələrə bax
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.

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.

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.

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.

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.

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.

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.

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.
Digər yazılar
BlueGrays tətbiqi
Bu dövrəni telefonunda addım-addım qur
Dövrə sxemi, kod və hissə siyahısı bir ekranda. 500-dən çox Arduino, ESP32 və Pico layihəsi səni gözləyir.
Telefonunla skan et
Kameranı koda tut; telefonunun tətbiq mağazası açılır.
ya da mağazada aç

