Arduino පාඩම 6 - Void සහ Function නිර්මාණය කිරීම.

7:41 PM 0

Void සහ Function නිර්මාණය ගැන කතා කරන්න කලින් අපි බලමු මොකක්ද මේ Void සහ Function කියන්නේ කියලා ඒ වගේම ඇයි ඒවා අපිට වැදගත් වෙන්නේ කියලා. Arduino එකත් එක්ක වැඩ කරද්දි නම් විශේෂයෙන්ම Void සහ Function වැදගත් මොකද කිව්වොත් Void සහ Function මගින් වැඩසටහනේ ස්ථාන කිහිපයක්දීම යෙදෙන එකම දිගු කේත පේලි වලට ආදේශකයක් විදිහට තමයි මේවා ක්‍රියාත්මක වෙන්නේ. එතකොට ප්‍රෝග්‍රෑම් එක Upload කරන කොට ඒ  සඳහා microcontroller එකේදී වැයවන ඉඩ ප්‍රමාණය අඩු වෙනවා. එතකොට අපිය ලොකු වැඩසටහනක් උනත්  අඩු ඉඩක ලියන්න පුළුවන් වෙනවා, ඒ වගේම තමයි coding කරන කොට අපෙන් සිදුවන අත් වැරදීම් වගේම සිදුවන පැටලිලි සහගත බවත් අඩුවෙනවා වගේම ප්‍රෝග්‍රෑම් එක හිර වෙන්නේ නැතුව run වෙනවා.

කලින් පාඩම් ටික බැලුවෙ නැත්නම් මෙතනින් ගිහින් බලන්න

VOID නිර්මාණය සහ භාවිතය.

void/function මේ දෙකම එකම වගේ පෙනුනත්  මේ දෙක තරමක් වෙනස්. void එක භාවිත වෙන්නේ නැවත නැවත භාවිත කලයුතු කේත පේළි කිහිපයක් වෙනුවට ආදේශයක් ලෙසයි.
උදාහරණයක් විදිහට මෙහෙම හිතන්නකො, අපි මොකක් හරි ප්‍රෝග්‍රෑම් එකක් ලියන කොට අපිට ඕනෙ වෙනවා  warning led එකක් 3න් පාරක් blink (නිවි නිවි පත්තු වෙන්න). මේ LED එක blink වෙන්නේ serial data වල 3, 5, 7, 25  වගේ අගයක් ලැබුනොත් විතරයි කියලා හිතන්නකො.
අපි සාමාන්‍ය විදිහට මේක කරනවන්ම් අපි කරන්නේ if හරි case එක හරි යොදාගෙන 3,5,7,25 කියන හැම තැන කටම led එක blink කරන්න ඕනෙ කෝඩ් එක ලියනවා, එතකොට කෝeඩ් එක දික් වෙනවා විතරක් නෙමෙයි blink code එකෙ මොකක් හරි වෙනසක් කරන්නෙ ඕනෙ උනොත් ඒ හැම තැනම වෙනස් කරන්න ඕනෙ නමුත් මේ විදිහට void එකක් යොදා ගත්තනම් වැඩේ ලේසියි. කෝඩ් එකත් කොටයි. වෙනසක් කරන්නෙ ඕනෙ උනොත් void එකේ විතරක් ඒ වෙනස කරා නම් ඇති. අපි මුලින්ම බලමු කොහොමද void එකක් හදන්නේ කියලා.

පහලින් තියෙන්නේ void එකක සරල අකෘතිය
void nameofvoid(datatype value1,datatype value2){
  \\ Your code here
}

nameofvoid කියන තැන void එක හදුනා ගැනීමට අදාලව නමක් දෙන්න, ඊට පස්සේ ඒකට ඉස්සරහින් තියෙන වරහන් දෙක ඇතුලේ අපි void එක use කරනකොට void එක ඇතුලෙ තියෙන කෝඩ් එක පොඩිපොඩි වෙනස් කම් කරලා භාවිතා කරන්න ඕනෙ අවස්ථා තියෙනවා ඒ වගේ අවස්තා වලදී ඒ වෙනස් කරන්න ඕනේ value එකේ datatype එකයි,  value එකට නමකුයි දෙන්න ඕනේ ඒ විදිහට වෙනස් කරන්න ඕනේ values ගොඩක් තියෙනවනම් උඩ example එකේ විදිහට කොමාව දාල ලියන් යන්න ඕනේ එහෙම වෙනස් කරන්න කෝඩ් එකේ මුකුත් නැත්නම් වරහන හිස්ව තියන්න. මේක තේරුම් ගන්න අපි කෝඩ් එකක් ලියලම බලමු.

පහල විදිහට circuit එක හදාගන්න

මම මෙතනදී කරන්න හදන්නේ Serial communication හරහා එන 1, 2, 3, 4 කියන ඉලක්කම් හතරට අදාලව LED 4 ක් blink කරන එක.

void setup() {
Serial.begin(9600);
pinMode(9,OUTPUT);
pinMode(10,OUTPUT);
pinMode(11,OUTPUT);
pinMode(12,OUTPUT);
}
void loop() {
  if(Serial.available()>0){
    int code=Serial.parseInt();
    switch(code){
      case 1:
      OffAllLED();
      LEDblink(9);
      break;
      case 2:
      OffAllLED();
      LEDblink(10);
      break;
      case 3:
      OffAllLED();
      LEDblink(11);
      break;
      case 4:
      OffAllLED();
      LEDblink(12);
      break;
    }
  }
}
void LEDblink(int LEDPin){
  digitalWrite(LEDPin,HIGH);
  delay(100);
   digitalWrite(LEDPin,LOW);
  delay(100);
digitalWrite(LEDPin,HIGH);
  delay(100);
   digitalWrite(LEDPin,LOW);
  delay(100);
digitalWrite(LEDPin,HIGH);
  delay(100);
   digitalWrite(LEDPin,LOW);
  delay(100);
}
void OffAllLED(){
     digitalWrite(9,LOW);
     digitalWrite(10,LOW);
     digitalWrite(11,LOW);
     digitalWrite(12,LOW);
}

මෙතනදී මම setup, loop ඇතුලේ තියෙන කෝඩ් එක  පැහැදිලි කරන්නේ නෑ, මොකද මම ඒවා කලින් පාඩමෙන් පැහැදිලි කරලා හියෙනව (බලපු නැති අය මෙතනින් ගිහින් බලන්න).
මම කෝඩ් කරලා තියෙන්නේ serial monitor එකේදී 1 හරි, 2 හරි, 3හරි, 4 හරි කියලා type කරලා send කලොත් ඊට අනුරූපව 9, 10, 11, 12 කියන digital pin වලට හයි කරපු LED  බ්ලින්ක් වෙන්න.
මෙතන්දී මම LEDblink හා OffAllLED කියලා void 2 ක් හදාගෙන තියෙනවා LEDblink කියන void එකෙදී මට blink වෙන්න ඕනේ LED එක හයි කරපු pin එක වෙනස් කරන්න ඕනෙ නිසා මම වරහන් ඇතුලෙදී LEDPin කියලා int datatype එකෙන් හදාගෙන තියෙනවා (data types ගැන කලින් පාඩමෙන් පැහැදිලි කරලා හියෙනව බලපු නැති අය මෙතනින් ගිහින් බලන්න).
Function නිර්මාණය හා භාවිතය.
Function එකත් Void එක වගේම වැදගත් දෙයක්. Function එකේදී අපි Function ඇතුලේදී කරන මොකක් හරි ක්‍රියාවලියකට පස්සේ මොකක් හරි ප්‍රතිඵලයක් ලබාගන්න භාවිතා කරන්න පුලුවන්.

