Showing posts with label arduino සිංහලෙන්. Show all posts
Showing posts with label arduino සිංහලෙන්. Show all posts

Arduino පාඩම 17 - [Advanced coding] Introduction to registers in ATmega328

7:41 PM 3 Comments

අපි අද කතා කරන්න යන්නේ registers ගැන. ඕනෑම CPU එකක තියෙනවා registers. මේ register එකක් කියන්නේ මතකයක් එහෙමත් නැත්නම් memory එකක්. ඒ වගේම මේ එක එක registers වලට විශේෂ රාජකාරී පැවරිලා තියෙනවා. අපි කතාකරන ATmega328 එහෙමත් නැත්නම් Arduino UNO/Nano board වල තියෙන microcontroller එකේ අපිට පාලනය කරන්න පුලුවන් මේවගේ registers එහෙමත් නැත්නම් General purpose registers 32 ක තියෙනවා.

මේ registers වලින් වැඩ ගන්න හැටි ඉගෙන ගන්න කලින් මේ registers හැදිලා තියෙන්නේ කොහොමද කියලා දැනගෙන ඉන්න එක වැදගත්.

Register එකක් හැදිලා තියෙන්නේ කොහොමද ?

කලිනුත් කිව්වා වගේ register කියන්නේ memory එකක්. ඒ කියන්නේ මේකේ data store කරලා තියෙනවා. data කියන්නේ 1 සහ 0. ඒ අනුව බලන කොට memory එකක්දී වෙන්නේ මේ 1/0 කියන data අපේ අවශ්‍යතාව store කිරීමයි. 

දැන් අපි බලමු single bit එකක් මේ memory එකේ store කරන්නේ කොහොමද කියලා.



ඉහලින් තියෙන Logic circuit එක සලකන්න. මෙතනදී OR gate එකේ output එක සම්බන්ධ කරලා තියෙනවා එම OR gate එකේම B input එකට. 
  1. ආරම්භයේදී OR gate එකේ input දෙකම 0 අවස්ථාවෙ තියෙනවා කියල සලකන්න. 
  2. දැන් අපි A input එකට 1 ඇතුලු කරමු. (A=1 සහ B=0)
  3. ඒ අනුව output එකත් 1 වෙනවා.
  4. output එක 1 වෙනවත් සමගම B input එකත් 1 වෙනවා.
  5. දැන් අපි අයෙමත් A input එක 0 කරමු. දැන් A=0 සහ B=1 අවස්ථාව. 
  6. මෙතනදී B=1 නිසා A වලට මොන විදිහක බලපෑමක් කලත් output එක වෙනස් නොවී පවතිනවා.
  7. ඒ කියන්නේ අපි කලින් කරපු වෙනස් කම, A=1 කිරිම්ම තවදුරට logic circuit එකේ සේව් වෙලා තියෙනවා.
  8. නමුත් මෙතනදී තියෙන අවාසිය තමා එක් වරක් A=1 කරාට පස්සේ නැවත output එක 0 කරන්න බෑ.
දැන් අපි බලමු ඉහල logic circuit එකම AND gate එක යොදාගෙන නිර්මාණය කරලා.


  1. ආරම්භයේදී AND gate එකේ input දෙකම 1 අවස්ථාවෙ තියෙනවා කියල සලකන්න. 
  2. දැන් අපි A input එකට 0 ඇතුලු කරමු. (A=0සහ B=1)
  3. ඒ අනුව output එකත් 0 වෙනවා.
  4. output එක 0 වෙනවත් සමගම B input එකත් 0 වෙනවා.
  5. දැන් අපි අයෙමත් A input එක 1 කරමු. දැන් A=1 සහ B=0 අවස්ථාව. 
  6. මෙතනදී B=0 නිසා A වලට මොන විදිහක බලපෑමක් කලත් output එක වෙනස් නොවී පවතිනවා.
  7. ඒ කියන්නේ අපි කලින් කරපු වෙනස් කම, A=0 කිරිම්ම තවදුරට logic circuit එකේ සේව් වෙලා තියෙනවා.
මේ logic circuit දේකේම තියෙන අවාසිය තමා එක වරක් සිදුකරන ලද වෙනස් කමක් circuit එක තුල දිගටම save වෙලා තිබීම. ඒ කියන්නේ එක් වරක් save කරාට පසුව නැවත update කරන්න බෑ. 

මේ හේතුව නිසා මේ logic circuit 2 කම එකතු කරලා වෙනත් circuit එකක් හදලා මේ අපහසුතාව මග ඇරගන්න පුලුවන් !

මේ විදිහට නිර්මාණය කරගන්න logic circuit එකකට කියනවා AND-OR Latch එකක් කියලා.

මෙතන්දී  SET = 1 කිරීම මගින් OUTPUT එක 1 කරන්නත් RESET = 1 කිරීම මගින් OUTPUT එක 0 කරන්නත් පුලුවන්. 

ඒ අනුව අපිට පුලුවන් අපි කැමති විදිහට single bit data එකක් store කරල තියන්න. ඒ අනුව මේක තමා single bit memory එකක මුලාකෘතිය. 

මේ ක්‍රමයෙදී එහෙමත් නැත්නම් AND-OR Latch එකක තියෙන දුරවල කමක් තමා output එක 1 කරන්න එක input එකකුත්, output එක 0 කරන්න තව input එකකුත් භාවිතා කිරීම.

මේ අපහසුතාව මග ඇරගන්න AND-OR Latch එකම තවත් වැඩිදියුණු කරලා Gated Latch එක නිර්මාණය කරලා තියෙනවා.


Gated Latch එකේත් input දෙකක් තියෙනවා DATA input සහ Write enable වශයෙන්. මෙතනදී අපිට මොනව හරි data එකක් memory එකේ write කරන්න ඕනෙ උනාම මුල්නම් කරන්න ඕන write enable =1 කරන එක. ඊට පස්සේ අපිට ඕන data එක input කරලා. නැවත write enable = 0 කරන්න්න ඕන.

මේ  විදිහට තමා single bit data එකක් අපි memory එකක් save කරන්නේ !

මේ ආකාරයට ක්‍රියාත්මක වෙන latch group එකකට අපි කියනවා REGISTER එකක් කියලා. ඒවගේම මේ register එකක තියෙන bit ගානට අපි කියනවා width එක කියලා.

සාමාන්‍යයෙන් අපි computer එකක 32-bit, 64-bit කියලා අදහස් කරන්නේ මේ register එකක් width එක. 

CPU වල මූලික අවදියේදි මේ register width එක 8-bit වලින් පටන් ගෙන 64-bit දක්වා  විකාශනය වෙලා තියෙනවා.

Why registers

register එකක් සාමාන්‍යයෙන් RAM එකකට වඩා ඉතාමත් වේගයෙන් ක්‍රියාකරනවා. අනිත් විශේෂ දේ තමා CPU එකේ program/task එකක් execute වීමට අදාල data තියෙන්නෙත් registers වලමයි. උදාහරණයක් විදිහට කියනවනම් ACR, IR, PCR දක්වන්න පුලුවන්.

Arduino program කරන්න register දැනුම ඕනෙ ඇයි?

Arduino කියන්නේ platform එකක්. ඒ කියෙන්නේ අපි භාවිතා කරන Arduino  Mega/Nano/UNO කියන development boards වලට නෙමේ Arduino කියන්නේ. ඒවා Arduino platform එක compatible development board. 

