අපි කලින් පාඩමේදී   Arduino UNO board එකක් භාවිතයෙන් LED 1 හා 2  පාලනය කරන්නේ කොහොමද යන්න විමසා බැලුවෙමු. ඒ වගේම  programming වල මූලික දේවල් බොහොමයක් ගැන සරලව පැහැදිලි කිරීමක් විමසා බැලුවෙමු. දැන් අපි LED 10 පාලනය කරන්න Circuit එකක් සහ Sketch එකක් නිර්මාණය කරන්නේ කොහොමද කියලා බලමු.

LED bar graph දර්ශකයක් පාලනය කිරීම.

දැන් අපි ආර්ඩුයිනෝ බෝර්ඩ්  එකක් භාවිතා කර LED 10ක්  හෝ LED bar graph නොහොත් LED තිරු දර්ශකයක් පාලනය කරන්නේ කොහොමද කියලා බලමු.

අවශ්‍යය උපාංග

උපාංග පිලිබද දැනුම

අපගේ ව්‍යාපෘති සදහා හොදින් සිදුකර ගැනීමට නම් අපි භාවිතා කරන ඉලෙක්ට්‍රොනික් උපාංග ගැන මනා අවබෝධයක් තිබිය යුතුයි. අපි දැන් මෙහිදී භාවිතා කරන  උපාංග පිලිබද විශේෂතා ගැන සලකා බලමු.

LED bar graph

LED තීරු දර්ශකයක LED 10 ක් අන්තර්ගත වේ. එහි පිටුපස පේළි දෙකකට එහි පින් පවතී. ඒ දෙපස පවතින්නේ එහි පවතින LED වල ධන හා ඍණ අග්‍රයි. එහි අග්‍ර පවතින ආකාරය පහත රුප සටහනේ දක්වා තිබේ. මෙහිදි අපි භාවිතා කරන්නේ රතු පාට තීරු දර්ශකයක වන අතර වෙළදපොළන් ඔබට විවිධ වර්ණ වලින් ලබා ගත හැකිය. මෙහිදි ඔබගේ පරිපථයේදී LED තිරු දර්ශකයක වැඩ නොකරන්නේ නම් එහි පින් අග්‍ර මාරු කර සවි කර උත්සාහ කරන්න.

කේතකරණය පිළිබද දැනුම

දැන් අපි මෙම පාඩමේදී භාවිතා කරන කේතකරණ වලට අදාල නව සංකල්ප කිහිපයක් ගැන ඉගෙනගනිමු

අරාව (Array)

Array එකක් යනු දත්ත ගොඩක් රදවා ගතා හැකි  විචල්‍යයකි. එනම් ඔබ පාසලේදි ගණිත පාඩමක් ලෙස කුලක පිළිබදව ඉගෙනගෙන ඇතැයි සිතමි. එම සංකල්පයම මෙහිදී  අපි කේතකරණ වලදි භාවිතා කරයි. එය පහත දැක්වෙන ආකාරයට භාවිතයට ගනී.

int a[10];

“int” යනු array එකේ භාවිතා කරන දත්ත වර්ගයයි(Data type). “10” ලෙස නම් කර ඇත්තේ array එකේ ගබඩා කරන දත්ත උපරිම අයිතම ප්‍රමාණයයි. එනම් ඉහත දක්වා ඇති array එකේ අයිතම 10 ගබඩා කරන්න හැකියි. එය පහත පරිදි සිදු කරන්න පුළුවන්.

int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

Array එකක ඇති අගයක් හෝ අයිතමයක් සාමන්‍යයයෙන් කෙලින්ම ලබා ගත නොහැකියි. ඒ සදහා විශේෂ ක්‍රමයක් භාවිතා කළ යුතුය. අවශ්‍ය විට එය අවශ්‍ය තැනට ලබා ගන්න ආකාරය පහත දක්වා තිබේ.

int i, j;
i = a[0];
j = a[1];
a[0] = 0;

මෙහිදී Array එකේ අයිතමය ගබඩා වී ඇති ස්ථානයට අදාල අංකයක් ඇත. එය array index එක ලෙස හදුන්වයි. එය පටන් ගන්නේ 0 වෙනි. එය මෙම “[]” තුළ ඇතුලත් කළ යුතුය. මුල්ම අයිතමය(first elements) හදුනාගන්නේ මේ ආකාරයටයි. a[0].

උදාහරණයක් ලෙස පහත දැකෙවෙන array b[] එක අරගෙන බලමු.

මෙහි b[0]  ලෙස දැක්වෙන්නේ array එකෙහි පළමු ස්ථානයයි. එහි ගබඩා වී ඇති අගය 5 වේ. ඒ ආකාරයටම අපිට b[1],b[2]….. ලෙස අදාළ ස්ථාන වල  ගබඩා වී ඇති අගයන් ලබා ගන්න පුලුවන්.

