Millis arduino funksiyası hansı taymerdən istifadə edir? Millis funksiyası ilə multitasking Arduino

Arduino-da gecikmələr çox böyük rol oynayır. Bunlar olmadan, müəyyən bir müddətdən sonra LED-i yanıb-sönən ən sadə Blink nümunəsi belə işləyə bilməz. Ancaq təcrübəsiz proqramçıların əksəriyyəti vaxt gecikmələri haqqında çox az şey bilir və bu əmrin yan təsirlərini bilmədən yalnız Arduino gecikməsindən istifadə edir. Bu yazıda mən vaxt funksiyaları və onlardan Arduino IDE-də necə istifadə olunacağı haqqında ətraflı danışacağam.

Arduino-da vaxt və fasilələrlə işləmək üçün cavabdeh olan bir neçə fərqli əmr var:

• gecikmə()
• gecikməMikrosaniyələr()
• millis()
• micros()

Onlar dəqiqliyi ilə fərqlənirlər və kod yazarkən nəzərə alınmalı olan öz xüsusiyyətlərinə malikdirlər.

Arduino gecikmə funksiyasından istifadə

Sintaksis

Arduino gecikməsi ən sadə əmrdir və ən çox yeni başlayanlar tərəfindən istifadə olunur. Əslində, bu, mötərizədə göstərilən millisaniyələrin sayına görə proqramı dayandıran bir gecikmədir. (Bir saniyədə 1000 millisaniyə var.) Maksimum dəyər 4294967295 ms ola bilər ki, bu da təxminən 50 günə bərabərdir. Bu əmrin necə işlədiyini aydın şəkildə göstərən sadə bir nümunəyə baxaq.