සාමාන්‍යයෙන් arduino board වල තියෙන්නේ Atmel microcontroller එකක්. මේ Atmel microcontroller  එකක් program කරන්න තියෙන default language එක තමයි assembly/C  වගේ language. ඉතින් මේ වගේ language එකක් use කරලා low level program කරන්න හොද දැනුමක් තියෙන්න ඕන. ඉතින් මේ අපහසු තාව මග ඇරගන්න තමා arduino හදුන්වා දෙන්නේ. ඒක නිසා තමා අද පොඩි ළමයෙකුට උනත් microcontroller  එකක් program කරන්න ලේසි වෙලා තියෙන්නේ.

කොහොම උනත් මේ විදිහට arduino වලින් program කරන්න ගියාම අපිට වැඩ කරන්න වෙන්නේ arduino වල තියෙන සීමා මායිම් වලට යටත් වෙලා. එහෙම උනාම සමහර අවස්තා වල අපිට microcontroller එකේ තියෙන full features use කරන්නත් බැරි වෙනවා. ඒ වගේම සමහර අවස්ථාවල code එකත් අනවශ්‍ය විදිහට complex වෙන්න පුලුවන්.

උදාහරණයක් විදිහට කිව්වොත් හිතන්න, අපිට ඕනෙ D8-D13 තියෙන pin ටික ඔක්කොම HIGH කරන්න. අපි මේක කරන්න සාම්ප්‍රදායික විදිහ,

digitalWrite(8,HIGH);
digitalWrite(9,HIGH);
digitalWrite(10,HIGH);
digitalWrite(11,HIGH);
digitalWrite(12,HIGH);
digitalWrite(13,HIGH);

මේ විදිහයි නමුත් අපි register පිළිබඳ දැනුම තියෙනවනම් කලින් code line 6 කින් කරපු දේ තනි පේළියෙන් කරන්න පුලුවන් පහල තියෙන විදිහට.

PORTD |= B00111111; // sets digital pins 8,9,10,11,12,13 HIGH

දැන් ඔයාලට තේරුම් ගන්න පුලුවන් register පිළිබද දැනුම තියෙනවනම් අපේ වැඩ කොච්චර ලේසි කරගන්න පුලුවන්ද කියලා! 

General purpose registers in  ATmega328

සාමාන්‍යයෙන් CPU එකක් තුල registers කිහිපයක් තියෙනවා. මේ තියෙන registers ප්‍රමාණය තීරණය වෙන්නේ ඒ ඒ CPU එකේ හැකියාව මත.

ATmega328 කියන්නේ AVR microcontroller පව්ලේ 8-bit microcongtroller එකක්. ඒකියන්නේ මේ ATmega328 එකේ තියෙන CPU එකේ register එකක් width එක 8 ක්. තවත් විදිහකට කියනවනම් මේ register එකේ bit 8 ක් වෙන වෙනම store කරන්න පුලුවන්.

කලිනුත් කිව්වා වගේ ATmega328 microcontroller එකෙ Register වර්ග 32 ක් තියෙනවා. පහල තියෙන්නේ එයින් කොටසක්. atmega328 datasheet එක බැලුවොත් ඔක්කොම බලාගන්න පුලුවන්.

Register Name Description
EEARH The EEPROM Address Register
EEARL The EEPROM Address Register
EEDR The EEPROM Data Register
EECR The EEPROM Control Register
GPIOR2 General Purpose I/O Register 2
GPIOR1 General Purpose I/O Register 1
GPIOR0 General Purpose I/O Register 0
OSCCAL Oscillator Calibration Register
CLKPR Clock Prescale Register
SMCR Sleep Mode Control Register
PRR Power Reduction Register
MCUCR MCU Control Register
MCUSR MCU Status Register
WDTCSR Watchdog Timer Control Register
EICRA External Interrupt Control Register A
EIMSK External Interrupt Mask Register
EIFR External Interrupt Flag Register
PCICR Pin Change Interrupt   Control Register
PCIFR Pin Change Interrupt Flag Register
PCMSK2 Pin Change Mask Register 2
PCMSK1 Pin Change Mask Register 1
PCMSK0 Pin Change Mask Register 0
PORTB The Port B Data Register
DDRB The Port B Data Direction Register
PINB The Port B Input Pins Address
PORTC The Port C Data Register
DDRC The Port C Data Direction Register
PINC The Port C Input Pins Address
PORTD The Port D Data Register
DDRD The Port D Data Direction Register
PIND The Port D Input Pins Address
ඊළඟ පාඩමෙන් මේ registers කොහොමද පාවිච්චි කරන්නේ කියලා බලමු !

Share කරගෙනම යන්න !!

Source : CrashCourse [Youtube Channel]

Arduino පාඩම 16 - [Advanced coding] Binary number system සහ Bitwise operations

11:35 AM Add Comment


ගොඩ කාලෙකට පස්සේ ලැබුන නිවාඩුවේ අලුතින් පාඩම් ටිකක් කරන්න හදන්නේ. අද ඉදලා පටන් ගන්න Advanced coding series එකේදී මන් බලාපොරොත්තු වෙන්නේ Arduino support කරන AVR microcontroller වලින් උපරිම ප්‍රයෝජන ගන්න පුලුවන් විදිහට කොහොමද ප්‍රොග්‍රෑම් කරන්නේ කියලා. මන් ඉස්සරහට කරන්න ඉන්නේ content ගැන කියනවනම්,

  • Binary number system with bitwise and bit shift operation
  • Introduction to registry
  • Port programming
  • Timers
  • ISR
  • Analog comparator විදිහට තමා මන් පාඩම් ටික ලිස්ට් ඩවුන් කරලා තියෙන්නේ. 
මේ විදිහ ටොපික් කතාකරන සිංහල බ්ලොග් එකක් හරි වීඩියෝ මන් දැනුවත්ව නම් නෑ දැනට. ඒක නිසා අනිත් අයටත් බලන්න ශෙයා කරගෙන යන්න.

මේ ටික අපිට කරන්න මූලික වශයෙන් ඕන වෙන්නේ binary number system එක ගැන තියෙන දැනුම. ඒක නිසා පලවෙනි පාඩම binary number system ගැන.

Binary number system

Binary(බයිනරි) එහෙමත් නැත්නම් ද්විමය සංඛ්‍යාවක් කියන්නේ මොකක්ද කියලා සරලව කිව්වොත්, binary number එකක් කියන්නේ මොකක් හරි අංකයක්  2 කේ පාදයෙන් නිරූපනයට. (අපි එදිනෙදා පාවිච්චි කරන්නේ decimal එහෙමත් එත්නම් දශමය සංඛ්‍යා පද්ධතිය.)
මීට අමතරව තව සංඛ්‍යා පද්ධති කිහිපයක් ම තියෙනවා. අපි ඒවා ගැන අවශ්‍යතාව අනුව ඉස්සරහට කතාකරමු.

මේ විදිඅහට මොන සංඛ්‍යා පද්ධතියෙන් තියෙන සංඛ්‍යාවක් උනත් ඒක වෙනත් සංඛ්‍යා පද්ධතියක තියෙන සංඛ්‍යාවක් විදිහට හරවගන්න පුලුවන්.
මෙතනදී සංඛ්‍යා පද්ධතිය වෙනස් උනාට ඒ සංඛ්‍යාවේ අගය වෙනස් වෙන්නේ නෑ. මෙතනදී වෙනස් වෙනේ පාදය විතරයි.

උදා : 4710 = 11012

උඩ උදාහරණයේ තියෙන්නේ 10 පාදයෙන් තියෙන සංඛ්‍යාව 2 පාදයේ (binary) සංඛ්‍යාවක් කරලා තියෙන විදිහයි.

