10 Jan
Arduino Basic Part 04 – Variables, Arrays and Functions
- Variable :-
Arduino program ලියද්දී අපිට නැතුවම බැරි දෙයක් තමයි variables කියන්නෙත්. Programming language වලදී variable එකක් කියන්නේ වෙනස් විය හැකි value එකකට.අපි සාමාන්‍යයෙන් කරන්නෙ එහෙම වෙනස් වෙන්න පුලුවන් අගය යම් කිසි නමකට assign කරල variable එකක් විදිහට භාවිතා කරන එක. අපි බාවිතා කරන variables එක එක විදියට තියෙන්න පුළුවන්. ඒක අංකයක්, අකුරක්, වචනයක් වෙන්න පුලුවන්. මෙන්න මේ විවිධ වර්ග ගැන තමයි මන් කලින් පෝස්ට් එකේදි data types ගැන කියල කිව්වෙ.
අපි ලියන variable එක int වර්ගයේ variable එකක්ද string වර්ගයේ variable එකක්ද කියන එක. ඒ කියන්නෙ ඔයා variable එකට assign කරගන්නෙ integer අගයක්ද, යම් කිසි character එකක්ද මොකක් හරි වචනයක්ද කියන එක තීරණය වෙන්නෙ ඔයා variable එක සදහා යොදාගන්න data type එකට අනුව.
int LED = 13; // integer variable
Sring Word = “Arduino”; // string variable
char sample = ‘$’; //character variable
Variables භාවිතයේදී සැලකිය යුතු කරුණු
Declaration :- ප්‍රථමයෙන්ම අපි variable එක හඳුන්වාදෙන්න ඕන.
String sample; // Declaration of variable
Initialization :- ඊට පස්සේ variable එකට අගයක් ආදේශ කරන්න ඕනෙ.
sample = “Arduino”;
* අවශ්‍යනම් මේ දෙකම එක පාර කරන්නත් පුළුවන්. අගයක් ආදේශ නොකෙරුවොත් default value එක විදියට null, 0 වගේ අගයක් වැටෙනවා.
int number = 15; // Declaration and Initialization at once.
int value; // default is value = 0
Variable size :- හැම වෙලේම අපි අපේ variable වලට අවශ්‍ය මතක ප්‍රමාණය ගැන හිතන්න ඕනෙ. Arduino Uno එකකට variables සඳහා තියෙන්නේ 2 kiloByte මතකයක්. ලොකු program එකක් ලියද්දි මේක මදි වෙනවා. ඒ හින්ද හැම වෙලේම අවශ්‍ය ප්‍රමාණයට පමණක් variables දාගන්න ඕනෙ. උදාහරණක් විදියට digital pin එකක reading ගන්නවානම් අපිට පුළුවන් int එකක් පාවිච්චි කරන්න. නමුත් digital pin එකක අගය 1 හෝ 0. ඒ කියන්නේ 1 bit පමණයි ඕන වෙන්නේ. නමුත් int එකක් පාවිච්චි කලාම එකට 16 bit මතකයක් අයින් කරනවා. ඒ නිසා Boolean වගේ data type එකක් පාවිච්චි කරන්න පුලුවන්. මේ වගේ දේවල් ගැන සැලකිලිමත් වෙලා variables පාවිච්චි කරන්න ඕනෙ.
- Arrays :-
Array එකක් කියන්නේ එක වර්ගයක variables වල එකතුවක්. අපි කලින් කතා කරපු ඕනෑම data type එකක එකතුවක් array එකක් විදියට ලියන්න පුළුවන්. ඒ හැම එකකම variable name එකට පස්සේ කොටු වරහන් ‘[ ]’ යෙදුවම ඒක array එකක් වෙනවා. මේ array වලට අගයන් ආදේශ කරද්දී සඟල වරහන් { } ඇතුලේ comma( , ) මගින් වෙන් කරලා ලියන්න ඕනෙ.
char sample1 [] = {‘H’,’E’,’L’,’L’,’O’,’!’};
int sample2 [] = {20,45,62,3,15};
String sample3 [] = {“This”,”is”,”String”,”Array”};
කොටු වරහන් ඇතුලේ array එකේ variable ගණන ලියන්න පුළුවන්. එත් මේක අත්‍යවශ්‍ය නෑ. ඒක හිස් තිබුනොත් අපි දීපු variable ගණන auto ගන්නවා. තියෙන variable ගානට වඩා වැඩි ගණනක් ලිව්වොත් අමතර ටික හිස් අගයන් (null values) ලෙස යොදා ගන්නවා. එත් තියෙන variable ගානට වඩා අඩු ගණනක් ලිව්වොත් error එකක් එනවා. ඒ වගේම variable එක define කරද්දී අගයන් ආදේශ කරන්නේ නැතිනම් අනිවාර්යයෙන්ම variable ගණන ලියන්න ඕන. මේ කියපු කරුණු ඔක්කොම පහල example එකෙන් බලාගන්න පුළුවන්.
int array1 [] = {2,5,3,5,5}; // array length will be substituted as [5]
int array2[6]= {2,5,3,5,5}; // array values will be substituted as {2,5,3,5,5,null}
int array3[3]; // array values will be substituted as {null,null,null}
int array4[5] = {4,5,2,6,3,5}; // this will give an error. no of values > array length
int array5[]; // this will give an error. array length not defined
array එකක ඇති අගයක් නැවත ගනිද්දී අදාල අගය ඇති තැන address එක පාවිච්චි කරන්න වෙනවා. මේ address පටන් ගන්නේ 0 ඉඳන්.
int intArray[5] = {2,5,3,7,9};
int number;
number = intArray[0]; // this will return 2
number = intArray[2]; // this will return 3
number = intArray[4]; // this will return 9
number = intArray[6]; // this will return an error as length of array < 6
- Functions :-
setup() සහ loop() කියන්නෙ Arduino වල තියෙන ප්‍රධාන function දෙක. මීට අමතරව අපිට අපේ අවස්තාව අනුව තව function හදාගන්න පුලුවන්.
උදාහරණයක් විදියට අපි LED එකක් blink වෙන එක බලමු. අපිට මේක loop() function එකේ ලියනව වගේම වෙනම function එකකත් ලියන්න පුලුවන්. මෙහෙම function යොදා ගත්තම ගොඩක් සංකීර්ණ code සරලව ලියන්න පුලුවන්.
අපි ලියාගත්තු function එක අපිට කොයි වෙලාවක හරි call කරන්න ඕනෙනම් functionName(); කියන විධානයෙන් ලබා ගන්න පුලුවන්. මෙ example එකේදි නම් ledBlink(); විදියට type කරන්න ඕනෙ.
දැන් අපි මේ function එකේ කොටස් වෙන වෙනම හඳුනගමු. function එකක මූලික ව්‍යුහය මේ වගේ.
type functionName(parameters){
statements
}
statements
}
type එකෙන් කියන්නෙ මේ function එක return කරන දේ. void කියන්නෙ මුකුත් return කරන්නෙ නෑ කියන එක. මේකට අපිට variable types පාවිච්චි කරන්න පුලුවන්. උදාහරනයක් විදියට අපේ program එකේ මොකක් හරි calculation එකක් කරනවනම්, ඒ calculation එකේ උත්තරය අපිට function එක call කරල ගන්න පුලුවන්.
parameters : මේ කොටසෙදි අපිට පුලුවන් අපිට function එක ඇතුලෙ වෙන දෙවල් වලට ඕන වෙන values pass කරන්න.
මේ හැම function එකක්ම ‘{‘ එකකින් පටන් අරගෙන ‘}‘ එකකින් ඉවර වෙන්න ඕනෙ. ඒ function එකට අදාල සීමාව තමයි ඒ සලකුණු වලින් පෙන්වන්නෙ. ඒ වගේම return කරන type එක function type එකට සමාන වෙන්නත් ඔනෙ.
දැන් අපි මේ function වල පොඩි යෙදීමක් බලමු. LED bulb 3ක් ක්රම 2,3කට පත්තු කරන්න ඕන වුනා කියල හිතන්න. ඒක function පාවිච්චි කරල ලේසියෙන්ම ලියාගන්න පුලුවන්.
void setup() {
//do something hear
}
//do something hear
}
void patten1 () {
//do something
}
//do something
}
void patten2 () {
//do something
}
//do something
}
මේකෙදි function එකක් Call කරන විදිහත් ඔයාලට පැහැදිලි වෙන්න ඇති. අපි වෙන වෙනම ලියාගන්න functions, loop එකේදි අපිට අවශ්‍ය වෙලාවට අපි call කරගන්නව.
ඉතින් මේ විදියට function පාවිච්චි කලාම අපේ code එක ගොඩක් සරල වෙනව වගේම error එකකදි වුනත් පහසුවෙන් හඳුනාගන්න පුලුවන්.
Compiled by: Yasas Sadeepa
