Understanding Memory in Arduino: Variables, Functions, and Storage.(sinhala)

 

Understanding Memory in Arduino: Variables, Functions, and Storage.
-
Arduino microcontrollers, ජනප්‍රිය සීමිත මතකයක් ඇති ATmega328P වැනි,මෙම මතකය සමඟ විචල්‍යයන් සහ ශ්‍රිතයන්(functions) අන්තර්ක්‍රියා කරන ආකාරය අවබෝධ කර ගැනීම කාර්යක්ෂම කේතයක් ලිවීමට අපට උපකාර කරයි.
-
1. ඔබ Arduino හි විචල්‍යයක් ප්‍රකාශ කළ විට කුමක් සිදුවේද?
-
ඔබ Arduino හි විචල්‍යයක් ප්‍රකාශ කරන විට, එහි වර්ගය සහ විෂය පථය (scope), එය මතකයේ ගබඩා වන්නේ කෙසේද සහ කොතැනද යන්න තීරණය කරයි.

-
විචල්‍ය වර්ග සහ ඒවායේ ගබඩාව:
-

1. ගෝලීය විචල්‍යයන්

ඕනෑම ශ්‍රිතයකින් පිටත ප්‍රකාශ කර ඇත (සාමාන්‍යයෙන් කටු සටහනේ මුදුනේ). -

වැඩසටහන උඩුගත කිරීමේදී ෆ්ලෑෂ් මතකයේ (non-volatile) ගබඩා කර ඇත. -

වැඩසටහන් ආරම්භයේදී RAM (volatile) වෙත පිටපත් කර ඇත.
-
උදාහරණ: int globalVar = 42; // ගෝලීය විචල්‍යයක්.
-
2-දේශීය විචල්යයන්

function එකක් තුළ ප්‍රකාශ කර ඇත. -

function එක ක්‍රියාත්මක කිරීමේදී RAM හි කොටසක් වන Stack තුළ ගබඩා වේ. -

කාර්යය සම්පූර්ණ වූ පසු විනාශ වේ. -

උදාහරණ: const int pin = 13; // Stored in Flash.
-
2. Function Call එකක් Stack සමග අන්තර්ක්‍රියා කරන්නේ කෙසේද?
-
Stack යනු තාවකාලික ගබඩා කිරීම සඳහා භාවිතා කරන RAM කලාපයකි. ශ්‍රිතයන් කැඳවා ආපසු එන විට එය ගතිකව වර්ධනය වී හැකිලී යයි.
-

Function Call එකකදී සිදු වන්නේ?
-

function call:

ආපසු එන ලිපිනය (ක්‍රියාකාරීත්වය අවසන් වූ පසු වැඩසටහන ආපසු යා යුතු ස්ථානය) Stack වෙත තල්ලු කරනු ලැබේ. -

function එකේ local variables සඳහා අවකාශය Stack මත වෙන් කර ඇත. -

කාර්යය ක්රියාත්මක කිරීම:

CPU එක Stack එකෙහි ගබඩා කර ඇති දේශීය විචල්‍යයන් සමඟ ක්‍රියා කරයි. -

කාර්යයෙන් ආපසු යාම:

දේශීය විචල්‍යයන් Stack වෙතින් ඉවත් කර ඇත. - ආපසු පැමිණීමේ ලිපිනය තොගයෙන් ඉවත් කර ඇති අතර, එම ස්ථානයේ සිට වැඩසටහන නැවත ආරම්භ වේ. -

උදාහරණය:
-
void myFunction(int value) {

int localVar = value * 2; // Stored on the Stack.

}

void loop() {

myFunction(10); // Stack grows to hold `value` and `localVar`.

} // Stack shrinks after `myFunction` completes.

-
ප්රධාන කරුණු:
-
stack එක වේගවත් නමුත් ප්‍රමාණයෙන් සීමිතයි (බොහෝ විට බයිට් සිය ගණනක්).
-

