Arduino millis() və delay(): kodu dayandırmadan zamanlama
Arduino millis() nədir, delay() proqramı niyə dayandırır? Blink without delay, eyni anda bir neçə iş, 49 günlük daşma, micros(), ESP32 və Pico qarşılıqları.
Arduino millis() funksiyası plata işləməyə başlayandan bəri keçən müddəti millisaniyə ilə verir və delay() istifadə etmədən zamanlama aparmağın əsas yoludur. delay(1000) yazanda Arduino bir saniyə ərzində başqa heç nə etmir: düyməyə basılsa fərq etmir, sensor oxunmur, ekran yenilənmir. millis() ilə isə "son işdən bəri nə qədər vaxt keçib?" deyə soruşursan; vaxtı çatan işi görür, çatmayanı keçirsən və loop() heç dayanmadan dövr edir. Beləliklə, tək Arduino eyni anda LED yandırıb söndürə, düymə oxuya, sensor ölçə və serial porta hesabat göndərə bilər.
Bu bələdçidə delay() funksiyasının proqramı niyə kilidlədiyini, məşhur blink without delay (delay olmadan yanıb-sönmə) nümunəsini, bir neçə işi eyni anda yerinə yetirməyi, 49,7 gündən sonra baş verən daşmanı (overflow) təhlükəsiz şəkildə ötməyi, mikrosaniyə ölçən micros() funksiyasını və təkrar istifadə oluna bilən taymer şablonlarını öyrənəcəksən. Son bölmələrdə eyni məntiqin ESP32-də və Raspberry Pi Pico-da (MicroPython) necə yazıldığını da görəcəyik.