Decimal to Binary conversion

අපි දැන් කතා කරන්න යන්නේ කොහොමද decimal number එකක් binary number එකකට convert කරගන්නේ කොහොමද කියලා.

බොහොම සුලු දෙයක් තමා මෙතනදී කරන්න තියෙන්නේ. ඒ කියන්නේ decimal number එක අන්තිමට 0 ලැබෙන කන් දිගින් දිගටම 2න් බෙදාගෙන යන එකෙ.

let's do it

උදාහරණය විදිහට කලින් කියපු 47 ගමු.

JavaScript Math: Convert a decimal number to binary, hexadecimal ...

මෙතනදී කරලා තියෙනේ මුලින්ම 47 කියන සංඛ්‍යාව 2න් බෙදනව ඉතුරු ගනන පැත්තකින් ලියනවා. බෙදිලා ලැබෙන උත්තරය නැවතත් 2න් බෙදවා, ඉතුරු ගනන පැත්තකින් ලියනවා. මේ විදිහට බෙදිලා ලැබෙන් උත්තරය  0 වෙනකන් දිගින් දිගටම මේක කරනවා. ඊට පස්සේ ඉතුරු විදිඅහට ලැබෙන අගයන් ටික පිලිවෙලට පහල ඉදන් උඩට ලිව්වාම උත්තරේ ලැබෙනවා.

Binary to Decimal conversion

දැන් අපි කතා කරන්න යන්නේ binary number එකක් කොහොමද decimal number එකක් බවට හරවගන්නේ කියලා. මන් මේකටත් කලින් උදාහරණයම පාවිච්චි කරන්වා.

අපි මුලින්ම කරන්න ඕනේ අපේ බයිනරි අංකය පිලිවෙලට ලියාගන්න ඕන.(අපි මේ එක කොටුවකින් නිරූපණය වෙන එක 1 හෝ 0 සංඛ්‍යාවකට bit එකක් කියලා කියනවා.) මෙහෙම bit ටික ලියාගත්තට පස්සේ අපේ දකුණු අත පැත්තේ අන්තිමට එන bit එකට LSB (least significant bit) කියලා කියනවා. ඒ වගේම වම් අත පැත්තේ අවසාන bit එකට MSB (least significant bit) කියලා කියනවා.

දැන් අපි binary number එක පීලිවලට ලියාගත්තට පස්සේ අපි ඒ ඒ bit වල්ට 2 පාදයෙන් බර තිය තිය එනවා LSB එකේ ඉදන් MSB වෙනකන්. 

ඊට පස්සේ bit එකයි ඒකට අදාල බර සංඛ්‍යාවයි ගුණකරනවා. අවසානයේ ඒ සියලු අගයන් එකට එකතු කරනවා.

32+0+8+4+2+1 = 47

Why binary

දැන් අපි කතා කරන්න යන්නේ ඇයි අපිට binary number system එකක් ඕනේ ? කියලා. මේකට දෙන්න පුලුවන සරලම උත්තරේ තමා, 
අපි වැඩ කරන්නේ ඉලෙක්ට්‍රොනික පද්ධති එක්ක. මේවට මිනිස භාෂාව තේරුම් ගන්න විදිහක් නෑ. මේවට තේරුම ගන්න පුලුවන් 1 සහ 0 පමණයි. ඒ ද කියලා කියන්නේ 0v ද නැත්නම් 5v විතරයි (logic level එක 5v කියලා හිතමු!). 

උදාහරණයක් විදිහට අපි arduino වල HIGH/LOW කියන අවස්තා දෙක වෙනුවට 1/0 යොදාගන්න පුලුවන්. මේ binary numbers වලින් කරන්න පුලුවන් වැඩගැන අවබෝධයක් ඉස්සරහ පාඩම් වලින් ගන්න පුලුවන් වෙයි තවත්.


Bitwise operation

bitwise operations කියන්නේ binary numbers වලදී කතාකරන බූලියානු ගණිත කර්ම වලට. අපි decimal numbers වලට +, /, *, - operators භාවිත කරනවා වගේ binary numbers වලටත් විශේෂ operators තියෙනවා. අපි ඒවට කියන්නේ bitwise operators කියලා. අපි දැන් මේ operators එකින් එක ගැන කතාකරමු.

Bitwise operators 

  • &  (bitwise and) 
  • |     (bitwise or) 
  • ~    (bitwise not) 
  • ^    (bitwise xor) 
  • << (bitshift left) 
  • >> (bitshift right) 

&  (bitwise and) 

& operator එකෙන් වෙන්නේ එකම ස්තානයේ තියෙන bit දෙකක් AND operation එකකට යටත් කරනවා.මේ ගැන අවබෝධයක් ගන්න truth table එක බලන්න.
Logic Gates and Truth Table - AND, OR, NOT, NOR, NAND, XOR, XNOR

& (AND) operation එක සරලවම සංඛ්‍යා දෙකක ගුණිතයක් වගේ.

0  0  1  1    operand1
0  1  0  1    operand2
----------
0  0  0  1    (operand1 & operand2) - returned result


Example code

පහල තියෙන්නේ කොහොමද & opeartor එක C/C++ එහෙමත් නැත්නම් arduino program එකදී  පාවිච්චි කරන්නේ කියලා.

මෙතනදී integer variblae 2ක් a සහ b කියලා declare කරලා පිලිවලින් values 2ක් assign කරලා තියෙනව. මේ value කෙලිනම් decimal format එකෙන් දීලා තියෙන්නේ.

අවසානයේ තවත් veriable එකක් declare කරලා ඒකට value එකක් assign කරලා තියෙනවා. මෙතනදී value එක assign කරන කොට a සහ b, & operator එකෙන් සම්බන්ධ කරලා තියෙනවා.  මෙතන වැදගත්ම දේ තමා bit wise operation එකක් කරන හැම අවස්ථාවකම values binary format එකෙන් තියෙන්නේ ඕනේ නෑ. සංඛ්‍යා කිහිපයක් සම්බන්ධ වෙන්නේ bitwise operator එකකින් නම්, bitwise operation එකක් තමා perform වෙන්නේ.

int a =  92;    // in binary: 0000000001011100
int b = 101;    // in binary: 0000000001100101 
int c = a & b; // result: 0000000001000100, or 68 in decimal.

| (bitwise or) 

මේකෙත් වෙන්නේ AND operation එක වගේමයි. මෙතන වෙනසක තියෙන්නේ operator එකයි. මේක හරියට සංඛ්‍යා දෙකක එකතුවක් වගේ. මේ ගැන අවබෝධයක් ගන්න OR gate truth table එක බලන්න.
Logic Gates and Truth Table - AND, OR, NOT, NOR, NAND, XOR, XNOR
0  0  1  1    operand1
0  1  0  1    operand2
----------
0  1  1  1    (operand1 | operand2) - returned result

Example code

int a =  92;    // in binary: 0000000001011100
int b = 101;    // in binary: 0000000001100101
int c = a | b;  // result:    0000000001111101, or 125 in decimal.


~    (bitwise not) 

සරලව කිව්වොත් මෙතනදි 1 තියෙනවනම් 0 වෙනවා, 0 තියෙනවනම්  1 වෙනවා. මේ ගැන අවබෝධයක් ගන්න truth table එක බලන්න.

Universal Logic Gate NAND - Logic Gate - DYclassroom | Have fun ...

0  1    operand1
-----
1  0   ~operand1

Example code

int a = 103;  // binary:  0000000001100111
int b = ~a;   // binary:  1111111110011000 = -104