Void quraşdırma() ( pinMode(13, OUTPUT); ) void loop() ( digitalWrite(13, HIGH); // pin 13 gecikməsinə yüksək siqnal göndərin (10000); // 10000ms və ya 10 saniyə digitalWrite13, LOW fasiləsi ; // pin 13 gecikməsinə aşağı siqnal göndərin (10000); // 10000ms və ya 10 saniyə fasilə)

Metodda qurmaqÇıxış kimi pin 13-ün istifadə olunacağını müəyyənləşdiririk. Proqramın əsas hissəsində əvvəlcə pinə yüksək siqnal göndərilir, sonra 10 saniyə gecikmə edirik. Bu müddət ərzində proqramın dayandırıldığı görünür. Sonra aşağı siqnal verilir və yenə gecikmə olur və hər şey yenidən başlayır. Nəticədə, pin alternativ olaraq 5 V və ya 0 ilə təchiz olunduğunu alırıq.

Gecikmədən istifadə edərək fasilə zamanı proqramın işinin dayandırıldığını, tətbiqin sensorlardan heç bir məlumat almayacağını aydın şəkildə başa düşməlisiniz. Bu, Arduino gecikdirmə funksiyasından istifadənin ən böyük çatışmazlığıdır. Kesintilərdən istifadə edərək bu məhdudiyyətin öhdəsindən gələ bilərsiniz, lakin bu barədə ayrı bir məqalədə danışacağıq.

Yanıb-sönən LED ilə gecikmə nümunəsi

Gecikmə funksiyasının necə işlədiyini göstərmək üçün nümunə dövrə.
Bir LED və bir rezistor ilə bir dövrə qura bilərsiniz. Onda biz bunu edə bilərik standart nümunə- yanıb-sönən LED. Bunu etmək üçün, çıxış olaraq təyin etdiyimiz pinlə müsbət kontaktlı bir LED bağlamalısınız. LED-in sərbəst ayağını təxminən 220 Ohm rezistor vasitəsilə yerə bağlayırıq (bir az daha çox mümkündür). İçərisinə baxaraq polariteyi təyin edə bilərsiniz. İçəridəki böyük fincan mənfiyə, kiçik ayaq isə artıya bağlıdır. LED-iniz yenidirsə, polariteyi aparıcıların uzunluğuna görə təyin edə bilərsiniz: uzun ayaq artı, qısa ayaq mənfidir.

delayMicrosaniyə funksiyası

Bu funksiya gecikmənin tam analoqudur, istisna olmaqla, onun ölçü vahidləri millisaniyələr deyil, mikrosaniyələrdir (1 saniyədə 1.000.000 mikrosaniyə var). Maksimum dəyər 16 ms-ə bərabər olan 16383 olacaq. Qətnamə 4-dür, yəni rəqəm həmişə dördün qatı olacaqdır. Nümunə parça belə görünəcək:

DigitalWrite(2, HIGH); // pin 2 gecikməsinə yüksək siqnal göndərMicroseconds(16383); // fasilə 16383 µs digitalWrite(2, LOW); // pin 2 gecikməsinə aşağı siqnal göndərMicroseconds(16383); // fasilə 16383 µs

GecikməMikrosaniyələri ilə bağlı problem gecikmə ilə eynidir - bu funksiyalar proqramı tamamilə "asdırır" və sözün əsl mənasında bir müddət donur. Bu zaman portlarla işləmək, sensorlardan məlumatları oxumaq və riyazi əməliyyatları yerinə yetirmək mümkün deyil. Bu seçim yanıb-sönən işıqlar üçün uyğundur, lakin təcrübəli istifadəçilər böyük layihələr üçün istifadə etmirlər, çünki orada belə uğursuzluqlara ehtiyac yoxdur. Buna görə aşağıda təsvir olunan funksiyalardan istifadə etmək daha yaxşıdır.

Millis gecikmə yerinə işləyir

Millis() funksiyası Arduino-da gecikmədən gecikmə yerinə yetirməyə imkan verəcək və bununla da çatışmazlıqları aradan qaldıracaq. əvvəlki üsullar. Millis parametrinin maksimum dəyəri gecikmə funksiyası ilə eynidir (4294967295ms və ya 50 gün).

Millidən istifadə edərək, biz bütün eskizin icrasını dayandırmırıq, sadəcə olaraq, Arduino-nun fasilə vermək istədiyimiz dəqiq kod blokunu sadəcə olaraq nə qədər müddətə “geçməli olduğunu” göstəririk. Gecikmə millisindən fərqli olaraq, özü heç nəyi dayandırmır. Bu əmr o, sadəcə olaraq mikrokontrolörün quraşdırılmış taymerindən başlanğıcdan keçən millisaniyələrin sayını bizə qaytarır. Döngə üçün hər bir çağırışla biz özümüz kodun son çağırışından keçən vaxtı ölçürük və əgər vaxt fərqi istədiyiniz fasilədən azdırsa, kodu nəzərə almırıq. Fərq tələb olunan fasilədən çox olan kimi kodu icra edirik, eyni millilərdən istifadə edərək cari vaxtı alırıq və yadda saxlayırıq - bu dəfə yeni başlanğıc nöqtəsi olacaq. Növbəti dövrədə geriyə sayma artıq yeni nöqtədən olacaq və millis ilə əvvəllər saxladığımız dəyər arasındakı yeni fərq yenidən istədiyiniz fasiləyə çatana qədər kodu yenidən nəzərdən qaçıracağıq.

Millidən istifadə edərək gecikmə olmadan gecikmə daha çox kod tələb edir, lakin onun köməyi ilə sistemi dayandırmadan LED-i yanıb-sönə və eskizi dayandıra bilərsiniz.

Komandanın işini aydın şəkildə göstərən bir nümunə:

İmzasız uzun müddət; // İstinad nöqtəsinin saxlanması üçün dəyişən void setup() ( Serial.begin(9600); ) void loop() ( /* Bu zaman gecikmə() analoqunun icrası başlayır. Cari an ilə an arasındakı fərqi hesablayın. Əgər fərq istədiyiniz dəyərdən böyükdürsə, kodu icra edin. = millis(); Serial.println ("10 saniyə") ) ;

Əvvəlcə millisaniyələrin sayını saxlayacaq zamanlama dəyişənini təqdim edirik. Varsayılan olaraq dəyişənin qiyməti 0-dır. Proqramın əsas hissəsində biz şərti yoxlayırıq: əgər mikrokontrolörün başlanğıcından millisaniyələrin sayı mininq dəyişənində yazılan rəqəm çıxılmaqla 10000-dən çox olarsa, onda port monitoruna mesajın çıxarılması hərəkəti yerinə yetirilir və cari vaxt dəyəri dəyişənə yazılır. Proqramın işləməsi nəticəsində hər 10 saniyədən bir port monitorunda 10 saniyə mesajı görünəcək. Bu üsul gecikmədən LED-i yanıb-sönməyə imkan verir.

Mikros gecikmə yerinə işləyir

Bu funksiya gecikmə əmrindən istifadə etmədən də gecikmə yerinə yetirə bilər. O, milli ilə eyni işləyir, lakin 4 μs ayırdetmə qabiliyyəti ilə millisaniyələri deyil, mikrosaniyələri hesablayır. Onun maksimum dəyəri 4294967295 mikrosaniyə və ya 70 dəqiqədir. Daşarsa, dəyər sadəcə 0-a sıfırlanır, bu barədə unutmayın.

Xülasə

Arduino platforması bizə layihəmizdə gecikmənin həyata keçirilməsi üçün bir neçə yol təqdim edir. Gecikmədən istifadə edərək, bir eskizin icrasını tez bir zamanda dayandıra bilərsiniz, lakin eyni zamanda mikrokontrolörün işini bloklayacaqsınız. Millis əmrindən istifadə Arduino-da gecikmədən bunu etməyə imkan verir, lakin bunun üçün bir az daha çox proqramlaşdırma tələb olunacaq. seçin Ən yaxşı yol layihənizin mürəkkəbliyindən asılı olaraq. Bir qayda olaraq, sadə eskizlərdə və 10 saniyədən az gecikmə ilə gecikmə istifadə olunur. Əgər əməliyyat məntiqi daha mürəkkəbdirsə və böyük gecikmə tələb olunursa, onda gecikmə əvəzinə millilərdən istifadə etmək daha yaxşıdır.

Arduino-nu öyrənən yeni başlayanların qarşılaşdığı ilk şey gecikdirmə () funksiyasının xoşagəlməz xüsusiyyətidir - proqramın icrasının bloklanması. İnternetdəki bir çox nümunə bu funksiyadan istifadə edir, lakin praktik tətbiq bir şəkildə onsuz etmək daha yaxşı olduğuna işarə edir.

Başlayana yaraşarsa, mən təkəri yenidən kəşf etdim və bloklanmayan gecikməni öz tətbiqimi etdim. Tapşırıq belə idi:

• Pseudo-multitasking təmin edin ki, müxtəlif hadisələr öz vaxtlarında, öz intervallarında baş verir və bir-birini bloklamasın.
• Bundan istifadə etmək rahat idi.
• Kitabxana kimi dizayn edilə bilər və kopyala-yapışdırılmadan asanlıqla digər layihələrə daxil edilə bilər.

Nəticə belədir.

#daxildir SmartDelay foo (1000000UL); // mikrosaniyələrdə boş döngə () ( if (foo.Now()) ( // Buradakı kod yuxarıdakı konstruktorda göstərilən hər mikrosaniyə intervalını yerinə yetirir. ) // Digər kod )
Əgər interval keçibsə Now() metodu doğru qaytarır. Bu halda, geri sayım eyni intervalla yenidən başlayır. Yəni, Now() hər dəfə avtomatik olaraq “doldurulur”.

Klassik LED yanıb-sönməsi dərhal iki yanıb-sönməyə qədər çətinləşə bilər. Məsələn, 12 və 11-ci pinlərə qoşulmuş işıq lampaları müvafiq olaraq 1s və 777ms aralıqlarla yanıb-sönməlidir.

#daxildir SmartDelay led12(1000000UL); SmartDelay led11(777000UL); quraşdırma () ( pinMode(12,OUTPUT); pinMode(11,OUTPUT); ) bayt led12state=0; bayt led11state=0; boş dövrə () ( if (led12.Now()) ( digitalWrite(12,led12state); led12state=!led12state; ) if (led11.Now()) ( digitalWrite(11,led11state); led11state=!led11state; ) )
Döngədə başqa bir şey edə bilərsiniz, yanıb-sönən LEDlər bu kodun icrasına mane olmayacaq;

Aydındır ki, bu, axını dayandıran gecikmə () üçün tam əvəz deyil müəyyən edilmiş vaxt, siz həmişə proqramı FSM (sonlu dövlət maşını mexanizmi) kimi yazmalısınız. Yəni vəziyyəti saxlayın və ondan asılı olaraq kodda istədiyiniz yerə keçin.

Köhnə versiya:

Fəaliyyət1(); gecikmə (1000); fəaliyyət2(); gecikmə (500); fəaliyyət 3(); ...
Yeni seçim:

Bayt vəziyyəti=0; SmartDelay d(); ... keçid (vəziyyət) ( hal 0: fəaliyyət1(); d.Set(1000000UL); vəziyyət=1; fasilə; hal 1: əgər (d.Now()) ( action2(); d.Set(500000UL) ; vəziyyət=2;
Set(interval) metodu yeni interval təyin edir və köhnəsini qaytarır. Siz sadəcə Get() metodundan istifadə edərək intervala baxa bilərsiniz;

Stop() emalını dayandırır və Now() həmişə yalanı qaytarır.

Start() davam edir və Now() normal olaraq işləməyə başlayır.

Əgər vaxtın hesablanmasını yavaşlatmaq lazımdırsa, lakin onu tamamilə dayandırmasanız, Wait() metodu var. Məsələn, LED 12 yanıb-sönürsə, lakin düyməyə basıldıqda yanıb-sönmürsə, yuxarıdakı iki diodlu nümunədə loop() funksiyasına aşağıdakı kodu əlavə edin:

Əgər (digitalRead(9)) led12.Wait(); ...
Bəli, nə vaxt yüksək səviyyə 9-cu ayaqda siqnal, 12-ci ayaqdakı diod yanıb-sönməyəcək və orada 0 görünəndə davam edəcək.

Məsələn, belə bir "taymer" istifadə edərək ekran çəkildikdə və düymələr paralel olaraq işləndikdə, intervalın bitməsini gözləmək əvəzinə, düyməni basdıqdan dərhal sonra ekranı və ya hissəni yenidən çəkmək lazım ola bilər. Bunun üçün Reset() metodundan istifadə olunur, bundan sonra Now()-a növbəti zəng doğru qaytarılacaq. Misal üçün:

SmartDelay displeyi (1000000UL); void loop() ( if (btClick()) display.Reset(); // düyməni basıb, ekranı çəkmək lazımdır. if (display.Now()) screenRedraw(); // ekranı çəkin. )
Gördüyüm yeganə səhv mikrosaniyə sayğacının daşmasının nəzərə alınmamasıdır, amma əks halda, bəli, kodu təmizləmək lazımdır. Reset() funksiyasının necə edildiyini bəyənmirəm, hələ də bu barədə düşünürəm.

Mikrokontrolleri "fasilə etmək" istəyirsinizsə, onda sadəcə gecikmə təlimatını proqramda lazımi yerə daxil etməlisiniz. Amma bu, izləmə düyməsinə kliklər kimi başqa şeylər etməyə çalışdığınız zaman əsl maneəyə çevrilir. Bu halda, bir növ multitasking həyata keçirmək lazımdır.

Bəli, o, proqramlarınıza bir neçə sətir kod əlavə edəcək, lakin bu da öz növbəsində sizi daha təcrübəli proqramçı edəcək və Arduino-nun potensialını artıracaq. Bunun üçün sadəcə millis funksiyasından istifadə etməyi öyrənməlisiniz.

Anlamaq lazımdır ki, gecikmə funksiyası Arduino proqramınızın icrasını dayandırır və bu müddət ərzində onu başqa heç nə edə bilməyəcəkdir. Bütün proqramımızı müəyyən bir müddətə dayandırmaq əvəzinə, bir hərəkətin tamamlanmasından əvvəl nə qədər vaxt keçdiyini hesablamağı öyrənəcəyik. Bu, əlbəttə ki, millis() funksiyasından və məlumatlarımızı saxlamaq üçün bir neçə dost dəyişəndən istifadə etməklə edilir. Hər şeyi asan başa düşmək üçün "Blink" adlı ilk dərslik eskizindən başlayacağıq, lakin bu halda gecikmədən LED-i yanıb-sönəcəyik.

Bu proqramın başlanğıcı digərləri ilə eynidir standart proqram Arduino üçün. Əvvəlcə bütün lazımi dəyişənlərin və giriş/çıxış xətlərinin elanı gəlir (məsələn, LED üçün sətir 13). Burada bizə də lazımdır tip dəyişən LED-in cari vəziyyətini saxlamaq üçün tam ədəd. LED-in ilkin vəziyyəti söndüyü üçün LOW olaraq təyin ediləcək. Sonra “unsigned long” tipli “previousMillis” dəyişənini elan edirik. "int"-dən fərqli olaraq, uzun işarəsiz dəyişənlər 32 bitdir, bu, dəyəri çox böyük ola bilən dəyişənlər üçün lazımdır - tədbir görülənə qədər gözləyə biləcəyimiz potensial vaxt kimi. ƏvvəlkiMillis dəyişəni LED-in sonuncu dəfə yanıb-söndüyü vaxtı saxlamaq üçün istifadə olunacaq. “const long” növü də var, o da 32 bitdir, lakin dəyəri dəyişmir, yəni sabitlər üçündür (bu halda interval sabiti üçün). Biz onu 1000-ə təyin edəcəyik və millisaniyələrlə ölçülən fasilə vaxtı kimi istifadə edəcəyik.

Sonra sonsuz bir döngəyə keçirik. Unutmayın ki, gecikmə əvəzinə, son göz qırpmağımızdan nə qədər vaxt keçdiyini saymaq istəyirik, bizim vəziyyətimizdə 1000 ms. Göstərilən vaxt keçibsə, LED-imizin vəziyyətini dəyişdirməyin vaxtı gəldi.

Əvvəlcə imzasız uzun "currentMillis"i "millis()" olaraq təyin edəcəyik ki, bu da cari vaxtı millisaniyələrlə müəyyən edir. Bu, cari vaxtla əvvəlki vaxt arasındakı fərqin 1000 ms-i keçib-keçmədiyini anlamağa kömək edəcək. Bunu etmək üçün biz deyirik: "Əgər cari vaxt mənfi LED-in yanıb-sönməsi bizim təyin etdiyimiz 1000ms dəyərindən böyük və ya ona bərabərdirsə, sonuncu yanıb-sönmə vaxtını əvvəlki kimi saxlayın." Bu, döngənin növbəti turunda son göz qırpımından nə qədər vaxt keçdiyini xatırlamağa kömək edəcək. Sonra LED vəziyyəti LOW olarsa, onu YÜKSƏK edin, əks halda LOW edin. Sonra cari vəziyyəti LED-ə yazmaq üçün digitalWrite əmrindən istifadə edin.

Salam Andrey. Topladığınız bilik və təcrübənin ötürülməsinə yanaşmanız çox maraqlıdır. Səylərinizdə çox kömək edir. Yaxşı, arduino-nu mənimsəməyə başlayanda irəliləyiş arzusu var. Üstəlik, kənar yardımla bunu daha sürətli edə bilərəm. Beləliklə: əvvəlcə mənim vəzifəm bir xətt boyunca hərəkət edən bir robot etmək idi. Mən bunu etdim - hər şey yaxşı idi. Ancaq əlavə olaraq, onu əlavə variantlarla təmin edərək, niyə xəttə düzgün cavab vermədiyini başa düşmədim. Bu yazıya rast gəldim və səbəbini anladım.

İndi sizə bir sualım var: aşağıda qeyd olunan və bitmiş eskizdə gecikmə problemlərini nəzərə alaraq, bu funksiyanın mövcud olduğu hər yerdə millilərə keçməliyəmmi? Əgər belədirsə, onda başa düşürəm ki, demək olar ki, bütün eskiz yenidən işlənməli olacaq? Məsafənin ölçülməsində millidən necə istifadə olunacağı tam aydın deyil? Çox sağ ol.

//Ağ xətt izləmə funksiyası olan robot

// ************************Motor naqillərinin quraşdırılması ************************ *

int MotorLeftSpeed ​​= 5; // Sol (A) motor SPEED - ENA

int MotorSol İrəli = 4; // Sol (A) motor İLERİ - IN1

int MotorLeftBack = 3; // Sol (A) motor BACK - IN2

int MotorRightForward = 8; // Sağ (B) motor İLERİ - IN3

int MotorRightBack = 7; // Sağ (B) motor BACK - IN4

int MotorRightSpeed ​​= 9; // Sağ (B) motor SPEED - ENB

// ************************Ultrasəs sensor çıxışlarının quraşdırılması************************ * *

int trigPinL = 14; // sol trig ultrasəs sensorunun pin nömrəsini təyin etmək

int echoPinL = 15; // sol echo ultrasəs sensorunun çıxış nömrəsinin təyin edilməsi

int trigPinC = 10; // mərkəzi trig ultrasəs sensorunun çıxış nömrəsini təyin etmək

int echoPinC = 11; // mərkəzi eko ultrasəs sensorunun çıxış nömrəsini təyin etmək

int trigPinR = 12; // sağ trig ultrasəs sensorunun pin nömrəsini təyin etmək

int echoPinR = 13; // sağ əks-səda ultrasəs sensorunun çıxış nömrəsini təyin etmək

// ********************* Xətt sensoru sancaqlarının quraşdırılması *******************

const int LineSensorLeft = 19; // sol xətt sensoru girişi

const int LineSensorRight = 18; // sağ xətt sensorunun girişi

int SL; // sol sensorun vəziyyəti

int SR; // sağ sensor statusu

// *********************İşıq və səs siqnalı çıxışının qurulması**************

int İşıq = 2; // işıq siqnalının çıxış nömrəsini təyin etmək

int Zumm = 6; // səs siqnalının çıxış nömrəsini təyin etmək

int ledState = LOW; // LED-in vəziyyətini bu dəyişənlə təyin edin

uzun əvvəlkiMillis = 0; // son LED keçid vaxtını saxla

uzun interval = 300; // LED-in yandırılması/söndürülməsi arasındakı interval (0,3 saniyə)

// *********************Setsorlarla dəyişən məsafənin ölçülməsi**************

imzasız int impulseTimeL=0;

imzasız int impulseTimeC=0;

imzasız int impulseTimeR=0;

uzun distL=0; // sol ultrasəs sensoru ilə ölçülən məsafə

uzun distC=0; // mərkəzi ultrasəs sensoru ilə ölçülən məsafə

long distR=0; // sağ Ultrasəs sensoru ilə ölçülən məsafə

// ********************************** QURMAQ ************ * ********************

Serial.begin(9600); //serial portu işə salın (sürət 9600)

//**************** Motor kontaktlarını təyin edin****************

pinMode(MotorRightBack, OUTPUT); // Sağ (B) motor GERİ

pinMode (MotorRightForward, OUTPUT); // Sağ (B) motor İrəli

pinMode(Sol Motor, ÇIXIŞ); // Sol (A) motor GERİ

pinMode (MotorSola İrəli, OUTPUT); // Sol (A) motor İLERİ

gecikmə (müddət);

//**************** Zolaq sensoru kontaktlarını təyin edin**************

pinMode(LineSensorLeft, INPUT); // sol xətt sensorunun pininin müəyyən edilməsi

pinMode(LineSensorRight, INPUT); // sağ xətt sensorunun pininin müəyyən edilməsi

// ***************Ultrasəs sensorlarının çıxış rejimlərinin qurulması**********************

pinMode(trigPinL, OUTPUT); // ultrasəs sensorunun sol trig çıxışının iş rejimini təyin etmək

pinMode(echoPinL, INPUT); // sol echo ultrasəs sensoru çıxışının iş rejimini təyin etmək

pinMode(trigPinC, OUTPUT); // mərkəzi trig ultrasəs sensoru çıxışının iş rejiminin qurulması

pinMode(echoPinC, INPUT); // mərkəzi echo ultrasəs sensoru çıxışının iş rejiminin qurulması

pinMode(trigPinR, OUTPUT); // sağ trig ultrasəs sensoru çıxışının iş rejiminin qurulması

pinMode(echoPinR, INPUT); // düzgün əks-səda ultrasəs sensoru çıxışının iş rejiminin qurulması

// ***************İşıq və səs siqnalları üçün kontaktlar qurun**************************** * *****

pinMode (Zumm, OUTPUT); // səs siqnalının çıxışının iş rejiminin qurulması

pinMode (İşıq, ÇIXIŞ); // işıq siqnalının çıxışının iş rejiminin təyin edilməsi

// ******************** Əsas hərəkət əmrləri ******************

boşluq irəli (int a, int sa) // İLERİ

analogWrite(MotorRightSpeed, sa);

analogWrite(MotorLeftSpeed, sa);

boşluq hüququ (int b, int sb) // SAĞA DÖNDÜR (bir tərəf)

digitalWrite(MotorRightBack, LOW);

digitalWrite(MotorLeftBack, LOW);

digitalWrite (MotorSola İrəli, YÜKSƏK);

analogWrite(MotorLeftSpeed, sb);

boşluq sola (int k, int sk) // SOLA DÖNDÜR (bir tərəf)

digitalWrite(MotorRightBack, LOW);

digitalWrite(MotorRightForward, HIGH);

analogWrite(MotorRightSpeed, sk);

digitalWrite(MotorLeftBack, LOW);

void stopp (int f) // STOP

digitalWrite(MotorRightBack, LOW);

digitalWrite(MotorRightForward, LOW);

digitalWrite(MotorLeftBack, LOW);

digitalWrite (MotorSola İrəli, LOW);

// *********************************Məsafənin ölçülməsi**************** ******** *

void izmdistL () // sol ultrasəs sensoru ilə məsafənin ölçülməsi

digitalWrite(trigPinL, HIGH);

digitalWrite(trigPinL, LOW); // Məsafənin ölçülməsi üçün ultrasəs sensorunun tətik çıxışına 10 mS nəbz

impulsTimeL = pulseIn(echoPinL, HIGH); // ultrasəs sensorundan məsafəni oxumaq

distL=impulseTimeL/58; // Santimetrə çevirin

void izmdistC () // mərkəzi ultrasəs sensoru ilə məsafənin ölçülməsi

digitalWrite(trigPinC, HIGH);

digitalWrite(trigPinC, LOW); // Məsafənin ölçülməsi üçün ultrasəs sensorunun tətik çıxışına 10 mS nəbz

impulsTimeC = pulseIn(echoPinC, HIGH); // ultrasəs sensorundan məsafəni oxumaq

distC=impulseTimeC/58; // Santimetrə çevirin

void izmdistR () // mərkəzi ultrasəs sensoru ilə məsafənin ölçülməsi

digitalWrite(trigPinR, HIGH);

digitalWrite(trigPinR, LOW); // Məsafənin ölçülməsi üçün ultrasəs sensorunun tətik çıxışına 10 mS nəbz

impulsTimeR = pulseIn(echoPinR, HIGH); // ultrasəs sensorundan məsafəni oxumaq

distR=impulseTimeR/58; // Santimetrə çevirin

// ************************************ DÖVQƏ ************ ********************

// ************************ LINE aşağıdakı rejimi *********************** ********* ***

// ********************işıq və səs siqnalı****************

ton (Zumm, 900); // 900 Hz-də səsi yandırın

ton (Zumm, 900); // 800 Hz-də səsi yandırın

imzasız uzun cariMillis = millis();

if (currentMillis - previousMillis > interval) //tələb olunan intervalın keçib-keçmədiyini yoxlayın, əgər keçibsə, onda

əvvəlkiMillis = cariMillis; // sonuncu keçidin vaxtına qənaət edin

əgər (ledState == LOW) // LED yanmırsa, onu yandırın və əksinə

ledState = YÜKSƏK;

digitalWrite(Light, ledState); // LED-i yandırmaq və ya söndürmək üçün çıxış vəziyyətlərini təyin edin

// ************************ Məsafənin ölçülməsi********************** **

Serial.println(distL);

Serial.println(distC);

Serial.println(distR);

əgər (distL>50 && distC>50 && distR>50) // ölçülən məsafə 50 santimetrdən çox olarsa, gedirik

SL = digitalRead(LineSensorLeft); // sol zolaqlı sensordan gələn siqnalı oxuyun

SR = digitalRead(LineSensorRight); // sağ zolaqlı sensordan gələn siqnalı oxuyun

// ******************************** Qara xəttdən sonra ************ ******* ****

// zolaqda ROBOT - düz get

əgər (SL == LOW & SR == LOW) // AĞ - AĞ - DÜZ

irəli (10, 100) // DIRECT (vaxt, sürət)

// ROBOT hərəkət zolağından çıxmağa başlayır - biz taksi edirik

başqa əgər (SL == AŞAĞI & SR == YÜKSƏK) // QARA - AĞ - SOL döndərin

sola (10, 100) // SOL (vaxt, sürət)

başqa əgər (SL == YÜKSƏK & SR == AŞAĞI) // AĞ - QARA - SAĞA dön

sağa (10, 100) // SAĞA dön (vaxt, sürət)

// FINISH - ROBOT hər iki sensorla zolağı görür

başqa (SL == YÜKSƏK & SR == YÜKSƏK) // QARA - QARA - DAYAN

stop (50); // STOP

başqa // əgər ölçülən məsafə minimumdan azdırsa və ya ona bərabərdirsə - dayanırıq

Millis() funksiyası başlanğıcdan keçən vaxtı saymağa imkan verir cari proqram. Funksiya "imzasız uzun" formatında bir dəyər qaytarır və proqramın işə salındığı andan 50 günə qədər olan dəyərləri saymağa imkan verir. Bu müddətdən sonra geri sayma yenidən başlayacaq. Aşağıda millis() funksiyasından istifadə nümunəsi verilmişdir:

Uzun müddət imzasız; void setup())( Serial.begin(9600); ) void loop())( Serial.print("On time: "); time = millis(); // time dəyərini yadda saxla Serial.println(time); // serial port delay (1000) vasitəsilə məlumatın göndərilməsi;

Yuxarıdakı misalda hər saniyə proqramın işə salınmasından sonra keçən vaxt haqqında məlumat port monitoruna göndəriləcək. Zaman millisaniyələrlə ölçüldüyü üçün hər bir sonrakı dəyər 1000 ilə fərqlənəcək. Oxunun dəqiqliyi Arduino kvars rezonatorunun sabitliyindən asılıdır.

micros() funksiyası

micros() funksiyası millis() funksiyasının analoqudur, fərq ölçmə dəqiqliyindədir. micros() funksiyasından istifadə edərək cari proqramın işə salınmasından sonra keçən vaxtı mikrosaniyələrlə alacağıq. Hesablanmış mikrosaniyələrin sayğacı 70 dəqiqədən sonra sıfırlanacaq. Aşağıda micros() funksiyasından istifadə nümunəsi verilmişdir:

Uzun müddət imzasız; void setup())( Serial.begin(9600); ) void loop())( Serial.print("Başlanğıcdan bəri vaxt: "); time = micros(); Serial.print(vaxt); Serial.println(" µs "); gecikmə (1000);

Millis() funksiyası ilə nümunədə olduğu kimi, burada da hər saniyədə ölçülən vaxt haqqında məlumat liman monitoruna göndəriləcək, yeganə fərq ondadır ki, bu halda vaxt mikrosaniyələrlə ölçülür.

gecikmə () funksiyası

Delay() funksiyası cari proqramın icrasını parametrdə göstərilən vaxt ərzində dayandırmağa imkan verir. Komanda sintaksisi aşağıdakı kimidir:

//əmrlərin gecikməsi (500); //0,5 saniyə gecikmə //komanda gecikməsi(1000); //1s gecikmə

Vaxt millisaniyələrlə göstərilir (1 san = 1000 ms). Bu parametr 0 ilə 4294967295 arasında dəyişən “unsigned long” tipli ola bilər. Aşağıda gecikmə() əmrindən istifadə nümunəsi verilmişdir:

#define ledPin 13 void setup() ( pinMode(ledPin,13); ) void loop() ( digitalWrite(ledPin,HIGH); //LED gecikməsini yandırın (500); //500ms (0,5 san) gözləyin digitalWrite( ledPin) ,LOW // LED gecikməsini söndürün (1000 ms (1 san) gözləyin);

Yuxarıdakı nümunədə LED 0,5 saniyə yanır, sonra 1 saniyə sönür və Arduino söndürülənə qədər belə davam edir.

delayMicroseconds() funksiyası

delayMicroseconds() funksiyası gecikmə() funksiyasının variasiyasıdır. Fərq kəmiyyət və vaxt dəqiqliyindədir. Delay() funksiyası vaxtı 1 millisaniyə dəqiqliyi ilə saxlamağa imkan verir, delayMicroseconds() isə 1 mikrosaniyəlik dəqiqliklə vaxtı ölçməyə imkan verir.

Parametrdə göstərilə bilən dəyər 0-dan 16383-ə qədərdir. Daha uzun zaman intervalları üçün delay() funksiyasından istifadə edin və ya delayMicroseconds() funksiyasından bir neçə dəfə istifadə edin.

#define outPin 8 void setup() ( pinMode(outPin, OUTPUT); // pin 8 çıxış kimi ) void loop() ( digitalWrite(outPin, HIGH); // pin 8 high state delayMicroseconds(50); // pauza 50 microseconds digitalWrite(outPin, LOW);

Bu nümunə 100 mikrosaniyəlik dövrə və 50% doldurma dərəcəsinə malik kvadrat dalğa yaradır.