delay() nədir, proqramı niyə dayandırır?
delay(ms) verdiyin müddət bitənə qədər prosessoru bir dövrdə gözlədir. Bu müddət ərzində loop() daxilindəki növbəti sətrə keçilmir; buna bloklayan gözləmə deyilir. Tək LED-i yandırıb söndürmək üçün problem yoxdur, amma layihəyə düymə əlavə etdiyin anda problem başlayır. Aşağıdakı kodda LED saniyədə bir yanıb-sönərkən düyməyə basılıb-basılmadığına da baxılır:
1const int LED_PIN = 13; // dahili LED / built-in LED
2const int BUTON_PIN = 2; // buton, diğer ucu GND / button, other leg to GND
3
4void setup() {
5 pinMode(LED_PIN, OUTPUT);
6 pinMode(BUTON_PIN, INPUT_PULLUP);
7 Serial.begin(9600);
8}
9
10void loop() {
11 digitalWrite(LED_PIN, HIGH);
12 delay(1000); // 1 sn bekle, buton okunmaz / wait 1 s, button is not read
13 digitalWrite(LED_PIN, LOW);
14 delay(1000);
15 if (digitalRead(BUTON_PIN) == LOW) { // 2 saniyede bir bakılır / checked once every 2 s
16 Serial.println(F("Butona basildi / Button pressed"));
17 }
18}Bu kodda düymə yalnız iki saniyədən bir və yalnız məhz həmin anda basılı saxlanılırsa aşkarlanır; qısa basış iki delay() arasında itir. Kəsmələr (interrupt) delay() zamanı da işləməyə davam edir: millis() saymağı sürdürür, serial portdan gələn baytlar 64 baytlıq buferə yazılır. Amma sənin kodun gözləyir. Layihəyə ekran, sensor və buzzer əlavə etdikcə hər delay() bütün digər işləri gecikdirir və cihaz ləng hiss olunur. Həll gözləməni buraxıb zamanı ölçməkdir.
millis() nədir, necə işləyir?
millis() plata açıldığından və ya resetləndiyindən bəri keçən millisaniyələri unsigned long (32 bit, işarəsiz) tipində qaytarır. Arduino Uno-da bu sayğac arxa planda Timer0 aparat taymerinin daşma kəsməsi ilə yenilənir. 16 MHz-də Timer0 hər 1,024 ms-dən bir daşır; nüvə kodu arada yaranan 0,024 ms-lik fərqi toplayır və təxminən hər 43 ms-dən bir sayğacı 1 əvəzinə 2 artırır. Yəni millis() bəzi dəyərləri heç göstərmir; buna görə millis() == 5000 kimi bərabərlik yoxlamaları etibarsızdır, həmişə >= istifadə olunur. Bundan başqa, millis() kəsmələr söndürülü olanda (məsələn, kəsmə funksiyasının daxilində) irəliləmir.
| Funksiya | Nə edir? | Dəqiqlik (Uno, 16 MHz) | Daşma müddəti | Proqramı dayandırır? |
|---|---|---|---|---|
| delay(ms) | Verilən millisaniyə qədər gözləyir | 1 ms | - | Bəli |
| delayMicroseconds(us) | Qısa müddət gözləyir (3–16383 µs arasında dəqiqdir) | Təxminən 1 µs | - | Bəli |
| millis() | Açılışdan bəri keçən millisaniyə | 1 ms (arabir 2 artır) | Təxminən 49,7 gün | Xeyr |
| micros() | Açılışdan bəri keçən mikrosaniyə | 4 µs | Təxminən 71,6 dəqiqə | Xeyr |
Blink without delay: millis() ilə LED-i yandırıb söndürmək
- Son işin görüldüyü anı saxlamaq üçün unsigned long tipində dəyişən yarat (oncekiZaman).
- Hər loop() dövründə millis() ilə indiki zamanı götür.
- simdi - oncekiZaman >= ARALIK şərti ilə kifayət qədər vaxtın keçib-keçmədiyinə bax.
- Müddət bitibsə işi gör (LED-in vəziyyətini dəyiş) və oncekiZaman dəyişənini yenilə.
- Müddət bitməyibsə heç nə etmə, loop() davam etsin; digər işlər məhz bu zaman işləyir.
1const int LED_PIN = LED_BUILTIN; // Uno'da 13 / pin 13 on the Uno
2const unsigned long ARALIK = 500; // yanıp sönme aralığı (ms) / blink interval (ms)
3
4unsigned long oncekiZaman = 0; // son değişim anı / time of the last toggle
5bool ledDurumu = false;
6
7void setup() {
8 pinMode(LED_PIN, OUTPUT);
9}
10
11void loop() {
12 unsigned long simdi = millis(); // şu anki zaman / current time
13 if (simdi - oncekiZaman >= ARALIK) { // taşmaya karşı güvenli / overflow-safe
14 oncekiZaman += ARALIK; // kaymayı önler / prevents drift
15 ledDurumu = !ledDurumu;
16 digitalWrite(LED_PIN, ledDurumu);
17 }
18 // burada başka işler beklemeden çalışır / other work runs here without waiting
19}Kodda oncekiZaman = simdi əvəzinə oncekiZaman += ARALIK yazdıq. Fərq kiçikdir, amma vacibdir: loop() bəzən bir neçə millisaniyə gecikirsə, birinci üsul bu gecikməni hər dəfə yığır və LED saatlar ərzində sürüşür; ikinci üsul isə hədəf zamanı sabit addımlarla irəli aparır, orta periyod düz 500 ms qalır. Saat, metronom və ya müntəzəm ölçmə kimi işlərdə += istifadə et. Proqram uzun müddət bloklana bilirsə (məsələn, Wi-Fi qoşulmasını gözləyəndə), += buraxılmış addımları ardıcıl çatdırmağa çalışır; belə hallarda = simdi daha təhlükəsizdir. LED-in parlaqlığını da kodu dayandırmadan dəyişmək istəsən, PWM və analogWrite yazısına bax.
Eyni anda bir neçə iş: millis() ilə çoxtapşırıqlılıq
Arduino Uno birnüvəli prosessordur və həqiqi mənada iki işi eyni anda görə bilməz. Amma loop() saniyədə on minlərlə dəfə dövr edə bildiyi üçün hər işə növbəsi gələndə bir neçə mikrosaniyə ayırmaq kənardan baxanda "eyni anda" görünür. Buna kooperativ çoxtapşırıqlılıq (cooperative multitasking) deyilir. Qayda sadədir: hər tapşırığın öz zaman dəyişəni və öz intervalı olur, heç bir tapşırıq uzun müddət gözləmir. Aşağıdakı nümunədə dörd tapşırıq birlikdə işləyir:
1const int KIRMIZI_LED = 8; // 300 ms'de bir yanıp söner / blinks every 300 ms
2const int YESIL_LED = 9; // 1000 ms'de bir yanıp söner / blinks every 1000 ms
3const int SARI_LED = 10; // butonla açılıp kapanır / toggled by the button
4const int BUTON = 2; // diğer ucu GND / other leg to GND
5
6unsigned long kirmiziZaman = 0, yesilZaman = 0, butonZaman = 0, seriZaman = 0;
7bool kirmizi = false, yesil = false, sari = false;
8int sonOkuma = HIGH; // son ham okuma / last raw reading
9int kararliDurum = HIGH; // titreşimsiz durum / debounced state
10
11void setup() {
12 pinMode(KIRMIZI_LED, OUTPUT);
13 pinMode(YESIL_LED, OUTPUT);
14 pinMode(SARI_LED, OUTPUT);
15 pinMode(BUTON, INPUT_PULLUP);
16 Serial.begin(9600);
17}
18
19void loop() {
20 unsigned long simdi = millis();
21
22 // Görev 1: kırmızı LED / Task 1: red LED
23 if (simdi - kirmiziZaman >= 300) {
24 kirmiziZaman = simdi;
25 kirmizi = !kirmizi;
26 digitalWrite(KIRMIZI_LED, kirmizi);
27 }
28
29 // Görev 2: yeşil LED / Task 2: green LED
30 if (simdi - yesilZaman >= 1000) {
31 yesilZaman = simdi;
32 yesil = !yesil;
33 digitalWrite(YESIL_LED, yesil);
34 }
35
36 // Görev 3: 50 ms debounce ile buton / Task 3: button with 50 ms debounce
37 int okuma = digitalRead(BUTON);
38 if (okuma != sonOkuma) { // değişti, sayacı yeniden başlat / changed, restart the timer
39 butonZaman = simdi;
40 sonOkuma = okuma;
41 }
42 if (simdi - butonZaman >= 50 && okuma != kararliDurum) {
43 kararliDurum = okuma;
44 if (kararliDurum == LOW) { // basıldı / pressed
45 sari = !sari;
46 digitalWrite(SARI_LED, sari);
47 }
48 }
49
50 // Görev 4: saniyede bir seri rapor / Task 4: serial report once per second
51 if (simdi - seriZaman >= 1000) {
52 seriZaman = simdi;
53 Serial.print(F("Calisma suresi (s) / Uptime (s): "));
54 Serial.println(simdi / 1000);
55 }
56}| Tapşırıq | Pin | İnterval | Nə edir? |
|---|---|---|---|
| Qırmızı LED | 8 | 300 ms | Sürətlə yanıb-sönür |
| Yaşıl LED | 9 | 1000 ms | Yavaş-yavaş yanıb-sönür |
| Düymə + sarı LED | 2 və 10 | 50 ms debounce | Hər basışda sarı LED-i yandırır və ya söndürür |
| Serial hesabat | - | 1000 ms | İşləmə müddətini saniyə ilə yazır |
Düymədə istifadə olunan üsul da millis() əsaslıdır: xam oxuma hər dəyişəndə sayğac yenidən başlayır və oxuma 50 ms ərzində sabit qalırsa, basış həqiqi sayılır. Beləliklə, düymənin mexaniki titrəyişi (bouncing) tək basışı onlarla basış kimi göstərmir və kod heç gözləmir. Düymənin qoşulması və daxili pull-up rezistoru haqqında ətraflı məlumat üçün Arduino-ya düymə necə qoşulur? yazısına baxa bilərsən. LED-lər üçün 220 Ω rezistor kifayətdir; fərqli rəng və cərəyanlar üçün LED rezistoru kalkulyatoru alətindən istifadə et.
49,7 günlük daşma (overflow) problemi və təhlükəsiz müqayisə
unsigned long ən çoxu 4.294.967.295 dəyərini saxlaya bilər. millis() bu ədədə çatanda, yəni təxminən 49 gün 17 saat 2 dəqiqə sonra, yenidən 0-dan saymağa başlayır. Plata həftələrlə açıq qalacaqsa (istixana nəzarəti, akvarium, siqnalizasiya sistemi), bu an mütləq gələcək. Yaxşı xəbər budur ki, simdi - onceki >= aralik şəklində, çıxma ilə yazılmış kod daşmadan təsirlənmir. İşarəsiz ədədlərdə çıxma 2-nin 32-ci qüvvətinə görə (modul ilə) aparılır. Məsələn, onceki = 4.294.967.000 olanda daşmadan sonra simdi = 200 olarsa, simdi - onceki əməliyyatı mənfi ədəd vermir, düzgün nəticə olan 496-nı verir. Buna görə gözlədiyin interval 49,7 gündən qısa olduğu müddətdə müqayisə həmişə düzgün işləyir.
| Yazılış | Nəticə | Niyə? |
|---|---|---|
| if (millis() - onceki >= aralik) | Düzgün | İşarəsiz çıxma daşma anında da düzgün fərqi verir |
| if (millis() >= onceki + aralik) | Səhv | onceki + aralik daşanda kiçik ədədə çevrilir, şərt vaxtından əvvəl doğru olur |
| if (millis() == hedef) | Səhv | millis() bəzən 2 artır, dəqiq dəyər heç görünməyə bilər |
| int onceki = millis(); | Səhv | Uno-da int 16 bitdir, 32,7 saniyədən sonra yanlış dəyər saxlayır |
| long onceki = millis(); | Riskli | İşarəli tip 24,8 gündən sonra mənfiyə keçir; qarışıqlığın qarşısını almaq üçün unsigned long istifadə et |
micros() ilə mikrosaniyə ölçmək
micros() eyni məntiqlə açılışdan bəri keçən mikrosaniyələri verir. Arduino Uno və Nano kimi 16 MHz platalarda dəqiqliyi 4 µs, 8 MHz platalarda 8 µs-dir və təxminən 71,6 dəqiqədən bir daşır; çıxma qaydası burada da keçərlidir. Kod parçasının nə qədər çəkdiyini ölçmək, qısa impulsları zamanlamaq və ya səs yaratmaq kimi həssas işlərdə istifadə olunur. Aşağıdakı nümunə yarım saniyədən bir analogRead() çağırışının müddətini ölçür; Uno-da təxminən 110–120 µs görəcəksən:
1unsigned long raporZaman = 0;
2
3void setup() {
4 Serial.begin(9600);
5}
6
7void loop() {
8 if (millis() - raporZaman >= 500) { // yarım saniyede bir ölç / measure every half second
9 raporZaman = millis();
10 unsigned long basla = micros(); // başlangıç (µs) / start (µs)
11 int deger = analogRead(A0);
12 unsigned long sure = micros() - basla; // geçen süre (µs) / elapsed time (µs)
13 Serial.print(F("A0 = "));
14 Serial.print(deger);
15 Serial.print(F(" sure / time: "));
16 Serial.print(sure);
17 Serial.println(F(" us"));
18 }
19}Daha uzun intervallarda micros() əvəzinə millis() seç; 71 dəqiqəlik daşma müddəti uzun gözləmələr üçün qısa qalır. delayMicroseconds() isə yalnız bir neçə mikrosaniyəlik, qaçılmaz gözləmələr üçündür: məsələn, HC-SR04 məsafə sensorunun TRIG pininə 10 µs-lik tətik impulsu göndərmək kimi. Belə qısa gözləmələr digər tapşırıqları nəzərə çarpacaq dərəcədə gecikdirmir.
Taymer şablonları: periodik, birdəfəlik və vəziyyət maşını
- Periodik tapşırıq: Müəyyən intervallarla təkrarlanan iş; yanıb-sönən LED, 2 saniyədən bir sensor oxumaq, saniyədən bir ekranı yeniləmək. Bunun şablonunu yuxarıda gördün.
- Birdəfəlik taymer (timeout): Hadisədən müəyyən müddət sonra bir dəfə işləyir. Pilləkən işığı yaxşı nümunədir: hərəkət olanda işığı yandır, zamanı yadda saxla, 30 saniyə ərzində yeni hərəkət gəlməsə söndür. Yeni hərəkət gələndə zamanı yeniləmək müddəti uzadır.
- Zaman aşımı qoruması ilə gözləmə: Cavabı və ya siqnalı gözləyərkən əbədi ilişib qalmamaq üçün yuxarı hədd qoyursan; məsələn, 2 saniyə ərzində məlumat gəlməsə xəta mesajı göstərirsən.
- Vəziyyət maşını (state machine): Cihazın olduğu addımı dəyişəndə saxlayırsan, hər addımın müddəti bitəndə növbətisinə keçirsən. Svetofor, paltaryuyan maşının proqramı və ya oyunun səviyyələri belə yazılır.
- Uzun basışın aşkarlanması: Düymənin nə qədər müddət basılı saxlanıldığını millis() ilə ölçərək qısa və uzun basışa fərqli tapşırıqlar verə bilərsən.
1// Yeniden kullanılabilir zamanlayıcı / Reusable timer
2struct Zamanlayici {
3 unsigned long baslangic = 0;
4 unsigned long sure = 0;
5
6 void kur(unsigned long ms) { // süreyi şimdiden başlat / start the period from now
7 baslangic = millis();
8 sure = ms;
9 }
10 bool doldu() const { // süre doldu mu? / has it expired?
11 return millis() - baslangic >= sure;
12 }
13};
14
15const int KIRMIZI = 11, SARI = 12, YESIL = 13;
16enum Durum { DUR, HAZIRLAN, GEC, YAVASLA }; // trafik lambası adımları / traffic light states
17Durum durum = DUR;
18Zamanlayici isik;
19
20void lambalar(bool k, bool s, bool y) {
21 digitalWrite(KIRMIZI, k);
22 digitalWrite(SARI, s);
23 digitalWrite(YESIL, y);
24}
25
26void setup() {
27 pinMode(KIRMIZI, OUTPUT);
28 pinMode(SARI, OUTPUT);
29 pinMode(YESIL, OUTPUT);
30 lambalar(true, false, false);
31 isik.kur(5000); // kırmızı 5 sn / red for 5 s
32}
33
34void loop() {
35 if (isik.doldu()) {
36 switch (durum) {
37 case DUR: durum = HAZIRLAN; lambalar(true, true, false); isik.kur(1500); break;
38 case HAZIRLAN: durum = GEC; lambalar(false, false, true); isik.kur(5000); break;
39 case GEC: durum = YAVASLA; lambalar(false, true, false); isik.kur(2000); break;
40 case YAVASLA: durum = DUR; lambalar(true, false, false); isik.kur(5000); break;
41 }
42 }
43 // loop serbest: buton, sensör, ekran... / loop stays free: buttons, sensors, display...
44}Bu kodda Zamanlayici adlı kiçik struktur (struct) müddəti başlatmağı və bitib-bitmədiyini soruşmağı tək sətrə endirir. Svetofor dörd addımdan ibarət vəziyyət maşınıdır: hər addımda lampalar tənzimlənir və növbəti keçidin müddəti qurulur. loop() heç gözləmədiyi üçün eyni plataya piyada düyməsi, gecə rejimi üçün LDR işıq sensoru və ya qalan müddəti göstərən ekran asanlıqla əlavə oluna bilər. Çoxlu taymer istifadə edəcəksənsə, Library Manager-dəki hazır taymer kitabxanaları da eyni prinsiplə işləyir.
ESP32-də millis(), delay() və Ticker
ESP32-nin Arduino nüvəsində millis() və micros() eyni adla və eyni 32 bitlik unsigned long tipi ilə işləyir; dəyərlər 64 bitlik esp_timer_get_time() sayğacından hesablanır. Buna görə 49,7 gün və 71,6 dəqiqəlik daşma müddətləri ESP32-də də keçərlidir və eyni çıxma qaydasından istifadə edirsən. Mühüm fərq delay() tərəfindədir: ESP32-də delay() FreeRTOS-un vTaskDelay() funksiyasını çağırır. Prosessor boş yerə dövr etmir, gözləmə müddətində Wi-Fi və Bluetooth kimi digər tapşırıqlar işləyir. Yenə də sənin loop() funksiyan gözləyir; veb server, MQTT və ya düymə oxuma kimi işlər gecikir. Periodik işlər üçün ESP32 nüvəsi ilə gələn Ticker kitabxanası da əlverişlidir:
1#include <Ticker.h>
2
3const int LED1 = 2; // çoğu DevKit'te dahili LED / built-in LED on most DevKits
4const int LED2 = 4;
5
6Ticker ticker;
7bool led1Durum = false;
8bool led2Durum = false;
9unsigned long oncekiZaman = 0;
10
11void led1Degistir() { // kısa tut, uzun iş yapma / keep it short, no long work
12 led1Durum = !led1Durum;
13 digitalWrite(LED1, led1Durum);
14}
15
16void setup() {
17 Serial.begin(115200);
18 pinMode(LED1, OUTPUT);
19 pinMode(LED2, OUTPUT);
20 ticker.attach_ms(250, led1Degistir); // her 250 ms'de çağır / call every 250 ms
21}
22
23void loop() {
24 unsigned long simdi = millis();
25 if (simdi - oncekiZaman >= 1000) { // Arduino ile aynı desen / same pattern as on Arduino
26 oncekiZaman = simdi;
27 led2Durum = !led2Durum;
28 digitalWrite(LED2, led2Durum);
29 int64_t us = esp_timer_get_time(); // 64 bit, pratikte taşmaz / 64-bit, practically never overflows
30 Serial.printf("millis=%lu esp_timer=%lld us\n", simdi, us);
31 }
32}Ticker-ə verilən funksiya arxa planda işləyən taymer tapşırığı tərəfindən çağırılır; içində uzun çəkən işlər (HTTP sorğusu, uzun serial çıxış, delay) görmə, yalnız bayraq qaldır və ya pini dəyiş. 64 bitlik esp_timer_get_time() yüz minlərlə il daşmır; aylarla açıq qalacaq və mikrosaniyə həssaslığı lazım olan ölçmələrdə ondan istifadə edə bilərsən. Daxili LED-in pini platadan asılı olaraq dəyişə bilər; öz platanın pin xəritəsini Pinout alətində görə bilərsən. ESP32-yə təzə başlayırsansa, ESP32 nədir? yazısı quraşdırma və pin seçimi üçün yaxşı başlanğıcdır.
Raspberry Pi Pico (MicroPython): ticks_ms() və ticks_diff()
MicroPython-da delay() əvəzinə time.sleep(), time.sleep_ms() və time.sleep_us(); millis() əvəzinə time.ticks_ms() istifadə olunur. Amma diqqət: ticks dəyərləri Arduino-dakı kimi 2-nin 32-ci qüvvətində deyil, portdan asılı olaraq dəyişən daha kiçik həddə başa qayıdır. Pico-da bu hədd 2-nin 30-cu qüvvəti ms-dir, yəni təxminən 12,4 gündür (öz platanda time.ticks_add(0, -1) ilə görə bilərsən). Buna görə iki ticks dəyərini heç vaxt birbaşa çıxma, müqayisə etmə; fərqi time.ticks_diff(yeni, köhnə) ilə al, irəli zamanı hesablamaq üçün time.ticks_add() istifadə et. Aşağıdakı kod Pico-nun daxili LED-ini kodu dayandırmadan yandırıb söndürərkən GP14-dəki düymə ilə GP15-dəki LED-i idarə edir:
1from machine import Pin
2import time
3
4led = Pin("LED", Pin.OUT) # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
5dis_led = Pin(15, Pin.OUT) # GP15'e harici LED / external LED on GP15
6buton = Pin(14, Pin.IN, Pin.PULL_UP) # GP14 buton, diğer ucu GND / GP14 button, other leg to GND
7
8ARALIK = 500 # ms
9onceki = time.ticks_ms()
10son_okuma = 1 # son ham okuma / last raw reading
11kararli = 1 # titreşimsiz durum / debounced state
12degisim = time.ticks_ms() # son değişim anı / time of the last change
13
14while True:
15 simdi = time.ticks_ms()
16 if time.ticks_diff(simdi, onceki) >= ARALIK: # taşmaya karşı güvenli / wrap-safe
17 onceki = time.ticks_add(onceki, ARALIK) # kaymasız / drift-free
18 led.toggle()
19 okuma = buton.value()
20 if okuma != son_okuma: # değişti, sayacı yeniden başlat / changed, restart the timer
21 degisim = simdi
22 son_okuma = okuma
23 if time.ticks_diff(simdi, degisim) >= 50 and okuma != kararli: # 50 ms debounce
24 kararli = okuma
25 if kararli == 0: # basıldı / pressed
26 dis_led.toggle()
27Periodik işlər üçün MicroPython-da machine.Timer də var: Timer(period=500, mode=Timer.PERIODIC, callback=funksiya) sətri verdiyin funksiyanı hər 500 ms-dən bir çağırır. Bu geri çağırış funksiyalarını da Ticker-dəki kimi qısa saxla. Pico-nu Arduino IDE ilə (arduino-pico nüvəsi) proqramlaşdırırsansa, millis() və micros() Arduino-dakı kimi işləyir. Pico-ya MicroPython quraşdırmaq və pinləri tanımaq üçün Raspberry Pi Pico nədir? yazısına baxa bilərsən.
millis() ilə layihə ideyaları
- Reaksiya testi: LED-i təsadüfi anda yandır, düyməyə basılana qədər keçən müddəti millis() ilə ölç və nəticəni millisaniyə ilə göstər.
- Pilləkən işığı: PIR sensoru hərəkət aşkarlayanda işığı yandır, son hərəkətdən 30 saniyə sonra söndür; bu müddətdə kod digər işlərə davam etsin.
- Sürətlənən park sensoru: HC-SR04 ilə ölçülən məsafə qısaldıqca buzzer-in bip intervalını qısalt.
- Bloklamayan melodiya: Buzzer ilə notları delay() əvəzinə millis() ilə sırala; melodiya çalınarkən düymələr də işləsin.
- Sensor və ekran birlikdə: DHT11 sensorunu 2 saniyədən bir oxu, ekranı isə hər 250 ms-dən bir yenilə.
- Xronometr: Başlat, dayandır və sıfırla düymələri ilə işləyən, müddəti 7 segment display üzərində göstərən xronometr düzəlt.
Tez-tez edilən xətalar və həlləri
| Xəta | Əlamət | Həll |
|---|---|---|
| Zaman dəyişəni int tipindədir | Proqram təxminən 33 saniyədən sonra qəribə davranır | Bütün zaman dəyişənlərini unsigned long et |
| millis() >= onceki + aralik yazmaq | 49,7 gündən sonra zamanlama pozulur | millis() - onceki >= aralik formasına keç |
| millis() == hedef yoxlaması | Hadisə bəzən heç tetiklənmir | Bərabərlik əvəzinə >= istifadə et |
| onceki dəyişənini yeniləməyi unutmaq | Müddət bir dəfə bitəndən sonra iş hər dövrdə təkrarlanır | Şərtin daxilində onceki = simdi və ya onceki += aralik yaz |
| Taymer kodunun içində delay() qalması | Digər tapşırıqlar yenə gecikir | Uzun gözləmələri vəziyyət maşınına böl |
| Kəsmə funksiyasında millis() ilə gözləmək | Plata donur | ISR daxilində gözləmə etmə, yalnız bayraq qaldır |
| 60 * 1000 kimi int hasili | İnterval mənfi və ya çox qısa çıxır | 60000UL və ya 60UL * 1000 yaz |
millis() məntiqini bir dəfə qavradıqdan sonra layihələrin tamamilə dəyişir: LED-lər, düymələr, sensorlar və ekranlar bir-birini gözləmədən birlikdə işləyir. Növbəti addım üçün Arduino layihə ideyaları siyahısından zamanlama tələb edən layihə seçə bilərsən. BlueGrays tətbiqində Svetofor, Polis mayakı, Ağıllı pilləkən və dəhliz işıqlandırması, Səs siqnallı reaksiya testi kimi layihələri addım-addım dövrə sxemi və hazır kodla araşdırıb öz platanda yoxlaya bilərsən.
Tez-tez verilən suallar
Arduino millis() nədir?
millis() Arduino-nun açıldığı və ya resetləndiyi andan bəri keçən müddəti millisaniyə ilə verən funksiyadır. Dəyəri unsigned long tipindədir və təxminən 49,7 gündən sonra sıfırdan yenidən başlayır. Proqramı dayandırmadan zamanlama aparmaq üçün istifadə olunur.
millis() ilə delay() arasında fərq nədir?
delay() verilən müddət ərzində proqramı gözlədir; bu zaman düymə oxuma və ya ekran yeniləmə kimi işlər görülə bilmir. millis() isə yalnız keçən müddəti bildirir, gözləmir. Keçən müddəti yoxlayıb vaxtı çatan işi görməklə bir neçə işi eyni anda apara bilərsən.
49 gündən sonra millis() sıfırlananda proqram pozulurmu?
Zamanı millis() - onceki >= aralik şəklində çıxma ilə yoxlayırsansa, pozulmur; işarəsiz çıxma daşma anında da düzgün fərqi verir. Problem millis() >= onceki + aralik kimi toplama ilə yazılmış müqayisələrdə və int tipli dəyişənlərdə yaranır.
Arduino-da millis() sıfırlana bilərmi?
Rəsmi millis() sıfırlama funksiyası yoxdur və nüvənin daxili dəyişənini dəyişmək tövsiyə olunmur. Buna ehtiyac da yoxdur: sıfırlamaq istədiyin anı dəyişəndə saxlayır, keçən müddəti həmin andan etibarən hesablayırsan. Platanı resetləmək isə millis() dəyərini təbii olaraq 0-dan başladır.
Arduino eyni anda iki iş görə bilərmi?
Uno birnüvəli olduğu üçün iki əmri fiziki olaraq eyni anda icra edə bilməz, amma millis() ilə hər işi qısa addımlara bölsən, loop() saniyədə minlərlə dəfə dövr edib hamısına növbə verir. Kənardan baxanda LED, düymə, sensor və ekran eyni anda işləyirmiş kimi görünür. ESP32-də isə iki nüvə və FreeRTOS tapşırıqları da var.
millis() saat düzəltmək üçün kifayət qədər dəqiqdirmi?
millis() platanın osilyatorundan asılıdır; Arduino Uno-dakı keramik rezonator səbəbindən gündə bir neçə dəqiqəyə çatan sapmalar görünə bilər. Qısa intervalları ölçmək üçün kifayətdir, amma günlərlə düzgün qalmalı saat üçün DS1307 və ya DS3231 kimi RTC modulu və ya ESP32-də internetdən NTP ilə saat almaq daha düzgündü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.

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.