^    (bitwise xor) 

මේ ගැන අවබෝධයක් ගන්න truth table එක බලන්න.
Devlog #006: XOR-encryption and how it works news - Mod DB

0  0  1  1    operand1
0  1  0  1    operand2
----------
0  1  1  0    (operand1 ^ operand2) - returned result

Example code

int x = 12;     // binary: 1100
int y = 10;     // binary: 1010
int z = x ^ y;  // binary: 0110, or decimal 6


<< (bitshift left) 

bitshift operators කලින් කතාකරපු ඒවට වඩා ටිකක් වෙනස්. bitsshift left  operator එකේදී වෙන්නේ operator එකට දකුණු අත පැත්තෙන් දෙන අගයට සමාන ස්තාන ගණනක් අපේ binary number එකේ ස්තාන කියිහිපයක් වම් අත පැත්තට තල්ලු වෙන එක. පහල රූපයෙන ඒ ගැන හොද අවබෝදයක් ලැබෙයි.

Original binary එක බලන්න, මේකේ decimal value එක වෙන්නේ 23. ඊට පස්සේ මන්  මේ original binary එක bitshift left operator එකෙන් ස්ථාන 2ක් වමට තල්ලු කරලා තීයෙනවා. (කොළ පාටින් තියෙන කොටු බලන්න). මෙහෙම වමට ස්ථාන 2ක් තල්ලු කරහම කලින් පිරිලා තිබුන 1-bit සහ 2-bit ස්ථාන වලට 0 එනවා.

දැන් මේ අලුත් shifted binary එකේ decimal value එක ගත්තොත් 92 ක. ඒකියනේ 23 x 4.
මේක තවත් සරල කලොත් 23 x 22  . මෙතනදී අපි ස්ථාන 2ක් shift කරපු නිසා 22 ප්‍රමාණයකින් අපේ මුලින් තිබුන සංඛ්‍යාව ගුණ වෙලා තියෙනවා. උදාහරණයක් විදිහට මෙතනදී අපි bit 3ක් වමට shift කලොත් 23 ප්‍රමාණයකින් අපේ මුලින් තිබුන සංඛ්‍යාව ගුණ වෙනවා.

පහල තියෙන්නේ මේ bitshift exmple එකට අදාලා c++ code එක.

int a = 23;      // binary: 0000000000010111
int b = a << 2; // binary: 0000000001011100, or 92 in decimal

>> (bitshift right) 

මේකත් කලින් කතා කරපු bitshift left operator එක වගේමයි. මෙතනදී වෙනස අදාලා bits ගණන දකුණට තල්ලු වීමයි. ඒ ගැන පහල රූපයෙන් වඩා හොද අවබෝධයක් ලැබෙයි. 


මෙතනදී මුලින් තිබුන decimal value එක වෙන්නේ 23, ඊට පස්සේ මන් bit 2ක් දකුණට shift කරලා තියෙනවා. මේ අලුත් decimal value එක බැලුවොත් ඒක 5.

තව දුරටත් පැහැදිලි කලොත් 23/ 22  = 5, ඉතිරි 3. (binary වලදි දශම අගයන් නිරූපණය කරන්න පුලුවන් උනත් දැනට අපි ඒ ගැන කතා කරන්නේ නෑ) 

කලින් 2 කේ බල ප්‍රමාණයකින් ගුණ උනා වගේ මෙතනදී වෙන්නේ 2 කේ බල ප්‍රමාණයකින් වෙන්නේ බෙදෙන එක.

පහල තියෙන්නේ මේ bitshift exmple එකට අදාලා c++ code එක.

int a = 23;     // binary: 10111
int b = a >> 2; // binary: 00101, or 5 in decimal

bitwise operations ගැන මේ ටික තමා කතාකරන්න තියෙන්නේ. ප්‍රශ්න comment section එකෙන් අහන්න. අනිත් අයටත් බලන්න share කරගෙනම යන්න !!!

Stepper motor running patterns

7:40 PM 1 Comment

සොෆ්ට්වෙයා ලන්තය අපි අද කතා කරන්නෙ stepper motor වල running patterns ගැන. ඒ වගේම තමයි මේ පාඩම ඉදිරිපත් කරන්නේ යසන්ත නිරෝෂන් අයියා. මේ articel එක එයාගෙ නිර්මාණයක්.
ලිපියේ මොනව හරි අපහැදිලි තැනක් තියෙනවනම් කමෙන්ට් කරන්න. යසන්ත අයියා පිලිතුරු දේවි.

contact Yasantha Niroshan on Facebook

ගොඩක් අයට ස්ටෙප්පර් ගැන කතා කරනව.cnc වගෙම තවත් ගොඩක් දේවල් වලට ගොඩක් වටිනව මෙ ස්ටෙප්ර් මොටර් .මෙක වැඩ කරන විදිය ගැන පොඩි දෙයක් තමයි මම කියන්න යන්නෙ

මෙක හොදින් බලන්න.ඔයලගෙ ප්‍රොජෙක්ට් එක අනුව ඔයල ස්ටෙප්පර් මොටොර් එක තොර ගන්නව වගෙම එක running pattern එකත් ගොඩාක් වැදගත් .මොකද ඒකෙන් තමඉ මොටොර් එකේ ගන්න load එකයි resolution එකයි තිරනය වෙන්නෙ.

1 ක්‍රමය

ඔය පලවෙනි එකේ තියනව වගෙ one pase -full step pattern එකෙන් ගන්න අම්පියර් ගන අඩුයි වෙගය වැඩ්..

2 ක්‍රමය

2නි රුපය tow phas full steps ක්‍රමයෙන් පලවෙනි ක්‍රමයට වඩා 30% ,40% torque එක වැඩි(torque =බලය වගෙ දෙයක්,එ ගැන හොයාගන්න) .
ඉතින් ස්ටෙප්පර් එකක් ඩුවන්නෙ ස්ටෙප්ස් වලින් කියල දන්නවන්නෙ.සමාන්‍යන් එක ස්ටෙප්ස් එකක් ලෙබුනම මොටොර් එක 1.8° යනව.360° යන්න 200ස්ටෙප් ඔන.ඔය ක්‍රම දෙකෙන්ම 200වලෙන් 360ක් යනව..

3 ක්‍රමය

3වෙනි ක්‍රමයට half steps අර ක්‍රම දෙකටම වඩා දෙගුණයක් resolution and smoother වැඩි.
හැබැයි 15%ක් විතර torque එක අඩුයි..

4 ක්‍රමය

4 වෙනි ක්‍රමය තමයි පට්ටම ක්‍රමය.මගෙ අසම ක්‍රමය.ස්ටෙප්පර් එකකින් හොදම resolution එකක් ගන්න පුලුවන් .basic step එකක් 256වතාවකින් කඩල ගන්න පුලුවන්.හැබැයි 30% වගෙ torque එක අඩු වෙනවා..මෙ ක්‍රමයට නම් අපිට pattern එකක් ලෙයල කරන්න අමාරුයි .එකට micro stepping steppe driver ekak ඔන.අර ක්‍රම වලට වඩා ටිකක් වෙගය අඩුයි .ඉතින් ඔයලා micro stepping controler එකක් තොර ගද්දි ඔයලගෙ prossesing unit , software ,මොටොර් එක අනුව තොරගන්න.micro stepping 1, 1/2, 1/4, 1/8 වගෙම 1/16 න් එහා තියනව advance driver වල..එවගෙ drivers වල තියන dip ස්විච් වලින් අදාළ micro steps ගනන select කරන්න පුලුවන් .
ඔයල දැනගන්න ඔන ස්ටෙප්පර් එකක වෙගය වැඩි වෙනකොට torque එක අඩුවෙනව..
ඉතින් ඔයල H bridge මොටොර් කොන්ට්‍රෝල් එකක් පවිච්චි කරනවනම් pattern එක ඔය තියන ක්‍රමවලින් එකකට ලියන්න.මොකද drive එකට pattern එක 4wire වලින් කෙලින්ම දෙන නිසා.
ඔයල ස්ටෙප්පර් කොන්ට්‍රෝල් එකකින් දෙනවනම් අපිට pattern එක ලියන්න ඔන නැ.දෙන්න ඔන step signel and direction සිග්නල් එක විතරයි.advance කොන්ට්‍රෝල් වල select කරන්න පුලුවන් dip ස්විච් වලින් ..
ඉතින් ස්ටෙප්පර් ගැන හොදට ඉගෙන ගන්න.ගොඩක් වැදගත් වෙයි.

