Əsaslar · 12 dəq oxu

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 Uno platası, rəqəmsal və analoq pinləri
Arduino Uno: 0–13 nömrəli rəqəmsal pinlər, A0–A5 analoq girişləri və ~ işarəli PWM pinləri bu yazıdakı bütün komandaları sınamaq üçün kifayətdir.

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.

C++ (Arduino IDE)
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.

KomandaSintaksisNə işə yarayır?Nümunə
pinModepinMode(pin, rejim)Pini giriş və ya çıxış edirpinMode(13, OUTPUT);
digitalWritedigitalWrite(pin, dəyər)Pini HIGH (5 V) və ya LOW (0 V) edirdigitalWrite(13, HIGH);
digitalReaddigitalRead(pin)Pinin HIGH, yoxsa LOW olduğunu oxuyurint b = digitalRead(2);
analogReadanalogRead(pin)0–5 V gərginliyi 0–1023 ədədinə çevirirint v = analogRead(A0);
analogWriteanalogWrite(pin, dəyər)0–255 arası PWM siqnalı yaradıranalogWrite(9, 128);
analogReferenceanalogReference(tip)analogRead üçün istinad gərginliyini seçiranalogReference(INTERNAL);
tone / noTonetone(pin, tezlik, müddət)Kvadrat dalğa ilə səs yaradır, noTone dayandırırtone(8, 440, 500);
pulseInpulseIn(pin, dəyər, vaxtAşımı)Bir impulsun müddətini µs ilə ölçürpulseIn(10, HIGH, 30000);
shiftOutshiftOut(dataPin, clockPin, order, byte)Baytı bit-bit göndərir (74HC595 kimi)shiftOut(11, 12, MSBFIRST, 255);
attachInterruptattachInterrupt(kəsmə, funksiya, rejim)Pin dəyişən kimi funksiyanı dərhal çağırırattachInterrupt(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.

KomandaSintaksisNə işə yarayır?Diqqət
delaydelay(ms)Verilən millisaniyə qədər gözləyirBu müddətdə proqram dayanır
delayMicrosecondsdelayMicroseconds(us)Mikrosaniyə səviyyəsində gözləyir3–16383 µs arasında dəqiqdir
millismillis()Açılışdan bəri keçən millisaniyəni verirunsigned long; təxminən 49,7 gündə sıfırlanır
microsmicros()Açılışdan bəri keçən mikrosaniyəni verirUno-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.

KomandaSintaksisNə işə yarayır?Nümunə nəticə
mapmap(x, köhnəAşağı, köhnəYuxarı, yeniAşağı, yeniYuxarı)Bir aralığı başqa aralığa miqyaslayırmap(512, 0, 1023, 0, 255) → 127
constrainconstrain(x, aşağı, yuxarı)Dəyəri iki hədd arasında saxlayırconstrain(300, 0, 255) → 255
min / maxmin(a, b) / max(a, b)Kiçik və ya böyük olanı verirmin(7, 3) → 3
absabs(x)Mütləq qiymətabs(-12) → 12
pow / sqrt / sqpow(əsas, qüvvət), sqrt(x), sq(x)Qüvvətə yüksəltmə, kvadrat kök, kvadratpow(2, 10) → 1024.0
randomrandom(min, max)Təsadüfi tam ədəd (max daxil deyil)random(1, 7) → 1 ilə 6 arası
randomSeedrandomSeed(toxum)Təsadüfi ardıcıllığın başlanğıcını dəyişirrandomSeed(analogRead(A3));
KomandaNə işə yarayır?Nümunə
Serial.begin(sürət)Serial portu verilən baud sürətində açırSerial.begin(9600);
Serial.print(məlumat)Məlumatı yazır, eyni sətirdə qalırSerial.print(temperatur);
Serial.println(məlumat)Məlumatı yazır və alt sətrə keçirSerial.println("Merhaba");
Serial.available()Oxunmağı gözləyən bayt sayını veririf (Serial.available() > 0)
Serial.read()Bir bayt oxuyur, məlumat yoxdursa -1 qaytarırchar c = Serial.read();
Serial.readStringUntil(s)Müəyyən simvola qədər mətn oxuyurString s = Serial.readStringUntil('\n');
Serial.parseInt()Gələn mətndən tam ədəd çıxarırint n = Serial.parseInt();
Serial.write(bayt)Xam bayt göndərirSerial.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.

pinMode(pin, OUTPUT) yazmağı unudub digitalWrite(pin, HIGH) istifadə etsən, pin çıxış olmur; Uno-da bu komanda yalnız daxili pull-up rezistorunu açır. Nəticədə LED yanır, amma çox solğun görünür, çünki cərəyan 20–50 kΩ-luq rezistordan keçməli olur. LED-in solğun yanırsa, ilk baxacağın yer setup() içindəki pinMode sətridir.

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:

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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}
PWM olmayan pində analogWrite() aralıq dəyər yarada bilmir: 128-dən kiçik dəyərlərdə pini LOW, 128 və yuxarıda HIGH edir. Uno-nun A0–A5 pinləri də PWM vermir və klassik Uno R3-də real analoq çıxış (DAC) yoxdur; analogWrite(A0, 100) yazmaq 2 V yaratmır. Real analoq gərginlik lazımdırsa, DAC-lı plata (məsələn, A0-da DAC olan Uno R4) və ya PWM çıxışına əlavə edilən RC filtr istifadə olunur.

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.