Polis çaxarı
Polis maşınının çaxarı kimi: qırmızı LED üç dəfə sürətlə yanıb-sönür, ardınca göy LED üç dəfə çaxır və bu ardıcıllıq dayanmadan davam edir. Arduino-ya iki LED və iki rezistor qoşmağın kifayətdir.

Sürət tənzimli qaçan LED
Altı LED növbə ilə yanıb-sönür və işıq sanki bir ucdan o biri uca qaçır. Potensiometrin düyməsini çevirdikcə bu qaçışın sürəti dərhal dəyişir: bir istiqamətə çevirəndə işıq uçur, o biri istiqamətə…

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.

Ağıllı pilləkən və koridor işıqlandırması
Pilləkənə və ya koridora addım atanda işıqlar sənin getdiyin istiqamətdə, pillə-pillə yanır.

Arduino səs siqnallı reaksiya testi: refleksini millisaniyə ilə ölç (LCD + Buzzer + 3 LED)
Refleksin nə qədər sürətlidir? Düyməyə bas: qırmızı LED hazırlaş, sarı LED diqqət deyir və 1,5 ilə 3,5 saniyə arası təsadüfi gözləmə başlayır. Yaşıl LED yanıb buzzer səslənən an yenidən bas; reaksiya müddətin I2C LCD-də millisaniyə ilə çıxır, altında sessiya rekordun və ortalaman görünür. Yaşıldan əvvəl basarsan, ekranda TOO EARLY! yazılır və uduzma səsi çalınır. Düyməni basılı saxlayanda yeni oyunçu başlayır, hamı eyni gözləmə ardıcıllığı ilə ədalətli yarışır.

4 rəqəmli 7 seqmentli displeylə rəqəmsal saat
Mətbəxdəki soba saatına bənzəyən dörd rəqəmli, işıqlı rəqəmsal saat. DS1302 saat modulu vaxtı saxlayır, Arduino hər saniyə saatı və dəqiqəni oxuyub dörd rəqəmli göstəriciyə yazır; saatla dəqiqə…
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ç