Arduino පාඩම 15 - I2C ප්‍රොටොකෝලය

10:38 PM 4 Comments

මේ ලිපියෙන් මම බලාපොරොත්තු වෙන්නේ I2C protocol එක ගැන කතා කරන්නයි. Arduino කරන ගොඩක් අය දැන හෝ නොදැන මේ Protocol එක use කරනවා ඇති මේවෙනකොටත්. මේ ලිපිය  මම protocol  එකක් ගැන කතාකරන පලවෙනි අවස්ථාව නිසා අපි මුලින්ම බලමු මොකක්ද මේ protocol කියන්නේ කියලා.

මොකක්ද  protocol කියන්නේ ?

 protocol කියන්නෙ නීති පද්ධතියකට. උදාහරණකින් පැහැදිලි කලොත් මෙහෙමයි. A හා B කියලා ඒ දෙක අතර communicate කරන device 2ක් තියෙනවා, ඒ වගේම මේ දෙක අතර data transfer වෙන්නේ x කියන  protocol එකෙන් කියලා හිතමු.

මේ x කියන  protocol එකෙන් වෙන්නේ මෙහෙම දෙයක්, අපි හැමෝම දන්නවා machine වලට තේරුම් ගන්න පුලුවන් 1  හා 0 කියන අවස්ථා විතරයි. ඒ කියන්නේ අපිට මේ device දෙක අතර communication එකේදී දාන සෙල්ලම් ඔක්කොම දාන්න වෙන්නෙ මේ 1  හා 0 වෙන් විතරයි. ඉතින් මේ 1  හා 0 තමන්ට කැමති විදිහට භාවිතා කරන්න පුලුවන්නේ ඉතින් මේ නිසා ඇතිවෙන අපහසුතා මගහරවා ගන්න අපිට protocol භාවිතා කරන්න පුලුවන්.

මෙතනදී අපි protocol එකක් හදනකොට එකේදී මෙ 1 හා 0 තේරුම ගන්නේ කොහොමද කියලා තමයි අර්ථ දක්වෙන්නේ. උදාහරණයක් විදිහට අපි හිතමු A device එකෙන් B device එකට x protocol එක හරහා "begin" කියලා command එකක් එනවා. ඉතින් මේ command එක එන්නේ 10001011 කියන  bit pattern කියලා, මේ bit pattern එක x protocol එකෙන් define කරලා තියෙන්නේ 10001011 කියන්නේ "begin" කියන වචනය කියලා. ඉතින් අර  A device එකෙන් B device එකට 10001011 කියලා pattern එක ආවහම B කියනා device එක දැන ගන්නවා 10001011 කියන්නේ "begin" කියන command එක කියලා, ඉතින් ඒ අනුව B device එක වැඩ කරනවා.

ඕක තමයි protocol කියන්නෙ මොකක්ද කියලා කියන්න පුලුවන් සරලම විදිහ. ඒත් ඇත්තටම මේ protocol වැඩකරන්නෙ මීට වඩා ගොඩක් සංකීර්ණ විදිහකට, ඊට අමතරව මේ protocol වැඩකරන විදිහ protocol එක අනුවත් වෙනස් වෙනවා.

protocol එකක් තෝරා ගැනීම

අපි මොකක් හරි project එකක් කරනකොට වඩා වැදගත් දෙයක් තමයි project එකට ගැලපෙන protocol එකක් තෝරාගන්නඑ එක. මේ වෙන කොට protocol විශාල ප්‍රමාණයක් තියෙනවා.ඒවා අතරින් කිහිපයක් තමයි,
  • UART (Serial protocol)
  • I2C
  • ISP
  • CAN
  • 4-20mA current loop
  • RS485
  • RS422
  • RS232 කියන්නේ.
UART කියන්නෙ අපි arduino වලදී නිතර භාවිත කරන Serial protocol එක.(හැම තිස්සෙම Serial.begin කියලා ගහන කෝඩ් එක), I2C ගැන අද අපි කතා කරමු, ICSP කියන්නෙ micro control අතර, ඒ වගේම Sensor-micro control අතර communication වලට භාවිතා කරන protocol එකක්, RS485,RS232 කියන්නේ ගොඩක්ම industrial වැඩ වලට ගැලෙපෙන device,sensor විශාල ප්‍රමාණයක් එකට සම්බන්ධ කරන්න පුලුවන් protocol  එකක්.

මම පසුගිය ලිපියක UART protocol එක use කරන හැටි ගැන කියලා දීලා තියෙනවා. මෙතනින් ඒ පාඩම බලන්න. අද මම කතා කරන්න යන්නේ I2C protocol එක ගැන.

I2C protocol 

I2C කියන්නෙ inter integrated circuit එකට. මේ protocol එකට power pin 2ක හැරුනහම SCL හා SDA කියලා තව pin 2ක් තියෙනවා. SCL pin එකෙන් කරනේ microcontroller එකේ ඉදලා වෙන microcontroller එකකට හරි sensor එකකට හරි clock signal එක යවන එක. SDA pin එකෙන් කෙරෙන්නේ data යවන එක. සාමාන්‍යයෙන් I2C protocol එකකට I2C device කිහිපයක් එකිනෙකට සම්බන්ධ කරන්න පුලුවන්. ඒ කියන්නේ මේ SCL,SDA pin වලට i2c device කිහිපයක්ම සම්බන්ධ කරන්න පුලුවන්. ඒ වගේම මේ වගේ device කිහිපයක් එකිනෙකට සම්බන්ධ කරහම ප්‍රධාන(Master) device එකට සම්බන්ධ කරලා තියෙන අනිත්(slave) device එකිනෙකින් වෙන් කරලා හදුනා ගන්න ID එකක් තියෙනවා. මේ කට අපි I2C address කියලා හදුන්වනවා. ඒ වගේම තමයි මේ master device එක සෑම විටම වගේ microcontroller එකක් සහිත device එකක් වෙනවා.

සාමාන්‍යයෙන් PCB එකක හදපු I2C device අතර twisted pair හෝ shielded cable යොදාගෙන 100m වගේ දුරකට data transmit කරන්න පුලුවන් කියලා සදහන් වෙනවා. කොහොම උනත් ප්‍රායෝගික තත්වයන් අනුව සත්‍ය දුර 100m වඩා අඩු වෙන්න ඉඩ තියෙනවා.

සාමනයෙන් අපිට මොකක් හරි device එකක් I2C connect කරන්න ඕනෙ උනොත් ප්‍රධාන වශයෙන් ක්‍රම 2ක් තියෙනවා.
  1. microcontroller එකක් භාවිතය
  2. I2C expander ic එකක් භාවිතය.
 ඒවගේම තමයි බොහොමයක් sensor සහ module වල I2C සදහා භාවිත වෙන්නෙ මේ I2C expander ic.

