Arduino Basic Part 05

Symbols & Operators

Symbols

Arduino වලදි අපි විවිධ Symbols පාවිච්චි කරනවා. Arduino වලදී භාවිතා වෙන ප්‍රධාන symbols සහ ඒවායේ යෙදීම් අපි දැන් බලමු.

1. Curly Brackets {}

අපි Curly Brackets පාවිච්චි කරන්නෙ function එකක සීමාව ලකුනු කරන්න. ඒ කියන්නෙ පටන් ගන්න තැනයි, ඉවර වෙන තැනයි පෙන්නන්න. මේකෙදි බලන ප්‍රධාන නීතිය වෙන්නෙ opening brackets ‘{‘ ගාන closing brackets ‘}’ ගානට සමාන වෙන්න ඔනෙ. අපිට ගොඩක් වෙලාවට හම්බවෙන error එකක් තමයි මේව සමාන නොවීම. Arduino IDE එකෙන් මේක check කරගන්න පුලුවන් ලේසියෙන්ම. කරන්න තියෙන්නෙ cursor එක opening bracket එක ගාවට ගේන එක. එතකොට නිකන්ම ඒකෙ closing bracket එක highlight වෙයි.

2. Semicolon ‘;’

මේක අපි පාවිච්චි කරන්නෙ statement එකක අවසානය ලකුනු කරන්න. මේක හරියට යෙදුවෙ නැත්තන් error එකක් එනව.

3. Line Comment ‘//…’

අපි පුරුද්දක් විදියට code එකේ comment දාගන්න ඕනෙ. වෙන දවසක ආයෙ code එක බලද්දි ඉක්මනින් අපිට තෙරුම් ගන්න පුලුවන් එතකොට. එක line එකක් විතරක් comment කරනවනම් අපිට ‘//’ ලකුන පාවිච්චි කරන්න පුලුවන්.

4. Block Comment ‘/*…*/’

අපිට අවශ්‍ය නම් line කීපයක් comment කරගන්න, මේ block comment සලකුන යොදාගන්න පුලුවන්. comment එක පටන් ගන්න තැනට /* දාල, ඉවර වෙන තැනට */ දැම්මම අපිට block comment එකක් දාගන්න පුලුවන්.

5. Hash ‘#’

Arduino වලදි # ලකුණ යෙදෙන අවස්ථා 2ක් තියෙනව. පිට තියෙන library එකක් program එකට දාගන්න ඕනෙනම් #include කියල යොදාගන්න පුලුවන්.

#include <Servo.h>

මේකෙදි semicolon ‘;’ එකක් යොදාගන්නෙ නෑ.

අනිත් යෙදීම වෙන්නෙ #define කියන එක. මේක පාවිච්චි කරන්නෙ pin එකකට අපිට ලේසි නමක් දාගන්න.

#define ledPin 5

මේකෙදිත් ‘;’ එකක් දාන්නෙ නෑ. ඒ වගේම ‘=’ ලකුනක් යොදාගන්නෙත් නෑ. අපි pin define කරන තව විදියක් ‘int ledPin=5′ කියන එක. මේකෙදි වෙන්නෙ board එකේ ledPin කියන variable එකට වෙනම memory යක් වෙන් කරනව. ඒත් #define යෙදුවම memory යක් පාවිච්චි වෙන්නෙ නෑ. compile වෙන්න කලින් code එකේ තියෙන හැම ledPin කියන තැනකටම 5 කියල ආදේශ වෙනව.

Operators

හරි. අපි දැන් බලමු මේ Operators කියන්නෙ මොනවද කියල. අපිට Arduino වලදී යම් කිසි ගණනය කිරීමක් හෝ logical දෙයක් කරද්දී මේ Operators ගොඩක් වැදගත් වෙනව. 

Operator එකක් කියන්නෙත් Symbol එකක්ම තමයි. නමුත් ඒකෙ විශේෂය තමයි mathematical හෝ logical function එකක් ගැන compiler එකට කියන එක.

ප්‍රධානම operator වර්ග 5ක් අපිට Arduino වල දැකගන්න පුලුවන්

1) Arithmetic Operators
2) Comparison Operators
3) Boolean Operators
4) Bitwise Operators
5) Compound Operators

අපි බලමු මේ එකින් එක Operators වලින් මොකද වෙන්නෙ කියල.

1) Arithmetic Operators :-

