Arduino komandaları və mənaları: nümunələrlə əsas komanda siyahısı
Arduino komandaları və mənaları: pinMode, digitalWrite, analogRead, analogWrite, millis, Serial, map, tone, pulseIn, attachInterrupt; nümunələr və tez-tez edilən səhvlər.
Arduino komandaları platana nə edəcəyini deyən hazır funksiyalardır: pini çıxış edən pinMode(), LED yandıran digitalWrite(), sensoru oxuyan analogRead() və kompüterə mesaj göndərən Serial.println() bunların ən məşhurlarıdır. Arduino proqramlarının böyük hissəsi əslində iyirmiyə yaxın əsas komandanın müxtəlif şəkildə birləşməsindən ibarətdir. Bu komandaları və mənalarını bir dəfə yaxşı öyrənəndə LED yandırmaqdan robot maşına qədər gördüyün hər kodu oxuya, öz layihəni də sıfırdan yaza bilərsən.
Bu bələdçidə ən çox istifadə olunan Arduino komandalarını dörd qrupda topladıq: giriş-çıxış, zaman, riyaziyyat və rabitə. Hər komanda üçün sintaksisi, parametrlərin nə demək olduğunu, Arduino Uno-da kompilyasiya olunub işləyən qısa nümunəni və yeni başlayanların ən çox düşdüyü səhvi tapacaqsan. Son bölmələrdə eyni komandaların ESP32-də necə fərqli davrandığını və Raspberry Pi Pico-dakı MicroPython qarşılıqlarını da görəcəyik.