Micro-Controller එකක් භාවිතය

මෙතනදී මම microcontroller එකක් භාවිතය කියලා අදහස් කලේ Master device එක වගේම slave devices සදහාත් microcontroller එකක් භාවිතා කිරීමයි. 
example එකකින්ම මේක පැහැදිලි කරන්නයි සූදානම.

Send Data to Slave from Master


මේවැඩේට arduino board 3ක් ඕනේ වෙනවා. මම මෙතන්දී කරන්න හදන්නේ Arduino master device එකකට හයි කරපු potentiometer 2කින් arduino salve device 2කට වෙන වෙනම හයි කරපු LED 2ක brightness control කරන එක. 

Arduino mega/uno/nano/pro mini  වගෙ board වල A4 pin එක SDA විදිහටත් A5 pin එක SCL pin එකත් වෙනවා.

circuit diagram එක මෙහෙම හදා ගන්න. potentiometer විදිහට 10k වගේ එකක් දාන්න. ඒ වගේම arduino board වලට වෙන වෙනම power supply කරනවා නම් arduino boards සියල්ලෙහිම GND පින් එකට connect කරන්න


මීලගට පහත් දැක්වෙන codes වෙන වෙනම අදාල arduino boards වෙත upload කරන්න.


Code explain

මම මෙතනදී කරන්න හදන්නේ master device එකට හයි කරපු potentiometer දෙකෙන් වෙන වෙනම slave device 2 කට හයි කරපු LED දෙකේ brightness control කරන එකයි.

Master code - Send Data to Slave from Master

උඩම පේලියෙන් කරලා තියෙන්නෙ wire කියන library එක import කරගන්න එකයි. මේ library එකේ තමයි I2C වලට අදාල data ටික.

ඊළඟ පේලි දේකේ තියෙන්නේ A0, A1 කියන arduino analog pin දෙක define කරලා තියෙනවා. මේ පින් දෙකට තමයි potentiometer දෙක හයි කරලා තියෙන්නේ.

ඊට පස්සේ address1,address2 කියන define දෙකෙන් තියෙන්නෙ slave device දෙකේ address. 1 කියන්නේ පලවෙනි slave device එකේ address එක 2 ක කියලා තියෙන්නේ දෙවෙනි slave device එකේ addres.


ඊට පස්සේ තියෙන්නේ setup එක, Wire.begin(); කියන line එකෙන් තමයි I2C connection එක start කරන්නේ. ඊට පස්සේ ඉතින් analog pin 2 ක setup කරලා තියෙනවා.

ඊට පස්සේ තියෙන්නෙ loop එක. loop එක ඇතුලේ ලියන ඕනම code එකක් cycle එකක් වගේ power දීලා තියෙනකන් වැඩ කරනවා.

int pot1=analogRead(pot1)/4; කියන line එකෙන් int කියන type එකේ pot1 කියන නමින් variable එකක් හදලා එතනම ඒ variable එකට පලවෙනි potentiometer එකේ data read කරලා 4න් බෙදලා සමාන කරලා තියෙනවා. 4 න් බෙදලා තියෙන්නේ අපිට analog read එකක් 5v වලින් 1024 පන්ගුවක් විදිහට ලැබුනත් අපිට arduino වලදී analog write කරන්න පුලුවන් 5v වලින් 256 න් පංගුවක් විදිහට විතරක් නිසයි.

Wire.beginTransmission(address1);  මේ ලයින් එකෙන් කරන්නේ address1 කියන device එක I2C network එකෙන් හොයාගෙන එයත් එක්ක communication එක ආරම්භ කරන එකයි.

Wire.write(pot1);  මෙතනදී pot1 කියන value එක අදාල device එකට යවනවා. ඊට පස්සේ පේලියෙන් අදාල device එක අතර communication එක නවත්තනවා.

ඊට පස්සේ තියෙන්නෙත් දෙවෙනි  device එකට අදාල මේ code කොටසමයි. අන්තිමේදී 500 ms delay එකක් තියලා තියෙනවා.

Slave Code- Send Data to Slave from Master

Send data to Master from Slave

අපි කලින් කතාකලේ I2C හරහා master device එකේ ඉදලා slave device වලට data යවන්නේ කොහොමද කියන එකයි.
දැන් මම කියන්න හදන්නේ Salve device වල ඉදලා master device එකට data එවන්නේ කොහොමද කියන එකයි.

ඒ කට පහල තියෙන විදිහට circuit එක හදාගන්න, board 3 ම GND පින් එකට සම්බන්ධ කරන්න.



ක්‍රියාවලිය

මම මෙතනදී මුලිනම code explain කරන්න කලින් I2C හරහා slave device එකේ data master device එක read කිරීමේ ක්‍රියාවලිය පැහැදිලි කරන්න හිතුවා. 
මොකද මේ ක්‍රියාවලිය master එකෙන් slave එකට data send ක්‍රියාවලියට වඩා පොඩ්ඩක් වෙනස්.

master එකෙන් slave එකට data send කරනකොට උනේ master අපි දෙන data set එක අපි යවන්න ඕනේ slave device එකේ device address එකේ header එකකුත් එක්ක යවන එක. slave device එක හැමතිස්සෙම master එකෙන් data එනවද කීය කිය බල බල ඉන්නවා. එහෙම master එකෙන් data packet එකක් අවොත් එකේ තියෙන device address එක තමන්ගෙ address එකනම් ඒ packet එක read කරනව එහෙම නැත්නම් නොසලකා හරිනවා.

නමුත් slave එකෙන් එන data master එකෙන් read කරන්නේ පොඩ්ඩක් වෙනස් විදිහකට.

ඇත්තටමමෙතනදී වෙන්නේ slave device එකකින් එන data එකක් read කරගන්න ඕනේ උනහම කරන්නේ අදාලා slave device එකට request එකක් ගහන එක එහෙම්ත් නැත්නම් master device එකෙන් slave device එකකට ඉල්ලීමක් කරන්වා data එවන්න කියලා. 
මෙහෙම request එකක් ගැහුවට පස්සේ අදාල slave device එකෙන් data එවනවා, ඊටපස්සේ තමයි master එකෙන් slave device එකේ data read කරන්නේ.

Code Explain

මම මෙතන කරන්න හදන්නේ salve device 2කට වෙන වෙනම හයි කරපු pot 2 ක values master device එකට එවලා. master device එකේ serial monitor එක හරහා බලන එකයි.

Master code - Send Data to Master from Slave

මෙතනදීත් මම මුලින්ම Wire library එක import කරගෙන තියෙනව. ඊට පස්සේ මම කලින් වගේම Wire.begin(); එකෙන් I2C communication එක initialize කරගෙන තියෙනවා, ඊට පස්සේ Serial.begin(9600); කියන code එකෙන්  line එකෙන් serial communication එක 9600 ක baudRate එකක් සහිතව initialize කරගෙන තියෙනවා.

ඊටපස්සේ තියෙන්නේ loop එක. loop එක ඇතුලෙ තියෙන 
Wire.requestFrom(1, 4); 
    while (Wire.available()) {
    char c = Wire.read();
    Serial.print(c);        
}

code කොටස තමයි slave එකෙන් එන data read කරන්නේ.

