Arduino Basic Part 06 – Timing

Time එහෙමත් නැත්තන් කාලයත් එක්ක අපි Arduino වලදී වැඩ කරනව. ඔයා LED එකක් blink කරන්න ගියත්, timer එකක් හදන්න ගියත් මොනම වැඩක් කරන්න ගියත් ගොඩක් වෙලාවට මේ කාලය කියන සාධකය අපිට පාලනය කරන්නට වෙනව.
අපි සාමාන්‍යෙන් LED එකක් තත්පරයක් පාසා on වෙමින් off වෙමින් යන blink program එකක් ගත්තොත්,
digitalWrite(13,HIGH);
delay(1000);
digitalWrite(13,LOW);
delay(1000);
මේ විදිහට තමයි ඒ program එකේ loop කොටස අපි ලියාගන්නෙ. මෙතනදි කාලය manage කරගන්න අපි යොදාගත්තෙ delay කියන function එක.
Arduino වලදී කාලය සම්බන්ධ වැඩ කරගන්න අපිට තියෙන්නෙ delay function එක විතරද?? නැහැ අපිට තවත් function කීපයක්ම කාලය සම්බන්ධ වැඩ වලදී යොදා ගන්නට පුලුවන්. අපි බලමු ඒ මොනවද කියල.
1) delay ( )
2) delayMicroseconds ( )
3) millis ( )
4) micros ( )
 
delay ( )
 
මේකෙදි function එකේ වරහන් ඇතුලතදී තමයි අපි අදාල කාලය ලබා දිය යුතු වන්නේ. අපි ලබා දෙන කාලය ලබා දිය යුත්තේ මිලි තත්පර වලිනි.
1s = 1000ms
delay (1000); ලෙස ලබා දුන් විට එහි අර්ථය තත්පර එකක් යන්නයි.
මේකෙදි වෙන්නෙ delay ( ) Function එකක් හමු වූ විට එහි ලබා දී ඇති කාලය තුල program එක run නොවී බලා සිටීමයි. එනම් delay ( ) function එක යටතේ මිලි තත්පර 1000 ක කාලයක් ලබා දුන් විට, එනම් තත්පර එකක කාලයක් ලබා දුන් විට එම තත්පරයක් කාලය තුල program එක run නොවී කලින් පියවරේම රැදී සිටී.
මේ විදිහට delay එක ලබාදෙන්න පුලුවන් උපරිම කාලය කොච්චරක්ද කියල කෙනෙක්ට හිතෙන්නට පුලුවන්. මේ delay ( ) Function එකේදි භාවිතා වෙන්නෙ unsigned long කියන data type එක. මේකෙදි 0 සිට 4,294,967,295 වෙනකන් අගයක් ලබා දෙන්න පුලුවන්. ඒ කියන්නෙ මේ උපරිම අගය මිලි තත්පර වලින් ගත්තොත් 4,294,967,295mS කාලයක්. ඒ කියන්නෙ,
4,294,967,295 / 1000 / 60 / 60 / 24 = දින 49 ක් සහ ඉතිරි 61,367,295 යි.
61,367,295 / 1000 / 60 / 60 = පැය 17 ක් සහ ඉතිරි 167,295 යි.
167,295 / 1000 / 60 = මිනිත්තු 2 ක් සහ ඉතිරි 47295 යි.
47,295 / 1000 = තත්පර 47 ක් සහ මිලි තත්පර 295 යි.
එනම් දින 49 යි පැය 17 යි මිනිත්තු 2 යි තත්පර 47 යි මිලි තත්පර 295 ක කාලයක delay එකක් උපරිම වශයෙන් ලබා දෙන්නට පුලුවන්.
මේ සම්පූර්ණ කාලයම delay function එකට එක විට ලබා දුන්නහොත් program එක stuck වෙලා. කිසිම respond එකක් දක්වන්නෙ නැති තත්වයට පත් වීමට ඇති හැකියාව ගොඩක් වැඩී. ඒ නිසා අපිට අවශ්‍ය කාලය තත්පර ගනන වෙනම, මිනිත්තු ගනන වෙනම, පැය ගනන වෙනව ආකාරයට Variable වාට assign කර පසුව එම variable වල ගුණිතය delay function එකට ලබා දීම සාර්ථක වෙනව. එනම්,
මන් මෙතනදි කරන්න යන්නෙ පැය 7 ක delay එකක් තියන එක.
int SECONDS = 1000;
int HOURS = 3600 * SECONDS;
delay (7 * HOURS);
මේ delay ( ) Function එක ඇත්තටම කිව්වොත් waiting function එකක් නෙවෙයි. delay ( ) කියන function එක blocking function එකක්. ඒ කියන්නෙ delay( ) කියන function එක ලබා දුන්නම වෙන්නෙ program එක අදාල කාලය ගත වෙන තුරු block වීමක්. මේකෙදි අපි delay එක ලබා දුන් කාලය අවසන් වන තිරුම වෙනත් කිසිදු දෙයකක් ක්‍රියාත්මක වෙන්නෙ නැහැ. ඒ කියන්නෙ ඔයා ලබා දීල තියන කාලය අවසන් වන තුරුම Arduino board එකට ලැබෙන intrupt කිසිවක් ක්‍රියාත්මක වෙන්නෙ නැහැ.
delayMicroseconds ( )
 