Arduino komandası nədir, proqram necə işləyir?
Arduino kodu C/C++ dili üzərində qurulub; "komanda" dediyimiz şeylərin çoxu əslində Arduino nüvəsinin sənə hazır təqdim etdiyi funksiyalardır. Funksiya mötərizə içində parametr qəbul edir (məsələn, pin nömrəsi və dəyər), bəziləri isə geriyə nəticə qaytarır: digitalRead() pinin vəziyyətini, millis() keçən müddəti verir. Hər Arduino proqramında iki məcburi funksiya var: setup() plata işə düşəndə və ya sıfırlananda yalnız bir dəfə işləyir, loop() isə ondan sonra sonsuza qədər təkrarlanır. Pin ayarları və Serial.begin() kimi hazırlıqlar setup() içinə, daim görüləcək işlər loop() içinə yazılır.
1// Her Arduino programı bu iki fonksiyondan oluşur / Every Arduino sketch has these two functions
2void setup() {
3 // Açılışta ya da resetten sonra bir kez çalışır / Runs once at power-up or after reset
4 pinMode(13, OUTPUT); // dahili LED pini çıkış / built-in LED pin as output
5}
6
7void loop() {
8 // Sonsuza kadar tekrar eder / Repeats forever
9 digitalWrite(13, HIGH); // LED'i yak / turn the LED on
10 delay(500); // 500 ms bekle / wait 500 ms
11 digitalWrite(13, LOW); // LED'i söndür / turn the LED off
12 delay(500);
13}Üç qaydaya əvvəldən diqqət etmək səni çoxlu kompilyasiya xətasından qurtarır: komandalar böyük-kiçik hərfə həssasdır (digitalwrite yazsan "'digitalwrite' was not declared in this scope" xətası alarsan), hər ifadə nöqtəli vergüllə bitir, mətnlər cüt dırnaq, tək simvollar isə tək dırnaq içində yazılır. Dəyişən tipləri, if və for kimi strukturlar üçün Arduino proqramlaşdırmanın əsasları yazısına nəzər sala bilərsən.
Arduino komandaları siyahısı: kateqoriyalara görə cədvəllər
Aşağıdakı dörd cədvəl gündəlik layihələrdə istifadə edəcəyin komandaların demək olar ki, hamısını ümumiləşdirir. İlk qrup giriş-çıxış komandalarıdır; pinlərin vəzifəsini təyin edir, pinlərə gərginlik verir və ya pinlərdən dəyər oxuyurlar. Platandakı pin nömrələrini Pinout alətində görə bilərsən.
| Komanda | Sintaksis | Nə işə yarayır? | Nümunə |
|---|---|---|---|
| pinMode | pinMode(pin, rejim) | Pini giriş və ya çıxış edir | pinMode(13, OUTPUT); |
| digitalWrite | digitalWrite(pin, dəyər) | Pini HIGH (5 V) və ya LOW (0 V) edir | digitalWrite(13, HIGH); |
| digitalRead | digitalRead(pin) | Pinin HIGH, yoxsa LOW olduğunu oxuyur | int b = digitalRead(2); |
| analogRead | analogRead(pin) | 0–5 V gərginliyi 0–1023 ədədinə çevirir | int v = analogRead(A0); |
| analogWrite | analogWrite(pin, dəyər) | 0–255 arası PWM siqnalı yaradır | analogWrite(9, 128); |
| analogReference | analogReference(tip) | analogRead üçün istinad gərginliyini seçir | analogReference(INTERNAL); |
| tone / noTone | tone(pin, tezlik, müddət) | Kvadrat dalğa ilə səs yaradır, noTone dayandırır | tone(8, 440, 500); |
| pulseIn | pulseIn(pin, dəyər, vaxtAşımı) | Bir impulsun müddətini µs ilə ölçür | pulseIn(10, HIGH, 30000); |
| shiftOut | shiftOut(dataPin, clockPin, order, byte) | Baytı bit-bit göndərir (74HC595 kimi) | shiftOut(11, 12, MSBFIRST, 255); |
| attachInterrupt | attachInterrupt(kəsmə, funksiya, rejim) | Pin dəyişən kimi funksiyanı dərhal çağırır | attachInterrupt(digitalPinToInterrupt(2), say, FALLING); |
İkinci qrup zaman komandalarıdır. Gözləyən delay() ilə müddət ölçən millis() və micros() arasındakı fərqi anlamaq axıcı işləyən proqram yazmağın açarıdır.
| Komanda | Sintaksis | Nə işə yarayır? | Diqqət |
|---|---|---|---|
| delay | delay(ms) | Verilən millisaniyə qədər gözləyir | Bu müddətdə proqram dayanır |
| delayMicroseconds | delayMicroseconds(us) | Mikrosaniyə səviyyəsində gözləyir | 3–16383 µs arasında dəqiqdir |
| millis | millis() | Açılışdan bəri keçən millisaniyəni verir | unsigned long; təxminən 49,7 gündə sıfırlanır |
| micros | micros() | Açılışdan bəri keçən mikrosaniyəni verir | Uno-da 4 µs addımlarla artır, təxminən 70 dəqiqədə sıfırlanır |
Üçüncü qrup riyaziyyat komandalarıdır; sensordan gələn ədədi başqa aralığa çevirmək, məhdudlaşdırmaq və ya təsadüfi ədəd yaratmaq üçün istifadə olunurlar. Dördüncü qrup olan rabitə komandaları isə platanın kompüterlə və digər cihazlarla məlumat mübadiləsi etməsini təmin edir.
| Komanda | Sintaksis | Nə işə yarayır? | Nümunə nəticə |
|---|---|---|---|
| map | map(x, köhnəAşağı, köhnəYuxarı, yeniAşağı, yeniYuxarı) | Bir aralığı başqa aralığa miqyaslayır | map(512, 0, 1023, 0, 255) → 127 |
| constrain | constrain(x, aşağı, yuxarı) | Dəyəri iki hədd arasında saxlayır | constrain(300, 0, 255) → 255 |
| min / max | min(a, b) / max(a, b) | Kiçik və ya böyük olanı verir | min(7, 3) → 3 |
| abs | abs(x) | Mütləq qiymət | abs(-12) → 12 |
| pow / sqrt / sq | pow(əsas, qüvvət), sqrt(x), sq(x) | Qüvvətə yüksəltmə, kvadrat kök, kvadrat | pow(2, 10) → 1024.0 |
| random | random(min, max) | Təsadüfi tam ədəd (max daxil deyil) | random(1, 7) → 1 ilə 6 arası |
| randomSeed | randomSeed(toxum) | Təsadüfi ardıcıllığın başlanğıcını dəyişir | randomSeed(analogRead(A3)); |
| Komanda | Nə işə yarayır? | Nümunə |
|---|---|---|
| Serial.begin(sürət) | Serial portu verilən baud sürətində açır | Serial.begin(9600); |
| Serial.print(məlumat) | Məlumatı yazır, eyni sətirdə qalır | Serial.print(temperatur); |
| Serial.println(məlumat) | Məlumatı yazır və alt sətrə keçir | Serial.println("Merhaba"); |
| Serial.available() | Oxunmağı gözləyən bayt sayını verir | if (Serial.available() > 0) |
| Serial.read() | Bir bayt oxuyur, məlumat yoxdursa -1 qaytarır | char c = Serial.read(); |
| Serial.readStringUntil(s) | Müəyyən simvola qədər mətn oxuyur | String s = Serial.readStringUntil('\n'); |
| Serial.parseInt() | Gələn mətndən tam ədəd çıxarır | int n = Serial.parseInt(); |
| Serial.write(bayt) | Xam bayt göndərir | Serial.write(65); // 'A' |
| Wire.begin() | I2C xəttini işə salır (Wire.h) | Wire.begin(); |
| SPI.begin() | SPI xəttini işə salır (SPI.h) | SPI.begin(); |
pinMode(): pinin vəzifəsini təyin etmək
pinMode(pin, rejim) rəqəmsal pinin giriş, yoxsa çıxış olacağını bildirir və adətən setup() içində bir dəfə yazılır. Üç rejim var: OUTPUT pini çıxış edir (LED, buzzer və ya rele idarə etmək üçün), INPUT pini yüksək empedanslı giriş edir (xaricdə pull-up və ya pull-down rezistoru olan dövrələr üçün), INPUT_PULLUP isə pini giriş edib daxili təxminən 20–50 kΩ-luq rezistoru 5 V-a qoşur. Analoq pinlər (A0–A5) də pinMode ilə rəqəmsal pin kimi istifadə oluna bilər; məsələn, pinMode(A0, OUTPUT) keçərli komandadır.
digitalWrite() və digitalRead(): rəqəmsal çıxış və giriş
digitalWrite(pin, HIGH) çıxış pinini Uno-da 5 V-a, digitalWrite(pin, LOW) isə 0 V-a çəkir. Bir pindən ən çox 20 mA cərəyan çəkmək təhlükəsizdir (mütləq hədd 40 mA); LED-i həmişə rezistorla qoş, uyğun dəyəri LED rezistoru hesablama aləti ilə tapa bilərsən. digitalRead(pin) isə pindəki gərginliyə baxır və HIGH və ya LOW qaytarır; Uno-da təxminən 3 V-dan yuxarı HIGH, 1,5 V-dan aşağı LOW sayılır. Aşağıdakı nümunədə D2-yə qoşulu düyməyə basanda daxili LED yanır:
1const int BUTON_PIN = 2; // buton: bir ucu D2, diğer ucu GND / button: one leg to D2, the other to GND
2const int LED_PIN = 13; // dahili LED / built-in LED
3
4void setup() {
5 pinMode(BUTON_PIN, INPUT_PULLUP); // dahili pull-up direnci açık / internal pull-up resistor enabled
6 pinMode(LED_PIN, OUTPUT);
7}
8
9void loop() {
10 int durum = digitalRead(BUTON_PIN); // HIGH ya da LOW döner / returns HIGH or LOW
11 if (durum == LOW) { // pull-up ile basılı = LOW / with pull-up, pressed = LOW
12 digitalWrite(LED_PIN, HIGH);
13 } else {
14 digitalWrite(LED_PIN, LOW);
15 }
16}INPUT_PULLUP istifadə edəndə məntiq tərsinə olur: düymə sərbəstdirsə, pin daxili rezistor sayəsində HIGH oxunur, basılanda GND-yə qoşulduğu üçün LOW oxunur. Düyməni rezistorsuz və INPUT rejimində qoşsan, pin havada qalır və digitalRead() təsadüfi dəyərlər qaytarır; əlini yaxınlaşdırman belə nəticəni dəyişə bilər. Düymənin sıçraması (bounce) və düzgün qoşulma üsulları üçün Arduino-ya düymə necə qoşulur? yazısına baxa bilərsən.
analogRead() və analogWrite(): analoq oxuma və PWM
analogRead(pin) A0–A5 pinlərindəki 0–5 V arası gərginliyi 10 bitlik çevirici (ADC) ilə 0–1023 arası ədədə çevirir. Bir oxuma təxminən 100 µs çəkir, yəni saniyədə təxminən 10.000 ölçmə aparmaq olar. Oxunan ədədi gərginliyə çevirmək üçün dəyər × 5,0 / 1023 düsturundan istifadə olunur; məsələn, 512 oxunuşu təxminən 2,5 V deməkdir. İstinad gərginliyi analogReference() ilə dəyişdirilə bilər: INTERNAL seçimi Uno-da 1,1 V-luq daxili istinadı istifadə edir və kiçik gərginliklərdə həssaslığı artırır. Həllediciliyin və istinadın təfərrüatları ADC və analoq-rəqəmsal çevirmə yazısındadır.
analogWrite(pin, dəyər) adına baxmayaraq real analoq gərginlik yaratmır. Pini çox sürətlə açıb-bağlayaraq PWM siqnalı yaradır: 0 həmişə bağlı, 255 həmişə açıq, 127 isə təxminən yarı-yarıya açıq deməkdir. LED-in gözümüzə yarı parlaq görünməsi və mühərrikin yavaş fırlanması bu ortalamadan gəlir. Uno-da yalnız platanın üzərində ~ işarəsi olan 3, 5, 6, 9, 10 və 11 nömrəli pinlər PWM verir; tezlik əksər pinlərdə 490 Hz, 5 və 6 nömrəli pinlərdə 980 Hz-dir. analogWrite() pini özü çıxış etdiyi üçün pinMode məcburi deyil. Aşağıdakı kod potensiometrlə LED parlaqlığını tənzimləyir və oxunan dəyəri gərginliklə birlikdə Serial Monitor-a yazır; doldurma əmsalı (duty cycle) və tezliyin təfərrüatları PWM nədir? yazısındadır.
1const int POT_PIN = A0; // potansiyometrenin orta bacağı / potentiometer wiper
2const int LED_PIN = 9; // ~9 PWM pini + 220 ohm direnç / ~9 PWM pin + 220 ohm resistor
3
4void setup() {
5 Serial.begin(9600);
6}
7
8void loop() {
9 int ham = analogRead(POT_PIN); // 0-1023 arası / between 0 and 1023
10 float volt = ham * (5.0 / 1023.0); // sayıyı gerilime çevir / convert the reading to volts
11 analogWrite(LED_PIN, ham / 4); // 0-1023 -> 0-255 PWM parlaklığı / 0-1023 -> 0-255 PWM brightness
12
13 Serial.print(F("Ham / raw: "));
14 Serial.print(ham);
15 Serial.print(F(" Gerilim / voltage: "));
16 Serial.print(volt, 2); // 2 ondalık basamak / 2 decimal places
17 Serial.println(F(" V"));
18 delay(200);
19}delay(), millis() və micros(): zaman komandaları
delay(ms) verilən millisaniyə qədər gözləyir və bu müddətdə loop() içindəki heç bir sətir işləmir; delay(1000) bir saniyəlik tam fasilədir. Mikrosaniyə səviyyəsində qısa gözləmələr üçün delayMicroseconds() var və 3 ilə 16383 µs arasında düzgün nəticə verir. millis() isə gözləmir; platanın açıldığı vaxtdan bəri keçən müddəti millisaniyə ilə qaytarır. Nəticəni həmişə unsigned long tipli dəyişəndə saxlamalısan: int istifadə etsən, Uno-da dəyər 32.767-ni keçən kimi, yəni təxminən 33 saniyə sonra daşır və zamanlama pozulur. millis() təxminən 49,7 gündən bir sıfıra qayıdır; aşağıdakı çıxma üsulu bu daşmada belə düzgün işləyir.
1const int LED_PIN = 13;
2const unsigned long ARALIK = 500; // yanıp sönme aralığı (ms) / blink interval (ms)
3unsigned long oncekiZaman = 0; // son değişim anı / time of the last toggle
4
5void setup() {
6 pinMode(LED_PIN, OUTPUT);
7}
8
9void loop() {
10 unsigned long simdi = millis();
11 if (simdi - oncekiZaman >= ARALIK) { // taşmada da doğru çalışır / safe across overflow
12 oncekiZaman = simdi;
13 digitalWrite(LED_PIN, !digitalRead(LED_PIN)); // LED'i tersine çevir / toggle the LED
14 }
15 // Burada buton, sensör ve ekran işleri de yapılabilir / button, sensor and display tasks can run here
16}Bu naxışda loop() heç dayanmır; LED yanıb-sönməyə davam edərkən eyni dövrdə düyməni oxuya, sensoru ölçə və ekranı yeniləyə bilərsən. micros() eyni məntiqlə mikrosaniyə verir; Uno-da 4 µs addımlarla irəliləyir və təxminən 70 dəqiqədə daşır. Bir neçə işi eyni anda aparmağın bütün təfərrüatlarını Arduino millis() və delay() yazısında izah etdik.
Serial.begin(), Serial.print() və Serial.read(): serial rabitə
Serial komandaları Arduino-nun USB kabeli üzərindən kompüterlə danışmasını təmin edir və sazlamanın ən vacib alətidir. Serial.begin(9600) serial portu saniyədə 9600 bit sürətlə açır; Serial Monitor-dakı sürət bu dəyərlə eyni olmasa, ekranda mənasız simvollar görərsən. Serial.print() məlumatı yazır və eyni sətirdə qalır, Serial.println() isə yazdıqdan sonra alt sətrə keçir. İkinci parametrlə format seçə bilərsən: Serial.print(78, HEX) ekrana "4E", Serial.print(78, BIN) "1001110" yazır; Serial.print(3.14159, 3) isə "3.142" göstərir (onluq ədədlərdə susmaya görə 2 rəqəmdir). Sabit mətnləri F("...") içinə yazmaq Uno-nun 2 KB-lıq RAM-ına qənaət edir.
Məlumat oxumaq üçün əvvəlcə Serial.available() ilə buferdə gözləyən bayt olub-olmadığına baxılır; Uno-nun gələn məlumat buferi 64 baytdır. Serial.read() bu bufrdən tək bayt götürür, oxunacaq məlumat yoxdursa -1 qaytarır. Aşağıdakı kod Serial Monitor-dan göndərdiyin 1 və 0 simvolları ilə LED-i yandırıb söndürür:
1const int LED_PIN = 13;
2
3void setup() {
4 Serial.begin(9600); // Seri Monitör de 9600 olmalı / Serial Monitor must be 9600 too
5 pinMode(LED_PIN, OUTPUT);
6 Serial.println(F("1: LED açık / on, 0: LED kapalı / off"));
7}
8
9void loop() {
10 if (Serial.available() > 0) { // tamponda bayt var mı? / any bytes waiting?
11 char c = Serial.read(); // ilk baytı al / read the first byte
12 if (c == '1') { // '1' karakteri, 1 sayısı değil / the character '1', not the number 1
13 digitalWrite(LED_PIN, HIGH);
14 Serial.println(F("LED açık / on"));
15 } else if (c == '0') {
16 digitalWrite(LED_PIN, LOW);
17 Serial.println(F("LED kapalı / off"));
18 }
19 // '\n' ve '\r' gibi diğer karakterler atlanır / other characters such as '\n' and '\r' are ignored
20 }
21}Burada müqayisənin '1' (tək dırnaq, yəni simvol) ilə aparıldığına diqqət et: klaviaturadan göndərilən 1 ASCII cədvəlində 49 ədədinə uyğundur, ona görə c == 1 şərti heç vaxt doğru olmur. Bir neçə rəqəmli ədədlər üçün Serial.parseInt(), bütün sətri almaq üçün Serial.readStringUntil('\n') istifadə edə bilərsən. Serial Monitor-un sətir sonu ayarları, baud sürəti və qrafik çəkicisi üçün Arduino Serial Monitor istifadəsi yazısına bax.
map() və constrain(): dəyərləri miqyaslamaq və məhdudlaşdırmaq
map(dəyər, köhnəAşağı, köhnəYuxarı, yeniAşağı, yeniYuxarı) ədədi bir aralıqdan digərinə mütənasib şəkildə köçürür. Arxa plandakı düstur belədir: (x − köhnəAşağı) × (yeniYuxarı − yeniAşağı) / (köhnəYuxarı − köhnəAşağı) + yeniAşağı. Məsələn, map(512, 0, 1023, 0, 255) nəticəsi 127,6 yox, 127-dir, çünki map() yalnız tam ədədlərlə işləyir və kəsr hissəni atır. Aralıqları tərsinə yazaraq tərs mütənasiblik də qura bilərsən: map(x, 0, 1023, 255, 0). map() nəticəni məhdudlaşdırmır; giriş verdiyin aralıqdan kənara çıxsa, çıxış da kənara çıxır. Buna görə çox vaxt constrain(x, aşağı, yuxarı) ilə birlikdə istifadə olunur.
1const int LDR_PIN = A0; // LDR + 10k gerilim bölücü / LDR + 10k voltage divider
2const int LED_PIN = 9; // ~9 PWM pini / ~9 PWM pin
3
4void setup() {
5 pinMode(LED_PIN, OUTPUT);
6}
7
8void loop() {
9 int isik = analogRead(LDR_PIN); // odada ölçülen aralık ~200-800 / measured range in the room ~200-800
10 int pwm = map(isik, 200, 800, 255, 0); // karanlıkta parlak, aydınlıkta sönük / bright in the dark, dim in the light
11 pwm = constrain(pwm, 0, 255); // aralık dışı değerleri kes / clip out-of-range values
12 analogWrite(LED_PIN, pwm);
13 delay(20);
14}Bu nümunədə LDR otaqda 200 ilə 800 arası dəyərlər verir. Gecə dəyər 100-ə düşsə, map() 297 hesablayır; constrain() olmasaydı, analogWrite() 0–255 aralığından kənar bu dəyəri alardı. Uno-da belə dəyər pinə görə fərqli və gözlənilməz nəticə verir: məsələn, 8 bitlik taymer istifadə edən 3, 5, 6 və 11 nömrəli pinlərdə 297 daşaraq 41 kimi davranır və LED tam qaranlıqda parlamaq əvəzinə demək olar ki, sönür. constrain(), min(), max() və abs() Uno-da makro kimi təyin olunduğu üçün mötərizə içinə x++ və ya başqa funksiya çağırışı yazma; ifadə bir neçə dəfə hesablana bilər və gözlənilməz nəticə verər. LDR qoşulması üçün LDR işıq sensoru yazısına baxa bilərsən.
tone() və noTone(): buzzer ilə səs yaratmaq
tone(pin, tezlik, müddət) pində 50% doldurma əmsallı kvadrat dalğa yaradır və passiv buzzer və ya kiçik dinamikdən həmin tezlikdə səs çıxarır. Müddət millisaniyə ilə verilir və ixtiyaridir; verilməsə, səs noTone(pin) çağırılana qədər davam edir. Vacib təfərrüat: tone() gözləmir, səsi başladıb dərhal növbəti sətrə keçir. Ona görə ardıcıl notlar çalanda hər tone() çağırışından sonra ən azı not müddəti qədər delay() qoymalısan, yoxsa yalnız son notu eşidərsən.
1const int BUZZER_PIN = 8; // pasif buzzer'ın + ucu / passive buzzer + leg
2
3void setup() {
4 int notalar[] = {262, 294, 330, 349, 392}; // Do Re Mi Fa Sol (Hz) / C D E F G (Hz)
5 for (int i = 0; i < 5; i++) {
6 tone(BUZZER_PIN, notalar[i], 200); // 200 ms çal / play for 200 ms
7 delay(250); // tone() beklemez, sen bekle / tone() does not wait, so you do
8 }
9 noTone(BUZZER_PIN); // sesi kapat / stop the sound
10}
11
12void loop() {
13}- Tezlik hədləri: Uno-da 31 Hz-dən aşağı ton yaratmaq olmur, yuxarı hədd 65.535 Hz-dir; buzzer ilə mənalı aralıq təxminən 100–5000 Hz-dir.
- Tək səs: Eyni anda yalnız bir pində ton çalınır; başqa pində səs çıxarmaq üçün əvvəlcə noTone() ilə əvvəlkini dayandırmalısan.
- PWM toqquşması: Uno-da tone() Timer2-ni istifadə edir; səs çalarkən 3 və 11 nömrəli pinlərdəki analogWrite() pozulur.
- Aktiv buzzer: Öz osilyatoru olduğu üçün tezliyi tone() ilə dəyişdirilə bilməz; aktiv buzzer-i digitalWrite() ilə açıb-bağlamağın kifayətdir. Fərqlər üçün Buzzer nədir? yazısına bax.
pulseIn(): impuls müddətini ölçmək
pulseIn(pin, HIGH) pinin HIGH olmasını gözləyir, HIGH qaldığı müddəti ölçür və nəticəni mikrosaniyə ilə qaytarır; 10 µs ilə 3 dəqiqə arasındakı impulsları ölçə bilər. Ən məşhur istifadəsi HC-SR04 ultrasəs məsafə sensorudur: sensor səsin gedib qayıtma müddəti qədər uzun impuls verir. Səs havada təxminən 343 m/s, yəni 0,0343 sm/µs sürətlə yayılır; yol gediş-dönüş olduğu üçün məsafə = müddət × 0,0343 / 2 düsturu ilə tapılır.
1const int TRIG_PIN = 9;
2const int ECHO_PIN = 10;
3
4void setup() {
5 Serial.begin(9600);
6 pinMode(TRIG_PIN, OUTPUT);
7 pinMode(ECHO_PIN, INPUT);
8}
9
10void loop() {
11 digitalWrite(TRIG_PIN, LOW);
12 delayMicroseconds(2);
13 digitalWrite(TRIG_PIN, HIGH); // 10 µs tetik darbesi / 10 µs trigger pulse
14 delayMicroseconds(10);
15 digitalWrite(TRIG_PIN, LOW);
16
17 unsigned long sure = pulseIn(ECHO_PIN, HIGH, 30000UL); // en fazla 30 ms bekle / wait at most 30 ms
18 if (sure == 0) {
19 Serial.println(F("Menzil dışı / out of range"));
20 } else {
21 float mesafe = sure * 0.0343 / 2.0; // ses hızı 343 m/s, gidiş-dönüş / speed of sound 343 m/s, round trip
22 Serial.print(mesafe, 1);
23 Serial.println(F(" cm"));
24 }
25 delay(100);
26}Üçüncü parametr olan vaxt aşımı çox vacibdir. Verilməsə, pulseIn() impuls gəlmədikdə 1 saniyə gözləyir və 0 qaytarır; sensor naqili çıxanda bütün proqram hər dövrdə bir saniyə donur. 30000 µs-lik vaxt aşımı təxminən 5 metrə uyğundur və HC-SR04-ün 4 metrlik məsafəsi üçün kifayətdir. Sensorun qoşulması və dəqiqliyi üçün HC-SR04 məsafə sensoru yazısına baxa bilərsən.
attachInterrupt(): kəsmə ilə dərhal reaksiya
attachInterrupt(digitalPinToInterrupt(pin), funksiya, rejim) pində dəyişiklik olan anda, loop() o vaxt nə ilə məşğul olursa olsun, verdiyin funksiyanı işə salır. Bu funksiyaya kəsmə xidmət rutini (ISR) deyilir. Rejim dörd dəyər ala bilər: RISING LOW-dan HIGH-a keçiddə, FALLING HIGH-dan LOW-a keçiddə, CHANGE hər dəyişimdə, LOW isə pin LOW qaldığı müddətdə işə salır. Uno və Nano-da yalnız D2 və D3 pinləri bu üsulla kəsmə yaradır; Mega-da 2, 3, 18, 19, 20 və 21 nömrəli pinlərdən istifadə etmək olar. Sürətlə fırlanan enkoderi, külək ölçənin impulslarını və ya çox qısa düymə basışını qaçırmamaq üçün idealdır.
1const int BUTON_PIN = 2; // Uno'da kesme pinleri: 2 ve 3 / interrupt pins on the Uno: 2 and 3
2volatile unsigned long sayac = 0; // ISR'de değişen değişken volatile olmalı / variables changed in an ISR must be volatile
3
4void say() { // kesme fonksiyonu (ISR): kısa tut / interrupt service routine: keep it short
5 sayac++;
6}
7
8void setup() {
9 Serial.begin(9600);
10 pinMode(BUTON_PIN, INPUT_PULLUP);
11 attachInterrupt(digitalPinToInterrupt(BUTON_PIN), say, FALLING); // HIGH'dan LOW'a geçişte / on a HIGH-to-LOW edge
12}
13
14void loop() {
15 noInterrupts(); // 4 baytlık değeri güvenle kopyala / copy the 4-byte value safely
16 unsigned long kopya = sayac;
17 interrupts();
18
19 Serial.print(F("Basma sayısı / presses: "));
20 Serial.println(kopya);
21 delay(500);
22}random() və randomSeed(): təsadüfi ədəd yaratmaq
random(max) 0 ilə max−1 arasında, random(min, max) isə min ilə max−1 arasında təsadüfi tam ədəd qaytarır; yuxarı hədd nəticəyə daxil deyil. Ona görə 1–6 arası zər üçün random(1, 7) yazılır. Arduino həqiqi təsadüfilik yaratmır, sabit düsturla ədəd ardıcıllığı hesablayır; randomSeed() çağırmasan, plata hər açılanda eyni ardıcıllıqla eyni ədədləri görərsən. Boş qoyulmuş analoq pinin küyünü toxum kimi istifadə etmək bu problemi praktikada həll edir:
1void setup() {
2 Serial.begin(9600);
3 randomSeed(analogRead(A3)); // boştaki A3 pininin gürültüsü / noise from the unconnected A3 pin
4}
5
6void loop() {
7 int zar = random(1, 7); // 1-6 arası; üst sınır dahil değil / 1 to 6; the upper bound is exclusive
8 Serial.print(F("Zar / dice: "));
9 Serial.println(zar);
10 delay(1000);
11}ESP32-də Arduino komandaları: nələrə diqqət etməlisən?
ESP32 Arduino IDE-də eyni komandalarla proqramlaşdırılır və bu yazıdakı kodların çoxu pin nömrələri dəyişdiriləndə birbaşa işləyir. Amma avadanlıq fərqli olduğu üçün bəzi komandalar fərqli davranır. Ən vacib fərq gərginlikdir: ESP32 pinləri 3,3 V ilə işləyir, digitalWrite(pin, HIGH) 3,3 V verir və 5 V-luq siqnallar pinlərə birbaşa qoşulmamalıdır. Platanı yaxından tanımaq üçün ESP32 nədir? yazısına baxa bilərsən.
| Komanda | Arduino Uno | ESP32 |
|---|---|---|
| digitalWrite(pin, HIGH) | 5 V | 3,3 V |
| analogRead() | 10 bit, 0–1023, A0–A5 | 12 bit, 0–4095; Wi-Fi açıq olanda yalnız ADC1 pinləri (GPIO 32–39) |
| analogWrite() | Yalnız ~ pinləri (3, 5, 6, 9, 10, 11), 490/980 Hz | Çıxış verə bilən demək olar ki, bütün GPIO-lar; tezlik üçün ledcAttach(pin, tezlik, həlledicilik) |
| attachInterrupt() | Yalnız D2 və D3 | Bütün GPIO-lar; ISR-ə IRAM_ATTR əlavə olunur |
| tone() | Timer2 istifadə edir, 3 və 11-dəki PWM-i pozur | LEDC avadanlığı ilə işləyir |
| Serial.begin() | Adətən 9600 | Adətən 115200 (açılış mesajları da bu sürətdədir) |
| delay() | Prosessoru tamamilə gözlətir | Vaxtı FreeRTOS-a həvalə edir; Wi-Fi arxa planda işləməyə davam edir |
1const int POT_PIN = 34; // ADC1 pini, Wi-Fi açıkken de okur / ADC1 pin, works with Wi-Fi on
2const int LED_PIN = 2; // çoğu DevKit'te dahili LED / onboard LED on most DevKits
3const int BUTON_PIN = 4; // butonun diğer ucu GND / other button leg to GND
4
5volatile bool basildi = false;
6
7void IRAM_ATTR butonISR() { // ESP32'de ISR IRAM'e yerleşmeli / on the ESP32 the ISR should live in IRAM
8 basildi = true;
9}
10
11void setup() {
12 Serial.begin(115200);
13 pinMode(BUTON_PIN, INPUT_PULLUP);
14 attachInterrupt(digitalPinToInterrupt(BUTON_PIN), butonISR, FALLING); // her GPIO kesme destekler / every GPIO supports interrupts
15}
16
17void loop() {
18 int ham = analogRead(POT_PIN); // 0-4095 (12 bit)
19 analogWrite(LED_PIN, map(ham, 0, 4095, 0, 255)); // 8 bit PWM / 8-bit PWM
20 if (basildi) {
21 basildi = false;
22 Serial.println("Butona basıldı / button pressed");
23 }
24 Serial.println(ham);
25 delay(200);
26}ESP32-də analogRead() 0–4095 arası dəyər verdiyi üçün map() aralığı da ona görə dəyişir. ISR funksiyasının əvvəlindəki IRAM_ATTR kodun sürətli daxili yaddaşa yerləşməsini təmin edir; çatışmasa, bəzi hallarda plata "Guru Meditation Error" ilə yenidən başlaya bilər. ESP32-nin analoq oxunuşları aralığın uclarına yaxın bölgələrdə (0 V və 3,3 V civarında) xətti deyil; daha dəqiq ölçmə lazımdırsa, analogReadMilliVolts() funksiyası kalibrlənmiş millivolt dəyəri qaytarır.
Raspberry Pi Pico: Arduino komandalarının MicroPython qarşılıqları
Raspberry Pi Pico-nu Arduino IDE ilə (arduino-pico nüvəsi) proqramlaşdırsan, bu yazıdakı komandaların hamısı eyni adlarla işləyir; analogRead() susmaya görə 10 bit qaytarır və analogWrite() 1 kHz PWM yaradır. Lakin Pico əksərən MicroPython ilə istifadə olunur. Orada komandalar machine və time modullarındakı obyektlərlə yazılır; məntiq eynidir, yalnız sintaksis dəyişir. Pico-nun pinləri də 3,3 V-dur və analoq girişləri GP26, GP27 və GP28 pinləridir. Başlanğıc üçün Raspberry Pi Pico nədir? yazısına baxa bilərsən.
| Arduino komandası | MicroPython qarşılığı | Qeyd |
|---|---|---|
| pinMode(15, OUTPUT) | led = Pin(15, Pin.OUT) | Pin obyekti bir dəfə yaradılır |
| pinMode(14, INPUT_PULLUP) | btn = Pin(14, Pin.IN, Pin.PULL_UP) | Daxili pull-up rezistoru |
| digitalWrite(15, HIGH) | led.value(1) | led.on() də işləyir |
| digitalRead(14) | btn.value() | 0 və ya 1 qaytarır |
| analogRead(A0) | ADC(26).read_u16() | 0–65535 arası qaytarır |
| analogWrite(15, 128) | PWM(Pin(15)).duty_u16(32768) | Doldurma 0–65535 arası |
| delay(500) | time.sleep_ms(500) | time.sleep(0.5) də işləyir |
| millis() | time.ticks_ms() | Fərq üçün time.ticks_diff() |
| Serial.println(x) | print(x) | Thonny shell-də görünür |
| tone(pin, 440) | pwm.freq(440) və pwm.duty_u16(32768) | Susdurmaq üçün duty_u16(0) |
| pulseIn(pin, HIGH, 30000) | machine.time_pulse_us(pin, 1, 30000) | Vaxt aşımında mənfi dəyər qayıdır |
| attachInterrupt(...) | btn.irq(trigger=Pin.IRQ_FALLING, handler=f) | f pin obyektini parametr kimi qəbul edir |
| random(1, 7) | random.randint(1, 6) | Yuxarı hədd daxildir |
| map() / constrain() | Hazır deyil, özün yazırsan | constrain üçün min(max(x, 0), 255) |
1from machine import Pin, ADC, PWM
2import time
3
4led = PWM(Pin(15)) # pinMode + analogWrite karşılığı / pinMode + analogWrite equivalent
5led.freq(1000) # 1 kHz PWM
6buton = Pin(14, Pin.IN, Pin.PULL_UP) # INPUT_PULLUP karşılığı / INPUT_PULLUP equivalent
7pot = ADC(26) # GP26 = ADC0
8
9def map_deger(x, giris_min, giris_max, cikis_min, cikis_max): # Arduino map() karşılığı / Arduino map() equivalent
10 return (x - giris_min) * (cikis_max - cikis_min) // (giris_max - giris_min) + cikis_min
11
12onceki = time.ticks_ms() # millis() karşılığı / millis() equivalent
13while True:
14 ham = pot.read_u16() # 0-65535 (analogRead)
15 led.duty_u16(ham) # parlaklık / brightness (analogWrite)
16 if buton.value() == 0: # digitalRead; basılı = 0 / pressed = 0
17 print("Butona basıldı / button pressed")
18 if time.ticks_diff(time.ticks_ms(), onceki) >= 1000: # saniyede bir / once a second
19 onceki = time.ticks_ms()
20 print("Yüzde / percent:", map_deger(ham, 0, 65535, 0, 100))
21 time.sleep_ms(50) # delay(50)Cədvəldə gördüyün kimi, MicroPython-dakı random.randint(1, 6) yuxarı həddi də əhatə edir və Arduino-dakı random(1, 7) ilə eyni nəticəni verir; time.ticks_diff() də millis() çıxmasındakı daşma təhlükəsizliyini təmin edir. Bu kiçik fərqlər iki platforma arasında keçid edərkən ən çox çaşdıran məqamlardır. MicroPython-un digər əsas komandaları üçün MicroPython əsasları yazısına nəzər sala bilərsən.
Bu komandalarla edə biləcəyin layihə ideyaları
- Svetofor: pinMode(), digitalWrite() və delay() ilə üç LED-i ardıcıl yandır; Arduino svetofor yazısında addım-addım izah etdik.
- Rəqəmsal zər: random() ilə 1–6 arası ədəd yarat, düyməyə basanda nəticəni LED-lərlə və ya 7 seqmentli displey üzərində göstər.
- Park sensoru: pulseIn() ilə məsafəni ölç, map() ilə siqnal aralığına çevir və tone() ilə xəbərdarlıq səsi çıxar.
- Avtomatik gecə lampası: analogRead() ilə işığı oxu, map() və constrain() ilə analogWrite() parlaqlığını tənzimlə.
- Serial port pultu: Serial.read() ilə kompüterdən gələn komandalarla LED, rele və ya servo mühərrik idarə et.
- Reaksiya testi: random() ilə təsadüfi anda LED yandır, attachInterrupt() və millis() ilə düyməyə basma müddətini millisaniyə dəqiqliyi ilə ölç.
Tez-tez edilən səhvlər və həlləri
| Səhv | Əlamət | Həll |
|---|---|---|
| pinMode() unudulub | LED çox solğun yanır və ya heç yanmır | setup() içində pinMode(pin, OUTPUT) yaz |
| Düymə rezistorsuz və INPUT rejimindədir | digitalRead() təsadüfi 0 və 1 verir | INPUT_PULLUP istifadə et; basılı vəziyyət LOW olur |
| Komanda adında hərf səhvi | 'digitalwrite' was not declared in this scope | Böyük-kiçik hərfə diqqət et: digitalWrite |
| Baud sürəti uyğun gəlmir | Serial Monitor-da mənasız simvollar | Serial.begin() ilə Serial Monitor sürətini bərabərləşdir |
| PWM olmayan pində analogWrite() | LED yalnız tam açıq və ya tam sönük olur | ~ işarəli pin istifadə et (3, 5, 6, 9, 10, 11) |
| millis() nəticəsi int dəyişəndədir | Zamanlama təxminən 33 saniyədən sonra pozulur | unsigned long istifadə et |
| random(1, 6) ilə zər | 6 heç gəlmir | random(1, 7) yaz; yuxarı hədd daxil deyil |
| map() ilə onluq nəticə gözləmək | Nəticə həmişə tam ədəddir, kiçik dəyişimlər itir | Lazım olsa, float ilə öz düsturunu yaz |
| pulseIn() vaxt aşımı olmadan | Sensor olmayanda hər dövr 1 saniyə donur | Üçüncü parametr kimi 30000 ver |
| ISR içində delay() və ya Serial | Proqram kilidlənir və ya qəribə davranır | ISR-də yalnız volatile bayraq dəyiş |
Bu yazıdakı komandalar Arduino ilə edəcəyin layihələrin böyük əksəriyyətinin tikinti blokudur; qalanları əsasən kitabxanaların təqdim etdiyi əlavə funksiyalardır. Hər komandanı öz kiçik dövrəsində bir dəfə sınayıb nəticəsini Serial Monitor-da görmək onları əzbərləməkdən daha davamlı öyrənmə təmin edir. BlueGrays tətbiqində LED yandırma, düymə ilə LED idarəsi, LDR ilə işıq ölçmə, buzzer ilə tezlik ayarı, HC-SR04 ilə məsafə ölçmə və zər layihəsi kimi bu komandaları istifadə edən layihələri dövrə sxemləri və izahlı kodları ilə addım-addım tapa bilərsən.
Tez-tez verilən suallar
Arduino-da ən çox istifadə olunan komandalar hansılardır?
Ən çox istifadə olunanlar pinMode(), digitalWrite(), digitalRead(), analogRead(), analogWrite(), delay(), millis(), Serial.begin() və Serial.println() komandalarıdır. Bunlara dəyər miqyaslamaq üçün map(), səs üçün tone(), məsafə sensorları üçün pulseIn() və kəsmələr üçün attachInterrupt() əlavə olunanda, yeni başlayan layihələrinin demək olar ki, hamısını yaza bilərsən.
Arduino komandaları hansı dildə yazılır?
Arduino kodu C və C++ dili üzərində qurulub; Arduino nüvəsi bu dilə pinMode() və digitalWrite() kimi hazır funksiyalar əlavə edir. Komandalar ingilis dilindədir, böyük-kiçik hərfə həssasdır və hər ifadə nöqtəli vergüllə bitir. İstəsən, ESP32 və Raspberry Pi Pico MicroPython ilə də proqramlaşdırıla bilər.
digitalWrite ilə analogWrite arasındakı fərq nədir?
digitalWrite() pini yalnız iki vəziyyətdən birinə gətirir: HIGH (Uno-da 5 V) və ya LOW (0 V). analogWrite() isə pini çox sürətlə açıb-bağlayaraq 0–255 arası PWM siqnalı yaradır; beləliklə, LED-in parlaqlığı və ya mühərrikin sürəti tənzimlənə bilər. Uno-da analogWrite() yalnız ~ işarəli pinlərdə işləyir.
void setup və void loop nə deməkdir?
setup() plata işə düşəndə və ya sıfırlananda bir dəfə işləyən funksiyadır; pinMode() və Serial.begin() kimi hazırlıqlar bura yazılır. loop() isə setup() bitəndən sonra sonsuza qədər təkrarlanan funksiyadır. Əvvəlindəki void bu funksiyaların geriyə dəyər qaytarmadığını bildirir.
Serial.print ilə Serial.println arasındakı fərq nədir?
Serial.print() məlumatı yazır və kursoru eyni sətirdə saxlayır, beləliklə növbəti məlumat yanına əlavə olunur. Serial.println() isə yazdıqdan sonra sətir sonu simvollarını (\r\n) göndərir və növbəti məlumat alt sətirdən başlayır. Bir sətirdə bir neçə dəyəri yan-yana göstərmək üçün əvvəlcə print(), ən sonda println() istifadə olunur.
Arduino map funksiyası nə işə yarayır?
map() bir aralıqdakı ədədi başqa aralığa mütənasib şəkildə çevirir; məsələn, analogRead() ilə oxunan 0–1023 dəyərini analogWrite() üçün 0–255 aralığına və ya servo üçün 0–180 dərəcəyə çevirir. Yalnız tam ədədlərlə işləyir və nəticəni məhdudlaşdırmır, ona görə aralıqdan kənar girişlərə qarşı constrain() ilə birlikdə istifadə olunması tövsiyə edilir.
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.

