Arduino Programming ඉගෙන ගනිමු – Part 2 : Variables

You are here:
Estimated reading time: 1 min

කලින් පාඩමෙන් අපි දැනගත්තනෙ Arduino වල මුලික ව්‍යුහය ගැන. ඒ වගේම වැදගත් දෙයක් තමා Variables කියන්නෙත්. Programming Language වලදී Variables කියන්නේ අපි තාවකාලිකව මතකය තබා ගන්න බාවිතා කරන දේවල් වලට. අපි බාවිතා කරන variables එක එක විදියට තියෙන්න පුළුවන්. ඒක අංකයක්, අකුරක්, වචනයක් වගේම function එකක් වෙන්නත් පුළුවන්. මේ වර්ග වලට අපි කියනවා Data Types කියල.

void

Void කියන data type එක අපි පාවිච්චි කරන්නේ function වලදී විතරයි. මේකෙන් කියවෙන්නේ return type එක null කියන එක. කලින් පාඩමේ function කොටස බැලුවනම් මේක හොඳට තේරෙයි. void කියල පටන් ගන්න function වලින් කිසිම දත්තයක් return කරන්නේ නෑ.

void sampleFunction(){
  // this function returns nothing
}

Boolean

Boolean කියන variable type එකට තියෙන්නේ values දෙකක් විතරයි. ඒ true සහ false කියන අගයන් දෙක. මේ අගයක් දෙක තව කිහිප විදියකටම දෙන්න පුළුවන්. 1 හෝ 0, HIGH හෝ LOW වුනත් පාවිච්චි කරන්න පුළුවන්. Boolean variable එකක් define කරද්දී boolean හෝ bool කියන වචන දෙකම පාවිච්චි කරන්න පුළුවන්. Digital Pin එකකින් එන reading එකක් store කරන්න ඕනෙ නම් අපිට මේ boolean කියන data type එක පාවිච්චි කරන්න පුළුවන්. Boolean එකකට ඕන වෙන්නේ 1 byte විතරයි.

boolean sampleBool1 = true;
bool sampleBool2 = 1;
bool sampleBool3 = HIGH;

if(sampleBool){
    // statements
}

char

char කියන්නේ Character එකක් සදහා යොදා ගන්න data type එකක්. Character එකක් කියන්නේ අපි type කරද්දී බාවිතා කරන එක සලකුණකට(symbol). ඔයාලගේ keyboard එකේ තියෙන හැම button එකක්ම character එකක්. ඒ හැම එකටම ආවේනික නොම්බරයක් තියෙනවා. මේවට කියන්නේ ASCII code කියල(American Standard Code for Information Interchange). මෙව්වා 128ක් තියෙනවා. ඒ කියන්නේ char එකක් 0 සිට 127 වෙනකන් අගයක් ගන්න පුළුවන්. ඒ ඒ අංක වලට ගැලපෙන සලකුණු මේ table එකෙන් බලාගන්න පුළුවන්.

අපි program එකේ char එකක් පාවිච්චි කරනවානම් ක්‍රම කීපයකට කරන්න පුළුවන්. එකක් තමා තනි වරහන් ඇතුලේ symbol එක ලියන එක. අනික ඒ symbol එකට අදාළ decimal code එක ලියන එක. char එකක් save කරන්න 1 byte memoryයක් ඕනෙ.

char sample1 = '$';  // '$' = 36
char sample2 = 103;  // 103 = 'g'

byte

Byte එකක් කියන්නේ bit 8ක binary නොම්බරයක්. Decimal වලින් ගත්තොත් 0 සිට 255 ට වෙනකන් නොම්බරයක්. byte එකක් පාවිච්චි කරද්දී binary හෝ decimal ක්‍රම පාවිච්චි කරන්න පුළුවන්.

byte exByte1 = 132;   // This is in decimal format
byte exByte2 = B00001001;  // This is in binary format, its 9 in decimal.

මේකෙදි binary නම් මුලට B අකුර යොදා ගන්න ඕනෙ.

int

මේක තමා අපි වැඩියෙන්ම බාවිතා කරන data type එක. Integer එකක්, පුර්ණ සංක්‍යාවක් පෙන්නන්න තමා int කියන data type එක පාවිච්චි වෙන්නේ. int එකක් කියන්නේ 16 bit (2 byte) අංකයක්. මේකෙන් එක bit එකක් පාවිච්චි වෙන්නේ ධන(+), ඍන(-) ලකුණු කරගන්න. අනික් bit 15න් අංක 32768ක් ගන්න පුළුවන්. ඒ කියන්නේ මේකේ මුළු පරාසය -32768 සිට +32767 වෙනකන්.

මේකම අපිට පාවිච්චි කරන්න පුළුවන් unsigned int කියලත්. එතකොට වෙන්නේ ධන(+), ඍන(-) ලකුණු අයින් වෙන එක. unsigned int එකක පරාසය 0 සිට 65,535 වෙනකන්.

int x = -268;
unsigned int y = 458;

long