delayMicroseconds ( ) function එකත් වැඩ කරන්නෙ delay ( ) function එක ආකාරයටමයි. මේකෙදි අදාල කාලය ලබා තිය යුත්තේ මයික්‍රො තත්පර වලිනි.
1s = 1000ms
1ms = 1000 Microseconds
මේ delayMicroseconds ( ) function එකේදි භාවිතා කරල තියෙන්නෙ unsigned int කියන data type එක. ඒ නිසා මෙහිදී ලබා දිය හැකි උපරිම අගය 16,383 කි. එනම් මයික්‍රො තත්පර 16,383 කි.
——————————————————————-
millis ( )
 
මෙම function එක භාවිතා කරන්නෙ Arduino board එක දැනට තියෙන වැඩේ කරන අතරෙම මිලි තත්පර සංඛ්‍යාව නැවත ලබා ගැමීම සදහාය.
ඒ කියන්නෙ මේකෙදි වෙන්නෙ මිලි තත්පර ගාන ගනන් කරන එක. මේ function එකේදිත් භාවිත කරල තියෙන්නෙ unsigned long කියන data type එක. ඒ නිසා මේකෙදිත් millis ( ) function එක ක්‍රියාත්මක වෙන උපරිම කාලය delay ( ) function එක ක්‍රියාත්මක වෙන උපරිම කාලයට සමාන වෙනව. එම කාලය අවසානයේදී millis හි අගය නැවත 0 බවට පත් වෙනව.
Ex :-
unsigned long TIME;
void setup ( ) {
Serial.begin(9600);
}
void loop( ) {
Serial.print(“Time:”);
TIME = millis( );
Serial.println(TIME);
delay (1000);
}
මේකෙදි මුලින්ම TIME කියන unsigned long data type එකේ variable එක හදාගෙන තියනව.
Setup කොටසෙදි තත්පරයට bit 9600 ක වේගයකින් serial communication එක ආරම්භ කරල තියනව.
loop කොටසෙදි millis ( ) function එකෙන් ලැබෙන අගය TIME කියන variable එකට assign කරගෙන තියනව. පසුව එම TIME variable එකෙහි අගය serial monitor එකෙහි print කරගෙන තියනව. අවසානයට මිලි තත්පර 1000ක delay එකක් මගින් TIME variable එකේ අගය තත්පරයෙන් තත්පරයට print වෙන ආකාරයට සකසාගෙන තිබෙනවා.
Arduino example වල blink without delay කියන example එක අධ්‍යනය කරල බලන්න.
මේ millis ( ) function එක භාවිතා කරල servo motors කීපයක් එක විට run කරනව වගේ වැඩ කරගන්න පුලුවන්.
micros ( )
 
මේකෙදිත් millis වලදි වගේම Arduino board එක දැනට තිබෙන වැඩේ සිදු කරන අතරම micro තත්පර ගනන return කිරීම සිදු කරනව.
මෙමෙ micros ( ) function එකද unsigned long Data type එක යටතේ ඇති නිසා මයික්‍රො තත්පර 4,294,967,295 ක කාලයක්. එනම් මිනිත්තු 71 යි , තත්පර 34 යි , මිලි තත්පර 967යි , මයික්‍රො තත්පර 295 ක කාලයක් උපරිම කාලයක් micros Function එක යටතේ දීමට හැකි වේ. මෙම කාලය අවසානයේ micros function එකෙහි අගය නැවත 0 වේ.
ඔයා මේ micros ( ) function එක භාවිතා කරන්නෙ 16MHz Speed එකකින් ක්‍රියා කරන Arduino board එකක නම්, ඒ කියන්නෙ Arduino Uno / Nano  එකක නම් microseconds 4න් 4ට තමයි Count වෙන්නෙ. ඒ කියන්නෙ microseconds ප්‍රමාණය ලැබෙන්නෙ 4 ගුණාකාර විදිහට.නමුත් ඔයා භාවිතා කරන්නෙ 8MHz Speed එකකින් ක්‍රියා කරන Lilypad , Pro mini වගේ Board එකක් නම් මේ micro ( ) හි අගය ලැබෙන්නෙ microseconds 8න් 8ට. ඒ කියන්නෙ 8 හි ගුණාකාරයන් විදිහට.
Ex :-
unsigned long TIME;
void setup(){
Serial.begin(9600);
}
void loop(){
Serial.print(“Time: “);
TIME = micros();
Serial.println(TIME);
delay(1000);
}
Arduino Basic Part 07 තුළින් නැවත හමු වෙමු.
Compiled by: Yasas Sadeepa

Leave a Reply

Your email address will not be published. Required fields are marked *