microc for pic
උසස් භාෂා ( HIGH LEVEL LANGUAGES)
මයික්රෝ සී ඛේතයක හැඩය
මෙහිදී මුලින්ම ඇත්තේ COMMENTS නමින් හදුන්වන ඛේතයේ ක්රියාකාරී නොවන කොටසකි.මෙය යොදා ඇත්තේ කේතය පිලිබඳ යම් කරුණු (භාවිතා කරන මයික්රෝකොන්ට්රෝලරය, ඝටීකා වේගය , යම් කේත පේලියකින් සිදු වන්නේ කුමක්ද ) යනාදී කරුණු පිලිබඳ සටහනකි.
උදා: TRISB=0; // MAKE PORTB AS AN OUTPUT
සලකුණින් අවසන් විය යුතුය .
ඔබ භාවිතා කරන සියලුම ෆන්ෂන් ප්රධාන ඛේතයට පෙර ප්රකාශ (DECLARE) කල යුතු අතර එසේ කරන විට පහත පිළිවෙල අනුගමනය කල යුතුය .
- FUNCTION NAME
- FUNCTION BODY
- LIST OF PARAMETERS
- DECLARATION OF PARAMETERS
- TYPE OF FUNCTION RESULTS
එනම්
පිළිතුරෙහි විචල්ය වර්ගය ඛේතයේ නම (විචල්ය ප්රකාශය 1 , විචල්ය ප්රකාශය 2 )
{
විධානය
විධානය
විධානය
..........
}
උදාහරණ : // Function to calculate the area of a cylinder
float Area(float radius, float height)
{
float s;
s = 2.0 x PI x radius x height;
return s;
}
උදා:
VOID BLINK ( )
{
PORTB = ~ PORTB;
}
ඔබ යම් දත්ත වර්ගයක් ප්රකාශ කල විට මෘදුකාංගය විසින් ඔබගේ මයික්රෝකොන්ට්රෝලරයේ රැම් එකෙන් යම් ඉඩක් එම දත්තය සඳහා වෙන් කර ගනී .වැරදි දත්ත වර්ගයක් ප්රකාශ කිරීම නිසා විචල්ය සඳහා ඉඩ මදි වීම හෝ රැම් අපතේ යෑම සිදුවිය හැකි නිසා දත්ත වර්ග පිලිබඳ මනා අවභෝධයකින් සිටීම අත්යවශ්ය වේ.
විචල්ය නම් කිරීමේදී A-Z දක්වා ඉංග්රීසි අකුරුද 0-9 දක්වා ඉලක්කම් ද _ ලකුණද භාවිතා කල හැකි නමුත් පහත දැක්වෙන කී වර්ඩ්ස් (KEYWORDS) නමින් හදුන්වන වචන තිස් තුනක් (33) භාවිතා කල නොහැක.
ඔපරේටර්ස් යනු යම් කිසි ගණිතමය , තාර්කික හෝ වෙනත් ආකාරයක ක්රියාවක් කිරීමට තැනුණු ක්රම වේදයකි.සී භාෂාවේ පහත දැක්වෙන ඔපරේටර්ස් ප්රයෝජනයට ගනී.
- එරිත්මැටික් ඔපරේටර්ස්
- එසයින්මන්ට් ඔපරේටර්ස්
- බිට්වයිස් ඔපරේටර්ස්
- ලෝජිකල් ඔපරේටර්ස්
- රිලේෂනල් ඔපරේටර්ස්
- කන්ඩිෂනල් ඔපරේටර්ස්
- ප්රී - ප්රොසෙසර් ඔපරේටර්ස්
ගණිතමය ක්රියාකාරකම් සඳහා භාවිතා කරයි.පහත දැක්වෙන ක්රියාකාරකම් මුලික වේ .
- එකතු කිරීම +
- අඩු කිරීම -
- ගුණ කිරීම *
- බෙදීම \
- ස්වයංක්රීය අගය වැඩිවීම ++
- ස්වයංක්රීය අගය අඩුවීම - -
උදා:-
/
/ Adding two integers පූර්ණ සංඛ්යා එකතු කිරීම පිළිතුර 17
5 + 12 // equals 17
//subtracting two integers පූර්ණ සංඛ්යා අඩු කිරීම
120 – 5 // equals 115
10 – 15 // equals – 5
// Dividing two integers පූර්ණ සංඛ්යා බෙදීම (දශම ස්ථාන නොමැත)
5 / 3 // equals 1
12 / 3 // equals 4
// Multiplying two integers පූර්ණ සංඛ්යා ගුණ කිරීම
3 * 12 // equals 36
// Adding two floating point numbers දශම ස්ථාන සහිත සංඛ්යා එකතු කිරීම
3.1 + 2.4 // equals 5.5
// Multiplying two floating point numbers දශම ස්ථාන සහිත සංඛ්යා ගුණ කිරීම
2.5 * 5.0 // equals 12.5
// Dividing two floating point numbers දශම ස්ථාන සහිත සංඛ්යා බෙදීම කිරීම
25.0 / 4.0 // equals 6.25
// Remainder (not for float) පූර්ණ සංඛ්යා බෙදීම (ඉතිරි අගය ලබා දේ)
7 % 3 // equals 1
// Post-increment operator විචල්යය ස්වයංක්රීය ඉහල දැමීමට ලක් කරයි.
j = 4;
k = j++ ; // k = 4 , j = 5
// Pre-increment operator විචල්යය ස්වයංක්රීය පහල දැමීමට ලක් කරයි.
j = 4;
k =++ j ; // k = 5, j = 5
// Post-decrement operator
j = 12;
k = j-- ; // k =12, j = 11
// Pre-decrement operator
j =12;
k =-- j; // k =11,
- සමාන = =
- අසමාන ! =
- විශාල >
- කුඩා <
- විශාල හෝ සමාන =>
- කුඩා හෝ සමාන =<
උදාහරණ
x = 10
x > 8 // returns 1
x == 10 // returns 1
x < 100 // returns 1
x > 20 // returns 0
x ! = 10 // returns 0
x >= 10 // returns 1
x <= 10 // returns 1
මේවා විචල්යයන් මත ක්රියා කර ඒවායේ බිටු වෙනස් කිරීම සදහා භාවිතා කරයි
- & බිට් වයිස් ඇන්ඩ්
- │ බිට් වයිස් ඕර්
- ^ බිට් වයිස් එක්ස් ඕර
- ~ අපවර්තනය
- >> වම් අතට ශිෆ්ට් කරයි
- << දකුණු අතට ශිෆ්ට් කරයි.
i.
0xFA &
0xEE returns 0xEA
0xFA: 1111
1010
0xEE: 1110
1110
----------------
0xEA: 1110
1010
================
ii.
0x01 | 0xFE
returns 0xFF
0x08: 0000
0001
0xFE: 1111
1110
----------------
0xFE: 1111
1111
================
iii.
0xAA ^ 0x1F
returns 0xB5
0xAA: 1010
1010
0x1F: 0001
1111
---------------
0xB5: 1011
0101
===============
iv.
~ 0xAA returns 0x55
0xAA: 1010 1010
~ : 0101 0101
--------------------
0x55: 0101 0101
====================
v.
0x14 >>
1 returns 0x08 (shift 0x14 right by 1 digit)
0x14: 0001
0100
>>1 :
0000 1010
----------------
0x0A: 0000
1010
================
vi.
0x14 >>
2 returns 0x05 (shift 0x14 right by 2 digits)
0x14: 0001
0100
>> 2:
0000 0101
----------------
0x05: 0000
0101
================
vii.
0x235A
<< 1 returns 0x46B4 (shift left 0x235A left by 1 digit)
0x235A: 0010
0011 0101 1010
<<1
: 0100 0110 1011 0100
-----------------------------
0x46B4 : 0100
0110 1011 0100
=============================
viii.
0x1A <<
3 returns 0xD0 (shift left 0x1A by 3 digits)
0x1A: 0001
1010
<<3 :
1101 0000
----------------
0xD0: 1101
0000
================
ලොජිකල් ඔපරේටර්ස්
ප්රධාන ලොජිකල් ඔපරේටර්ස් වර්ග තුනකි.ඒවා නම්
- && (LOGICAL AND)
- || (LOGICAL OR)
- ~ (LOGICAL NOT
උදාහරණ 1
x = 7;
x > 0 && x < 10 // returns 1
x > 0 || x < 10 // returns 1
x > = 0 && x < = 10 // returns 1
x > = 0 && x < 5 // returns 0
උදාහරණ 2
a = 10; b = 20; c = 30; d = 40;
a > b && c > d // returns 0
b > a && d > c // returns 1
a > b || d > c // returns 1
අසයින්මන්ට් ඔපරේටර්ස්
මයික්රෝ සී භාෂාව තුල අසයිමන්ට් ඔපරේටර් වර්ග දෙකකි .ඒවා නම්
- සිම්පල් අසයිමන්ට්
- කොම්පව්න්ඩ් අසයිමන්ට්
සිම්පල් අසයිමන්ට්
මෙහිදී ප්රකාශනයක් සුළු කොට පිළිතුර පළමු විචල්යය තුලම ගබඩා කරයි. උදාහරණ
A = A + 8 = A += 8
මෙලෙසම....
නමින් කියවෙන පරිදිම මේවා මගින් කොන්දේසිය පරීක්ෂා කර බලන අතර කොන්දේසිය සංතෘප්ත වී නම් එක් ක්රියාවක්ද සංතෘප්ත නොවී නම් තවත් ක්රියාවක්ද සිදු කරයි.
තවද මෙම ප්රකාශනයම පහත ආකාරයට ලිවිය හැක
expression1 ? expression2 : expression3
උදාහරණ
maximum = (a > b)? a : b // Variable maximum is assigned the value of
// larger variable (a or b)
මෙහිදී A හා B යන විචල්ය දෙක සලකා වඩා ලොකු විචල්යයේ අගය MAXIMUM යන විචල්ය තුල ගබඩා කරයි.
මෙය භාවිතා කිරීමෙන් පහත පහසුකම් ලැඛෙන අතර ඔබ දැනටමත් සමහරවිට ඇසෙම්බ්ලර් සමඟ මේවා භාවිතා කරනවා විය හැක.
- කොන්දේසි සහිතව කෝඩින් එකක් කොම්පයිල් කිරීම (අවශ්ය කොටස් පමණක් කල හැක.)
- සංඛේත වෙනත් සංඛේත හා අගයන්ගෙන් ප්රතිස්ථාපනය කල හැක.
- ප්රධාන C ගොනුව තුලට තවත් උප ගොනු ඇතුල් කිරීම
උදාහරණ:
#define MAX = 100
මෙහිදී MAX යන විචල්ය යෙදෙන සෑම තැනම විචල්යය 100 යන අගය මඟින් ප්රතිස්ථාපනය කරයි.
# undef MAX මඟින් මෙය ඉවත් කල හැක
#ifndef MAX
#define MAX 100
#endif
කොම්පයිලර් එක මගින් MAX ඇත්දැයි පරීකෂා කර බලා ඇත්නම් පමණක් 100 මඟින් ප්රතිස්ථාපනය කරයි. නැතිනම් එම පේළිය අතහැර දමයි.
#include
මෙමගින් ඔබ විසින් කලින් සකස් කර ගත් ගොනුවක් හෝ ගොනු කීපයක් ඔබගේ නව ව්යාපෘතියක් තුලට ඇතුල් කර ගැනීම පුළුවන. මෙමගින් ඔබගේ කේතය අනවශ්ය ලෙස විශාල වීම වලකින අතර ඔබගේ ක්රියාකාරී ගොනු නැවත නැවත භාවිතා කිරීමට පුළුවන .
එකිනෙකට සම්බන්ධ දත්ත අයිතම එකම මෙමරි බ්ලොක් එකක් යටතේ ගබඩා කිරීමට භාවිතා කරයි. ඇරේ එකක් ප්රකාශ කිරීමට වර්ගය නම සහ ඒ යටතේ භාවිතා වන මූලයන් ගණන ප්රකාශ කල යුතුය.
component_type array_name [number_of_components];
උදා:
මෙහිදී මූලයන් පහක අරාවක් ඇති අතර පළමු මූලය බින්දුවද අවසන් මූලය හතරද වේ. මේ අතර ඇති සියලූම අයිතමයන් අනුයාත ලෙස මෙමරිය තුළ පිහිටයි.
උදාහරණ (-
unsigned int Total[5] ;
TOTAL[0] |
TOTAL[1] |
TOTAL[2] |
TOTAL[3] |
TOTAL[4] |
ද්වී මාන අරා (TWO DIMENSIONAL ARRAYS)
අප කලින් සලකා බැලූ අරාව ඒක මාන (SINGLE DIMENSIONAL ARRAY ) අරාවකි. ද්වී මාන අරාවක හැඩය නම්
component_type array_name [number_of_rows] [number_of_columns];
එනම් මෙහි දත්ත පේලි සහ තීරු වශයෙන් වෙන් කල හැකි නිසා ඔබට මෙය වගුවක් ආකාරයෙන් භාවිතා කල හැක.
ස්ට්රක්චර් යනු එකිනෙකට සම්බන්ධ අයිතම වල එකතුවකි. නමුත් අරාවක මෙන් නොව මෙයට විවිධ වර්ගයෙ දත්ත ඇතුල් කල හැක. උදාහරණයක් වශයෙන් පුද්ගලයෙකුගේ ජීව දත්ත සලකා බලමු. ආරම්භ වන්නේ ස්ට්රක්චර් යන කී වර්ඩ් එක සමඟිනි. ඉන්පසු නම සහ ඇතුළත් වන අයිතම ප්රකාශ කල හැක. මෙම අයිතම වලට මෙමරියේ ඉඩක් වෙන් කර නොගන්නා අතර ක්රියාත්මක වන අවස්ථාවේදී ඉඩ ගැනීම සඳහා කොම්පයිලර් එක විසින් ටෙම් ප්ලේට් එකක් සකස් කර ගනු ලැබේ.
උදාහරණ (-
structure Person
{
unsigned char name[20] ;
unsigned char surname[20] ;
unsigned char nationality[20] ;
unsigned char age;
}
ක්රමලේකය තුල යම් කිසි ඛේත කොටසක් නැවත නැවත කරවා ගැනීමට මේවා භාවිතා කරයි.මෙම ක්රියාව කොන්දේසියක් සහිතව හෝ රහිතව කරව ගත හැක
ඛේතයක යම් ඛේත ඛණ්ඩයක් නම් කිරීමට යොදා ගනී. නැවත නැවත එය ක්රියාත්මක කරවීම ලේබල මඟින් කල හැක.
උදාහරණ :-BLINK:
PORTA= 0XFF
DELAY 100
PORTA= 0X00
DELAY 100
GOTO BLINK
if (expression1) statement1
else statement2 /* this belongs to: if (expression3) */
මෙහිදී ස්විච් එක්ස්ප්රෙෂන් එකට අදාළ අගය කේස් ටේබල් එකෙන් සංසන්ධනය කර බලා අදාළ කේස් අගය ලබාගනී.දත්ත වගු සඳහා බහුලව භාවිතා කරයි.
උදාහරණ :-
switch (condition)
{
case condition1:
Statements;
break ;
case condition2:
Statements;
break ;
මෙහිදී වයිල් කොන්දේසිය අසත්ය වන තුරු වයිල් ප්රකාශය ක්රියාත්මක වීම සිදුවේ. ලුප් සඳහා බහුලව පාවිච්චි කරයි. කොන්දේසි රහිත වයිල් ලුප් එකක් (While (1) ) නොනවතින ලුප් එකක් ආකාරයෙන් හැසිරේ.
උදාහරණ (-
while(PORTB.B0 == 1) ; // Wait until PORTB.0 becomes 1
or
while(PORTB.0) ;
මෙහිදී පළමු කොටසින් මෙය සඳහා භාවිතා කරන විචල්යයන් ඉනීෂල්යිස් කරන අතර ඉන් පසුව කොන්දේසිය පරීක්ෂා කරයි. තෙවන කොටසින් ලූප් එක පරීක්ෂා කරයි. කොන්දේසිය සංතෘප්ත වන තුරු මෙය සිදුවේ. කොන්දේසි රහිත ෆෝ ලූප් එකක් ( FOR(;;) ) නොනවතින ලුප් එකක් එකක් ආකාරයෙන් හැසිරේ.
for(i = 0 ; i < 10; i ++)
{
Statements ;
ප්රථමව ඔබට අවශ්ය මයික්රෝකොන්ට්රෝලරය තොර ගන්න
ප්රොජෙක්ට් එක සේව් කිරීමට අවශ්ය ස්ථානය තොර දෙන්න
මෙසේ ඔබ සදා ගත් ව්යාපෘතිය බිල්ඩ් අයිකන් එක මගින් හෝ CTRL+F9 යන යතුරු සංයෝජනයෙන් කොම්පයිල් කර ගත යුතුය.
Comments
Post a Comment