අපිට integer එකක පරාසය වඩා වැඩි සංක්‍යාවක් අවශ්‍ය නම් long කියන data type එක පාවිච්චි කරන්න පුළුවන්. මේක 32 bit (4 byte) අංකයක්. ඒ කියන්නේ -2,147,483,648 ඉඳන් 2,147,483,647 වෙනකන් අගයක් දෙන්න පුළුවන්.

unsigned long කියල පාවිච්චි කලොත් unsigned int වගේම ඍන කොටස අයින් කරලා 0 ඉඳන් 4,294,967,295 වෙනකන් අගයක් දෙන්න පුළුවන්.

float / double

Arduino වලදී float සහ double කියන දෙකම පාවිච්චි වෙන්නේ දශම සංක්‍යා හඳුන්වන්න. මේවට පුළුවන් 32 bit (4 byte) අංකයක් මතක තබා ගන්න. මේකෙදි දශමස්ඨාන 7 කට පමණ නිවැරදි අගයක් ගන්න පුළුවන්. Arduino වල double වල අගයත් float වගේම තමයි. නමුත් සමහර language වල double අගයක් දශමස්ඨාන 15 කට පමණ නිවැරදියි. දශම සංක්‍යා හදුන්වද්දී එහි දශම අගයක් නැතිනම් අනිවාර්යයෙන්ම ‘.0’ පාවිච්චි කරන්න ඕනෙ.

float example1 = 1.2695;
double example2 = 256.0;

String

අපිට අවශ්‍යනම් සම්පුර්ණ වචනයක් variable එකක් විදියට පාවිච්චි කරන්න, string කියන data type එක බවිත කරන්න වෙනවා. මේක අපිට ක්‍රම දෙකකට කරන්න පුළුවන්. එකක් තමා character වල එකතුවක් ලෙස (char array). අනික සම්පුර්ණ වචනයක් ලෙස (object). ඒ ඒ අවස්ථාවට අනුව මේක අපිට අවශ්‍ය ආකාරයට යොදා ගන්න ඕනෙ.

char stringArray[10] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '.', 'l', 'k'};   // string as array
char stringArray2[10] = "arduino.lk";    // string as array

String stringObject = "arduino.lk";   // string as object

Arrays

Array එකක් කියන්නේ එක වර්ගයක variables වල එකතුවක්. අපි කලින් කතා කරපු ඕනෑම data type එකක එකතුවක් array එකක් විදියට ලියන්න පුළුවන්. ඒ හැම එකකම variable name  එකට පස්සේ කොටු වරහන් ‘[ ]’ යෙදුවම ඒක array එකක් වෙනවා. මේ array වලට අගයන් ආදේශ කරද්දී සඟල වරහන් { } ඇතුලේ comma , මගින් වෙන් කරලා ලියන්න ඕනෙ.

char charArray[] = {'H','E','L','L','O','!'};
int intArray[] = {20,45,62,3,15};
String stringArray[] = {"This","is","String","Array"};

කොටු වරහන් ඇතුලේ array එකේ variable ගණන ලියන්න පුළුවන්. එත් මේක අත්‍යවශ්‍ය නෑ. ඒක හිස් තිබුනොත් අපි දීපු variable ගණන auto ගන්නවා. තියෙන variable ගානට වඩා වැඩි ගණනක් ලිව්වොත් අමතර ටික හිස් අගයන් (null values) ලෙස යොදා ගන්නවා. එත් තියෙන variable ගානට වඩා අඩු ගණනක් ලිව්වොත් error එකක් එනවා. ඒ වගේම variable එක define කරද්දී අගයන් ආදේශ කරන්නේ නැතිනම් අනිවාර්යයෙන්ම variable ගණන ලියන්න ඕන. මේ කියපු කරුණු ඔක්කොම පහල code එකෙන් බලාගන්න පුළුවන්.

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

 

Variables බාවිතයේදී සැලකිය යුතු කරුණු.

Declaration : ප්‍රථමයෙන්ම අපි variable එක හඳුන්වාදෙන්න ඕන.

String str1;  // Declaration of variable

Initialization : ඊට පස්සේ variable එකට අගයක් ආදේශ කරන්න ඕනෙ.

str1 = "Arduino.lk";

* අවශ්‍යනම් මේ දෙකම එක පාර කරන්නත් පුළුවන්. අගයක් ආදේශ නොකෙරුවොත් 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 මතකයක් අයින් කරනවා. මේ වගේ දේවල් ගැන සැලකිලිමත් වෙලා variables පාවිච්චි කරන්න ඕනෙ.

 

මම හිතනවා මේ පාඩමෙන් variables ගැන ලොකු දැනුමක් ලැබෙන්න ඇති කියල. ඉදිරි පාඩම් වලදී මේවගේ බාවිතය ගැන ඉගෙන ගන්න පුළුවන්. සුබ දවසක්.

<<< කලින් පාඩමට

මීලග පාඩමට >>>    

Tags:
Was this article helpful?
Dislike 0
Views: 530

Leave a Reply

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