පහල තියෙන්නේ Function එකක් පොදු අකෘතියයි.

DataType FunctionName(datatype value1,datatype value2){
//Your code here
return resault;
}

මේක තේරුම් ගන්න පහලතියෙන code එක try කරලා බලන්න.
මම මෙතනදී කරලා තියෙන්නේ Serial monitor එක හරහා අපි ලබාදෙන මොකක් හරි අගයන් දෙකක් ගුණ කරලා ප්‍රතිඵලය Serial Print කරන එකයි.

void setup() {
  Serial.begin(9600);
}
void loop() {
if (Serial.available()>0) {
  int a=Serial.parseInt();
   int b=Serial.parseInt();
  Serial.println(GetValue(a,b));
}
}
int GetValue(int num1, int num2){
  int val;
  val=num1*num2;
  return val;
}

මම මෙතනදී මුලින්ම මම හදාගත්ත function එක විස්තර කරන්නම්. මම මෙතනදී GetValue කියන නමින් int data type එකේ function එකක් හදාගෙන තියෙනවා. ඒ වගේම function එකට අගයන් ඇතුලු කරන්න පුලුවන් විදිහට num1, num2 කියලා int data type එකේ variable 2 කුත් හදාගෙන තියෙනවා.
function එක ඇතුලෙදී val කියන නමින් int වර්ගයේ variable එකක් හදාගෙන තියෙනවා. ඊළඟ පියවරේදී num1, num2 ගුණ කරලා එන අගය val variable එකට යොමුකරලා තියෙනවා.
අන්තිම පියවරේදී  return val; කියන පේලියෙන් කරන්නේ function එකේ result එකවිදිහට val variable එකේ තියෙන අගය සකස් කරන එකයි. මෙතනදී කියන්න ඕනේ වැදගත් දෙයක් තියෙනවා, ඒ තමයි function එකේ data type එකත් return කියන කොටසට ඉස්සරහින් ලියන කොටසේ data type එකත් සමාන වෙන්න ඕනේ.
දැන් අපි loop එක ඇතුලේ කරලා තියෙන්නේ මොකක් කියලා බලමු, මෙතනදී මම මුලින්ම කරලා තියෙන්නේ if condition එක දාලා serial monitor එක හරහා data ලැබෙනවද කියලා බලලා තියෙනවා data ලැබෙනවනම් ඒ එන data a හා b කියලා හදාගත්ත int variable 2 කට වෙන වෙනම යොමු කරලා තියෙනවා.
Serial.println(GetValue(a,b)) පේලියෙන් කරන්නේ Serial monitor  එකේදී GetValue කියන අපි කලින් හදාගත්ත function එකෙන් ලැබෙන result එක print කරන එකයි. ඒ වගේම function එකේ සංඛ්‍යා 2 ක a හා b කියලත් ලබාදීලා හියෙනව.
දැන් code එක arduino එකට upload කරලා Serial monitor එක open කරලා ඔයාට ගුණ කරන්න  ඕනේ සංඛ්යා දෙක කොමාවක් දාල type  කරලා send කරන්න. ඔයා කොමාවට මුලින් ලියපු සංඛ්‍යාව a variable එක විදිහටත් කොමාවට පස්සේ ලියපු සංඛ්‍යාව b variable එක විදිහටත් හදුනගෙන ඒ දෙකේ ගුණිතය Serial monitor එකේ  print වෙයි.



මේවිදිහට  Void සහ Function යොදගෙන coding  වැඩ ලේසි කරගන්න පුලුවන්. comment එකක් දාගෙනම යන්න. අයෙත් අපි ඉක්මනටම හම්බවෙමු.
article එක හොදයි නම් තව කෙනෙකුට බලන්න  share කරගෙනම යන්න .

Arduino පාඩම 5 - If සහ case යොදාගෙන කොන්දේසි පරික්ෂා කිරීම.

5:59 PM 11


Arduino එකත් එක්ක වැඩ කරන ඕනෑම කෙනෙක් අනිවාර්යයෙන් දැනගෙන තියෙන්න ඕනෙ දෙයක් තමයි If සහ case කියන්නේ. මේ දෙකෙන්ම කරන්නේ කොන්දේසි පරීක්ෂා කරන එක තමයි. උදාහරණයක් විදිහට අපි හිතමු Arduino එකට පිටින් හයි කරලා තියෙන බට්න් එකක් එබුවොත් LED එකක් පත්තු වෙන්න ඕනෙ බට්න් එක අතහැරියොත් LED එක නිමෙන්න ඕනේ. මේ වගේ අවස්ථාවලට පාවිච්චි කරන්නේ if හරි case හරි තමයි. If සහ case යන දෙකම කොන්දේසි පරීක්ෂා කරන්න භාවිත කලත් මේ දෙක ටිකක් වෙනස්.

කලින් පාඩම් ටික බැලුවෙ නැත්නම් මෙතනින් ගිහින් බලන්න

if වැඩිපුරම භාවිතා වෙන්නේ එකිනෙකට වෙනස් කොන්දේසි කිහිපයක් පරීක්ෂා කරල ඒ අනුව මොනව හරි කරන්න. උදාහරණයක් විදිහට Arduino එකට පිටින් හයි කරලා තියෙන බට්න් එකක් එබුවොත් එකදෙයක් වෙන්න, LDR එකට එලිය වැටුනොත් තවදෙයක් වෙන්න, serial data වලින් මොකක් හරි අගයක් ලැබුනොත් මොකක් හරි වෙන්න වගේ එකිනෙකට කිසිම සම්බන්ධයක් නැති කොන්දේසි කිහිපයක් පරීක්ෂා කරලා ඒ අනුව තීරණයක් ගන්න If යොදගන්න පුළුවන් ඒ වගේම තනි කොන්දේසියක් පරීක්ෂා කරල බලන්නත් හොදම විදිහ තමයි If භාවිතා කරන එක.

case එක වැඩිපුරම භාවිත වෙන්නේ එකිනෙකට සම්බන්ධයක් තියෙන කොන්දේසි පරීක්ෂා කරල බලලා තීරණයක් ගන්න ඕනෙ උනාම. උදාහරණයක් විදිහට කිව්වොත් serial data වලින් 1, 5, 4, 9, 20, 52 වගෙ අගයන් ටික විතරක් ආවොත් විතරක් ඒ ඒ අගයන් වලට අදාළ මොනවා හරි ක්‍රියාවලි කිහිපයක් වෙන්න ඕනෙයි කියල හිතන්නෙකො, ඒ වගේ වෙලවට case එක වැදගත් වෙනවා, මේකට If භාවිතා කරන්න පුලුවන් උනත් ඒක ටිකක් කරදර කාර වැඩක් ඒ වගේම If එකට වඩා වේගයෙන් case එක ක්‍රියාත්මක වෙන එකත් වාසියක්.

