ගොඩ කාලෙකට පස්සේ ලැබුන නිවාඩුවේ අලුතින් පාඩම් ටිකක් කරන්න හදන්නේ. අද ඉදලා පටන් ගන්න 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 ගමු.
මෙතනදී කරලා තියෙනේ මුලින්ම 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 එක බලන්න.
& (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 එක බලන්න.
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 එක බලන්න.
0 1 operand1 ----- 1 0 ~operand1
Example code
int a = 103; // binary: 0000000001100111
int b = ~a; // binary: 1111111110011000 = -104^ (bitwise xor)
මේ ගැන අවබෝධයක් ගන්න truth table එක බලන්න.
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 කරගෙනම යන්න !!!