අපි මෙහි භාවිතා කරේ ඒක දිශානතික(one-dimensional) array එකකි. එනම් එක දිශා පවතින array එකකි. තව අපිට two-dimensional arrays(දිශා දෙකකට පවත්නා), three-dimensional arrays(දිශා 3 කට පවත්නා), සහ multi-dimensional arrays(දිශා ගොඩකට පවතින) ආකාරයට  නිර්මාණය කරගන්න පුළුවන්. ඒ ගැන වැඩිදුර අපි ඉදිරියේදී ඉගෙන ගනිමු.

Loop

එකම දේ නැවත නැවත සිදු වෙන ආකාරයේ ක්‍රියාදාමයක් සකස් කරගැනීමට අපි  Loop භාවිතට ගනි. Array එකකට අයිතම ගබඩා කර ගැනීමට  ලූප් අවශ්‍ය වේ. කේතකරණයේදි  ලූප් වර්ග කිහිපයක් තිබේ. අපි ඒවා එකින් එක ගෙන බලමු.

While loop

මුලින්ම පහත දැක්වෙන උදාහරණය බලන්න. පහත දක්වා තිබෙන්නේ while ලූප් එකයි. එහි දී සිදු වන්නේ සත්‍යයතා ප්‍රකාශනය ලෙස “()”. තුළ ඇතුළත් කල තිබෙන ප්‍රකාශය සත්‍යය වන තෙක් එක දිගට ඊළග පේළියේ හෝ “{}” තුළ තිබෙන කේත පේලි ක්‍රියාත්මක වීමයි.

while(සත්‍යයතා ප්‍රකාශනය)
functionX();

ක්‍රියාදාම කිහිපයක් හෝ කේත පේළි ගොඩක් පවතී නම් එය පහත ආකාරයට {} යොදා අදාල කේත පේළි ඒවා තුළ ඇතුළත් කරනු ලැබේ.

while(සත්‍යයතා ප්‍රකාශනය){
 functionX();
 functionY();
}

සත්‍යයතා ප්‍රකාශනය ලෙස “()”. තුළ ඇතුලත් කල තිබෙන ප්‍රකාශය අසත්‍ය වූ විට ලූප් එක නවතීන අතර ඊට පසු “{}” තුළ තිබෙන කේත පේලි ක්‍රියාත්මක වීම නැවතී.

පහත උදාහරණය බලන්න.

int i = 0;
while (i < 2)
i = i + 1;        // while ලුප් එකට අදාළව ක්‍රියත්මක වන කේත පේළිය
i = 5;

• මුල් අවස්ථාවේ: i < 2, i = 0 නිසා ප්‍රකාශය සත්‍ය වේ, i = i + 1 පේලිය ක්‍රියාත්මක වේ, ඉන් පසු i = 1 වේ;
• දෙවන අවස්ථාවේ: i < 2, i = 1 නිසා ප්‍රකාශය සත්‍ය වේ, i = i + 1 පේලිය ක්‍රියාත්මක වේ, ඉන්පසු i = 2 වේ;
• තුන්වන අවස්ථාවේ: i < 2, i = 2 නිසා ප්‍රකාශය අසත්‍ය වේ, එම නිසා i = i + 1 පේලිය ක්‍රියාත්මක නොවේ. මෙම අවස්ථාවෙන් ලූප් එක නවතින අතර ඊළගට i = 5 කේත පේලිය ක්‍රියාත්මක වේ.

do while loop

ඊළගට අපි “do while” ලූප් එක ගැන විමසා බලමු. “do while” සහ “while” ලූප් දෙකම එක වගෙයි. වෙනසකට ඇත්තේ “do while” loop එකේදී අපි {} තුළ යොදන කේත කොටස කලින් ක්‍රියාත්මක වී අවසානයේ  ප්‍රකාශයක සත්‍ය අසත්‍යතාව විමසා බලා ලූප් එක නැවත්විමයි. While ලූප් එකේදී සිදු වන්නේ ප්‍රකාශයේ සත්‍ය අසත්‍යතාව මුලින් විමසා පසුව {} තුළ ඇති කේත කොටස ක්‍රියාත්මක වීමයි.

එය කේතනය කරන්නේ පහත ආකාරයටයි. එහිදි සත්‍යයතා ප්‍රකාශනය යොදන්නේ අවසානයටයි.

do {
functionX();
} while (සත්‍යයතා ප්‍රකාශනය);

for loop

දැන් අපි “for”එක ගැන බලමු, මෙය බහුලව භාවිතා වන වැදගත් ලූප් එකකි. මෙය යොදාගෙන ගොඩක් දේවල් පහසුවෙන් සිදු කර ගත හැකිය.  එය අර්ථ දක්වන්නේ පහත ආකාරයටයි:

for (ප්‍රකාශනය-1; ප්‍රකාශනය-2; ප්‍රකාශනය-3)
functionX();

For ලූප් එකේදී : ප්‍රකාශනය 2 ක් ගැන සලකා බලා අදාළ කේත කොටස ක්‍රියාත්මක කෙරේ. පසුව නැවතත් 3 වන ප්‍රකාශනය සලකා බලයි. මෙහිදී ද කේත පේළි කිහිපයක් පවතී  නම් {} තුළ අදාළ කේතයන් ඇතුළත් කළ යුතුය.

for (ප්‍රකාශනය-1; ප්‍රකාශනය-2; ප්‍රකාශනය-3) {
functionX();
functionY();
}

• පළමු ප්‍රකාශනය-1 තුළීන් විචල්‍යයක් සමග ආරම්භය අර්ථ දැක්වේ.
• දෙවැනි ප්‍රකාශනය-2 තුළීන් ලූප් එක නවතින ස්ථානය හෙවත් අවසානය අර්ථ දක්වයි.
• තුන්වන ප්‍රකාශනය-3 තුළීන් පළමු හා දෙවන ප්‍රකාශන වලදි යොදාගත් විචල්‍යයයෙහි අගය වෙනස් වන ආකාරය අර්ථ දක්වයි.

පහත උදාහරණය බලන්න:

int i = 0, j = 0;
for (i = 0; i < 2; i++)
j++;
i = 5;

• පළමු අවස්ථාවේ: i = 0, i < 2 ප්‍රකාශ සත්‍ය වන බැවින්  j++ පේළිය හා i++ ක්‍රියාත්මක වන අතර ඉන්පසු i = 1,  j = 1 වේ.
• දෙවන අවස්ථාවේ: i = 1, i < 2 ප්‍රකාශ සත්‍ය වන බැවින්,  j++, පේළිය හා  i++ ක්‍රියාත්මක වන අතර ඉන්පසු i = 2,  j = 2 වේ.
• තුන්වන අවස්ථාවේ: i = 2, i < 2 ප්‍රකාශ සත්‍ය නොවේ. එම නිසා ලූප් එක මෙතනින් නවතී. එම නිසා j++, පේලිය හා  i++ ක්‍රියාත්මක නොවේ අතර ඊළගට 4 වන පේළිය වන  i = 5 ක්‍රියාත්මක වේ.

Increment and Decrement Operators

මෙය භාවිතා කරන්නේ යම් අගයක් එකකින් අඩු කිරීමට හෝ එකකින් වැඩි කිරීමටයි. අගය එකකින් වැඩි කිරීම Increment ලෙස හදුන්වයි. අදාල විචල්‍යය i ලෙස ගත්නේ නම් එහිදී “i++” ලෙස භාවිතා කරයි. එය “i = i + 1” සමාන වේ. අගය එකින් අඩු කිරීම Decrement ලෙස හදුන්වයි. එය  “i–”  ලෙස භාවිතා කරයි. එය “i = i – 1” සමාන වේ..

පරිපථ සැකැස්ම

දැන් අපි ආර්ඩුයිනෝ බෝර්ඩ් එකේ D3, D4, D5, D6, D7, D8, D9, D10, D11, D12 යන pin භාවිතා කර  LED තීරු දර්ශකයක LED පාලනය කරමු. එයට අදාල පරිපථ සටහන පහත දැක්වේ.

Schematic diagram

Hardware connection

Sketch 1.1

දැන් අපි ඉහත පරිපථ සටහනට අදාලව තීරු දර්ශකයේ LED පාලනය කිරිමට sketch නිර්මාණය කරමු. පළමුව එක් දිශාවකට LED එකින් එක දැල්වීගෙන යන ආකාරයට සකස් කරමු.

const int ledCount = 10;    // the number of LEDs in the bar graph

// an array of pin numbers to which LEDs are attached
int ledPins[] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };

void setup() {
  // loop over the pin array and set them all to output:
  for (int i = 0; i < ledCount; i++) {
    pinMode(ledPins[i], OUTPUT);
  }
}

void loop() {
  // the ith LED of LED bar graph will light up in turn
  for (int i = 0; i < ledCount; i++) {
    barGraphDisplay(i);
  }
}

void barGraphDisplay(int ledOn) {
  // make the "ledOn"th LED of bar graph LED on and the others off
  for (int i = 0; i < ledCount; i++) {
    if (i == ledOn)
      digitalWrite(ledPins[i], HIGH);
    else
      digitalWrite(ledPins[i], LOW);
  }
  delay(100);
}

const int ledCount = 10;    // the number of LEDs in the bar graph