ගැඹුරු nested functions හෝ අධික දේශීය විචල්‍යයන් stack over flow වලටහේතු විය හැක. -

3. ගෝලීය විචල්‍යයන් ෆ්ලෑෂ් හි ගබඩා කර RAM වෙත පිටපත් කරන ආකාරය.
-
වැඩසටහන Arduino වෙත උඩුගත කරන විට ගෝලීය විචල්‍යයන් ආරම්භ කර ෆ්ලෑෂ් මතකයේ (nested functions) ගබඩා වේ.
-
ධාවන වේලාවේදී->
-

ආරම්භ කිරීම:
-
ඔබගේ Arduino හි ස්ථිරාංගයේ ආරම්භක දින චර්යාව RAM හි ගෝලීය විචල්‍යයන් ආරම්භ කරයි.
-
ආරම්භ නොකළ ගෝලීය විචල්‍යයන් සඳහා, BSS කොටස RAM හි ශුන්‍ය කර ඇත.
-
ක්‍රියාත්මක කිරීමේදී ප්‍රවේශය:
-
RAM වෙත පිටපත් කළ පසු, ෆ්ලෑෂ් මතකය RAM වලට වඩා ප්‍රවේශ වීම මන්දගාමී බැවින් ක්ෂුද්‍ර පාලකය එතැන් සිට ගෝලීය විචල්‍යයන් වෙත ප්‍රවේශ වේ.
-
උදාහරණය:
-
int globalVar = 42; // Stored in Flash and copied to RAM at startup.

void loop() {

globalVar++; // Modified directly in RAM.

}
-
මෙය වැදගත් වන්නේ ඇයි:
-

විශාල ගෝලීය විචල්‍යයන් පවතින RAM අඩු කරයි, එබැවින් ඒවා බුද්ධිමත්ව භාවිතා කරන්න.
-
විචල්‍යයක් වෙනස් කිරීමට අවශ්‍ය නැතිනම්, එය ෆ්ලෑෂ් තුළ තබා ගැනීමට එය const ලෙස සලකුණු කරන්න.
-
Arduino Microcontroller එකක Memory Layout:
-

මතකය සංවිධානය වන ආකාරය පිළිබඳ සරල බිඳවැටීමක් මෙන්න:
-
ෆ්ලෑෂ් (වැඩසටහන් මතකය)
-
ඔබගේ වැඩසටහන් කේතය, නියතයන් සහ ආරම්භක ගෝලීය විචල්‍යයන් ගබඩා කරයි.
-
RAM (දත්ත මතකය)
-

Stack: ක්‍රියාකාරී ඇමතුම් සහ දේශීය විචල්‍ය සඳහා තාවකාලික ඉඩ.
-
Heap: ගතිකව වෙන් කරන ලද විචල්‍ය සඳහා ඉඩ (උදා., malloc හෝ අලුත් new).
-
ගෝලීය විචල්‍යයන්: ආරම්භයේදී මෙහි පිටපත් කර ඇත.
-

EEPROM (Non-Volatile Memory)

විදුලිය විසන්ධි කිරීමෙන් පසුව පවා ඔබට රඳවා ගැනීමට අවශ්‍ය දත්ත ගබඩා කරයි. -

ප්රධාන කරුණු :
-
ගෝලීය විචල්‍යයන්: ෆ්ලෑෂ් හි ගබඩා කර ඇති අතර ධාවන වේලාවේදී RAM වෙත පිටපත් කර ඇත.
-
ස්ථානීය විචල්‍යයන්: තොගයේ ගබඩා කර ඇති අතර ක්‍රියාකාරී ඇමතුම අතරතුර පමණක් පවතී.
-
RAM සහ Flash සීමිත බැවින් කාර්යක්ෂම මතක භාවිතය Arduino ව්‍යාපෘති සඳහා ඉතා වැදගත් වේ.
-

උදාහරණ: Sketch: Memory Interaction in Arduino
-
// Global Variables

int globalVar = 42; // Stored in Flash and copied to RAM during startup.