මේක පැහැදිලි කරන්න A=10, B=20 කියල මම ගන්නම්,

i) assignment operator ( = )
                                                මේකෙදි කියන්නෙ සමාන ලකුනෙන් වම් පැත්තෙ තිබෙන Variable එකට සමාන ලකුනෙන් දකුනු පැත්තෙ තියන අගය සමාන කිරීම සිදු කරනව. හරියට අපි පොඩි කාලෙ ලිව්ව x=5 වගේ.
Ex :- A=B ( මේකෙදි A හි අගය Bට සමාන කරනව )

ii) addition ( + )
                           මේකෙදි යම් සංඛ්‍යා දෙකක් හෝ Variable 2ක් එකතු කිරීම සිදු කරනව.
Ex :- A+B will give 30

iii) subtraction ( - )
                                 මෙමගින් පළමු Value එකෙන් දෙවෙනි Value එක අඩු කිරීම සිදු කරනවා.
Ex :- A - B will give -10

iv) multiplication ( * )
                                      මෙමගින් Values දෙක ගුණ කිරීම සිදු කරනවා.
Ex :- A*B will give 200

v) division ( / )
                         සංක්‍යා 2ක් බෙදීම සදහා භාවිතා කරනවා.
Ex :- B / A will give 2

vi) modulo ( % )
                          පළමු සංඛ්‍යාව ද්වන සංඛ්‍යාවෙන් බෙදූ විට ඉතිරි ගණන integer ආකාරයට ලබාගැනීම සදහා භාවිත කරයි.
Ex :- B % A will give 0

2) Comparison Operators :-

මේක පැහැදිලි කරන්නත් A=10, B=20 කියල මම ගන්නම්,

i) equa to ( == )
                          ලබා දෙන Values දෙක සමානද යන බව පරීක්ෂා කිරීමේදී යොදා ගනී. Values දෙක සමාන නම් true ද, Values දෙක අසමාන නම් not true ද වේ.
Ex :- A == B is not true

ii) not equal to ( != )
                                  ලබා දෙන values දෙකක් සමාන නොවේද යන්න පරීක්ෂා කිරීමට යොදා ගනියි. මෙහිදී Values දෙක අසමාන නම් true ද, Values දෙක සමාන නම් not true ද වේ.
Ex :- A != B is true

iii) less than ( < )
                             පළමු Value එක, දෙවන Value එකට වඩා අඩු ද යන බව පරීක්ෂා කිරීම සදහා යොදා ගනියි.
Ex :- A < B is true

iii) greater than ( > )
                                   පළමු Value එක, දෙවන Value එකට වඩා විශාල ද යන බව පරීක්ෂා කිරීම සදහා යොදා ගනියි.
Ex :- A > B is not true

iv) less than or equal to ( <= )
                                                   පළමු Value එක, දෙවන Value එකට වඩා අඩු හෝ සමාන ද යන බව පරීක්ෂා කිරීම සදහා යොදා ගනියි.
Ex :- A <= B is true

v) greater than or equal to ( >= )
                                                         පළමු Value එක, දෙවන Value එකට වඩා විශාල හෝ සමාන ද යන බව පරීක්ෂා කිරීම සදහා යොදා ගනියි.
Ex :- A >= B is not true

3) Boolean Operators ;-

මේක පැහැදිලි කරන්නත් A=10, B=20 කියල මම ගන්නම්,

i) and ( && )
                   AND logic එකට සමානව ක්‍රියා කරනව. ( Logic Gates ගැන Post එකක් ඕනෙ නම් Comment එකකින් කියන්න ) Values දෙකම zero නොවේ නම් condition එක true වේ.
Ex :- A && B is true

ii) or ( || )
              OR logic එකට සමානව ක්‍රියා කරයි. Values දෙකෙන් එකක් හෝ zero නොවේ නම් condition එක true වේ.
Ex :- A || B is true

iii) not ( ! )
                 NOT logic එකට සමානව ක්‍රියා කරයි. යම් Operator එකක් යටතේ true වූ condition එකක් not true කිරීමට හෝ not true වූ Condition එකක් true කිරීමට හෝ යොදා ගනියි.
Ex :- !(A && B) is not true

4) Bitwise Operators :-