දැන් අපි LED තීරු දර්ශකය හා සම්බන්ධ කරන පින් ටික ගබඩා කර ගන්න තබා ගැනීමට array එක භාවිතා කරනු ලැබේ. ඒ විට array එකට යොදන අගයන් වෙනස් කිරීමෙන් ඕනෑම වෙලාවක අපි භාවිතා කරන පින් වෙනස කරගන්න පුළුවන්. මෙම ආකාරයේ දී ඔබ පින් පිලිවෙළකට යොදා නොතිබුනත් කිසිම ගැටළුවක් නොවේ.

// an array of pin numbers to which LEDs are attached
int ledPins[] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };

ඊළගට අපි for ලූප් එකක් භාවිතා කරලා array එකේ තියෙන පින් ටික පහසුවෙන් ප්‍රතිදාන(output) බවට පත්කර ගනිමු. එය setup() ෆන්ශන් එක තුළ ඇතුළත් කල යුතුයි. එය කරන ආකාරය පහත දැක්වේ.

void setup() {
  // loop over the pin array and set them all to output:
  for (int i = 0; i < ledCount; i++) {
    pinMode(ledPins[i], OUTPUT);
  }
}

දැන් අපි පරාමිතියක් ලෙස එන පින් එකට අදාල අගය සහිත LED එක පමණක් දල්වෙන්නත් අනිත් LED නිවෙන්නත් ෆන්ශන් නිර්මාණය කරමු. මෙහිදී අපි කලින් පරිදිම for ලූප් එකක් සහ if-else කොන්දේසි සහිත ප්‍රකාශන ආකාරය භාවිතා කරයි.

void barGraphDisplay(int ledOn) {
  // make the "ledOn"th LED of LED bar graph on and the others off
  for (int i = 0; i < ledCount; i++) {
    if (i == ledOn)
      digitalWrite(ledPins[i], HIGH);
    else
      digitalWrite(ledPins[i], LOW);
  }
  delay(100);
}

අන්තිමට, ඉහත ෆන්ශන් එකට කතා කළ විට එය එක දිගට loop එකක් විදියට වැඩ කරයි. එයට කතා කරන ආකාරය පහත දැක්වේ.

void loop() {
  // make the "i"th LED of LED bar graph on and the others off in turn
  for (int i = 0; i < ledCount; i++) {
    barGraphDisplay(i);
  }
}

ඔබගේ ප්‍රෝග්‍රෑම් එක නිවැරදිදැයි බලා බෝර්ඩ් එක වෙත අප්ලෝඩ් කරන්න, එවිට LED තීරු දර්ශකයේ LED එක් දිශාවට LED එකින් එක දැල්වීගෙන යයි. මෙහිදී හැමවිටම එක LED එකක් පමණක් දැල්වී තිබෙන අතර අනිත් LED නිවී පවතී.

Sketch 1.2

දැන් අපි LED දෙපැත්තටම යන ආකාරයට ඉහත ප්‍රෝග්‍රෑම් එක වෙනස් කරමු.

const int ledCount = 10;    // the number of LEDs in the bar graph

// an array of pin numbers to which LEDs are attached
int ledPins[] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };

void setup() {
  // loop over the pin array and set them all to output:
  for (int i = 0; i < ledCount; i++) {
    pinMode(ledPins[i], OUTPUT);
  }
}

void loop() {
  // makes the "i"th LED of LED bar graph bright in turn
  for (int i = 0; i < ledCount; i++) {
    barGraphDisplay(i);
  }
  // makes the "i"th LED of LED bar graph bright in reverse order
  for (int i = ledCount; i > 0; i--) {
    barGraphDisplay(i - 1);
  }
}

void barGraphDisplay(int ledOn) {
  // make the "ledOn"th LED of LED bar graph on and the others off
  for (int i = 0; i < ledCount; i++) {
    if (i == ledOn)
      digitalWrite(ledPins[i], HIGH);
    else
      digitalWrite(ledPins[i], LOW);
  }
  delay(100);
}

දැන් අපි loop() එක තුළ තියෙන කේත අලුත් කර LED ටික දෙපැත්තටම යන විදියට නැවත සකස් කර ඇත්තෙමු. loop() ෆන්ෂන් එක තුළ ඇති කේත  වෙනස් කර ගැනීමෙන් මෙය සිදු කරගන්න පුළුවන්. මෙහිදි තවත් for ලුප් එකක් එකතු කර එය මගින් array එකේ index එක වැඩි අගයේ සිට අඩු අගය දක්වා පැමිනෙන ආකාරයට සකස් කර ගනී.

ඉහත කේතනය අප්ලෝඩ් කරගත්තට පස්සේ ඔබට පහත ආකාරයට LED දෙපැත්තට ගමන් කරන ආකාරය දැකගත හැකිය.

Reference

• https://www.arduino.cc/reference/en/language/variables/data-types/array/
• https://www.arduino.cc/reference/en/language/structure/control-structure/dowhile/