නමුත් බොහොමයක් වෙලාවට if එක වෙනුවට case එකත් case එක වෙනුවට if එකත් භාවිත කරන්න පුළුවන්. If සහ case ගැන ඉගෙන්ගන්න කලින් Arduino වලදී භාවිතා වන logical opraters ගැන ඉගෙන ගන්න ඕනෙ.

Arduino logical Operators වර්ග.

Arduino වලදී භාවිතා වන logical Operatorsපහත පරිදිවේ.

Comparison Operators
== (equal to) - සමානයි.
!= (not equal to) - අසමානයි.
< (less than) - අඩුයි.
> (greater than) - වැඩියි.
<= (less than or equal to) - සමානයි හෝ අඩුයි.
>= (greater than or equal to) - සමානයි හෝ වැඩියි.

Boolean Operators

&& (and)
|| (or)
! (not)

if ගැන කතා කරනකොට ඒකේ ආකාර 2 ක් තියෙනවා. if සහ if-else තමයි ඒ  ආකාර 2 ක. මුලින්ම අපි if ගැන කතා කරමු.

If ආකාරය.

පහලින් දැක්වෙන්නේ if වල තියෙන පොදු  ආකෘතිය.

if(කොන්දේසිය){
      කොන්දේසිය සත්‍ය නම් සිදු විය යුතු කාර්යය
 }

මේ ගැන හරියට තේරුම් ගන්න අපි පොඩි circuit එකක් හදමු. මම මෙතන්දී කරන්න යන්නේ Arduino වලට Serial input වලින් On කියලා command එකක් අවහම Arduino එකට හයි කරලා තියෙන් LED එකක් ON වෙන්නයි. ඒ කට පහල තියෙන විදිහය circuit එක හදාගෙන පහල තියෙන code එක upload කරන්න.

void setup() {
pinMode(9,OUTPUT); // Set pin 9 as output pin
Serial.begin(9600); // Start serial communication
}
void loop() {
  if(Serial.readString()=="ON"){  // Check condition
    digitalWrite(9,HIGH);  // On led
  }
}

2 සහ 3 වෙනි පේලි වලින් කරලා තියෙන්නේ 9 වෙනි pin එක output pin එකක් කිරීම සහ serial communication එක start කිරීමයි. loop එක ඇතුලෙ තියෙන 6 වෙනි පේලියෙන් කරලා තියෙන්නේ Serial communication වලින් ලැබෙන data එක වචනයක් විදිහට කියවලා ඒ වචනය ON ද කියලා check කරන එකයි. අපි මෙතනදී සැසදමක් අරන නිසා තනි සමාන ලකුණ වෙනුවට සමාන ලකුණු 2ක් පාවිච්චි කරන්න ඕනෙ. 7 වෙනි පේලියෙන් කරලා තියෙන්නේ උඩින් තියෙන කොන්දේසිය සත්‍ය නම් 9 පින් එකේ voltage එක high කිරීමයි.

මෙතනදී Serial.readString() කියන function එක භාවිතා කරලා තියෙන නිසා අපි serial monitor එකට ඉන්පුට් කරපු වචනය හරි, අගයහරි ඒ විදිහටම කියව ගන්න පුලුවන.

කෝඩ් එක upload කරලා Serial monitor එක open කරන ඒකේ ON කියලා type කරලා send කරන්න එතකොට LED එක ඔන් වෙයි. ඒ වගේම මොන දේ Type කරලා send කලත් LED එක off කරගන්න බැරිවෙයි.

if-else ආකාරය.

පහලින් දැක්වෙන්නේ if-else වල තියෙන පොදු  ආකෘතිය.

if(කොන්දේසිය){
කොන්දේසිය සත්‍ය නම් සිදු විය යුතු කාර්යය
  } else {
කොන්දේසිය අසත්‍ය නම් සිදු විය යුතු කාර්යය
}


මේ ක්‍රමයත් තේරුම් ගන්න තියෙන හොදම විදිහ තමයි පොඩි ප්‍රෝග්‍රෑම් එකක් ලියන එක. ඒකටත් කලින් circuit එකම හදාගන්න, මෙතනදී මම කරන්න හදන්නේ ON කියලා type කලොත් LED එක ON වෙන්න, වෙන මොකක් හරි type කලොත් LED එක Off වෙන්න. ඒ කට පහල code එක ලියලා upload කරන්න.

void setup() {
pinMode(9,OUTPUT); // Set pin 9 as output pin
Serial.begin(9600); // Start serial communication
}
void loop() {
  if(Serial.available()>0){
    if(Serial.readString()=="ON"){
    digitalWrite(9,HIGH);
  }else{
    digitalWrite(9,LOW);
  }
  }
  }
1 සහ 2 පේලි වලින් වෙන්නේ කලින් කියපු දේමයි. 6 වෙනි පේලියෙන් කරන්නේ serial වල තියෙන data එක 0 වඩා විශාලද කියලා බලන එකයි. 0 ට වඩා විශාල නම් ඊළඟ කොන්දේසිය check කරන්වා. 7 වෙනි පේලියෙන් කරන්නේ ඒක. එතනදී කරල  තියෙන්නේ Serial communication වලින් ලැබෙන data එක වචනයක් විදිහට කියවලා ඒ වචනය ON ද කියලා check කරන එකයි. data එක ON නම් LED එක on වෙනවා, data එක ON නෙමෙයි නම් LED එක off වෙනවා. දැන් කෝඩ් එක upload කරලා Serial monitor එක open කරලා check කරලා බලන්න.

මෙතන්දී මම මුලින්ම if condition එක දාලා serial වල තියෙන data එක 0 වඩා විශාලද කියලා බැලුවෙ Arduino එකට අපි data එකක් send  නොකර තියෙන කොට තත්පරයකට vවතාවක් විතර auto ම 0 කියලා ලැබෙනවා, ON කියන වචනය නොවන data ගොඩට 0 ත් අයිති වෙන නිසා ප්‍රෝග්‍රෑම් එක අවුල් නොයන්නයි if condition එක දාලා serial වල තියෙන data එක 0 වඩා විශාලද කියලා බැලුවෙ.

Case ආකාරය.

පහලින් දැක්වෙන්නේ case හි පොදු ආකෘතියයි.

switch (int වර්ගයේ විචල්‍යක් ) {
      case විච්ල්‍යයේ_යම්_අගයක්  :
ඉහත අගය සත්‍ය නම් වියයුතු කාර්යය.
        break;
      case විච්ල්‍යයේ_යම්_අගයක්  :
ඉහත අගය සත්‍ය නම් වියයුතු කාර්යය.
        break;
      case විච්ල්‍යයේ_යම්_අගයක්  :
ඉහත අගය සත්‍ය නම් වියයුතු කාර්යය.
        break;
      default:
        විච්ල්‍යයේ අගය ඉහත එකක් වත් නොවේ නම් සිදුවිය යුතු කාර්යය.
    }

(විචල්‍යයේ අගය ඉහත එකක් වත් නොවේ නම් සිදුවියයුතු කාර්යයන් කිසිවක් නැත්නම් උඩදී නිල් පාටින් තියෙන කෝඩ් කොටස ලියන්න අවශ්‍ය නෑ, ඒ වගේම ඉහත විදිහට කැමති කොන්දේසි ගානක් එකතු කරගන්නත් පුළුවන්.)