C++ (Arduino IDE)
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:

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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}
ISR içində dəyişdirdiyin hər dəyişəni volatile kimi təyin et və funksiyanı mümkün qədər qısa saxla. ISR içində delay() işləmir, millis() irəliləmir və Serial.print() proqramı kilidləyə bilər; yalnız bayraq və ya sayğac yenilə, əsl işi loop() içində gör. Mexaniki düymələr sıçradığı üçün tək basışda sayğac bir neçə dəfə arta bilər; sıçrama həlli və kəsmələrin təfərrüatları Arduino interrupt yazısındadır.

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:

C++ (Arduino IDE)
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.

KomandaArduino UnoESP32
digitalWrite(pin, HIGH)5 V3,3 V
analogRead()10 bit, 0–1023, A0–A512 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ə D3Bütün GPIO-lar; ISR-ə IRAM_ATTR əlavə olunur
tone()Timer2 istifadə edir, 3 və 11-dəki PWM-i pozurLEDC avadanlığı ilə işləyir
Serial.begin()Adətən 9600Adətən 115200 (açılış mesajları da bu sürətdədir)
delay()Prosessoru tamamilə gözlətirVaxtı FreeRTOS-a həvalə edir; Wi-Fi arxa planda işləməyə davam edir
C++ (Arduino IDE)
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ırsanconstrain üçün min(max(x, 0), 255)
MicroPython
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ətHəll
pinMode() unudulubLED çox solğun yanır və ya heç yanmırsetup() içində pinMode(pin, OUTPUT) yaz
Düymə rezistorsuz və INPUT rejimindədirdigitalRead() təsadüfi 0 və 1 verirINPUT_PULLUP istifadə et; basılı vəziyyət LOW olur
Komanda adında hərf səhvi'digitalwrite' was not declared in this scopeBöyük-kiçik hərfə diqqət et: digitalWrite
Baud sürəti uyğun gəlmirSerial Monitor-da mənasız simvollarSerial.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ədirZamanlama təxminən 33 saniyədən sonra pozulurunsigned long istifadə et
random(1, 6) ilə zər6 heç gəlmirrandom(1, 7) yaz; yuxarı hədd daxil deyil
map() ilə onluq nəticə gözləməkNəticə həmişə tam ədəddir, kiçik dəyişimlər itirLazım olsa, float ilə öz düsturunu yaz
pulseIn() vaxt aşımı olmadanSensor olmayanda hər dövr 1 saniyə donurÜçüncü parametr kimi 30000 ver
ISR içində delay() və ya SerialProqram kilidlənir və ya qəribə davranırISR-də yalnız volatile bayraq dəyiş
Bir komandanın dəqiq nə etdiyindən əmin deyilsənsə, kiçik sınaq kodu yaz və nəticəni Serial.println() ilə ekrana çıxar; Arduino IDE 2-də komandanın adına sağ klikləyib "Go to Definition" seçimi ilə mənbə koduna da baxa bilərsən. Kod kompilyasiya olunmursa, xəta mesajının ilk sətri adətən problemin yerini göstərir; ən geniş yayılmış mesajlar və həlləri Arduino kompilyasiya xətaları yazısındadır.

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.

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(198)
1241
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)
252
LDR ilə işıq intensivliyinin oxunması
AR-11Başlanğıc

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.

4.6(83)
143
Buzzer ilə tezlik tənzimi
AR-14Orta

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.

4.6(69)
120
HC-SR04 ilə məsafə ölçmə (Serial ekran)
AR-27Başlanğıc

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.

4.6(50)
82
Sürət tənzimli qaçan işıq LED
AR-8Orta

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…

4.5(60)
124
Potensiometrlə servo mühərrikdən istifadə
AR-36Başlanğıc
Premium

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.

4.6(37)
53
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