LDR ilə işıq intensivliyinin oxunması
Otağın nə qədər işıqlı olduğunu rəqəmlə görmək istəyirsən? İşığa həssas kiçik hissə olan LDR ətraf işığı ölçür, Arduino isə bu dəyəri yarım saniyədən bir kompüter ekranına yazır.

Buzzer ilə tezlik tənzimi
Dörd düymə ilə buzzer-dən çıxan səsi idarə edirsən: biri səsi başladır, biri susdurur, digər ikisi səsi incəldir və qalınlaşdırır.

HC-SR04 ilə məsafə ölçmə (Serial ekran)
Yarasalar qaranlıqda yolunu necə tapırsa, HC-SR04 sensoru da elə işləyir: eşidə bilmədiyin bir səs göndərir, əks-sədasını dinləyir və qarşısındakı cismin nə qədər uzaqda olduğunu ölçür.

Sürət tənzimli qaçan işıq LED
Altı LED üzərində bir işıq bir ucdan o biri uca qaçır, dönür və yenidən qaçır. Potensiometrin düyməsini çevirərək bu qaçışın sürətini dərhal tənzimləyirsən: düymə bir tərəfdə olanda işıq az qala…

Potensiometrlə servo mühərrikdən istifadə
Potensiometrin düyməsini çevirdikcə servo mühərrikin qolu da onunla birlikdə dönür; düymənin bir ucu sıfır dərəcəyə, o biri ucu yarım dövrəyə uyğundur.

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ç