const int constGlobalVar = 100; // Stored in Flash, does not use RAM.

void setup() {

Serial.begin(9600);

Serial.println("Memory Demonstration Started!");

// Demonstrating Global Variables

Serial.print("Global Variable (RAM): ");

Serial.println(globalVar);

// Demonstrating Local and Static Variables

exampleFunction(10); // First call

exampleFunction(20); // Second call

// Demonstrating Stack Usage

recursiveFunction(1); // Test stack growth

}

void loop() {

// Do nothing in the loop

}

// A function to demonstrate local and static variables

void exampleFunction(int input) {

int localVar = input * 2; // Local variable (Stack)

static int staticVar = 0; // Static variable (RAM, retains value between calls)

staticVar += localVar;

Serial.print("Local Variable: ");

Serial.println(localVar);

Serial.print("Static Variable: ");

Serial.println(staticVar);

}

// A recursive function to demonstrate Stack growth

void recursiveFunction(int count) {

int localStackVar = count; // Each recursive call adds to the Stack

Serial.print("Stack Depth: ");

Serial.println(localStackVar);

if (count < 5) { // Limit recursion depth to avoid stack overflow

recursiveFunction(count + 1);

}

Serial.print("Returning from Depth: ");

Serial.println(localStackVar);

}
-
මෙයින් සිදුවන්නේ ?
-
ගෝලීය විචල්යයන්:
-

ගෝලීය විචල්‍යයක් ෆ්ලෑෂ් හි ආරම්භ කිරීමෙන් පසු RAM හි ගබඩා කරන්නේ කෙසේද යන්න GlobalVar පෙන්නුම් කරයි. - const GlobalVar එය const ලෙස සලකුණු කර ඇති බැවින් ෆ්ලෑෂ් තුළ පවතී. -

දේශීය සහ ස්ථිතික විචල්‍ය:
-

localVar යනු Stack මත ගබඩා කර ඇති තාවකාලික විචල්‍යයකි. කාර්යය අවසන් වූ පසු එය විනාශ වේ. - staticVar RAM හි ගබඩා කර ඇති අතර ක්‍රියාකාරී ඇමතුම් හරහා එහි අගය රඳවා ගනී. -

Stack භාවිතය:
-

පුනරාවර්තන ක්‍රියාකාරිත්වය පුනරාවර්තන ඇමතුම් සමඟ Stack වර්ධනය අනුකරණය කරයි.
-
සෑම ඇමතුමක්ම Stack මත localStackVar හි නව අවස්ථාවක් නිර්මාණය කරයි.
-
අපේක්ෂිත ප්රතිදානය->
-

අනුක්‍රමික මොනිටරය තුළ:
-
Memory Demonstration Started!

Global Variable (RAM): 42

Local Variable: 20

Static Variable: 20

Local Variable: 40

Static Variable: 60

Stack Depth: 1

Stack Depth: 2

Stack Depth: 3

Stack Depth: 4

Stack Depth: 5

Returning from Depth: 5

Returning from Depth: 4

Returning from Depth: 3

Returning from Depth: 2

Returning from Depth: 1
-
මෙය ක්‍රියාත්මක කර බැලීමට:
-

Arduino IDE එකට කේතය පිටපත් කරන්න. -

ඔබගේ Arduino පුවරුව සම්බන්ධ කරන්න (උදා: UNO හෝ Nano). -

Serial Monitor එක විවෘත කරන්න, එහි baud rate එක 9600 ට සකසන්න. -

කේතය උඩුගත කර විචල්‍යයන් සහ stack තත්‍ය කාලීනව හැසිරෙන ආකාරය නිරීක්ෂණය කරන්න. - තාමත් අපේ group එකේ නැත්තන් group එකට සෙට් වෙන්න :⁣

https://www.facebook.com/groups/paperclipx

මේ group එකේ දාන දේවල් හොඳයි කියල හිතෙනවනම් ඕගොල්ලොන් ගේ යාලුවන්වත් group එකට එකතු කරන්න !⁣