Wire.requestFrom(1, 4);  මේ code එකෙන් තමයි slave device එකට request එක ගහන්නේ. වරහන් ඇතුලේ තියෙන 1 කියන ඉලක්කමෙන් කියවෙන්නේ slave device එකේ address එක. 4 කියන ඉලක්කමෙන් කියවෙනේ slave device එක එවන byte ගනන. මේ අගය slave device එක එවන data ප්‍රමාණය අනුව වෙනස් වෙනා .

video coming soon......

ඊලඟ කොටසින් I2C ගැන තව කතා කරමු.  article එක හොදයි නම් අනිත් අයටත් බලන්න share කරන්න. comment එකකුත් දාගෙන යන්න.



Arduino පාඩම 14 - පින් 3 කින් පින් 8 ක වැඩ.

8:56 PM 3 Comments

ගොඩ කාලෙකට පස්සේ තමයි arduino ගැන post එකක් ලියන්න පුලුවන් උනේ. මේ පාර පාඩමෙන් මම කතා කරන්න යන්නේ decoders ගැන.

Decoders කියන්නේ මොකක්ද ?

decoders කියන්නේ අපි ලබාදෙන bit කියපයක් තවත් bit කිහිපයකට වෙන් කරලා output එකක් ලබාදෙන්න පුලුවන් දෙයකට. උදාහරණයක් විදිහට කිව්වොත් අපිට arduino එකේ pin 3 භාවිතා කරලා වෙන වෙනම LED 8 ක් control කරන්න බැහැ. නමුත් decoder එකක් use කලොත් අපිට decoder එකට arduino එකේ pin 3 කින් input ලබාදීලා decoder එකෙන් pin 8 කින් output ගන්න පුලුවන්. තවත් විදියකට කිව්වොත් arduino එකේ pin 3 ක් විතරක් use කරලා වෙන වෙනම LED 8 ක් කොන්ට්‍රොල් කරන්න පුලුවන්.

මන් කලින් විස්තර කලේ pin 3 කින් input දීලා pin 8 කින් output ගන්න පුලුවන් decoder එකක් ගැන. මේ වගේ decoder වලට 3 bit to 8 bit decoder කියලා කියනවා. මේ වගේ තවත් decoders වර්ග තියෙනවා.

2 bit to 4 bit decoder       - input 2 කින් output 4 ක්
4 bit to 16 bit decoder     - input 4 කින් output 16 ක්
5 bit to 32 bit decoder     - input 5 කින් output 32 ක්

Decoders වැඩ කරන්නේ කොහොමද ?

decoders වර්ග කිහිපයක්ම තිබුනත් මේවා හැම එකක්ම වගේ වැඩ කරන්නේ පොදු ආකෘතියකට. මේ ආකෘතිය තේරුම් ගත්තහම ඕනේම decoder එකකින් වැඩ කරන්න පුලුවන්. 
මන් මෙතන කියලා දෙන්නේ 74HC237 කියන 3 bit to 8 bit decoder එක use කරන්නේ කොහොමද කියලා.74HC238 IC එකත් කිසිම වෙනසක් නැතුව use කරන්න පුලුවන්.  IC එක රු. 60-80 ත් අතර ගානකට ලංකාවේ මිලදී ගන්න තියෙනවා.

මේ decoder තවත් විශේෂත්වයක් තියෙනවා. ඒ මේ pin 8 න් අපි HIGH කරන පින් එක ඇරුනහම අනිත් pin ඔක්කොම LOW වෙනවා. ඒ කියන්නෙ අපිට වෙලාවකට output ගන්න පුලුවන් එක පින් එකකින් විතරයි.

  • සාමාන්‍ය විදිහට මේ IC එකට GND, VCC pin වලට power එක දෙන්න ඕනේ. 
  • Y0-Y7 වෙනකන් තියෙන්නේ Output pin 8
  • A0-A2 වෙනකන් තියෙන්නේ Inout pin 3
  • E1, E2, E3 කියන්නේ enable pin (සාමාන්‍යයෙන් E1, E2 ground කරලා E3 vcc connect කරනාවා)






සාමාන්‍යයෙන් decoder වැඩ වලදී මේ 4,5 පින් ground කරලා 6 pin එක 5v වලට connect කරනව. උඩ වගුවේ තියෙන්නේ input pin වල voltage level, HIGH සහ LOW කරහම output pin වල voltage වෙනස් වෙන විදිහ.

Arduino සමග decoder

මම මෙතනදී කරන්න යන්නේ push button එකක් ඔබන වාරයක් ගානේ LED එක එක on කරන්න යන්නේ. මේවගේ වැඩක් කරන්න LED 8 කට arduino ouputs 8 ක් ඕනෙ උනත් මම decoder එකක් භාවිතා කරලා arduino ouputs 3 කින් මේක කරලා තියෙන්නේ.

Components

Arduino              x1
74HC238 IC       x1
LED                   x8
680Ohm Resi.    x2
Push button        x1

Diagram


Arduino Sketch


Code explain 

setup එකේදී සාමාන්‍ය විදිහට 4,5,6 pin output විදිහටත්, push button එකට හයි කරපු 11 pin එක input විදිහටත් setup කරගෙන තියෙනවා.

ඊට පස්සේ මම LEDon කියලා function එකක හදාගෙන තියෙනවා. මේක තමයි මෙතන තියෙන වැදගත්ම code කොටස. LEDon කියන function එක call කරන තැන d1,d2,d3 කියන parameters වලට ලබාදෙන අගයන් අනුව 4,5,6 කියන pin වල status වෙනස් වෙනවා. ඒ කියන්නේ pin HIGH ද ? LOW ද ? කියලා තීරණය වෙන්නේ d1,d2,d3 කියන parameters වලට ලබාදෙන අගයන් අනුව.

උදාහරණයක් විදිහට  LEDon(0,0,0); විදිහට function එක call කලා කියලා හිතමු. එතකොට වෙන්නේ 4,5,6 කියන pin 3 ම low වෙන එක. එතකොට comment එකේ තියෙනවා වගේ පළවෙනි LED එක විතරක් on වෙලා අනිත් LED 7 ම off වෙනවා.
LEDon(0,0,1); විදිහට function එක call කලා කියලා හිතමු. එතකොට වෙන්නේ 4,5 කියන pin 2 low වෙලා 6 pin එක high වෙන එක. එතකොට දෙවෙනි LED එක විතරක් on වෙලා අනිත් LED 7 ම off වෙනවා.

මේක හරියට වැඩ කරන්නේ truth table එකක් වගේ. මේ විදිහටම තමයි ඕනම decoder එකක් වැඩ කරන්නෙ.

ඊට පස්සේ loop එකේදී මුලින්ම බලනවා ll පින් එක high වෙලාද කියලා. 11 pin එක high වෙලා නම් counter කියන variable එකේ අගය 8 ට අසමානද කියලා බලනවා. අසමාන නම් counter කියන variable එකේ දැන් තියෙන අගයට තව එකක් එකතු වෙනවා. variable එකේ අගය 8 ට අසමාන නැත්නම් ඒ කියන්නේ අගය 8 නම්, variable එකේ අගය 1 කරනවා.

ඊට පස්සේ case statement එකක් දාලා counter එකේ තියෙන අගය අනුව අදාල LED එක on කරනවා. article එක හොදයි නම් අනිත් අයටත් බලන්න share කරන්න.

demo





Arduino පාඩම 12 - EEPROM එකේ Data save කරන්නේ මෙහෙමයි.

5:30 PM 17 Comments

