এই পর্বে যা শিখবেন
- Polling-এর super loop থেকে SysTick-নির্ভর, ঘুমানো, task table-চালিত loop পর্যন্ত ধাপে ধাপে নকশা
- Cooperative scheduling-এর নিয়ম, দেরি মাপা, আর “ছন্দ ধরে রাখা” বনাম “এখন থেকে গোনা”
- Finite state machine-কে switch-case আর table-driven দুই রূপে C-তে লেখা, আর দুটি মেলানো
- Event-driven নকশা: ঘটনা, queue, run-to-completion আর নিরাপদে ঘুমানো
- Super loop-এর সীমা চেনা, আর কখন RTOS-এ যেতে হয় তা যুক্তি দিয়ে বলা
১ · Super loop — OS ছাড়া firmware-এর কঙ্কাল
পাড়ার একজন চা-দোকানি একাই সব সামলান: কেতলিতে পানি দেখেন, কাপ ধোন, কারও টাকা নেন, আবার কেতলিতে ফেরেন। কোনো ম্যানেজার তাঁকে বলে না কখন কী করতে হবে; তিনি নিজেই একটি চক্রে ঘোরেন আর প্রতিটি কাজে একটু করে সময় দেন। কোনো কাজ বেশি লম্বা হলে, ধরুন একজন খদ্দেরের সঙ্গে দশ মিনিট গল্প, তখন কেতলির পানি শুকিয়ে যায়। ছোট microcontroller-এর বেশিরভাগ firmware ঠিক এই চা-দোকানির মতো চলে। এই কাঠামোর নাম super loop: শুরুতে একবার hardware প্রস্তুত, তারপর main-এর ভেতরে একটি অসীম loop, যা কাজগুলো পালা করে দেখে।
পর্ব ০৪-এ এর পরিচয় হয়েছিল, সেখানে দেখা গিয়েছিল একটি blocking কাজ কীভাবে পুরো loop-এর সাড়া দেরি করায়। এই পর্বে সেই কঙ্কালকে পূর্ণ firmware-এর নকশায় নিয়ে যাওয়া হবে, পাঁচটি ধাপে: (১) সরল polling loop, (২) SysTick-এর tick দিয়ে সময়, (৩) task table, (৪) state machine, (৫) event-driven নকশা। তারপর দেখা হবে কোথায় এই পথ ফুরায় আর RTOS লাগে। Register আর ঠিকানা এই পর্বে C-এর ধরনে লেখা, যেমন 0x40012400.
সবচেয়ে সরল super loop শুধু polling করে: প্রতিবার ঘুরে প্রতিটি input-এর অবস্থা পড়ে দেখে কিছু বদলেছে কি না।
int main(void)
{
hw_init(); /* clock, GPIO, ADC, UART একবার */
for (;;) { /* super loop: চিরকাল */
if (button_pressed()) do_tare();
int32_t g = read_weight(); /* ADC পড়া আর gram-এ রূপান্তর */
show_weight(g); /* UART বা display */
}
}এই উদাহরণ চালানো হয়নি, এটি শুধু কাঠামো দেখায়। এর তিনটি সমস্যা চোখে পড়ার মতো। প্রথমত, loop যত দ্রুত পারে ঘোরে, তাই একই ওজন প্রতি সেকেন্ডে হাজারবার ছাপা হয় আর CPU কখনো ঘুমায় না। দ্বিতীয়ত, কাজগুলোর কোনো নিজস্ব ছন্দ নেই; display-এর একটি ধীর কাজ ওজন পড়ার হারও কমিয়ে দেয়। তৃতীয়ত, button_pressed() যদি সরাসরি pin পড়ে, তাহলে লাফানো বোতাম একাধিক চাপ দেবে, যার সমাধান পর্ব ৪২-এর debouncing. প্রথম দুটির সমাধান সময়ের একটি নির্ভরযোগ্য উৎস।
২ · SysTick-এর tick দিয়ে সময় — অপেক্ষা নয়, তুলনা
স্কুলের ঘণ্টার কথা ভাবুন। ঘণ্টা বাজে প্রতি ৪৫ মিনিটে, আর শিক্ষক ঘণ্টা শুনে পরের ক্লাসে যান; কেউ ঘড়ির দিকে তাকিয়ে বসে থাকেন না। Firmware-এ সেই ঘণ্টা হলো SysTick-এর interrupt: প্রতি 1 ms-এ একটি ছোট ISR একটি counter বাড়ায়। বাকি সব কাজ সেই counter-এর সঙ্গে নিজের পরের সময় তুলনা করে। SysTick-এর LOAD আর tick-এর হিসাব পর্ব ৪৪-এ, আর ISR আর main loop কীভাবে flag দিয়ে কাজ ভাগ করে (deferred work) তা পর্ব ৪৩-এ এসেছে; এখানে শুধু super loop-এর দিক।
Reference lab-এর scale.c (বাজারঘরের smart scale-এর আসল firmware) ঠিক এই ধরনের loop. তার ISR প্রতি 1 ms-এ বোতামের ৮ নমুনার debounce চালায়, আর main loop দুটি প্রশ্ন করে:
while (next <= 1200u) {
if (tare_requests != tares_done) { /* ISR একটি চাপ গুনেছে */
tares_done++;
tare_g = gross_g;
/* ... "TARE set to ..." ছাপা ... */
}
if (ms_ticks >= next) { /* 100 ms হয়েছে? */
next += PERIOD_MS;
/* ... ৪টি ADC নমুনা, gram, দাম, ছাপা ... */
}
__WFI(); /* পরের interrupt পর্যন্ত ঘুম */
}তিনটি জিনিস লক্ষ করুন। (১) কোথাও delay_ms() নেই; loop কখনো অপেক্ষায় আটকে থাকে না, শুধু তুলনা করে। (২) ms_ticks আর tare_requests ISR বদলায়, তাই দুটিই volatile (পর্ব ৩৪)। (৩) কাজ না থাকলে WFI CPU-কে পরের tick পর্যন্ত ঘুম পাড়ায়। README-এর run-এ তাই ওজনের লাইন আসে ঠিক 100 ms পরপর (100.0889, 300.0978, 500.0981 ms …), আর বোতাম 420 ms-এ চাপার পরে tare হয় 427 ms-এ।
একটি সূক্ষ্ম ফাঁদ: ms_ticks >= next তুলনা uint32_t counter-এর wrap-এ ভেঙে পড়ে। 1 ms-এর tick-এ 232 ms ≈ 49.71 দিন, তারপর counter আবার 0. বাজারঘরের scale দোকানে মাসের পর মাস চালু থাকে, তাই নিরাপদ রূপ হলো পার্থক্য দেখা: (int32_t)(now - next) >= 0, যা পর্ব ৪৪-এর unsigned wrap-এর নিয়ম। এই পর্বের নিজের firmware সেটিই ব্যবহার করে।
৩ · Task table — cooperative scheduling
কাজ বাড়লে প্রতিটির জন্য আলাদা if লেখা অগোছালো হয়ে যায়। রেলস্টেশনের ঘোষণার বোর্ড যেমন প্রতিটি ট্রেনের সময় এক সারিতে রাখে, তেমনি firmware প্রতিটি কাজের তথ্য একটি task table-এ রাখতে পারে: নাম, period, পরের চলার সময় আর কোন function চলবে (একটি function pointer, যার C-এর দিক C প্রোগ্রামিং পর্ব ২৮-এ)। Loop প্রতিবার table-এর সারিগুলো দেখে, যার সময় হয়েছে তাকে চালায়। প্রতিটি কাজ একটি periodic task.
এখানে কোনো কাজ আরেকটিকে মাঝপথে থামায় না। প্রতিটি task নিজে শেষ করে ফিরলে তবেই পরেরটি চলে। এর নাম cooperative multitasking, বা cooperative scheduling: সবাই সহযোগিতা করলে চলে, কেউ না করলে সবাই আটকে যায়। (Interrupt অবশ্য সবসময় main loop-কে preemption করতে পারে; সহযোগিতার নিয়মটি শুধু task-দের মধ্যে।) আমার lab-এর scale_fsm.c-এর scheduler অংশ:
typedef struct {
const char *name;
uint32_t period_ms, next_ms;
void (*run)(void);
uint32_t runs, max_late;
} task_t;
static task_t tasks[] = {
{ "button", 10u, 10u, task_button, 0, 0 },
{ "measure", 100u, 100u, task_measure, 0, 0 },
{ "heartbeat", 500u, 500u, task_heartbeat, 0, 0 },
{ "report", 1000u, 1000u, task_report, 0, 0 },
};
while (ms_ticks < END_MS) { /* the super loop */
uint32_t now = ms_ticks;
for (unsigned i = 0; i < NTASKS; i++) {
task_t *t = &tasks[i];
if ((int32_t)(now - t->next_ms) >= 0) { /* wrap-নিরাপদ */
uint32_t late = now - t->next_ms;
if (late > t->max_late) t->max_late = late;
t->next_ms += t->period_ms; /* ছন্দ ধরে রাখা */
t->runs++;
t->run();
now = ms_ticks;
}
}
__WFI(); /* পরের tick পর্যন্ত ঘুম */
}চারটি task: button প্রতি 10 ms-এ দেখে ISR কোনো debounced চাপ গুনেছে কি না; measure প্রতি 100 ms-এ ADC থেকে ৪টি নমুনা নিয়ে ওজন বের করে আর state machine-কে একটি ঘটনা দেয়; heartbeat প্রতি 500 ms-এ PA5-এর সবুজ LED উল্টায় (“আমি বেঁচে আছি”); report প্রতি 1000 ms-এ একটি অবস্থার লাইন ছাপে। ISR-এর debounce ঠিক reference-এর মতো ৮ নমুনার shift register, আর calibration আর দামের নিয়ম README-এর: 400 counts = 0 g, 1800 counts = 2000 g, দাম = (net × 6550 + 500) / 1000 paisa. প্রতিটি task নিজের দেরি (max_late) মাপে, আর শেষে ছাপে। Board-এর শেষ লাইনগুলো:
$ python -B bd.py run build/scale_fsm.elf --script fw/scale_ui.json
...
[ 2900.0589 ms] UART: button: runs=289 max_late=0 ms
[ 2900.0981 ms] UART: measure: runs=28 max_late=0 ms
[ 2900.1368 ms] UART: heartbeat: runs=5 max_late=0 ms
[ 2900.1731 ms] UART: report: runs=2 max_late=0 ms
[ 2900.1996 ms] UART: button: max latency=3 ms
[ 2900.2005 ms] exit(0) after 23201604 cycles
সত্যিকারের run (বাজারঘর board BG-M3, Clang 22.1.8 / ziglang 0.17.1, Unicorn 2.1.4). bd.py হলো reference-এর board.py-এর একটি ছোট মোড়ক, যা শুধু compiler-এর cache আমার lab-এ রাখে; board আর firmware-এর নিয়ম reference-এর। প্রতিটি task ঠিক সময়ে চলেছে (দেরি 0 ms), আর বোতাম চাপা থেকে কাজ পর্যন্ত latency সর্বোচ্চ 3 ms, কারণ debounce 1027 ms-এ চাপ মেনেছে আর button task পরের পালায়, 1030 ms-এ, সেটি দেখেছে। মনে রাখবেন, এই board-এ ১টি নির্দেশ = ১টি cycle (Spec decision 17), তাই কাজের দৈর্ঘ্য আসল chip-এর মতো নয়; কোন ms-এ কী ঘটল, সেটিই এখানে শিক্ষণীয়।
| কে চলছে | |
| সময় | |
| next_ms | |
| কাজ | |
| state |
- Tick. SysTick-এর ISR
ms_ticks-কে 1300 করে, বোতামের নমুনা (0) history-তে ঢোকায়। Interrupt CPU-কে WFI থেকে জাগায়, আর main loop__WFI()-এর পরের লাইন থেকে চলে। - button.
now= 1300,next_ms= 1300, তাই সময় হয়েছে। ISR-এরpressesআরpresses_doneদুটিই 1 (1030 ms-এর tare আগেই সামলানো), তাই কিছু করার নেই।next_ms= 1310. - measure. সময় হয়েছে। ADC ৪ বার: 1400 g-এ load cell দেয় 400 + 0.7 × 1400 = 1380 counts, তাই gross = (1380 − 400) × 2000 / 1400 = 1400 g.
next_ms= 1400. - ঘটনা। tare 150, তাই net = 1250 g; আগের gross 150, বদল 1250 g, 2 g-এর বেশি: ঘটনা CHANGED. Table বলে IDLE + CHANGED → WEIGHING. UART-এ
t=1300 CHANGED: IDLE -> WEIGHING net=1250 g (settling), board-এর সময় 1300.1091 ms. - বাকিরা। heartbeat-এর পালা 1500-এ, report-এর 2000-এ; দুটিই এবার বাদ। একটি সারি দেখতে মাত্র একটি তুলনা লাগে।
- ঘুম। পুরো ঘোরা শেষ হয়েছে tick-এর প্রায় 0.11 ms-এর মধ্যে (board-এর মডেলে)।
__WFI()CPU-কে 1301 ms-এর tick পর্যন্ত ঘুম পাড়ায়। বেশিরভাগ tick-এ শুধু button-এর একটি তুলনা হয়, তারপর আবার ঘুম।
৪ · Finite state machine — switch-case আর table
ট্রাফিক সিগন্যালের বাতি সবসময় তিনটি অবস্থার একটিতে থাকে: লাল, সবুজ বা হলুদ। কোন অবস্থার পরে কোনটি, তা নিয়মে বাঁধা; সবুজ থেকে সরাসরি লাল হয় না। Firmware-এর অনেক অংশ এভাবে ভাবলে সহজ হয়। একটি finite state machine (FSM) সবসময় নির্দিষ্ট কয়েকটি state-এর একটিতে থাকে; একটি ঘটনা (event) এলে নিয়ম দেখে পরের state ঠিক করে, আর state বদলের সময় কিছু কাজ করে। Automaton-এর তত্ত্ব, DFA, Moore আর Mealy-র সংজ্ঞা Theory of Computation পর্ব ২৪-এর বিষয়; এখানে শুধু firmware-এ লেখার কৌশল।
কেন FSM? কারণ এর বিকল্প হলো এক গাদা flag: is_tared, is_overload, showing_price … তিনটি flag-এ আটটি সম্ভাব্য মিশ্রণ, যার কয়েকটি অর্থহীন (একসাথে overload আর দাম দেখানো)। এক বছর পরে কেউ একটি flag বদলাতে ভুলে গেলে যন্ত্র এমন অবস্থায় পৌঁছায়, যা কেউ ভাবেননি। FSM-এ একটিমাত্র state ভ্যারিয়েবল, আর বৈধ অবস্থাগুলো নাম ধরে লেখা।
C-তে FSM লেখার দুটি প্রচলিত রূপ। Switch-case-এ নিয়ম কোডের ভেতরে: switch (state)-এর প্রতিটি case-এ ঘটনা দেখে পরের state. ছোট FSM-এ এটি পড়তে সহজ, আর প্রতিটি transition-এর পাশে আলাদা কাজ লেখা যায়। Table-driven রূপে নিয়ম data-তে: একটি দুই-মাত্রার array, NEXT[state][event], যা একটি transition table. নিয়ম বদলাতে কোড নয়, table বদলাতে হয়; সব state × event-এর জোড়া চোখের সামনে থাকে, তাই কোনো ঘটনা “ভুলে যাওয়া” কঠিন। নিচের block দুটি রূপ পাশাপাশি লেখে, ২৫টি জোড়াই মেলায়, তারপর একটি ঘটনার ক্রম চালায়:
#include <stdio.h>
enum { IDLE, WEIGHING, STABLE, TARE, OVERLOAD, NS };
enum { EMPTY, CHANGED, SAME, OVER, BUTTON, NE };
static const char *SN[NS] = {"IDLE", "WEIGHING", "STABLE", "TARE", "OVERLOAD"};
/* রূপ ১: switch-case — নিয়ম কোডের ভেতরে */
static int next_switch(int s, int e) {
if (e == OVER) return OVERLOAD;
if (e == EMPTY) return IDLE;
if (e == CHANGED) return WEIGHING;
switch (s) { /* বাকি: SAME আর BUTTON */
case IDLE: case TARE: return e == BUTTON ? TARE : WEIGHING;
case WEIGHING: case STABLE: return e == BUTTON ? TARE : STABLE;
default: return e == BUTTON ? OVERLOAD : WEIGHING;
}
}
/* রূপ ২: table — নিয়ম data-তে, const বলে flash-এ থাকে */
static const unsigned char NEXT[NS][NE] = {
{IDLE, WEIGHING, WEIGHING, OVERLOAD, TARE},
{IDLE, WEIGHING, STABLE, OVERLOAD, TARE},
{IDLE, WEIGHING, STABLE, OVERLOAD, TARE},
{IDLE, WEIGHING, WEIGHING, OVERLOAD, TARE},
{IDLE, WEIGHING, WEIGHING, OVERLOAD, OVERLOAD}};
int main(void) {
int differ = 0, s = IDLE;
for (int st = 0; st < NS; st++)
for (int e = 0; e < NE; e++) differ += next_switch(st, e) != NEXT[st][e];
printf("checked %d pairs, differ = %d\n", NS * NE, differ);
int ev[] = {CHANGED, SAME, BUTTON, EMPTY, CHANGED, SAME, OVER, BUTTON, CHANGED};
for (int i = 0; i < 9; i++) { s = NEXT[s][ev[i]]; printf("%s%s", SN[s], i < 8 ? " > " : "\n"); }
printf("table size = %zu bytes\n", sizeof NEXT);
return 0;
}আসল আউটপুট (Wandbox-এর C compiler):
checked 25 pairs, differ = 0
WEIGHING > STABLE > TARE > IDLE > WEIGHING > STABLE > OVERLOAD > OVERLOAD > WEIGHING
table size = 25 bytes
২৫টি জোড়ার একটিতেও দুই রূপ আলাদা নয়, তাই এরা একই FSM. লক্ষ করুন, switch-case রূপটি ছোট দেখাতে তিনটি “সাধারণ নিয়ম” আগে লিখেছে (OVER সবসময় OVERLOAD-এ, EMPTY সবসময় IDLE-এ); এমন কৌশল পড়া সহজ করে, কিন্তু কোনো একটি state-এর ব্যতিক্রম যোগ করতে গেলে ভুলের জায়গাও তৈরি করে। Table-এ প্রতিটি ঘর আলাদা, আর পুরো table 25 byte, const বলে এটি RAM নয়, flash-এ বসে। ঘটনার ক্রমের অষ্টম ধাপে OVERLOAD-এ BUTTON এসেও state বদলায়নি; এর অর্থ পরের অংশে।
Cortex-M-এ table থেকে পরের state পড়া কতটা সস্তা? Clang-কে শুধু lookup-এর একটি ছোট function দিয়ে Thumb assembly চাওয়া হলো (-S --target=thumbv7m-none-eabi -mcpu=cortex-m3 -O2):
next_state: @ return NEXT[s][e]; r0 = s, r1 = e
movw r2, :lower16:NEXT
add.w r0, r0, r0, lsl #2 @ r0 = s × 5
movt r2, :upper16:NEXT
add r0, r2
ldrb r0, [r0, r1] @ এক byte পড়া
bx lr
সত্যিকারের run (Clang 22.1.8, ziglang 0.17.1). সারির দৈর্ঘ্য 5, তাই s × 5 বের হয়েছে একটি shift-যোগে (s + s × 4), তারপর একটি মাত্র ldrb. ঘটনা যত বেশিই হোক, lookup-এর খরচ এক।
৫ · Smart scale-এর UI state machine — board-এ সত্যিকারের run
এবার আসল যন্ত্র। বাজারঘরের দোকানদারের চোখে smart scale-এর পর্দা কয়েকটি অবস্থায় থাকে: কিছু নেই (IDLE), ওজন থিতোচ্ছে (WEIGHING), ঝুড়ি বা পাত্রের ওজন বাদ দেওয়া (TARE, অর্থাৎ tare), আর ক্ষমতার বাইরে (OVERLOAD, 5000 g-এর ওপরে)। আমার নকশায় একটি পঞ্চম অবস্থা যোগ হয়েছে: STABLE. দাঁড়িপাল্লায় আলু ঢালার সময় কাঁটা কিছুক্ষণ দোলে; ভালো দোকানদার কাঁটা থামলে তবে দাম বলেন। তেমনি scale দাম দেখাবে পরপর দুটি মাপ (100 ms ব্যবধানে) 2 g-এর মধ্যে মিললে। এতে দোলার সময়ের ভুল দাম ক্রেতার সামনে আসে না।
ঘটনা পাঁচটি। চারটি আসে প্রতি 100 ms-এর মাপ থেকে: OVER (gross > 5000 g), EMPTY (net-এর মান 2 g-এর মধ্যে, অর্থাৎ শূন্যের কাছে), SAME (আগের মাপের 2 g-এর মধ্যে) আর CHANGED (বাকি সব), এই ক্রমে যাচাই করা। পঞ্চমটি BUTTON, debounced tare বোতাম। প্রতিটি state-এ ঢোকার মুহূর্তে একটি কাজ চলে, যার নাম entry action: STABLE-এ ঢুকে দাম ছাপা, TARE-এ ঢুকে বর্তমান gross-কে tare হিসেবে রাখা, OVERLOAD-এ সতর্কবার্তা। Output state-এর সঙ্গে বাঁধা থাকায় এটি Moore machine-এর ধরনের; transition-এর গায়ে output লিখলে হতো Mealy machine.
ছবি ৫৫.১ — বাজারঘরের smart scale-এর UI state machine
পাঁচটি state, প্রধান transition তীরে; সব state-এর সাধারণ নিয়ম নিচে লেখা
OVERLOAD-এ BUTTON-এর ঘর OVERLOAD-ই রাখা হয়েছে, ইচ্ছা করে। 5100 g-এর বোঝা থাকা অবস্থায় tare নিলে tare = 5100 g জমা হতো, যা একটি অর্থহীন মান; পরে বোঝা নামালে net ঋণাত্মক হাজার হাজার গ্রাম দেখাত। এমন “ঘটনা এলেও শর্ত না মিললে transition নয়”-এর নাম guard condition. Table-driven FSM-এ guard একটি ঘরের মানেই লেখা যায়, যেমন এখানে।
Firmware-এর FSM অংশ ছোট: table-এ পরের state খোঁজা, বদলালে ছাপা আর entry action চালানো। আমার lab-এর scale_fsm.c থেকে:
static event_t classify(void) /* একটি 100 ms-এর মাপ → একটি ঘটনা */
{
int32_t net = gross_g - tare_g, d = gross_g - last_gross;
if (gross_g > CAPACITY_G) return E_OVER;
if (net >= -BAND_G && net <= BAND_G) return E_EMPTY;
if (d >= -BAND_G && d <= BAND_G) return E_SAME;
return E_CHANGED;
}
static void fsm_dispatch(event_t e)
{
state_t next = (state_t)NEXT[state][e];
if (next == state && e != E_BUTTON)
return; /* বদল নেই, ছাপারও কিছু নেই */
put_time();
uart_puts(ENAME[e]); uart_puts(": "); uart_puts(SNAME[state]); uart_puts(" -> ");
if (next == state) { uart_puts(SNAME[state]); uart_puts(" (ignored)\r\n"); return; }
state = next;
enter(next); /* entry action: দাম, tare, সতর্কবার্তা */
}Script (scale_ui.json): 250 ms-এ 150 g-এর ঝুড়ি, 1020 ms-এ tare বোতাম চাপা আর 1070-এ ছাড়া, 1300-এ ঝুড়িসহ 1400 g আলু, 1800-এ 5100 g, 1950-এ বোঝার ওপর আবার বোতাম, 2200-এ 650 g, 2600-এ শুধু ঝুড়ি (150 g). Board-এর পুরো UART আর GPIO:
$ python -B bd.py run build/scale_fsm.elf --script fw/scale_ui.json
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0000 ms] > load on the scale: 0 g
[ 0.0504 ms] UART: scale FSM, 4 tasks, report blocks 0 ms
[ 250.0000 ms] > load on the scale: 150 g
[ 300.1037 ms] UART: t=300 CHANGED: IDLE -> WEIGHING net=150 g (settling)
[ 400.1135 ms] UART: t=400 SAME: WEIGHING -> STABLE net=150 g price=9.83 Tk
[ 500.0362 ms] GPIO PA5 LED ON
[ 1000.0362 ms] GPIO PA5 LED OFF
[ 1000.0759 ms] UART: t=1000 report: state=STABLE
[ 1020.0000 ms] > button pressed
[ 1030.0881 ms] UART: t=1030 BUTTON: STABLE -> TARE tare=150 g
[ 1070.0000 ms] > button released
[ 1100.0825 ms] UART: t=1100 EMPTY: TARE -> IDLE net=0 g
[ 1300.0000 ms] > load on the scale: 1400 g
[ 1300.1091 ms] UART: t=1300 CHANGED: IDLE -> WEIGHING net=1250 g (settling)
[ 1400.1210 ms] UART: t=1400 SAME: WEIGHING -> STABLE net=1250 g price=81.88 Tk
[ 1500.0363 ms] GPIO PA5 LED ON
[ 1800.0000 ms] > load on the scale: 5100 g
[ 1800.1070 ms] UART: t=1800 OVER: STABLE -> OVERLOAD gross=5100 g > 5000 g
[ 1950.0000 ms] > button pressed
[ 1960.0799 ms] UART: t=1960 BUTTON: OVERLOAD -> OVERLOAD (ignored)
[ 2000.0000 ms] > button released
[ 2000.0346 ms] GPIO PA5 LED OFF
[ 2000.0757 ms] UART: t=2000 report: state=OVERLOAD
[ 2200.0000 ms] > load on the scale: 650 g
[ 2200.1094 ms] UART: t=2200 CHANGED: OVERLOAD -> WEIGHING net=500 g (settling)
[ 2300.1182 ms] UART: t=2300 SAME: WEIGHING -> STABLE net=500 g price=32.75 Tk
[ 2500.0363 ms] GPIO PA5 LED ON
[ 2600.0000 ms] > load on the scale: 150 g
[ 2600.0840 ms] UART: t=2600 EMPTY: STABLE -> IDLE net=0 g
... (task-এর সারাংশ, অংশ ৩-এ)
সত্যিকারের run (বাজারঘর board BG-M3, Clang 22.1.8 / ziglang 0.17.1, Unicorn 2.1.4). সব সংখ্যা README-এর “বাজারঘর devices”-এর সঙ্গে মেলে: 150 g → 9.83 টাকা, ঝুড়ি বাদ দিয়ে 1250 g → 81.88 টাকা, 500 g → 32.75 টাকা, 5100 g → OVERLOAD. দাম একবারই ছাপা হয়েছে, STABLE-এ ঢোকার মুহূর্তে, আর WEIGHING-এর লাইনে কোনো দাম নেই।
| সময় (ms) | |
| ঘটনা | |
| state | |
| gross / tare | |
| পর্দায় |
- ঝুড়ি রাখা। 250 ms-এ 150 g এল; 300 ms-এর মাপে gross 150, আগেরটি 0: বদল 150 g, ঘটনা CHANGED. IDLE → WEIGHING, পর্দায় শুধু ওজন, দাম নয়।
- থিতু। 400 ms-এ আবার 150 g, বদল 0: SAME. WEIGHING → STABLE, entry action দাম ছাপে: (150 × 6550 + 500) / 1000 = 983 paisa = 9.83 টাকা।
- Tare. বোতাম 1020 ms-এ চাপা, ISR-এর debounce 1027-এ মানে, button task 1030-এ দেখে: BUTTON. STABLE → TARE, entry action tare = gross = 150 g.
- শূন্য। 1100 ms-এর মাপে net = 150 − 150 = 0, 2 g-এর মধ্যে: EMPTY. TARE → IDLE. ঝুড়ি থাকলেও পর্দা শূন্য দেখায়, ঠিক যা দোকানদার চান।
- আলু ঢালা। 1300 ms-এ gross 1400, বদল 1250: CHANGED. IDLE → WEIGHING, net 1250 g, দাম এখনো নয়।
- দাম। 1400 ms-এ আবার 1400 g: SAME. WEIGHING → STABLE, দাম (1250 × 6550 + 500) / 1000 = 8188 paisa = 81.88 টাকা।
- বেশি বোঝা। 1800 ms-এ 5100 g, 5000-এর বেশি: OVER. STABLE → OVERLOAD. OVER প্রথমে যাচাই হয়, তাই অন্য কোনো ঘটনা এর আগে আসে না।
- Guard. 1950 ms-এ বোতাম, 1960-এ button task দেখে। Table-এর ঘর OVERLOAD-ই, তাই tare বদলায়নি (150 g-ই আছে); শুধু “ignored” ছাপা হলো।
- বোঝা কমানো। 2200 ms-এ 650 g, বদল −4450: CHANGED. OVERLOAD → WEIGHING, net 650 − 150 = 500 g.
- আবার দাম। 2300 ms-এ SAME: STABLE, (500 × 6550 + 500) / 1000 = 3275 paisa = 32.75 টাকা।
- খালি। 2600 ms-এ শুধু ঝুড়ি: net 0, EMPTY. STABLE → IDLE. EMPTY-র যাচাই SAME-এর আগে, তাই বদল থাকলেও শূন্যের কাছে net হলে সরাসরি IDLE.
একই নিয়ম ব্রাউজারের Python-এ, একই script-এর ওজন আর বোতামের সময় নিয়ে। Board-এর C কোড আর এই Python যদি একই transition দেয়, তাহলে নিয়ম দুই জায়গায় একভাবে বোঝা হয়েছে; host-এ এমন যাচাই পর্ব ০৬-এর lab-এর পরামর্শও:
# smart scale-এর UI state machine, table-driven (board-এর scale_fsm.c-এর মতো)
NEXT = { # NEXT[state][event] -> পরের state
"IDLE": {"EMPTY": "IDLE", "CHANGED": "WEIGHING", "SAME": "WEIGHING", "OVER": "OVERLOAD", "BUTTON": "TARE"},
"WEIGHING": {"EMPTY": "IDLE", "CHANGED": "WEIGHING", "SAME": "STABLE", "OVER": "OVERLOAD", "BUTTON": "TARE"},
"STABLE": {"EMPTY": "IDLE", "CHANGED": "WEIGHING", "SAME": "STABLE", "OVER": "OVERLOAD", "BUTTON": "TARE"},
"TARE": {"EMPTY": "IDLE", "CHANGED": "WEIGHING", "SAME": "WEIGHING", "OVER": "OVERLOAD", "BUTTON": "TARE"},
"OVERLOAD": {"EMPTY": "IDLE", "CHANGED": "WEIGHING", "SAME": "WEIGHING", "OVER": "OVERLOAD", "BUTTON": "OVERLOAD"},
}
def div_round(n, d): # bglib-এর মতো: অর্ধেক হলে শূন্য থেকে দূরে
q, r = divmod(abs(n), d)
return (q + (2 * r >= d)) * (1 if n >= 0 else -1)
def grams(load): # load cell -> ADC -> gram (README-এর calibration)
raw = min(4095, max(0, round(400 + 0.7 * load)))
return div_round((raw - 400) * 2000, 1400)
def classify(gross, last, tare):
if gross > 5000: return "OVER"
if abs(gross - tare) <= 2: return "EMPTY"
return "SAME" if abs(gross - last) <= 2 else "CHANGED"
loads = {250: 150, 1300: 1400, 1800: 5100, 2200: 650, 2600: 150} # t_ms: gram
buttons = {1030, 1960} # debounce-এর পরে button task যখন চাপ দেখে
state, load, gross, tare = "IDLE", 0, 0, 0
for t in range(10, 2900, 10):
load = next((g for tt, g in loads.items() if tt == t), load)
events = ["BUTTON"] if t in buttons else []
if t % 100 == 0:
last, gross = gross, grams(load)
events.append(classify(gross, last, tare))
for e in events:
new = NEXT[state][e]
if new != state or e == "BUTTON":
if new == "TARE": tare = gross
note = " (ignored)" if new == state else ""
print(f"t={t} {e}: {state} -> {new}{note} gross={gross} tare={tare} net={gross - tare}")
state = newআসল আউটপুট (ব্রাউজারের Python):
t=300 CHANGED: IDLE -> WEIGHING gross=150 tare=0 net=150
t=400 SAME: WEIGHING -> STABLE gross=150 tare=0 net=150
t=1030 BUTTON: STABLE -> TARE gross=150 tare=150 net=0
t=1100 EMPTY: TARE -> IDLE gross=150 tare=150 net=0
t=1300 CHANGED: IDLE -> WEIGHING gross=1400 tare=150 net=1250
t=1400 SAME: WEIGHING -> STABLE gross=1400 tare=150 net=1250
t=1800 OVER: STABLE -> OVERLOAD gross=5100 tare=150 net=4950
t=1960 BUTTON: OVERLOAD -> OVERLOAD (ignored) gross=5100 tare=150 net=4950
t=2200 CHANGED: OVERLOAD -> WEIGHING gross=650 tare=150 net=500
t=2300 SAME: WEIGHING -> STABLE gross=650 tare=150 net=500
t=2600 EMPTY: STABLE -> IDLE gross=150 tare=150 net=0
এগারোটি লাইনই board-এর এগারোটি transition-এর সঙ্গে সময় আর state ধরে হুবহু মেলে। Python-এ ADC নেই, তাই grams() README-এর load-cell মডেল (raw = 400 + 0.7 × gram) আর div_round-এর নিয়ম নিজে করে। এই ধরনের host-মডেল দিয়ে FSM-এর নিয়ম hardware ছাড়াই যাচাই করা যায়; firmware-এর unit test-এর পুরো পদ্ধতি পর্ব ৬৪-এ।
৬ · Event-driven নকশা — ঘটনা, queue আর run-to-completion
Task table সময় ধরে চলে: প্রতি 10 ms-এ বোতাম “দেখা”, যদিও বেশিরভাগ সময় দেখার কিছু নেই। এর নাম time-triggered scheduling. উল্টো ধারণা হলো event-driven programming: কিছু ঘটলে তবেই কাজ। পোস্ট অফিসের কাউন্টারের মতো: চিঠি এলে সারিতে দাঁড়ায়, কর্মী একটি একটি করে নেন, সারি খালি হলে বসে থাকেন। Firmware-এ ISR ঘটনাগুলো একটি ছোট queue-তে রাখে (সাধারণত একটি ring buffer), আর main loop একটি event loop: queue থেকে একটি ঘটনা নিয়ে state machine-কে দেয়, খালি হলে ঘুমায়।
for (;;) {
__disable_irq(); /* PRIMASK = 1: ISR আপাতত বন্ধ */
if (queue_empty()) {
__WFI(); /* pending interrupt থাকলে সঙ্গে সঙ্গে জাগে */
__enable_irq(); /* ISR এখন চলে, ঘটনা queue-তে রাখে */
continue;
}
event_t e = queue_get(); /* ISR-এর সঙ্গে ভাগ করা: critical section */
__enable_irq();
fsm_dispatch(e); /* run-to-completion: শেষ না করে পরেরটি নয় */
}এটি উদাহরণ, এই রূপে চালানো হয়নি। দুটি সূক্ষ্মতা লক্ষ করুন। প্রথমত, “queue খালি কি না দেখা” আর “ঘুমানো”-র মাঝখানে একটি ঘটনা এলে সাধারণ কোড সেটি পরের interrupt পর্যন্ত ভুলে ঘুমিয়ে পড়ে। তাই দেখার আগে interrupt বন্ধ করা হয়। ARMv7-M-এ PRIMASK চালু থাকলেও pending interrupt WFI থেকে জাগায় (ISR তখনই চলে না, __enable_irq()-এর পরে চলে); বাজারঘর board-ও এটি মানে (Spec decision 21). দ্বিতীয়ত, queue-র পড়া ISR-এর লেখার সঙ্গে একটি critical section, যার নিয়ম পর্ব ৪৩-এর।
Event-driven নকশার মূল নিয়ম run-to-completion: একটি ঘটনার পুরো কাজ (transition আর entry action) শেষ হলে তবে পরের ঘটনা। এতে state machine কখনো আধা-বদলানো অবস্থায় আরেকটি ঘটনা দেখে না, তাই কোনো lock লাগে না। দামও স্পষ্ট: একটি ঘটনার কাজ লম্বা হলে বাকি ঘটনা queue-তে অপেক্ষা করে। বাস্তবে দুই ধারা মিশে থাকে: SysTick-এর tick নিজেই একটি ঘটনা (“100 ms হলো”), আর বোতাম, UART-এর byte বা ADC-এর শেষ হওয়া আলাদা ঘটনা। এই পর্বের firmware-এও তাই: সময়ের ঘটনা আসে task table থেকে, বোতামের ঘটনা ISR-এর counter থেকে।
৭ · একটি লম্বা task সবাইকে আটকায় — cooperative-এর সীমা
এবার একই firmware, শুধু একটি বদল: report task প্রতিবার 150 ms আটকে থাকে (scale_fsm_long.c-এ LONG_REPORT_MS = 150), যেমন হতে পারে একটি বড় graphic display পুরো আঁকতে বা flash-এ একটি পাতা লিখতে। কেউ তাকে থামাতে পারে না; cooperative scheduler শুধু অপেক্ষা করে, আর বাকি task-রা ততক্ষণ CPU পায় না, এক ধরনের সাময়িক starvation. একই script-এ board-এর পার্থক্য:
$ python -B bd.py run build/scale_fsm_long.elf --script fw/scale_ui.json
...
[ 1000.0759 ms] UART: t=1000 report: state=STABLE
[ 1020.0000 ms] > button pressed
[ 1070.0000 ms] > button released
[ 1151.0886 ms] UART: t=1151 BUTTON: STABLE -> TARE tare=150 g
[ 1151.1506 ms] UART: t=1151 EMPTY: TARE -> IDLE net=0 g
...
[ 2900.0631 ms] UART: button: runs=289 max_late=141 ms
[ 2900.1045 ms] UART: measure: runs=28 max_late=51 ms
[ 2900.1431 ms] UART: heartbeat: runs=5 max_late=0 ms
[ 2900.1795 ms] UART: report: runs=2 max_late=0 ms
[ 2900.2103 ms] UART: button: max latency=124 ms
সত্যিকারের run (একই board আর compiler). Transition-গুলোর ফল একই, কিন্তু সময় বদলেছে: tare 1030 ms-এর বদলে 1151 ms-এ। দোকানদার বোতাম চেপে ছেড়েও দিয়েছেন (1070 ms), পর্দা তখনো আগের মতো; মানুষের চোখে 124 ms-এর দেরি “একটু ধীর” মনে হয়, কিন্তু একই নকশায় 1.5 s-এর কাজ হলে বোতাম “কাজ করে না” মনে হবে। মাপের task 51 ms দেরিতে চলেছে, আর button task-এর পালা 141 ms পিছিয়েছিল।
| সময় (ms) | |
| CPU-তে | |
| ISR-এর খবর | |
| অপেক্ষায় | |
| দেরি |
- 1000 ms. button, measure আর heartbeat (LED OFF, 1000.0362 ms) সময়মতো চলে, তারপর report ছাপে “t=1000 report: state=STABLE” আর 150 ms-এর busy-wait-এ ঢোকে। button-এর পরের পালা এখন 1010.
- 1020 ms. দোকানদার বোতাম চাপলেন। SysTick-এর interrupt main loop-কে preempt করতে পারে, তাই ISR প্রতি 1 ms-এ নমুনা নিতে থাকে। button task-এর পালা 10 ms পেরিয়ে গেছে।
- 1027 ms. ৮টি পরপর 1, history = 0xFF: ISR চাপ মানে:
presses0 থেকে 1,press_ms= 1027. খবর জমা হলো, কিন্তু দেখার কেউ নেই। - 1070 ms. বোতাম ছাড়া হয়েছে। ISR-এর stable আবার 0, কিন্তু counter-এ চাপটি রয়ে গেছে, হারায়নি। এটিই ISR থেকে counter বা flag দিয়ে খবর রাখার সুবিধা।
- 1100 ms. measure-এর পালা এল, কিন্তু CPU report-এর হাতে। এই মুহূর্তে আলু ঢাললে তার মাপও অপেক্ষায় থাকত।
- 1150 ms. report-এর busy-wait শেষ, function ফেরে। for loop-এর এটি শেষ সারি, তাই loop
__WFI()-এ গিয়ে পরের tick-এর অপেক্ষা করে। - 1151 ms. button task: দেরি 1151 − 1010 = 141 ms, চাপ দেখে TARE (সাড়ার দেরি 1151 − 1027 = 124 ms). তারপর measure: দেরি 1151 − 1100 = 51 ms, net 0 → IDLE.
- পিছিয়ে পড়া পালা।
next_ms += periodছন্দ ধরে রাখে, তাই button-এর পালা 1020, 1030 … বাকি; loop প্রতি tick-এ একবার চালায়, 1151 থেকে 1166 পর্যন্ত ১৬ বার, তারপর 1170-এ আবার সময়মতো। মোট চলা ২৮৯ বার, ছোট report-এর run-এর সমান।
RTOS-এর জগতেও cooperative scheduling আছে, আর একই ঘটনা ঘটে। Reference lab-এর rtos_sim.py-এর demo coop-এ কম গুরুত্বের L (priority 1) 4 tick গুনে নিজে yield করে, তারপর আরও 2 tick; বেশি গুরুত্বের H (priority 2) আসে tick 1-এ। আমার lab-এর coop_noyield.json-এ L একটানা 6 tick চলে, yield নেই:
$ python -B rtos_sim.py demo coop $ python -B rtos_sim.py run coop_noyield.json
0123456789 0123456789
H .---##.... H .-----##..
L ####--##.. L ######....
H released 1 start 4 finish 6 response 5 H released 1 start 6 finish 8 response 7
সত্যিকারের run (rtos_sim.py, Gantt-এ # চলছে, - প্রস্তুত; বাম দিক reference-এর expected file-এর সঙ্গে হুবহু এক). Priority বেশি হলেও H অপেক্ষা করেছে: yield-সহ 3 tick, yield ছাড়া 5 tick (response 7). একই coop_noyield.json preemptive scheduler-এ ("fp") চালালে H tick 1-এই চলে, response 2, যা পর্ব ৫৬-এর বিষয়। Cooperative নিয়ম মনে রাখতে Spec decision 32 দেখুন: “a running task keeps the CPU until it blocks, yields or ends”.
প্রতিকার কী? লম্বা কাজকে ছোট টুকরোয় ভাঙা: report একবারে পুরো display না এঁকে প্রতি পালায় এক সারি আঁকে, আর কোথায় থামল তা নিজের একটি ছোট state machine-এ মনে রাখে। একে বলে কাজকে “resumable” করা; C-তে এর একটি চতুর রূপ protothread, যা coroutine-এর মতো থেমে আবার চলে। আরেকটি প্রশ্ন পিছিয়ে পড়ার নীতি: ছন্দ ধরে রাখা (next += period) নাকি এখন থেকে গোনা (next = now + period)? নিচের block দুটিকে 1 ms-এর একটি মডেলে চালায়, report 150 আর 250 ms আটকালে:
# cooperative task table, প্রতি 1 ms-এ একবার দেখা; report মাঝে মাঝে লম্বা হয়
def run(policy, report_ms, end=3000):
tasks = {"measure": [100, 100], "report": [1000, 1000]} # নাম: [period, next]
now, starts = 0, []
while now < end:
ran = False
for name, t in tasks.items():
if now >= t[1]:
if name == "measure":
starts.append(now)
if policy == "next+=period":
t[1] += t[0] # ছন্দ ধরে রাখা
else:
t[1] = now + t[0] # "এখন থেকে" গোনা
now += report_ms if name == "report" else 0
ran = True
if not ran:
now += 1 # WFI: পরের tick পর্যন্ত ঘুম
return starts
for report_ms in (150, 250):
for policy in ("next+=period", "next=now+period"):
s = run(policy, report_ms)
late = [x - 100 * (i + 1) for i, x in enumerate(s)]
print(f"report {report_ms} ms, {policy:16}: runs={len(s)} "
f"max_late={max(late)} last_late={late[-1]}")
print(" starts 1000-1400:", [x for x in s if 1000 <= x <= 1400])আসল আউটপুট (ব্রাউজারের Python):
report 150 ms, next+=period : runs=29 max_late=50 last_late=0
starts 1000-1400: [1000, 1150, 1200, 1300, 1400]
report 150 ms, next=now+period : runs=28 max_late=150 last_late=150
starts 1000-1400: [1000, 1150, 1250, 1350]
report 250 ms, next+=period : runs=29 max_late=150 last_late=0
starts 1000-1400: [1000, 1250, 1250, 1300, 1400]
report 250 ms, next=now+period : runs=26 max_late=350 last_late=350
starts 1000-1400: [1000, 1250, 1350]
মডেলটি সরল (কাজের দৈর্ঘ্য শুধু report-এর, পালার ক্রম measure আগে), তবু board-এর ফলের সঙ্গে মেলে: 150 ms-এ মাপের সর্বোচ্চ দেরি 50 ms (board-এ 51, কারণ সেখানে WFI-এর পরের tick-এ জাগে)। ছন্দ ধরে রাখলে দেরি সাময়িক, শেষে আবার 0, আর মাপের সংখ্যা ঠিক থাকে। এখন থেকে গুনলে প্রতিটি আটকে যাওয়ার দেরি স্থায়ী হয়ে জমে (jitter থেকে drift; দুটির পার্থক্য পর্ব ৫৪-এ), 250 ms-এ শেষে 350 ms পিছিয়ে, মাপ ৩টি কম। কিন্তু ছন্দের নীতিরও দাম আছে: 250 ms-এ 1250 ms-এ মাপ দুবার পরপর চলেছে, অর্থহীন দুটি একই মাপ। কাজটি যদি motor-এ pulse দেওয়া হতো, পরপর দুটি pulse ক্ষতিকর হতে পারত। তাই অনেক নকশায় নিয়ম মিশ্র: ছন্দ ধরে রাখা, কিন্তু একটির বেশি পালা পিছিয়ে পড়লে বাকিগুলো বাদ দেওয়া আর বাদের সংখ্যা গুনে রাখা।
৮ · কখন super loop যথেষ্ট নয় — RTOS-এর দিকে
Super loop আর state machine-এর জোর অনেক: পুরো firmware একটি stack-এ, কোনো context switch নেই, আচরণ সম্পূর্ণ নির্ধারিত আর পরীক্ষা সহজ। এই পর্বের firmware-এর map file দেখায়, ৪টি task, FSM, debounce আর ছাপার কোডসহ মোট RAM: .data 16 byte আর .bss 72 byte (Clang task table-এর অপরিবর্তনীয় অংশ, যেমন নাম, period আর function pointer, flash-এ রেখে শুধু বদলানো field-গুলো RAM-এ রেখেছে)। FSM-এর table .rodata-তে 25 byte. একটি RTOS-এ প্রতিটি task-এর নিজের stack লাগে, যার আকার আলাদা করে হিসাব করতে হয় (পর্ব ৩৯)। তাই ছোট যন্ত্রে super loop প্রায়ই সঠিক পছন্দ।
তবু কিছু লক্ষণ বলে দেয় যে সীমা এসে গেছে:
| লক্ষণ | Super loop-এ কী হয় | সম্ভাব্য পথ |
|---|---|---|
| একটি লম্বা কাজ ভাঙা যায় না (তৃতীয় পক্ষের library, যেমন একটি TLS handshake) | সব task ওই সময় পর্যন্ত আটকে; সবচেয়ে খারাপ সাড়া = সবচেয়ে লম্বা কাজ | Preemptive RTOS-এ আলাদা কম-priority task |
| কঠিন deadline-এর কাজ আর ধীর কাজ একসাথে | দ্রুত কাজের সাড়া ধীর কাজের WCET-এর ওপর নির্ভর করে | সময়-সংকট কাজ ISR-এ বা উচ্চ-priority task-এ |
| অনেক জায়গায় “অপেক্ষা” (network-এর উত্তর, UART-এর পুরো বার্তা, flash-এর লেখা) | প্রতিটি অপেক্ষাকে state machine-এ ভাঙতে হয়; কোড state-এ ছড়িয়ে যায় | RTOS-এর blocking call আর queue (পর্ব ৫৭–৫৮) |
| Task অনেক, দল অনেক | একজনের ভুলে (একটি busy-wait) সবার সময় নষ্ট; দেরি বিশ্লেষণ কঠিন | RTOS আর response-time analysis (পর্ব ৫৬) |
| সব কাজ ছোট, period বড়, deadline নরম | Super loop ঠিকই চলে, সহজ আর ছোট | Super loop + state machine রাখুন |
বাজারঘরের দুটি যন্ত্রের জন্য সিদ্ধান্ত: smart scale-এর কাজগুলো ছোট (একটি মাপ, একটি লাইন ছাপা), তাই super loop আর state machine যথেষ্ট, যদি display-এর আঁকা টুকরোয় ভাঙা হয়। Cold-storage monitor-এর অবস্থা কঠিনতর: প্রতি 1 s-এ মাপ আর alarm, তার পাশে Wi-Fi আর MQTT-এর লম্বা, অনিশ্চিত অপেক্ষা (পর্ব ৭৩)। সেখানে network-এর কাজ একটি কম-priority task-এ আর alarm একটি উচ্চ-priority task-এ রাখলে network আটকালেও alarm সময়মতো বাজে। পর্ব ৫৬ (RTOS-এর task আর scheduling) সেখান থেকেই শুরু। একটি জিনিস মনে রাখুন: RTOS আসলে state machine-কে বাদ দেয় না; প্রতিটি task-এর ভেতরেও প্রায়ই একটি FSM থাকে।
আরও গভীরে: সমতল FSM-এ বৈশিষ্ট্য যোগ করলে state গুণ হারে বাড়ে (state explosion): scale-এ “kg বা পোয়া” দুটি এককের প্রদর্শন যোগ করলে ৫টি state ১০টি হয়ে যায়। David Harel ১৯৮৭ সালে “Statecharts: A visual formalism for complex systems” প্রবন্ধে এর সমাধান দেন: state-এর ভেতরে state (hierarchy), একসাথে চলা অংশ আর entry/exit action. এই statechart পরে UML-এর state machine-এর ভিত্তি হয়। Embedded C-তে hierarchical state machine আর event-driven “active object” নিয়ে Miro Samek-এর বই (Practical UML Statecharts in C/C++, দ্বিতীয় সংস্করণ ২০০৮) বহুল উদ্ধৃত। আর ছোট sensor node-এর জন্য Adam Dunkels ও সহকর্মীরা ২০০৬ সালে protothread প্রস্তাব করেন: একটি stack-এ চলা, প্রতি “thread”-এ মাত্র কয়েক byte-এর অবস্থা নিয়ে থেমে-আবার-চলা কোড।
পরীক্ষা ও ইন্টারভিউতে: (১) “Super loop-এর worst-case response?” → ঘটনা আসার পরে নিজের পালা পর্যন্ত অপেক্ষা যোগ এক ঘোরায় বাকি সব কাজের সবচেয়ে খারাপ সময়; একটি লম্বা task সবার সাড়া ঠিক করে দেয়। (২) “Cooperative আর preemptive-এর পার্থক্য?” → cooperative-এ task নিজে না ছাড়লে কেউ CPU পায় না; preemptive-এ scheduler উচ্চ-priority-কে সঙ্গে সঙ্গে চালায়। (৩) “Switch-case বনাম table-driven FSM?” → switch পড়তে সহজ, প্রতিটি transition-এ আলাদা কাজ; table-এ সব জোড়া চোখের সামনে, flash-এ const, বদলানো আর যাচাই সহজ। (৪) “ms_ticks >= next-এর সমস্যা?” → 32-বিট counter 1 ms-এ ≈ 49.71 দিনে wrap করে; (int32_t)(now - next) >= 0 লিখুন। (৫) “Run-to-completion কী?” → একটি ঘটনার কাজ শেষ না করে পরের ঘটনা নয়, তাই FSM কখনো আধা-বদলানো অবস্থা দেখে না।
৯ · AI-এর যুগে super loop আর state machine যাচাই
“একটি smart scale-এর firmware লিখুন” বললে AI assistant কয়েক সেকেন্ডে একটি পরিপাটি state machine দেয়। কাঠামো প্রায়ই ঠিক থাকে; ভুল লুকায় সময়, ভাগ করা data আর না-ভাবা ঘটনায়। সবচেয়ে চেনা ভুল আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
Loop-এ delay() বা ISR-এর ভেতরে অপেক্ষা | প্রতিটি task-এর দেরি মাপার কোড যোগ করে কোর্সের board-এ চালান; ISR-এ blocking নিষেধ (পর্ব ৪৩) |
ms_ticks >= next বা next = now + period | Wrap-এর পরীক্ষা (counter 0xFFFFFF00 থেকে শুরু করে host-এ চালানো) আর drift মাপা |
ISR-এর ভ্যারিয়েবল volatile নয়, বা queue-র পড়া অরক্ষিত | Clang-এর -S আউটপুটে loop-এর ভেতরে load আছে কি না; critical section |
| Switch-case-এ কিছু state × event জোড়া বাদ (default-এ চুপচাপ উপেক্ষা) | Table বানিয়ে ২৫টি ঘরই পূরণ করা; দুই রূপ মিলিয়ে পরীক্ষা, অংশ ৪-এর মতো |
| OVERLOAD-এ tare-এর মতো guard ভুলে যাওয়া | প্রতিটি state-এ প্রতিটি ঘটনার ফল নিজে লিখে প্রশ্ন করা: “এটি কি অর্থপূর্ণ?” |
| “FreeRTOS লাগবে” বা “RTOS লাগবে না” বলে দেওয়া, হিসাব ছাড়া | সবচেয়ে লম্বা কাজের WCET আর সবচেয়ে কড়া deadline পাশাপাশি লিখে তুলনা |
AI-কে সংখ্যা, নিয়ম আর যাচাইয়ের শর্ত শুরুতেই দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১Arduino-র setup() আর loop() কি আসলে একটি super loop? লক্ষ লক্ষ শিক্ষানবিশের প্রথম firmware-এ delay() কেন সমস্যা হয়ে দাঁড়ায়?
হ্যাঁ। ২০০৫ সালের দিকে ইতালির একটি design স্কুলে শুরু হওয়া Arduino প্রকল্প microcontroller-কে শিক্ষানবিশের কাছে পৌঁছাতে একটি সহজ কাঠামো দেয়: setup() একবার চলে, loop() চিরকাল। ভেতরে আসলে Arduino-র নিজের main() আছে, যা setup() ডেকে একটি অসীম loop-এ বারবার loop() ডাকে। অর্থাৎ পর্ব ০৪-এর super loop, একটি সুন্দর নামে। এতে শিক্ষানবিশ register আর startup code না জেনেই প্রথম LED জ্বালাতে পারেন, যা এই প্ল্যাটফর্মের বড় অবদান।
সমস্যা আসে দ্বিতীয় কাজে। প্রথম উদাহরণ “Blink”-এ delay(1000) থাকে; শিক্ষানবিশ একই ধাঁচে বোতাম আর sensor যোগ করেন, আর দেখেন বোতাম মাঝে মাঝে “কাজ করে না”। কারণ delay() একটি busy-wait: সেই এক সেকেন্ডে loop আর কিছু দেখে না। এই পর্বের ভাষায়, একটি task পুরো CPU আটকে রেখেছে, ঠিক 150 ms-এর report-এর মতো, শুধু আরও খারাপ। Arduino-র সঙ্গে আসা উদাহরণগুলোর মধ্যেই এর সমাধান আছে: “BlinkWithoutDelay”, যেখানে millis()-এর মান আগের সময়ের সঙ্গে তুলনা করা হয়, ঠিক অংশ ২-এর নীতি।
শিক্ষানবিশের পথ তাই প্রায়ই এই পর্বের ক্রমেই এগোয়: delay → সময়ের তুলনা → কয়েকটি স্বাধীন “task” → state machine (যেমন একটি বোতাম কতক্ষণ চাপা তা বুঝতে) → কখনো RTOS. ESP32-এর Arduino core-এর মতো কিছু প্ল্যাটফর্মে loop() নিজেই একটি FreeRTOS task-এর ভেতরে চলে বলে বিভিন্ন সূত্রে উল্লেখ আছে; সেখানে কাঠামো দেখতে super loop হলেও নিচে একটি RTOS কাজ করছে।
শিক্ষাটি প্ল্যাটফর্ম-নিরপেক্ষ: loop() একটি ভাগাভাগির জায়গা। এর ভেতরে প্রতিটি কাজের দায়িত্ব দ্রুত ফেরা, যাতে বাকিরা নিজের পালা পায়।
মূল উপলব্ধি: Arduino-র loop() একটি super loop; delay() তার ভেতরে একটি অসহযোগী task, আর “BlinkWithoutDelay”-এর সময়-তুলনাই cooperative নকশার প্রথম ধাপ।
প্র ০২Time-triggered আর event-triggered নকশার মধ্যে নিরাপত্তা-সংবেদনশীল যন্ত্রে অনেক প্রকৌশলী প্রথমটিকে কেন পছন্দ করেন? বাজারঘরের cold room-এ কোনটি মানাবে?
Time-triggered নকশায় সবকিছু আগে থেকে ঠিক করা সময়সূচি ধরে চলে: প্রতি 1 ms-এ একটিমাত্র interrupt (timer), আর কোন tick-এ কোন task চলবে তা নকশার সময়ই জানা। বাইরের ঘটনা interrupt দেয় না; সেগুলো নির্দিষ্ট সময়ে poll করা হয়। Michael J. Pont-এর “Patterns for Time-Triggered Embedded Systems” (২০০১) বইটি এই ধারার cooperative scheduler-কে ছোট microcontroller-এ জনপ্রিয় করে বলে ধরা হয়; বড় পরিসরে Hermann Kopetz-এর time-triggered architecture-এর গবেষণা গাড়ি আর বিমানের network-এর নকশাকে প্রভাবিত করেছে।
পছন্দের কারণ অনুমানযোগ্যতা। যেহেতু একটিই interrupt, CPU-র load প্রতিটি tick-এ হিসাব করা যায়, আর পরীক্ষায় যা দেখা গেল মাঠেও তাই ঘটবে। Event-triggered নকশায় দশটি ঘটনা একসাথে এলে কী হবে, তা নির্ভর করে তাদের আসার ক্রমের ওপর; সবচেয়ে খারাপ ঘটনাটি পরীক্ষায় হয়তো কখনো ঘটেনি। আবার একটি ত্রুটিপূর্ণ sensor-এর তার থেকে interrupt-এর ঝড় (পর্ব ৪২-এর লাফানো বোতামের মতো) event-triggered যন্ত্রকে ডুবিয়ে দিতে পারে, অথচ time-triggered যন্ত্র শুধু নির্দিষ্ট সময়ে pin পড়ে।
দামও স্পষ্ট। সাড়ার দেরি poll-এর period পর্যন্ত, আর বেশিরভাগ tick-এ “দেখার কিছু নেই” বলে শক্তি খরচ। প্রতিটি task-কে tick-এর মধ্যে শেষ হতে হয়, তাই লম্বা কাজ ভাঙতে হয়, এই পর্বের অংশ ৭-এর মতো।
বাজারঘরের cold room-এর নিয়মগুলো (প্রতি 1 s-এ মাপ, ৩টি পরপর reading-এ alarm, প্রতি 10 s-এ telemetry) এমনিতেই সময়ে বাঁধা, তাই time-triggered কাঠামো স্বাভাবিকভাবে মানায়; README-এর coldroom.c-ও তাই করে। কিন্তু network-এর দিকটি event-driven: MQTT-এর উত্তর কখন আসবে কেউ জানে না। বাস্তব নকশা তাই প্রায়ই মিশ্র: নিরাপত্তার মূল অংশ (alarm) কঠোর সময়সূচিতে, যোগাযোগ ঘটনা-নির্ভর আর আলাদা।
মূল উপলব্ধি: Time-triggered নকশা সাড়ার গতি ছেড়ে অনুমানযোগ্যতা কেনে; নিরাপত্তার মূল লুপে এটি শক্তিশালী, আর অনিশ্চিত ঘটনার জগতের (network) জন্য event-driven অংশ আলাদা রাখা ভালো।
প্র ০৩একটি cooperative super loop-এ watchdog timer কোথায় “kick” করা উচিত? Loop-এর শুরুতে একবার kick দেওয়া কেন যথেষ্ট নয়?
Watchdog timer-এর চুক্তি সহজ: নির্দিষ্ট সময়ের মধ্যে software তাকে reload না করলে পুরো chip reset. বাজারঘর board-এর IWDG-তে (Spec decision 28) KR-এ 0xAAAA লিখে reload, আর timeout RLR ms. প্রশ্ন হলো, কোন শর্তে reload দেওয়া “সব ঠিক আছে” প্রমাণ করে? সবচেয়ে সহজ উত্তর, loop-এর প্রতিটি ঘোরার শুরুতে একবার, প্রায়ই ভুল।
ধরুন measure task-এর ভেতরে ADC-এর EOC বিটের জন্য অপেক্ষার loop কোনো hardware ত্রুটিতে আটকে গেল। Loop আর ঘুরবে না, watchdog reset দেবে; এখানে সহজ নকশা কাজ করে। কিন্তু অন্য ধরনের ব্যর্থতা ভাবুন: একটি task-এর state machine একটি অবৈধ state-এ পৌঁছে চুপচাপ কিছু করছে না, অথচ loop দিব্যি ঘুরছে আর প্রতি ঘোরায় watchdog খুশি। বা task table-এর next_ms কোনো memory ভুলে অনেক দূরের ভবিষ্যতে চলে গেছে, ফলে measure আর কখনো চলবে না। দুই ক্ষেত্রেই যন্ত্র “জীবিত” কিন্তু অকেজো: scale আর ওজন দেখায় না, cold room-এর alarm আর মাপে না।
ভালো নকশায় প্রতিটি জরুরি task নিজের কাজ শেষ করে একটি “হাজিরা” বিট বসায়; loop শুধু তখনই watchdog reload করে, যখন নির্দিষ্ট সময়ের মধ্যে সব বিট বসেছে, তারপর বিটগুলো মুছে দেয়। এতে watchdog-এর অর্থ দাঁড়ায় “প্রতিটি জরুরি task সময়মতো চলেছে”। আরও কড়া রূপে window watchdog খুব আগে reload-কেও ভুল ধরে, যা লাফিয়ে চলা loop-এর লক্ষণ। Timeout বাছাইয়ে এই পর্বের মাপ কাজে লাগে: লম্বা report-এর রূপে button-এর পালা 141 ms পিছিয়েছিল, তাই 100 ms-এর watchdog সেখানে ভুল reset দিত।
Watchdog, reset-এর কারণ পড়া আর নিরাপদে ফেরার পুরো আলোচনা পর্ব ৬১-এ আসবে; এখানে মূল কথা cooperative নকশার সঙ্গে এর সম্পর্ক।
মূল উপলব্ধি: Loop ঘুরছে মানেই যন্ত্র ঠিক নয়; watchdog reload করুন শুধু তখন, যখন প্রতিটি জরুরি task তার হাজিরা দিয়েছে, আর timeout ঠিক করুন মাপা সবচেয়ে খারাপ দেরির ওপর মার্জিন রেখে।
প্র ০৪Smart scale-এ পরের বছর “দামের হার বদলানো”, “kg বা পোয়ায় দেখানো” আর “calibration mode” যোগ করতে হবে। সমতল FSM কীভাবে বেড়ে যায়, আর Harel-এর statechart কীভাবে সাহায্য করে?
প্রথমে গুনে দেখা যাক। এখনকার FSM-এ ৫টি state. Kg আর পোয়া দুটি এককে দেখানো একটি স্বাধীন বৈশিষ্ট্য: প্রতিটি পুরোনো state-কে দুই ভাগ করতে হয় (WEIGHING_KG, WEIGHING_POA …), অর্থাৎ ১০টি। দামের হার বদলানোর একটি মোড যোগ করলে প্রতিটি অবস্থায় “হার বদলাচ্ছি” কি না, আবার দ্বিগুণ। এই গুণ হারে বাড়াই state explosion. ৫ × ৫-এর table তখন ২০ × ৮, আর প্রতিটি ঘরে ভুলের সুযোগ।
David Harel ১৯৮৭ সালের প্রবন্ধে তিনটি উপায় দেন। এক, hierarchy: “ওজন মাপা” নামে একটি বড় state, যার ভেতরে IDLE, WEIGHING, STABLE, TARE; OVER ঘটনার transition একবার বড় state-এর গায়ে লিখলেই চলে, ভেতরের প্রতিটি state থেকে আলাদা তীর লাগে না। আমাদের table-এর “OVER সব সারিতে OVERLOAD” ঠিক এই পুনরাবৃত্তি। দুই, orthogonal region: একক (kg বা পোয়া) একটি আলাদা, সমান্তরাল ছোট FSM, মূল FSM-এর সঙ্গে গুণ না হয়ে যোগ হয়: ৫ + ২, ১০ নয়। তিন, entry আর exit action, যা এই পর্বেই ব্যবহার হয়েছে। Harel-এর এই ধারণা পরে UML-এর state machine-এ ঢোকে।
Firmware-এ hierarchical FSM-এর প্রচলিত কৌশল: প্রতিটি state একটি function, যা ঘটনা সামলাতে না পারলে তার “parent”-এর হাতে দেয়। Miro Samek-এর ২০০৮ সালের বইয়ের কাঠামো এই ধারার, আর তার ওপর ভিত্তি করে খোলা লাইসেন্সের framework-ও আছে বলে জানা যায়। Calibration mode-এর মতো একটি সম্পূর্ণ আলাদা আচরণ আবার একটি আলাদা top-level state: “সাধারণ ব্যবহার” আর “calibration”, যার ভেতরে নিজের ছোট FSM.
সব FSM-এ statechart লাগে না। ৫টি state আর ৫টি ঘটনার জন্য সমতল table সবচেয়ে স্পষ্ট। সংকেত হলো table-এ একই সারি বা একই কলাম বারবার লেখা হচ্ছে কি না; হলে hierarchy-র সময় এসেছে।
মূল উপলব্ধি: স্বাধীন বৈশিষ্ট্য সমতল FSM-এর state গুণ করে; hierarchy সাধারণ transition একবার লিখতে দেয়, আর orthogonal region স্বাধীন অংশকে গুণের বদলে যোগে রাখে।
প্র ০৫Protothread বা হাতে লেখা state machine দিয়ে লম্বা কাজ ভাঙা, নাকি একটি RTOS নেওয়া: ২ KB-এর মতো RAM-এর একটি ছোট chip-এ কোনটি যুক্তিসঙ্গত, আর কেন?
একটি RTOS-এর প্রতিটি task-এর নিজের stack লাগে, কারণ preemption যেকোনো মুহূর্তে task থামায়, আর তখনকার সব local ভ্যারিয়েবল আর ফেরার ঠিকানা সেই stack-এ থাকতে হয়। Stack-এর আকার সবচেয়ে গভীর function-ডাক আর interrupt-এর frame ধরে হিসাব করতে হয় (পর্ব ৩৯)। পাঁচটি task-এর প্রতিটিতে কয়েকশো byte হলেই ২ KB-এর অর্ধেক চলে যেতে পারে। এর বিপরীতে এই পর্বের পুরো firmware-এর RAM ছিল 88 byte, আর একটিই stack.
Cooperative নকশায় একটি stack-ই যথেষ্ট, কারণ প্রতিটি task ফিরে আসে, আর ফেরার সময় তার stack খালি। কিন্তু তাহলে লম্বা কাজের “কোথায় ছিলাম” কোথায় থাকবে? উত্তর: static ভ্যারিয়েবলে, একটি ছোট state machine হিসেবে। Display আঁকার কাজ “কোন সারি পর্যন্ত আঁকা হলো” একটি সংখ্যায় রাখে; প্রতি পালায় একটি সারি, তারপর ফেরা। Adam Dunkels ও সহকর্মীরা ২০০৬ সালে এর একটি চতুর রূপ প্রকাশ করেন, protothread: C-এর switch আর __LINE__ দিয়ে বানানো কয়েকটি macro, যা কোডকে সাধারণ ক্রমিক রূপে লিখতে দেয় (“শর্ত সত্য না হওয়া পর্যন্ত অপেক্ষা”), কিন্তু আসলে প্রতিটি অপেক্ষার জায়গায় function থেকে ফেরে আর পরে সেখান থেকে চলে। প্রতি protothread-এ কয়েক byte মাত্র; Contiki-র মতো sensor-network OS-এ এটি ব্যবহার হয়েছে।
সীমাও আছে। Protothread-এর ভেতরে local ভ্যারিয়েবল অপেক্ষার পরে টেকে না, তাই সব অবস্থা static রাখতে হয়; একই function-এর ভেতরে switch লেখায় বাধা আসে; আর preemption নেই, অর্থাৎ ভাঙা না-যাওয়া একটি লম্বা library ডাক এখনো সবাইকে আটকায়। RTOS এই শেষ সমস্যার সমাধান দেয়, RAM আর জটিলতার বিনিময়ে।
তাই ২ KB RAM-এর chip-এ সাধারণত state machine বা protothread-এর পথ যুক্তিসঙ্গত, যদি সব কাজ ভাঙা যায়। ভাঙা না গেলে, বা task-দের মধ্যে কড়া priority লাগলে, বেশি RAM-এর chip আর RTOS-এর খরচ তুলনা করতে হয়। সিদ্ধান্তটি সংখ্যায়: stack-এর হিসাব, সবচেয়ে লম্বা কাজের সময়, আর সবচেয়ে কড়া deadline.
মূল উপলব্ধি: RTOS-এর preemption-এর দাম প্রতি task-এ একটি stack; ছোট RAM-এ লম্বা কাজকে state machine বা protothread-এ ভেঙে একটি stack-এ চালানো প্রায়ই ভালো, যতক্ষণ সব কাজ ভাঙা যায়।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর lab-এ চালিয়ে বা হিসাব-script দিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — cold room-এর alarm-এর state machine: বাজারঘরের cold room-এর নিয়ম (README): প্রতি 1 s-এ একটি reading; 8.00 °C-এর ওপরে পরপর ৩টি reading হলে HIGH alarm, 0.00 °C-এর নিচে পরপর ৩টি হলে LOW alarm; alarm বন্ধ হবে পরপর ৩টি reading 0.50 … 7.50 °C-এর মধ্যে এলে। State আর তাদের মধ্যে transition নকশা করুন, প্রতি reading-এ ডাকার মতো একটি C function লিখুন, আর README-এর script (4.00 °C, 2.5 s → 5.50, 4.5 s → 8.25, 5.5 s → 9.00, 6.5 s → 9.50, 8.5 s → 7.75, 9.5 s → 7.00, 14.5 s → −0.50) দিয়ে কোন সেকেন্ডে কী ঘটবে বলুন।
typedef enum { NORMAL, HIGH_ALARM, LOW_ALARM } cr_state_t; static cr_state_t st = NORMAL; static uint8_t hi, lo, ok; /* পরপর কতটি reading */ void coldroom_step(int32_t t_centi) /* প্রতি 1 s, °C × 100 */ { if (st == NORMAL) { hi = (t_centi > 800) ? hi + 1 : 0; lo = (t_centi < 0) ? lo + 1 : 0; if (hi >= 3) { st = HIGH_ALARM; ok = 0; alarm_on("HIGH"); } else if (lo >= 3) { st = LOW_ALARM; ok = 0; alarm_on("LOW"); } } else { /* HIGH_ALARM বা LOW_ALARM */ ok = (t_centi >= 50 && t_centi <= 750) ? ok + 1 : 0; if (ok >= 3) { st = NORMAL; hi = lo = 0; alarm_off(); } } }State তিনটি: NORMAL, HIGH_ALARM, LOW_ALARM; counter তিনটি state-এর বাড়তি অবস্থা (extended state), নইলে “পরপর ৩টি” মনে রাখতে HIGH_1, HIGH_2 … আলাদা state লাগত। Hysteresis আসে দুটি আলাদা সীমা থেকে: চালু হয় 8.00-এর ওপরে, বন্ধের জন্য লাগে 7.50 বা নিচে। Script-এ (Python-এ এই নিয়মে চালিয়ে মেলানো): 5, 6, 7 s-এ 8.25, 9.00, 9.50 → 7 s-এ ALARM ON HIGH; 9 s-এ 7.75 °C ব্যান্ডের বাইরে, তাই ok আবার 0; 10, 11, 12 s-এ 7.00 → 12 s-এ ALARM OFF; 15, 16, 17 s-এ −0.50 → 17 s-এ ALARM ON LOW. এটি README-এর
coldroom.c-এর সত্যিকারের run-এর সঙ্গে হুবহু মেলে (7000, 12000 আর 17000 ms). -
ভুল খুঁজুন — একটি task table-এর তিনটি ভুল: একজন লিখলেন:
static uint32_t ms_ticks;(SysTick-এর ISR এটি বাড়ায়), আর loop-এif (ms_ticks >= t->next_ms) { t->next_ms = ms_ticks + t->period_ms; t->run(); }. Bench-এ কয়েক মিনিট চালিয়ে সব ঠিক দেখা গেল। মাঠে কী কী ঘটতে পারে? তিনটি ভুল আর ঠিক রূপ লিখুন।(১)
ms_ticksvolatileনয়। -O2-এ compiler loop-এর ভেতরে মানটি একবার register-এ পড়ে রেখে দিতে পারে, কারণ সে জানে না ISR এটি বদলায়; তখন কোনো task আর কখনো চলবে না (পর্ব ৩৪)। (২)ms_ticks >= next_ms: 232 ms ≈ 49.71 দিনে counter wrap করে। ঠিক তার আগেnext_mswrap করে ছোট সংখ্যা হলে তুলনা সঙ্গে সঙ্গে সত্য হয়ে task-টি প্রতি ঘোরায় চলে; উল্টো দিকে,next_msবড় আরms_tickswrap করে ছোট হলে task প্রায় ৫০ দিন চলে না। Bench-এর কয়েক মিনিটে এটি কখনো ধরা পড়ে না। (৩)next_ms = ms_ticks + period: প্রতিটি দেরি স্থায়ী drift হয়ে জমে; অংশ ৭-এর মডেলে 250 ms আটকালে শেষে 350 ms পিছিয়ে, মাপ ৩টি কম। ঠিক রূপ:static volatile uint32_t ms_ticks;, তুলনা(int32_t)(now - t->next_ms) >= 0, আরt->next_ms += t->period_ms;(পিছিয়ে পড়লে burst এড়াতে চাইলে সচেতনভাবে বাদ দেওয়ার নিয়ম)। Wrap পরীক্ষার কৌশল: host-এ counter-কে 0xFFFFFF00 থেকে শুরু করে চালানো। -
আগে বলুন, তারপর মেলান — ঘটনার ক্রম: ছবি ৫৫.১-এর smart scale FSM (table: অংশ ৪-এর
NEXT) IDLE থেকে শুরু করে এই ঘটনাগুলো পায়: SAME, SAME, BUTTON, CHANGED, OVER, BUTTON, SAME, SAME, EMPTY. প্রতিটি ঘটনার পরের state লিখুন। কোন ধাপে দাম ছাপা হবে, আর কোন ধাপে tare বদলাবে না?WEIGHING → STABLE → TARE → WEIGHING → OVERLOAD → OVERLOAD → WEIGHING → STABLE → IDLE (Python-এ table দিয়ে চালিয়ে মেলানো)। প্রথম SAME-এ IDLE থেকে সরাসরি STABLE নয়, WEIGHING: একটি মিল যথেষ্ট নয়, দাম আসে দ্বিতীয় মিলে (ধাপ ২ আর ধাপ ৮-এ STABLE-এ ঢুকে দাম ছাপা)। ধাপ ৬-এর BUTTON OVERLOAD-এ guard-এর কারণে উপেক্ষিত, tare বদলায় না। OVERLOAD থেকে SAME-এ সরাসরি STABLE নয়, WEIGHING: বোঝা নামানোর পরের প্রথম মাপকে নতুন শুরু ধরা হয়।
-
হিসাব — পিছিয়ে পড়া আর সবচেয়ে খারাপ সাড়া: একটি cooperative loop প্রতি 1 ms-এ জাগে। Measure task-এর period 100 ms (প্রথম পালা 100 ms-এ), report task 1000 ms-এ শুরু হয়ে 250 ms আটকে থাকে, আর একই tick-এ measure আগে চলে। (ক) “ছন্দ ধরে রাখা” আর (খ) “এখন থেকে গোনা” নীতিতে 1000 থেকে 1400 ms-এর মধ্যে measure কখন কখন চলবে? (গ) এই পর্বের board firmware-এ (button task প্রতি 10 ms, report 150 ms আটকায়, report-এর ঠিক আগে button চলে) debounced চাপ থেকে button task-এর দেখা পর্যন্ত সবচেয়ে খারাপ দেরি মোটামুটি কত?
(ক) 1000, 1250, 1250, 1300, 1400: 1100 আর 1200-এর পালা জমে ছিল, report শেষে 1250-এ পরপর দুবার চলে ধরে ফেলে, তারপর আবার ছন্দে। (খ) 1000, 1250, 1350: প্রতিটি পালা পিছিয়ে যায়, আর ফেরে না। দুটিই অংশ ৭-এর block-এর আসল আউটপুট। (গ) সবচেয়ে খারাপ ক্ষেত্রে ISR চাপ মানে ঠিক তখন, যখন 1000 ms-এ button task সবে চলে গেছে আর report শুরু হচ্ছে। Report 150 ms পরে ফেরে, loop WFI-তে গিয়ে পরের tick-এ জাগে, তারপর button: প্রায় 150 + 1 = 151 ms. Board-এ 1020 ms-এ চাপা বোতাম (মানা 1027-এ) দেখা হয়েছে 1151-এ, দেরি 124 ms, এই সীমার ভেতরে। লম্বা report না থাকলে সীমা শুধু button-এর period, 10 ms (board-এ মাপা 3 ms).
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমSysTick-এর 1 ms tick আর WFI-সহ একটি task-table super loop-এর একটি ঘোরার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- SysTick-এর ISR tick counter এক বাড়ায় আর CPU WFI থেকে জাগে
- Main loop counter-এর বর্তমান মান একবার পড়ে রাখে
- Task table-এর প্রতিটি সারিতে দেখা হয় পালার সময় হয়েছে কি না
- সময় হওয়া task-এর পরের পালা এক period এগিয়ে তার function চালানো হয়
- সব সারি দেখা শেষে WFI দিয়ে পরের interrupt পর্যন্ত ঘুম
একটি cooperative super loop-এ 100 ms period-এর একটি measure task আছে। প্রতি 1000 ms-এ একটি report task চলে আর 150 ms আটকে থাকে, এবং একই tick-এ measure আগে চলে। Measure-এর পরের পালা “ছন্দ ধরে রাখা” নীতিতে গোনা হলে তার সর্বোচ্চ দেরি মোটামুটি কত?
- 0 ms
- প্রায় 50 ms
- প্রায় 150 ms
- Measure আর কখনো চলে না
একটি table-driven state machine-এ ৫টি state আর ৫টি event, পরের state রাখা হয় static const uint8_t NEXT[5][5]-এ। Cortex-M-এ এই table কত byte নেয়, আর সাধারণত কোথায় থাকে?
- 100 byte, RAM-এ
- 10 byte, flash-এ
- 25 byte, flash-এ
- 25 byte, RAM-এ
একটি super loop-এ লেখা আছে if (ms_ticks >= next) { next += 1000u; send(); }, যেখানে ms_ticks একটি 32-বিটের unsigned counter, প্রতি 1 ms-এ বাড়ে। এই তুলনার মূল ঝুঁকি কী?
- প্রতিটি পালা একটু করে পিছিয়ে drift তৈরি হয়
- 32-বিট counter পড়া atomic নয়
- send() কখনোই চলে না
- প্রায় 49.71 দিন পরে counter wrap করলে তুলনা ভুল হয়
Cooperative scheduling-এ একটি কম গুরুত্বের task L tick 0 থেকে একটানা 6 tick চলে, কোথাও yield করে না। বেশি গুরুত্বের task H tick 1-এ প্রস্তুত হয় আর 2 tick চায়। H-এর response time (প্রস্তুত থেকে শেষ) কত?
- 7 tick
- 2 tick
- 5 tick
- 8 tick
একটি event-driven firmware-এর main loop এভাবে ঘুমায়: __disable_irq(); if (queue_empty()) __WFI(); __enable_irq();. Cortex-M-এ queue দেখার আগে interrupt বন্ধ করা হয় কেন?
- WFI-কে আরও গভীর ঘুমে পাঠাতে
- যাতে CPU আর কখনো না জাগে
- Queue দেখা আর ঘুমানোর মাঝে আসা ঘটনা যেন হারিয়ে না যায়
- ISR-এর priority বাড়াতে
একটি ওজন-যন্ত্রের UI state machine-এ OVERLOAD (5000 g-এর বেশি) অবস্থায় tare বোতামের ঘটনা আসে, কিন্তু নকশায় state বদলায় না আর tare-ও বদলায় না। এই নকশার নাম আর উদ্দেশ্য কী?
- Debouncing, যাতে লাফানো চাপ না গোনে
- Guard condition, যাতে অর্থহীন tare (যেমন 5100 g) জমা না হয়
- Hysteresis, যাতে সীমার কাছে দোলা না হয়
- Preemption, যাতে জরুরি কাজ আগে চলে
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Super loop: init, তারপর অসীম loop; সময় SysTick-এর tick থেকে, তুলনা
(int32_t)(now - next) >= 0, অপেক্ষা নয়; কাজ না থাকলে WFI. - Task table: নাম, period, পরের পালা আর function pointer;
next += periodছন্দ রাখে,next = now + perioddrift জমায়। Board-এ ৪টি task, দেরি 0 ms, বোতামের সাড়া 3 ms. - FSM: একটি state ভ্যারিয়েবল, ঘটনা, table বা switch; table-এ সব জোড়া স্পষ্ট, 5 × 5 = 25 byte flash-এ; entry action আর guard (OVERLOAD-এ tare নয়)।
- Event-driven: ISR ঘটনা queue-তে রাখে, loop একটি করে নিয়ে run-to-completion; queue দেখা আর WFI interrupt বন্ধ রেখে।
- সীমা: cooperative-এ একটি লম্বা task সবাইকে আটকায় (board-এ বোতাম 3 → 124 ms, মাপ 51 ms দেরি); ভাঙা না গেলে বা কড়া deadline মিশলে RTOS.
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ৫৪ · Real-time systemআগের পর্বDeadline, WCET, jitter আর drift, latency budget আর utilisation.
- পর্ব ৪৩ · Interrupt আর ISR নকশাভিত্তিISR-এর নিয়ম, ভাগ করা data আর ISR থেকে main loop-এ কাজ পাঠানো।
- Theory of Computation পর্ব ২৪ · Software-এ state machineপাশের ট্র্যাকProtocol, UI আর workflow-এর FSM, Moore আর Mealy-র তত্ত্বসহ।
- Operating Systems পর্ব ২০ · Multiprocessor আর real-time schedulingপাশের ট্র্যাকRM আর EDF-এর সাধারণ তত্ত্ব, পর্ব ৫৬-এর আগে পড়ার মতো।