case එක වැඩ කරන විදිහ තේරුම් ගන්න පොඩි circuit එකක් හදමු, ඒ කට පහල රූපයේ තියෙන විදිහට ciruit එක හදගන්නේ පස්සේ පහල තියෙන කෝඩ් එක upload කරන්න.

void setup() {
 Serial.begin(9600);
 pinMode(9,OUTPUT);
pinMode(10,OUTPUT);
pinMode(11,OUTPUT);
}
void loop() {
 if(Serial.available()>0){
 int intByte=Serial.read();
  switch(intByte){
  case 'a':
  digitalWrite(9,HIGH);
  break;
  case 'b':
  digitalWrite(10,HIGH);
  break;
  case 'c':
  digitalWrite(11,HIGH);
  break;
  default:
    digitalWrite(9,LOW);
    digitalWrite(10,LOW);
    digitalWrite(11,LOW);
  }

මම මෙතනදී 8 පේලියෙන් කරලා තියෙන්නේ  serial communication හරහා data එකක් එනවද කියලා බලන එක. data එකක් එනවනම් ප්‍රෝග්‍රෑම් එක ඊළඟ පියවරට යනවා.

9 වෙනි පේලියෙදී කරලා තියෙන්නේ intByte කියලා integer(Int) වර්ගයේ variable එකක් define කරලා  serial communication හරහා එන data එක read කරලා intByte වලට යොමු කරපු එක.

10 වෙනි පේලියෙදි මම විචල්‍ය විදිහට යොදගත්තේ intByte කියන වේරියබල් එක තමයි.

11 පේලියේදී බලනවා intByte වලට ආපු data එක a ද කියලා, a කියන්නේ අකුරක් උනත් "a" නැතුව 'a' විදිහට ලියලා තියෙන්නේ  Serial.read(); කියන function එක හරහා intByte වලට ලැබෙන්නේ a අක්ෂරයේ ASCII අගය නිසා ඒකට ගැලපෙන්නේ a හි ASCII අගය නිසා a හි ASCII අගය ලබා ගැනීමට "a" නැතුව 'a' විදිහට ලියනවා.

තේරුනේ නැත්නම් මෙහෙම හිතන්නකෝ ඔයා Serial monitor එක open කරලා a කියන අකුර type කරලා send කරනවා ඔයා Serial.read(); කියන function එක භාවිතා කරලා ඒ අකුර read කරන්න ගියොත් ඔයාට ලැබෙන්නේ a අකුර වෙනුවට a අකුරට අදාල ASCII අගයයි.

ASCII කියන්නේ HEX, Decimal වගේ සංඛ්‍යා පද්ධතියක් මේ පද්ධතියේ අපි භාවිතා කරන හැම සංකේතයකටම ASCII අගයක් තියෙනවා, පහලින් තියෙන වගුවේ තියෙනේ ඒ අගයන් වලින් කිහිපයක්.
ඒ ත් තවම තේරුනේ නැත්නම් උඩලියපු කෝඩ් එකේ 'a' වෙනුවට 97, 'b' වෙනුවට 98, 'c' වෙනුවට 99 ත් දාලා බලන්නකෝ ඒත් කෝඩ් එක වැඩකරනවා.


අපි දැන් ආයේ කෝඩ් එකට යමු, මේ විදිහට 19 වෙනි පේලියට වෙනකන් කරලා තියෙන්නේ serial communication වලින් ලැබෙන්නේ a ද,  b ද,  c ද කියලා චෙක් කරලා ඒ ඒ අකුරට අදාල LED එක පත්තු කරන එක.

20 පේලියේදී   default: කියන කෝඩ් එකට පහලි ලියලා තියෙන කෝඩ් එකෙන් කරන්නේ serial communication වලින් a, b, c නැතුව වෙනත් අකුරක් හරි ඉලක්කමක් හරි ලැබුනොත් LED ඔක්කොම OFF කරන එක.
දැන ප්‍රෝග්‍රෑම් එක run කරලා බලන්න.

article එකේ අඩුපාඩු හරි අදහස් හරි තියෙනවනම් කමෙන්ට් කරගෙන යන්න.



WPF VB.Net පාඩම 10 - Control එකකට Bitmap effect යොදන හැටි.

9:45 AM 0

WPF Application තුල දැකිය හැකි විශේෂ ලක්ෂණයක් තමයි control එකක් තුල bitmap effect භාවිතා කිරීමේ හැකියාවයි. තවත් සරල විදිහකට කිව්වොත් Photoshop වැනි මෘදුකාංග තුල පින්තූරයකට යොදන Glow, Dropshadow, Blur, Emboss හා Bevel වැනි effects WPF Application තුල භාවිතා වන Button, Canvas, Checkbox වැනි ඕනෑම control එකකට යෙදිය හැකි වීමයි. contol එකකට effect එකක් apply කිරීම ක්‍රම දෙකකට සිදු කල හැක එනම් XAML code ලියා හෝ VB.NET code ලියායි. පළමුව XAML code ලියා effect එකක් apply කරන ආකාර සලකමු.

XAML code ලියා effect එකක් apply කිරීම

මේ සඳහා පළමුව අළුත් WPF application එකක් open කරගෙන එහි ඇති MainWindow එක මතට   effect එක යෙදීමට අවශ්‍ය control එක add කර ගත යුතුය. මෙතැනදී විස්තර කරන්නේ එලෙස ලබාගත් button එකකට effect apply කරන ආකාරයයි. button එක MainWindow එක මතට ලබාගත් පසුව එහි XAML code window එක මතට පිවිසිය යුතුය. අනතුරුව එහි පහත පරිදි XAML code එක ලිවිය යුතුය.

<Button Content="Button"  Width="75" Margin="36,30,0,0" HorizontalAlignment="Left" VerticalAlignment="Top" Height="22">
            <Button.BitmapEffect >
                <BitmapEffectGroup >
                </BitmapEffectGroup>
            </Button.BitmapEffect>
        </Button>

ඉහත පරිදි XAML code එක ලියා ගත් පසුව <BitmapEffectGroup > යන්න මත click කල යිතුය එවිට Properties window එක තුලදී ඉහත ලබා ගත් BitmapEffectGroup තුල සිදු  කල හැකි සැකසුම් දිස්වේ. (Properties window දැක ගත නොහැකිනම් F4 ඔබා Properties window එක ලබා ගත හැක)  දැන් Properties window එකෙහි childern යන්න ඉදිරියෙන් ඇති button එක ක්ලික් කල යුතුය.


එවිට විවෘත වන්නේ BitmapEffect collection editor Window එකයි. අනතුරුව එහි වම් පස පහල කෙලවරෙහි ඇති Dropdown list එකෙන් අවශ්‍ය effect එක තෝරා add button එක ක්ලික් කල  යුතුය.

 අනතුරුව එහි සැකසුම් සිදු කර OK බ්ට්න් එක ක්ලික් කිරීමයි. වැඩසටහන RUN කරන විට effect එක දැක ගත හැක.

VB.NET code ලියා effect එකක් apply කිරීම

මෙහිදී MainWindow එක Load වෙන අවස්ථාවේදී effect එක apply වීමටයි. මේ සඳහා MainWindow එක මතට Button එකක් ලබාගෙන එහි Name එක btnEffect ලෙස සකසන්න. මෙහිදී Load වෙන  අවස්ථාවේදී effect එක apply කිරීමට බලාපොරොත්තුවෙන නිසා MainWindow එකෙහි Loaded එක තුල පහත Code එක ලිවිය යුතුය.

Dim Group As New Effects.BitmapEffectGroup
        Dim Effect1 As New Effects.DropShadowBitmapEffect
        Effect1.Color = Colors.Red
        Effect1.Direction = 315
        Effect1.Opacity = 100
        Effect1.ShadowDepth = 4
        Effect1.Softness = 50
        Group.Children.Add(Effect1)
        btnEffect.BitmapEffect = Group

මෙහිදී පළමු පේලියෙන් සිදුකර ඇත්තේ Effect Group එකක් ලබා ගැනීමයි, එය Group ලෙස නම් කර ඇත. දෙවන පේලියෙන් සිදුකර ඇත්තේ අලුතින් DropShadow effect එකක් ලබා ගැනීමයි, එය Effect1 ලෙස නම් කර ඇත. 3 පේලියේ සිට 7 පේලිය දක්වා සිදුකර ඇත්තේ ඉහත ලබාගත් DropShadow effect එකට අදාල සැකසුම්ය.

8 පේලියේදී සිදුකර ඇත්තේ ඉහත ලබාගත් effect group එකට DropShadow effect එක ඇතුලත් කිරීමයි. අනතුරුව එය button එකෙහි bitmap effect property එකට සමාන කර ඇත. දැන්  වැඩසටහන RUN කරන විට effect එක දැක ගත හැක.

වැඩිදියුණු කර සැකසූ වැඩසටහන


මෙවර පාඩමට අදාල Project file එක download කරගන්න.
මොනව හරි දැනගන්න තියෙනවනම් comment එකක් දාලා අහන්න, ලිපිය හොදයි  නම් යාළුවන්ටත් බලන්න share කරන්න.




Arduino පාඩම 4 - Variable භාවිතා කරන හැටි.

2:40 PM 0

මෙවර Arduino ලිපියෙන් මම ඉදිරිපත් කරන්නේ Arduino වලදී Variable භාවිතා කරන ආකාරය හා variable යොදාගෙන pin declaration කරන ආකාරයයි. Arduino වලින් දක්ෂ විදිහට ප්‍රොග්‍රෑම් කරන්න ආස ඕනෑම කෙනෙක් අනිවාර්යයෙන් ඉගෙන ගන්න ඕන දෙයක් තමයි Variable කියන්නේ. Variable යොදාගෙන වැඩසටහන් පහසුවෙන් ලියා ගන්න පුළුවන් ඒ වගේම අනවශ්‍ය විදිහට Variable යොදාගත්තොත් එය වැඩසටහන මන්දගාමී වීමට බලපාන්න පුලුවන්. ඒ නිසා ප්‍රොග්‍රෑම් කරන ඕනෑම කෙනෙක් Variable ගැන ඉගෙන ගන්නම ඕනේ. මේ ගැන ඉගෙන ගන්න කලින් අපි Variable එකක් කියන්නේ මොකක්ද කියලා හදුනාගනිමු.

පසුගිය පාඩම් සියල්ල  මෙතනින් බලන්න.

Variable එකක්  කියන්නේ මොකක්ද ?

අපි Arduino වලදී Variable ගැන කතාකලත් Variable කියන්නේ ඉලෙක්ට්‍රොනික් වලට සම්බන්ධ දෙයක් නෙමෙයි. නමුත් ඒක Arduino වලට සම්බන්ධ වෙන්නේ කෝඩ් ලිවීමේදී යි. සරලවම Variable කියන්නේ මොකක්ද කියලා කිව්වොත් Arduino ප්‍රෝග්‍රෑම් එකක් ධාවනය වන විට Arduino තුල තියෙන RAM එකෙන් කොටසක් ඒ සඳහා යොදා ගන්නවා. Variable එකක් කියන්නේ ප්‍රෝග්‍රෑම් එකට පිටින් ගිහින් Arduino තුල තියෙන RAM එක තුල තාවකාලිකව දත්ත තැන්පත් කරන ක්‍රමවේදයක්. Variable සෑම පරිගණක භාෂාවකම භාවිතා උනත් භාෂාවෙන් භාෂාවට ඒවා නම් කරන හැටි තරමක් වෙනස්. Arduino තුලදී භාවිතා වෙන්නේ C++ භාෂාව නිසා මේ ලිපියෙන් මම ඉදිරිපත් කරන්නේ C++ භාෂාවේ තියෙන Arduino වලට අදාල Variable පමණයි.


Variable වර්ග.

Variable තුලදී යොදාගත හැකි අගය පරාසය, දත්ත වර්ගය, අනුලක්ෂණ හෙවත් characters ප්‍රමාණය හා RAM එකෙන් අත් කරගන්නා ඉඩ ප්‍රමාණය අනුව Variable වර්ග කිහිපයක් තියෙනවා. පහල රූපයේ දැක්වෙන්නේ Variable පිළිබඳ විස්තරයි.



Variable භාවිතයේදී සැලකිලිමත් විය යුතු කරුනු.

  • Variable තුල ගබඩා කිරීමට බලාපොරොත්තුවෙන දත්ත වර්ගය හා ප්‍රමාණය අනුව Data type  එක තෝරා ගත යුතුය.
  • සෑම විටම RAM එක අඩුවෙන් භාවිතා වන Data type එකක් තෝරාගත යුතුයි. එවිට ප්‍රෝග්‍රෑම් එක සුමටව ධාවනය කල හැක.
  • සෑමවිටම අඩු Variable ගණනකින් ප්‍රෝග්‍රෑම් එක ලිවීමට වගබලා ගත යුතුය.
  • එකම ප්‍රොජෙක්ට් එකතුල එකම නමින් වේරියබල් දෙකක් සැකසිය නොහැක.
  • වේරියබල් එකෙහි නම ආරම්භ කළ යුත්තේ අකුරකිනි, අවශ්‍ය නම නෙමේ මැද කොටස සදහා ඉලක්කම් භාවිතා කලහැක.
  • වේරියබල් එකක වචන දෙකක් අතර හිස් ඉඩක් නොතැබිය යුතුය. එසේ අවශ්‍ය නම් ඒවෙනුවට අන්ඩර්ස්කෝ ලකුණ ( _ ) භාවිතා කලහැක.
  • වේරියබල් එක සදහා නමක් ලබා දීමේදී %, &, !, #, $ යන සලකුණු භාවිතා කළ නොහැක.
  •  වේරියබල් එකක නමක් සදහා භාවිතා කලහැකි උපරිම අකුරු ගණන 255 කි.
  •  ගණිත කර්ම සදහා boolean, String, array වැනි data types භාවිතා කල නොහැක.
  • දශමස්ථාන සහිත අගයන් භාවිතා කරන විට ඒ සඳහා float, double වැනි data types භාවිතා කල යුතුය.



Variable නම් කිරීම.

ඕනෑම Variable එකක් නම් කීරීමේ පොදු  අකෘතිය පහත පරිදි වේ.

[ඩේටා ටයිප් එක] [Variable එකෙහි නම];

උදාහරණ :

int Age;
boolean pass;
String MyName;
double resault;

Variable තුලට Data input කිරීම.

ඕනෑම Variable එකක් තුලට අවස්ථා දෙකකදී Data input කිරීම සිදුකල හැක. එනම් Variable එක සාදන අවස්ථාවේදී හා වෙනත් අවස්ථාවකදී. මේ සඳහා උදාහරණ ලෙස ඉහත සැකසූ Variable තුලට දත්ත  ඇතුලත් කරන ආකාරය බලමු.

සාදන අවස්ථාවේදී-----

int Age = 27;
boolean pass = true;
String MyName = "Arduino";
double resault = 85.78;

වෙනත් අවස්ථාවකදී------


Age = 27;
pass = true;
MyName = "Arduino";
resault = 85.78;

Data Read කිරීම.

මේ සදහා ඉහත සාදාගත් MyName නම් Variable එකතුල ඇති දත්තය Serial monitor එකතුල ප්‍රින්ට් කරන ආකරයේ වැඩසටහනක් සාදමු.
String MyName;

void setup() {
Serial.begin(9600);
MyName = "Arduino";
}

void loop() {
Serial.println(MyName);
}
මෙහිදී Arduino යන්න ප්‍රින්ට් කිරීමට MyName නම් Variable එක yodhaagena යොදාගෙන ඇත.

Arduino pin declaration (පින් නම් කිරීම).

Arduino තුලදී pin declaration කිරීම ප්‍රධාන වශයෙන් ක්‍රම 3 ක් තියෙනවා, එනම් Direct declaration, Variable declaration හා #define tag වශයෙනුයි.

Direct declaration

මෙහිදී කෙලින්ම පින් එකෙහි අංකය යොදා ගෙන නම් කිරිම සිදුකරයි. අනෙක් ආකාර දෙකට සාපේක්ෂව මෙහි ඇති අවාසිය වන්නේ වැඩි වාරගණනක් එකම පින් අංකය විවිධ තැන් වල යෙදී  ඇති විට යම් හෙයකින් පින් අංකයේ වෙනසක් සිදු කිරීමට අවශ්‍ය වුවහොත් එම සෑම තැනක්ම එකින් එක වෙනස්  කල යුතු වීමයි.
උදාහරණයක් ලෙස LED blink ප්‍රෝග්‍රෑම් එකක් සලකමු.
void setup() {.
  pinMode(13, OUTPUT);
}
void loop() {
  digitalWrite(13, HIGH);  
  delay(1000);              
  digitalWrite(13, LOW);    
  delay(1000);              
}
මෙහි 13 වෙනි පින් එක වෙනුවට 12 පින් එක භාවිතා කල යුතුයැයි සිතන්න. එවිට 13 ලෙස යෙදී ඇති සෑම තැනක්ම 12 ලෙස වෙන් වෙන්ව ලිවිය  යුතුය. මෙය කරදර කාරී වැඩකි.

#define tag

මෙහිදී සිදුකරනුයේ පින් අංකය වෙනුවට වෙනත් නමක් යොදාගෙන එම නම පින් අංකය යෙදිය යුතු ස්ථානවලට ආදේශ කිරීමයි. නමුත් මෙහි  ඇති අවාසිය වන්නේ define  tag එක යොදන අවස්ථාවේදී පින් අංකය හදුන්වා දිය යුතූ අතර වෙනත් ස්ථානයකදී පින් අංකය වෙනස් කල නොහැකි වීමයි.
මේ සඳහා ඉහත උදාහරණයම සලකමු

#define ledpin 13
void setup() {
  pinMode(ledpin, OUTPUT);
}
void loop() {
  digitalWrite(ledpin, HIGH);  
  delay(1000);              
  digitalWrite(ledpin, LOW);    
  delay(1000);              
}
මෙහි 13 වෙනි පින් එක වෙනුවට 12 පින් එක භාවිතා කල යුතුයැයි සිතන්න. එවිට කලයුත්තේ  #define ledpin 13 වෙනුවට #define ledpin 12 ලෙස ලිවීමයි.

Variable declaration

මෙහිදීද  සිදුකරනුයේ පින් අංකය වෙනුවට වෙනත් නමක් යොදාගෙන එම නම පින් අංකය යෙදිය යුතු ස්ථානවලට ආදේශ කිරීමයි. නමුත් මෙහිදී #define tag හි මෙන් නොව Variable එක  declaration කරන අවස්ථාවේදී මෙන්ම වෙනත් අවස්ථාවකදීද පින් අංකය වෙනස් කිරීමට හැකි වීමයි.
මේ සඳහාද  ඉහත උදාහරණයම සලකමු

char ledpin;
void setup() {
ledpin=13;
  pinMode(ledpin, OUTPUT);
}
void loop() {
  digitalWrite(ledpin, HIGH);  
  delay(1000);              
  digitalWrite(ledpin, LOW);    
  delay(1000);              
}

මෙහි 13 වෙනි පින් එක වෙනුවට 12 පින් එක භාවිතා කල යුතුයැයි සිතන්න. එවිට කලයුත්තේ  ledpin=13; වෙනුවට ledpin=12; ලෙස ලිවීමයි. මෙයද පහසු ආකාරයකි.
නැවතත් මෙවැනිම ලිපියකින් මුනගැහෙමු. 




Arduino පාඩම 3 - LDR හා Variable resistor මගින් ලැබෙන දත්ත Serial monitor තුලදී කියවීම.

7:58 AM 4

Arduino එකට බාහිරින් input ලබාදිය යුතු අවස්ථාවලදී ඒ සඳහා  විවිධ උපකරණ යොදාගැනීමට සිදු වනවා, input ලබාදීමේදී ඒ සඳහා අවශ්‍ය කරන උපකරණ කරනු ලබන නිර්මාණය අනුව වෙනස් වනවා. input ලබාදීමේදී වඩාත් ප්‍රයෝජනවත් වන උපකරණ දෙකක් වශයෙන් LDR හා Variable resistor හැදින්විය හැක.
LDR හා Variable resistor යන ද්විත්වයම වෙනස් වන විද්‍යුත් ප්‍රතිරෝධ සහිත උපාංගයි. එනම් එවැනි ප්‍රතිරෝධයකට අවම ප්‍රතිරෝධය ලෙස 0 ohm ද උපරිම ප්‍රතිරෝධය ලෙස එහි සදහන් වන ප්‍රතිරෝධය ද ලබා දිය හැකි අතර Variable resistor එකක් නම් එය කැරකැවීමෙන් ඒ අතර මැද අගයක් ඇති ප්‍රතිරෝධයකුත් LDR එකක් නම් ඒ මතට වැටෙන් ආලෝකයේ තීව්‍රතාව වෙනස් කිරීමෙන් ඒ අතර මැද අගයක් ඇති ප්‍රතිරෝධයකුත් ලබාදිය හැක.

කෙසේ වෙතත් LDR එකක් නම් බොහෝවිට එහි අවම ප්‍රතිරෝධය 0 ohm හා උපරිම ප්‍රතිරෝධය අනන්තය ලෙස සදහන් වනවා. LDR එකමතට වැටෙන් ආලෝකයේ තීව්‍රතාව (එළිය) වැඩිවත්ම එහි ප්‍රතිරෝධය අඩු වන  අතර ආලෝකයේ තීව්‍රතාව අඩුවත්ම එහි ප්‍රතිරෝධය වැඩිවේ.

මෙහිදී මම බලපොරොත්තු වන්නේ LDR\Variable resistor මගින් ලැබෙන දත්ත Serial monitor තුල ප්‍රින්ට් කිරීමයි.  ඒ සදහා Serial Print භාවිතා කිරීම කිරීම පිළිබඳව සලකා බලමු.

Serial Print භාවිතා කිරීම.

Serial monitor තුල යමක් ප්‍රින්ට් කිරීමට අදාල මූලික කෝඩ් එක පහත පරිදි වේ.

void setup() {
Serial.begin(9600);
}
void loop() {
 Serial.println(අගය හෝ වැකිය);
}

 setup කොටස තුල ලියා ඇති Serial.begin(9600); යන්නෙන් කෙරෙන්නේ වැඩසටහන  ආරම්භයේදීම Serial communicaton ආරම්භ කරන අතර එහි වේගය තත්පරයට bit 9600 ලෙස සැකසීමයි.

Serial communicaton මගින් Arduino එක USB මාර්ගයෙන් computer එකහා සම්බන්ධ කර වෙනත් වැඩසටහනක් මාර්ගයෙන් පාලනය කල හැකි අතර වෙනත් Serial communicaton සදහා සහය දක්වන වෙනත්  module/shield හා සම්බන්ධ කර ඒව අතර සන්නිවේදන මාර්ගයක් ගොඩනගා ගැනීමට උපකාරීවේ. එසේම Serial monitor එක හරහා විවිධ Output ප්‍රින්ට් කරගත හැකි අතර Arduino වෙත Input ලබාදීමද මේ හරහා සිදුකර ගත හැක.

මෙහි loop කොටස තුල ලියා ඇති Serial.println(අගය හෝ වැකිය); කෙරෙන්නේ Serial monitor තුල ඔබ ලබාදෙන අගය හෝ  වැකිය පේලියෙන් පේලියට පහලට ප්‍රින්ට් කිරීමයි.


Serial monitor තුල අගයක් print කිරිම.

මෙහි Serial monitor තුල 300 යන්න print කිරිමට අවශ්‍ය යැයි සිතමු. ඒ සදහා කෝඩ් එක පහත පරිදි වේ.

void setup() {
Serial.begin(9600);
}
void loop() {
 Serial.println(300);
}

මෙහිදී loop එක ක්‍රියාත්මක වන වාරයක් පාසා 300 යන්න ප්‍රින්ට් වේ.


Serial monitor වචනයක් අගයක් print කිරිම.

මෙහි Serial monitor තුල Computer යන්න print කිරිමට අවශ්‍ය යැයි සිතමු. ඒ සදහා කෝඩ් එක පහත පරිදි වේ. මෙහිදී වඩාත් සැලකිලිමත් විය යුතු කරුන වන්නේ වචනයක් හෝ වැකියක් ප්‍රින්ට් කරන විට එය "" සලකුණු තුල ලිවීමයි.

void setup() {
Serial.begin(9600);
}
void loop() {
 Serial.println("Computer");
}

මෙහීදි Serial.println("Computer"); ලෙස ලියා  ඇති නිසා Computer යන්න පහලට ප්‍රින්ට් වේ.

නමුත් මෙහිදී Serial.print("Computer"); ලෙස ලියුවහොත්  Computer යන්න ඉදිරියට ප්‍රින්ට් වේ.


Circuit Diagram



Arduino Code

ඉහත පරිදි circuit (දෙකෙන් ඕනෑම එකක්) එක සදාගැනීමෙන් පසු පහත කෝඩ් එක ලියා Ardunio වෙත Upload කරන්න. Circuit Diagram දෙකටම කෝඩ්  එක පහත පරිදි වේ.

void setup() {
Serial.begin(9600);
}
void loop() {
 Serial.println(analogRead(A0));
}

 setup කොටස තුල ලිaයා ඇති Serial.begin(9600); යන්නෙන් කෙරෙන්නේ වැඩසටහන  ආරම්භයේදීම Serial communicaton ආරම්භ කරන අතර එහි වේගය තත්පරයට bit 9600 ලෙස සැකසීමයි.
මෙහි loop කොටස තුල ලියා ඇති Serial.println(analogRead(A0)); කෙරෙන්නේ Serial monitor තුල A0 පින් එකෙන් ලැබෙන අගයන් ප්‍රින්ට් කිරීමයි.

මෙහිදී data input pin එක ලෙස analog pin එකක් භාවිත කර  ඇත්තේ LDR හා Variable resistor යන දෙකටම උපරිම හා අවම අගයන්ට අමතරව ඒ අතර පරාසයේ විචලනය වන ප්‍රතිරෝධ අගයන් ඇති නිසාය. එවිට වෝල්ටීයතාව 0 හා 5 පමණක් නොව 0 හා 5 අතර වන අනෙක් අගයන්ද ලැබේ. එවිට එම අගයන් කියවීම සදහා analog pin එකක් යොදා ගත යුතුය.


කෝඩ් එක Upload කල පසුව Serial monitor  එක විවෘත කර අදාල අගයන් බැලිය හැක.

Arduino පාඩම 2 - Analog write function භාවිතය.

12:20 PM 2
ඕනෑම Arduino Board එකක ප්‍රධාන වශයෙන් pin වර්ග 2 ක් තියෙනවා. එනම් Analog හා Digital pin ය. මෙහි digital පින් නැවතත් කොටස් 2 කට බෙදෙනවා එනම් PWM පහසුකම ඇති හා නැති යනුවෙන්. සාමාන්‍යයෙන් PWM පහසුකම ඇති pin ඉදිරියෙන් ~ සලකුණ යොදා ඇති අතර Arduino UNO board එකක මෙවැනි පින් 6 ක් තිබෙනවා.

සාමාන්‍ය Digital output එකකින් ලබා ගත හැක්කේ 0V හා 5V යන අවස්ථා 2 ක පමණයි. එය උදාහරණයකින් දැක්වුවහොත් සාමාන්‍ය Digital output එකකින් කල හැක්කේ LED එකක් දැල්වීම හා නිවා දැමීම පමණයි. 

නමුත් මෙම PWM(Pulse With Modulation)  පහසුකම ඇති පින් එකක විශේෂත්වය වන්නේ 0V හා 5V යන අවස්ථා 2 කට අමතරව 0V ත් 5V ත් අතර වෝල්ටීයතා අගයන්ද  output කිරීමට ඇති හැකියාවයි. එය උදාහරණයකින් දැක්වුවහොත් LED බල්බයක්  ON හා OFF කරන අවස්ථාවන්ට අමතරව LED බල්බයක දීප්තිය අඩුවැඩි කිරීමට (LED fade) මෙම PWM පින් යොදාගත් හැක. එසේම කුඩා DC Motor එකක වේගය පාලනයටද මෙය යොදා ගත හැක.


LED fade කිරීම.

ඒ සදහා පහත පරිදි පරිපථය සාදාගන්න


අනතුරුව පහත කෝඩ් කොටස Arduino වෙත Upload කරන්න.

void setup() {
 pinMode(3,OUTPUT);
 analogWrite(3,200);
}
void loop() {
}

මෙහි Loop කොටස තුල කිසිවක් ලියා නොමැත්තේ වැඩසටහන ධාවනය වන අතරතුර අගයන් වෙනස් නොකරන බැවිනි.

මෙහි 2 වන පේලියේදී සිදු කර ඇත්තේ 3 වන පින් එක output pin එකක් වශයෙන් යොදා ගන්නා බව Arduino board එකට දන්වා සිටීමයි. 
3 වන පේලියේ සිදු කර ඇත්තේ 3 වන පින් එකෙහි අගය 200 ලෙස සැකසීමයි. මේ සදහා 0 ත් 255 ත් අතර ඕනෑම අගයක් යෙදිය හැක. 0 න් 0V යන්නත් 255 න් 5V යන්නත් අදහස් වේ. ඒ මෙහි 200 යෙදීමෙන් +3.92 V  විභවයක්  3 පින් එක හරහා ලබා ගත  හැක.

මෙම Output volatage එක පහත පරිදි ගණනය කළ හැක.

Output volatage = (5/255)*200 = 3.92 V

Motor Speed control කිරීම.

ඒ සදහා පහත පරිදි පරිපථය සාදාගන්න
image source : instructables.com

මේ සඳහා පහත කොටස් අවශ්‍ය වේ.

TIP 120 Transistor
1k Ohms Resistor
IN 4004 Diode
1mF Capasitor

අනතුරුව පහත කෝඩ් කොටස Arduino වෙත Upload කරන්න.
void setup() {
 pinMode(11,OUTPUT);
 analogWrite(11, 200);
}
void loop() {
}

මෙහි කේත පැහැදිලි කිරීම ඉහත පරිදිම වේ.

මෙහි 200 වෙනුවට වෙනත් අගයන් යෙදීමෙන් වෙනස් වේග වලින් මෝටරය කැරකැවිය හැක.

ප්‍රශ්නයක් තියෙනවනම් අහන්න.


WPF VB.net පාඩම 9 - Solid colours භාවිතය.

12:32 PM 0


මෙවර පාඩම් මාලවෙන් ඉදිරිපත් කෙරෙන්නේ WPF තුලදී Solid Colours භාවිතා කරන ආකාරයයි. WPF Application තුලදී WinForm Application තුලට වඩා දක්න ඇති විශේෂත්වය වන්නේ විවිධ Colours(Solid/Gradient) හා Visual Effect (ඉදිරියේදී සාකච්ඡා කරන්නම්) භාවිතා කිරීමට ඇති හැකියාවයි. ඕනෑම IDE එකකදී මෙන්ම WPF තුලදීද Colours භාවිතා කිරීම අවස්ථා 2 කදී සිදු කල හැක. එනම් Design mode එක හා Run time mode එක තුලයි.

Design Mode එක තුලදී  Colours භාවිතය.

Design mode එකතුලදී Colours භාවිතය සත්‍ය වශයෙන්ම යම් කිසි Control එකකට අදාලව Colour property සැකසීමයි. WPF තුලදී වර්ණ භාවිතය Winform තුලදී වර්ණ භාවිතයෙන් වෙනස් වන්නේ මෙතැනදීය. මක්නිසාද යත් Winform තුලදී  මෙන් නොව  එනම් Design Mode එක තුලදී  Colours භාවිතය ඉතාම පහසුවෙන් ඕනෑම කෙනෙකුට  Properties Window එක යොදාගෙන සිදු කලහැක. එබැවින් මා මෙම ලිපිය තුලදී ඒ පිළිබඳව දීර්ඝ වශයෙන් විස්තර කිරීමට බලාපොරොත්තු නොවේ.

Runtime mode එක තුලදී Solid Colours භාවිතය.

එක් නිශ්චිත වර්ණයක් ලබාදීම.

මේ සදහා පළමුව නව WPF Project එකක් Open කර Window එක මතට Rectangle එකක් සහ Button එකක් ලබා ගෙන එහි Properties පහත පරිදි සකසා ගන්න.
Rectangle Name = rtg

Button Name = btn
        Content = Change To Red

මෙහිදී සිදු කිරීමට අදහස් කරන්නේ Button එක Click කල විට Rectangle හි Fill colour එක රතු පැහැ කිරීමය. සඳහා Button එකෙහි Click ඉවෙන්ට් එකතුල පහත පරිදි කෝඩ් ලිවිය යුතුය.
 rtg.Fill = Brushes.Red
මෙහි සිදු කර ඇත්තේ Rectangle හි Fill එක Red ලෙස සැකසීමයි.

Slider මගින් Colour වෙනස් කිරීම

මේ සඳහා Slider 3 ක් Window වෙතට ලබාගෙන එහි properties පහත පරිදි සැකසිය යුතුය.
Slider1 Name = sldR
Maximum = 255

Slider2 Name = sldG
Maximum = 255

Slider3 Name = sldB
Maximum = 255

අනතුරුව ඉහත එක් එක් Silder එකෙහි ValueChanged event එක තුල පහත කෝඩ් කොටස ලිවිය යුතුය.

rtg.Fill = New SolidColorBrush(Color.FromRgb(sldR.Value, sldG.Value, sldB.Value))

මෙහිදී sldR.Value, sldG.Value, sldB.Value ලෙස යොදා ඇත්තේ අදාල වර්ණයට අදාල RGB value එකයි.

Color Dialog භාවිතය.

මේ සඳහා පළමුව Color Dialog එක ඇති dll file එක Project එක තුලට ඇතුලත් කර ගත යුතුය. ඒ සදහා Solution Explorer තුලදී Project එකෙහි නම මත Right click කර ලැබෙන මෙනුව තුලින් Add>Reference හරහා ගොස් Reference Manager වින්ඩෝව තුලට පිවිස ඒ තුලින් System.Windows.Form යන්න තෝරා Ok කල යුතුය. අනතුරුව කෝඩ් වින්ඩෝව වෙත පිවිස Class MainWindow යන්නට ඉහළින් පහත කෝඩ් කොටස ලිවිය යුතුය.

Imports System.Windows.Forms



දැන් Colour Dialog එක ඇති dll file එක Project එක තුලට ඇතුල් වී ඇත.
මීළගට Window එක මතට නව Button එකක් ලබාගෙන ඉහි Properties පහත පරිදි සකසා ගන්න.

Button Name = btnDialog
        Content = Select Color

අනතුරුව Button එකෙහි Click එවෙන්ට් එක තුල පහත කෝඩ් කොටස ලියන්න

        Dim dialog As New ColorDialog
        Dim brush As New SolidColorBrush
        dialog.ShowDialog()
        brush.Color = Color.FromRgb(dialog.Color.R, dialog.Color.G,dialog.Color.B)
        rtg.Fill = brush


Download Project file here

ප්‍රශ්න තියෙනවානම් කමෙන්ට් කරන්න............!