අපිට Arduino එක්ක වැඩ කරන කොට සමහර දේවල් save කරගන්න උවමනා වෙනවා. Arduino එකට power එක දීලා තියෙන වෙලාවට විතරක් data එක save කරගෙන තියාගන්න ඕනේ උනාම අපි variable use කරනවා. නමුත් Arduino එක power එක off කරහම මේ data මැකිලා යනවා.
අපිට Power එක off කරපු වෙලාවට මැකිලා යන්නේ නැතුව data save කරලා තියගන්න ඕනෙ උනහම වෙනත් ක්‍රම පාවිච්චි කරන්න වෙනවා. උදාහරණයක් විදිහට කිව්වොත් EEPROM, SD Card, Pen Drive වගේ ඒවා  යොදාගන්න පුලුවන්.
මම මේ පාර පාඩමෙන් කියලා දෙන්නේ Ardunio වල තියෙන EEPROM එක use කරලා data save කරන්නේ කොහොමද කියන එක ගැනයි. Arduino board වල තියෙන Micro Controller එක අනුව මේ EEPROM එකේ තියෙන ඉඩ ප්‍රමාණය වෙනස් වෙනවා. පහලින් තියෙන්නේ විවිධ Arduino board වල තියෙන EEPROM size එකයි.

   - Arduno Duemilanove: 512b EEPROM storage.
    - Arduino Uno, Mini, Pro Mini, Nano:        1kb EEPROM storage. (Atmega 328 based boards)
    - Arduino Mega:       4kb EEPROM storage.

කොහොම උනත් මේ EEPROM එක පාවිච්චි කරන්න කලින් ඒකේ තියෙන සීමා හා සැකැස්ම ගැන පොඩ්ඩක් දැනගෙන ඉන්න ඕනේ.

EEPROM හි සැකැස්ම.

මම මෙතනදී කතා කරන්න බලාපොරොත්තු වෙන්නේ Arduino UNO හි ඇති EEPROM එක ගැනයි. නමුත් මේක Atmega 328 based වෙලා තියෙන Pro Mini, Nano වගේ board වලටත් අදාලයි. 
ඒ වගේම අනිත් ඕනෑම Arduino board  එකකටත් වලංගුයි. වෙනසකට තියෙන්නේ EEPROM එකේ size එක විතරයි.

Arduino UNO board එකක 1024 Bytes (= 1KB) ක EEPROM එකක් තියෙනවා. අපි data save කරන්නේ මේ එක byte එකක තමයි. මේ එක byte එකකට එහි පිටීමට අදාලව Byte address එකක් තියෙනවා. අපි data save කරන කොට ඒ data save කරන්නේ මොන byte එකේද කියලා හදුවලා දෙන්නේ මේ address එකේ උදව්වෙන්. 

ඒ වගේම තමයි අපිට මේ byte එකක් තුල ගබඩා කරන්න පුලුවන් වෙන්නේ 0 ඉදලා 255 දක්වා වෙන සංඛ්‍යාත්මක අගයන් විතරයි. ඒ කියන්නේ මේකේ වචන save කරන්න බෑ ඉලක්කම් විතරයි.

EEPROM  Data Write/Read

 මේ සඳහා යොදා ගන්න Keyword 2 ක් තියෙනවා. එකක් data write කරන්න අනික data read කරන්න.

 EEPROM.write(addr, val);

data write කරන්නේ මේ keyword එකෙන් තමයි. මෙතන addr කියලා තියෙන්නේ data write කිරීමට බලාපොරොත්තුවෙන Byte එකට හිමි address එකයි. val කියලා තියෙන්නේ write කරන value එකයි . මෙතන 0-255 වෙන අගයක් ලියන්න පුලුවන්.

EEPROM.read(address);

data read  කරන්නේ මේ keyword එකෙන් තමයි. මෙතන address කියලා තියෙන්නේ data read කිරීමට බලාපොරොත්තුවෙන Byte එකට හිමි address එකයි

මේක වැඩ කරන හැටි තේරුම්  ගන්න මුලින්ම මේ code එක ලියලා බලන්න. මෙතනදී මම කරලා තියෙන්නේ 1, 2 හා 3 කියන Byte වලට 128, 12 හා 0 කියන value write කරලා ඊට පස්සේ ඒ values read කරලා serial monitor එකේ print කරන එකයි.

#include <EEPROM.h>
void setup(){
    Serial.begin(9600);
    Serial.println(EEPROM.length());  
    //Write values
    EEPROM.write(1,128);
    EEPROM.write(2,12);
    EEPROM.write(3,0);
    //Read values
    Serial.println(EEPROM.read(1));
    Serial.println(EEPROM.read(2));
    Serial.println(EEPROM.read(3));
}

මම මෙතනදී මුලින්ම EEPROM library එක include කරගෙන තියෙනවා. 3 වෙනි පෙලියෙන් serial communication එක start කරලා තියෙනවා.

4 පේලියෙන් කරලා තියෙන්නේ EEPROM එකේ කොච්චර byte ප්‍රමාණයක් තියෙනවද කියන එක serial monitor එකේ print කරන එක.

6,7,8 පේලි වලින් කරලා තියෙන්නේ 1,2,3 කියන byte වල පිලිවලින් ඒ byte වලට 128,12,0 කියන values write කරලා තියෙනවා.

10,11,12 පේලි වලින් කරලා තියෙන්නේ 1,2,3 කියන byte වල තියෙන value එකින් එක serial monitor එකේ print කරන එකයි.

එක පාරක් මේ code එක upload කරලා arduino එකේ power off කරලා අයෙත් arduino එක PC එකට connect කරලා 6,7,8 පේලි delete කරලා code එක අයේ upload කරන්න. ඊර පස්සේ serial monitor එක ආයෙත් open කරලා බලන්න්. 128, 12, 0 කියන values අයේ ප්‍රින්ට් වේවි.



EEPROM Update.

EEPROM එකේ තියෙන එක byte එකක data write කරන්න පුලුවන් වාර ගණනක් තියෙනවා ඒ කියන්නේ මේ එක byte එකක data write කරන්න පුලුවන් 100,000 වතාවක් විතරයි. ඒ වගේම මේ එක data write එකකට 3.3 ms (3.3 මිලි තත්පර) කාලයක් වැයවෙනවා.

මේ කාරනා දෙකම මග හැර ගන්න අපිට මේ update keyword එක use කරන්න පුලුවන්. 

EEPROM.update(addr, val);

මෙතන addr කියලා තියෙන්නේ data update කිරීමට බලාපොරොත්තුවෙන Byte එකට හිමි address එකයි. val කියලා තියෙන්නේ write කරන value එකයි . මෙතන 0-255 වෙන අගයක් ලියන්න පුලුවන්.

#include <EEPROM.h>
void setup(){
    Serial.begin(9600);
    Serial.println(EEPROM.length());  
    //Write values
    EEPROM.update(1,255);
    EEPROM.update(2,25);
    EEPROM.update(3,1);
    //Read values
    Serial.println(EEPROM.read(1));
    Serial.println(EEPROM.read(2));
    Serial.println(EEPROM.read(3));
}

මේකටත් තියෙන්නේ කලින් පැහදිලි කිරීමම තමයි. වෙනසකට තියෙන්නේ data write කිරීම වෙනුවට data update කිරීමයි.
Ardunio සදහාම නිර්මාණය කෙරුනු ලංකාවේ පලවෙනි Alternative IDE එක මෙතනින් download කරගන්න.

article එක හොදයි නම් comment එකක් දාගෙනම යන්න !
article එක හොදයි නම් අනිත් අයටත් බල්න්න share කරන්න. අපේ page එකටත් like කරන්න අමතක කරන්න එපා.