මේක පැහැදිලි කරන්න A=60, B=13 කියල මම ගන්නම්. මේ Operators වලට භාජනය වෙන්නෙ Bit එකෙන් Bit එක. ඒ කියන්නෙ සංඛ්‍යාවක් ද්වීමය ආකාරයට Bit 8කින් ලියල ඒ bit එකෙන් bit එක තමයි Operate කරන්නෙ.

i) and ( & )
                 Binary AND operator එක ආකාරයට ක්‍රියා කරයි.
                
Ex :- A - 00111100 ( A = 60, එම 60 binary ආකාරයට bit 8 කින් ලියූ විට )
B - 00001100
A & B will give 00001100 equal 12

මෙහිදී සිදු වූයේ 60 සහ 13 ද්වීමය ආකාරයට බිට් 8කින් ලියා එයට AND logic දැමූ විට ලැබෙන්නෙ 00001100 වේ.  එය දශමය කල විට 12 වේ . ( logic gates ගැන දන්නෙ නැත්තම් comment එකකින් කියන්න. ඒ ගැන post එකක් දාන්නම් )

ii) or ( | )
             Binary OR operator එකට අනුව ක්‍රියා කරයි. ඉස්සරල කිව්ව වගේම තමයි binary සන්ඛ්‍යා දෙකට OR logic එක දාල එන පිළිතුර තමයි මේකෙදිත් එන්නෙ.
Ex :- A | B will give 61 which is 00111101

iii) xor ( ^ )
                 Binary XOR operator එකට අනුව ක්‍රියා කරයි.
Ex :- A ^ B will give 49 which is 00110001

iv) not ( ~ )
                  මෙය not gate එකක් ආකාරයට ක්‍රියා කරනව. ඒ කියන්නෙ 1 ආවොත් 0 out කරනව.0 ආවොත් 1 Out කරනව. මේ දේ සංඛ්‍යාවේ සෑම Bit එකකටම සිදු වෙනව.
Ex :- ~A will give -60 which is 11000011

v) shift left ( << )
                            මේකෙන් වෙන්නෙ bit pattern එක වම් පැත්තට තල්ලු කරන එක. ඒ කියන්නෙ අපි දෙන අගයට සමාන bit ප්‍රමාණයක් වම් පැත්තට තල්ලු කරන එක.

Ex1 :- A << 2 will give 240 which is 11110000 ( A=60 නිසා 60 දිවීමය විදිහට ලිව්වම 00111100 නේ. ඉතින් මේ bit pattern එක bit දෙකකින් වමට තල්ලු කරනව )

Ex2 :- A << 1 will give 120 which is 01111000

vi) shift right ( >> )
                                 කලින් වගේම මේකෙදිත් වෙන්නෙ bit pattern එක තල්ලු කිරීමක්. මේකෙදි bit pattern එක තල්ලු කරන්නෙ දකුණු පැත්තට.
Ex :- A >> 2 will give 15 which is 00001111

5) Compound Operators :-

මේ Operator එක ගැන් පැහැදිලි කරන්න මම A=10, B=20 කියල ගන්නම්.

i) increment ( ++ )
                               දැනට තියන Value එකට එකක් එකතු කිරීම සිදු කරයි.
Ex :- A++ will give 11

ii) decrement ( -- )
                               දැනට තියන Value එකෙන් එකක් අඩු කිරීම මෙමගින් සිදු කරයි.
Ex :- A-- will give 9

iii) compound addition ( += )
                                                   මේක Example එකකින්ම පැහැදිලි කරන්නම්.
Ex :- B += A equal to B = B + A

iv) compound subtraction ( -= )
                    Ex :- B -= A equal to B = B - A

v) compound multiplication ( *= )
                   Ex :- B *= A equal to B = B * A

vi) compound division ( /= )
                    Ex :- B /= A equal to B = B / A

vii) compound modulo ( %= )
                                              Modulo Operator එක ආකාරයටම ක්‍රියා කරයි. ,Modulo Operator එක ගැන මම මුලින් කිව්ව.
Ex :- B %= A equal to B = B % A

viii) compound bitwise or ( |= )
                                                       Binary Or operator එක ලෙසම ක්‍රියා කරයි.
Ex :- A |= 2 equal to A = A | 2

ix) compound bitwise and ( &= )
                                                         Binary AND Operator එක ලෙසම ක්‍රියා කරයි.
Ex :- A &= 2 equal to A = A & 2

Arduino Basic Part 05 තුළින් හමු වෙමු