এই পর্বে যা শিখবেন
- Message queue-র নিয়ম: FIFO, মান কপি করা, ভরা আর খালি অবস্থায় block, আর block-এর সময়সীমা
- ISR থেকে task-এ কাজ পাঠানো:
FromISRনিয়ম, জাগা task-এর জন্য সঙ্গে সঙ্গে switch - বাজারঘরের cold room-এর তিন-task pipeline নকশা আর কোথায় কে আটকাতে পারে তা খুঁজে বের করা
- Queue-র গভীরতা হাতে হিসাব করে simulator-এ সব phase চালিয়ে যাচাই করা
- Event group, task notification, semaphore আর queue-র মধ্যে কাজ অনুযায়ী বাছাই
১ · Task-এর মধ্যে বার্তা কেন — global variable যথেষ্ট নয়
পর্ব ৫৬-এ firmware ভাগ হয়েছে কয়েকটি task-এ, প্রত্যেকের নিজের priority আর stack. এখন প্রশ্ন: তারা একে অপরকে খবর দেবে কীভাবে? Cold room-এর sensor task একটি reading পেল; logic task সেটি কখন জানবে, আর একটির পরে আরেকটি এলে প্রথমটি হারাবে কি? এই পর্বে hex লেখা হবে C-ধাঁচে, 0x….
সবচেয়ে সরল উত্তর একটি global variable: sensor লেখে, logic পড়ে। কিন্তু তিনটি সমস্যা এখনই দেখা যায়। এক, logic জানে না কখন নতুন মান এসেছে, তাই বারবার দেখতে হয় (polling), যা CPU খায়, অথবা ঘুমিয়ে থাকলে দেরি হয়। দুই, logic পড়ার আগে sensor দুবার লিখলে একটি মান হারায়। তিন, বহু-byte মানের মাঝপথে preemption হলে ছেঁড়া মান পড়া হয়; এর নাম race condition, যা পর্ব ৪৩-এ board-এ দেখেছেন।
উপমা — হোটেলের অর্ডার-স্লিপের তার: পুরান ঢাকার একটি ভাতের হোটেলে বেয়ারা অর্ডার লিখে স্লিপটি রান্নাঘরের জানালার তারে গেঁথে দেন। রাঁধুনি তার থেকে সবচেয়ে পুরোনো স্লিপটি খোলেন। বেয়ারাকে রাঁধুনির জন্য দাঁড়িয়ে থাকতে হয় না, রাঁধুনিকেও বারবার ডাইনিংয়ে উঁকি দিতে হয় না। তার ভরে গেলে বেয়ারা অপেক্ষা করেন; তার খালি থাকলে রাঁধুনি বিশ্রাম নেন। স্লিপ মানে বার্তার একটি কপি: বেয়ারা নিজের খাতার পাতা ছিঁড়ে দেননি, তাই খাতায় পরের অর্ডার লিখলেও আগের স্লিপ বদলায় না। RTOS-এর message queue ঠিক এই তার।
RTOS ছোট কয়েকটি যন্ত্র দেয়, প্রতিটি একটি নির্দিষ্ট কাজের জন্য। সাধারণ OS-এ এদের সমষ্টিগত নাম IPC, যার process-এর দিক Operating Systems পর্ব ১২-এ আছে। RTOS-এ সবাই একই address space-এ থাকে, তাই এগুলো অনেক হালকা:
| যন্ত্র | কী বহন করে | Cold room-এ উদাহরণ |
|---|---|---|
| Message queue | সংকেত + data, ক্রমে, একাধিক জমতে পারে | sensor → logic: প্রতিটি reading |
| Binary / counting semaphore | শুধু সংকেত বা গোনা | “I2C-র কাজ শেষ” সংকেত |
| Mutex | সংকেত নয়, ভাগ করা জিনিসের তালা | UART-এ দুই task-এর লাইন যেন না মেশে |
| Event group | কয়েকটি বিট; ALL বা ANY শর্তে জাগা | Wi-Fi আর MQTT দুটিই চালু হলে telemetry |
| Task notification | একটি নির্দিষ্ট task-কে সরাসরি জাগানো, ৩২ বিটের একটি মানসহ | ISR থেকে logic-কে “নতুন frame এসেছে” |
Semaphore, mutex আর priority inversion পর্ব ৫৭-এর বিষয়; এখানে আমরা data বহনকারী queue আর সংকেতের দুটি হালকা রূপে মনোযোগ দেব। একটি ধারণা সবার নিচে কাজ করে: অপেক্ষার সময় task blocked অবস্থায় থাকে। Scheduler তাকে CPU দেয় না, তাই অপেক্ষা বিনামূল্যে; ঘটনা ঘটলে kernel নিজেই তাকে ready করে।
মূল নিয়ম Task-এর মধ্যে খবর পাঠান kernel-এর যন্ত্র দিয়ে, global variable আর flag দিয়ে নয়। তাতে তিনটি জিনিস একসাথে পাওয়া যায়: data, ক্রম, আর অপেক্ষার সময় CPU-র ছুটি।
২ · Message queue — FIFO, কপি আর block
Queue-র data structure দিক (FIFO, ring-এর মতো ঘোরা index) DSA পর্ব ১৪-এ, আর ISR থেকে main-এ একক লেখক-একক পাঠকের ring buffer পর্ব ৪৩ আর পর্ব ৪৯-এ। RTOS-এর queue এর ওপরে দুটি জিনিস যোগ করে। এক, যেকোনো সংখ্যক task পাঠাতে আর নিতে পারে, kernel ভেতরে নিজের critical section দিয়ে রক্ষা করে। দুই, block: ভরা queue-তে send ডাকা task ঘুমায় যতক্ষণ না জায়গা হয়, খালি queue-তে receive ডাকা task ঘুমায় যতক্ষণ না কিছু আসে। এটি producer-consumer সমস্যার kernel-এর তৈরি সমাধান, যার তত্ত্ব আছে Operating Systems পর্ব ২৬-এ।
Block কতক্ষণ? প্রতিটি ডাকে একটি সর্বোচ্চ সময় দেওয়া যায়, যাকে বলে block time: 0 মানে একদম অপেক্ষা নয় (ভরা হলে সঙ্গে সঙ্গে ব্যর্থতা ফেরে), একটি সংখ্যা মানে এত tick পর্যন্ত, আর “চিরকাল”. কোনটি বাছবেন, তা নকশার সিদ্ধান্ত, আর অংশ ৪-এ দেখবেন এটি কতটা গুরুত্বপূর্ণ।
RTOS simulator-এ — দ্রুত sensor, ধীর logic
কোর্সের reference lab-এর rtos_sim.py queue-কে Spec decision 35 অনুযায়ী মডেল করে: FIFO, একটি capacity, ভরা হলে sender block, খালি হলে receiver block. Spec decision 33 অনুযায়ী send আর recv শূন্য সময়ের কাজ, tick-এর শুরুতে ঘটে, আর কেউ জাগলে scheduler সঙ্গে সঙ্গে আবার সিদ্ধান্ত নেয়। বড় priority সংখ্যা বেশি জরুরি (Spec decision 32). আমার lab-এর scenario: sensor (priority 2) প্রতি tick-এ একটি reading বানিয়ে পাঠায়, মোট ৫টি; logic (priority 1) প্রতিটির জন্য 2 tick কাজ করে; queue-র capacity 3.
{"scheduler": "fp", "ticks": 16, "queues": {"q": {"capacity": 3}},
"tasks": [
{"name": "sensor", "priority": 2, "release": 0, "script":
[["compute",1],["send","q",1], ["compute",1],["send","q",2],
["compute",1],["send","q",3], ["compute",1],["send","q",4],
["compute",1],["send","q",5]]},
{"name": "logic", "priority": 1, "release": 0, "script":
[["recv","q"],["compute",2]] x 5}]} (x 5 = পাঁচবার)সত্যিকারের run — python -B rtos_sim.py run fill.json (reference lab, Python 3.13.5)
tick run events
0 sensor sensor released; logic released
1 sensor sensor sends 1 to q (1/3)
2 sensor sensor sends 2 to q (2/3)
3 sensor sensor sends 3 to q (3/3)
4 sensor sensor blocks: q is full; logic receives 1 from q;
sensor unblocks: its 4 enters q
5 logic sensor blocks: q is full
7 logic logic receives 2 from q; sensor unblocks: its 5 enters q;
sensor finishes (response 7)
9 logic logic receives 3 from q
11 logic logic receives 4 from q
13 logic logic receives 5 from q
Gantt (# running, - ready, B blocked, . not active):
0 1
0123456789012345
sensor #####BB.........
logic -----##########.
| সময় (tick) | |
| CPU-তে | |
| queue q | |
| sensor | |
| logic | |
| Gantt sensor |
- শুরু: queue খালি। দুজনই ready, কিন্তু sensor-এর priority বেশি, তাই সে চলে আর প্রথম reading বানায়। Logic অপেক্ষার সারিতে (
-), block নয়: সে এখনোrecvডাকার সুযোগই পায়নি। - প্রথম পাঠানো। Tick 1-এর শুরুতে sensor
sendকরে; জায়গা আছে, তাই 1 ঢোকে আর sensor থামে না। Simulator লেখে(1/3). - Queue ভরে গেল। 2 আর 3 একইভাবে ঢোকে। এখন 3/3. Logic এখনো একটিও নেয়নি, কারণ বেশি জরুরি sensor CPU ছাড়েনি। Queue এখানে ধাক্কা শুষে নিচ্ছে।
- ভরা queue-তে পাঠানো। Tick 4-এ sensor 4 পাঠাতে গিয়ে block হয়। এবার logic সুযোগ পেয়ে 1 নেয়; জায়গা খালি হতেই kernel অপেক্ষারত sensor-এর 4 ঢুকিয়ে দেয় আর তাকে ready করে। বেশি জরুরি বলে sensor সেই tick-এই আবার চলে। Logic 1 পেয়েছে, কিন্তু CPU পায়নি।
- এবার সত্যিকারের অপেক্ষা। Tick 5-এ sensor 5 পাঠাতে চায়, queue ভরা, block (
B). এখন sensor CPU চায় না, তাই logic চলে: 1-এর 2 tick কাজ। Sender-এর গতি এখন receiver-এর গতিতে বাঁধা। - জায়গা হলো, sensor শেষ। Tick 7-এ logic 2 নেয়; kernel সঙ্গে সঙ্গে sensor-এর 5 ঢোকায়। Sensor-এর script শেষ, response 7. Block না থাকলে 5 tick-এ শেষ হতো।
- Logic সারি খালি করে। 9-এ 3, 11-এ 4, 13-এ 5; শেষ 15-এ। মোট কাজ একই; queue শুধু ঠিক করেছে কে কখন অপেক্ষা করবে। ভরা queue-র এই উল্টো চাপের নাম backpressure.
মান কপি হয়, ঠিকানা নয়
FreeRTOS-এর queue.h-এর নিজের মন্তব্য: “Items are queued by copy, not by reference.” Queue তৈরির সময় প্রতিটি item-এর byte সংখ্যা বলা হয়, আর পাঠানোর সময় সেই কয়টি byte queue-র নিজের জায়গায় কপি হয়। তাই sender নিজের local variable পরের মুহূর্তেই আবার ব্যবহার করতে পারে। উল্টো নকশা, ঠিকানা পাঠানো, কেমন ভুল করে, দেখুন। নিচের C program একটি ছোট copy-queue বানিয়ে দুটি পথ পাশাপাশি চালায়:
#include <stdio.h>
#include <string.h>
#include <stdint.h>
typedef struct { uint16_t seq; int16_t t100; } Reading; /* 4 byte */
#define LEN 4
static uint8_t store[LEN][sizeof(Reading)]; /* queue-র নিজের জায়গা */
static unsigned head, tail, count;
static int q_send(const void *item, size_t size) { /* by copy */
if (count == LEN) return 0; /* ভরা: আসল RTOS-এ block */
memcpy(store[head], item, size);
head = (head + 1) % LEN; count++; return 1;
}
static int q_recv(void *out, size_t size) {
if (count == 0) return 0; /* খালি */
memcpy(out, store[tail], size);
tail = (tail + 1) % LEN; count--; return 1;
}
int main(void) {
static const int16_t temps[3] = {825, 900, 950};
Reading r; /* একটিই buffer, বারবার লেখা */
Reading *ptrs[3]; /* ভুল নকশা: pointer রাখা */
for (int i = 0; i < 3; i++) {
r.seq = (uint16_t)(i + 5); r.t100 = temps[i];
q_send(&r, sizeof r); /* মানটি কপি হয়ে গেল */
ptrs[i] = &r; /* শুধু ঠিকানা রাখা */
}
Reading got;
while (q_recv(&got, sizeof got))
printf("copy : seq=%u T=%d\n", (unsigned)got.seq, got.t100);
for (int i = 0; i < 3; i++)
printf("ptr : seq=%u T=%d\n", (unsigned)ptrs[i]->seq, ptrs[i]->t100);
return 0;
}আসল আউটপুট (Wandbox-এর C compiler):
copy : seq=5 T=825
copy : seq=6 T=900
copy : seq=7 T=950
ptr : seq=7 T=950
ptr : seq=7 T=950
ptr : seq=7 T=950
কপির পথে তিনটি reading (8.25, 9.00, 9.50 °C, শতাংশে) যেমন পাঠানো, তেমনই এসেছে। Pointer-এর পথে তিনটি ঠিকানাই একই r-কে দেখায়, তাই তিনবারই শেষ মান 950. RTOS-এ অবস্থা আরও খারাপ: r যদি sensor task-এর stack-এর local হয়, logic যখন পড়বে তখন সেখানে অন্য কিছু থাকতে পারে, আর ভুলটি নির্ভর করবে task-দের সময়ের ওপর, যা পরীক্ষায় ধরা কঠিন। কপির দাম হলো প্রতিবার memcpy; ছোট struct-এ তা নগণ্য। বড় buffer (যেমন পর্ব ৪৬-এর DMA-র ৫১২ byte) হলে নিয়ম হলো pointer পাঠানো, কিন্তু মালিকানাসহ: buffer আসে একটি pool থেকে, আর receiver কাজ শেষে তা ফেরত দেয়। এর নাম zero-copy নকশা, ভাবনার প্রশ্ন ১-এ।
FreeRTOS-এ একই কাজ কেমন দেখায়, নিচে। এটি উদাহরণ, চালানো হয়নি: কোর্সের virtual board (BG-M3) PendSV, SVC আর PSP মডেল করে না (Spec decision 19), তাই কোনো আসল RTOS port তাতে চলে না। Function-এর নাম FreeRTOS-Kernel-এর queue.h আর task.h থেকে মিলিয়ে নেওয়া; FreeRTOS MIT লাইসেন্সে।
typedef struct { uint16_t seq; int16_t t100; } Reading;
static QueueHandle_t raw_q; /* sensor → logic */
static volatile uint32_t raw_drops;
void sensor_task(void *arg) {
Reading r = {0, 0};
TickType_t next = xTaskGetTickCount();
for (;;) {
vTaskDelayUntil(&next, pdMS_TO_TICKS(1000)); /* পরম সময়, পর্ব ৫৪ */
r.seq++;
r.t100 = read_temp_100(); /* I2C, পর্ব ৫১ */
if (xQueueSend(raw_q, &r, 0) != pdPASS)
raw_drops++; /* ভরা: অপেক্ষা নয়, গুনে রাখা */
}
}
void logic_task(void *arg) {
Reading r;
for (;;) {
xQueueReceive(raw_q, &r, portMAX_DELAY); /* খালি হলে ঘুম */
update_alarm(&r); /* ৩ reading, hysteresis */
}
}
/* main-এ: raw_q = xQueueCreate(4, sizeof(Reading)); */দুটি সিদ্ধান্ত লক্ষ্য করুন। Sensor-এর xQueueSend-এ block time 0: sensor-এর নিজের deadline আছে (প্রতি 1 s), তাই ধীর logic-এর জন্য সে অপেক্ষা করবে না, বরং হারানো reading গুনে রাখবে। Logic-এর xQueueReceive-এ portMAX_DELAY: কাজ না থাকলে চিরকাল ঘুমানোই ঠিক। Queue-র জায়গা চলার সময় malloc দিয়ে না নিতে চাইলে xQueueCreateStatic আছে, যা পর্ব ৩৯-এর static allocation-এর নীতির সঙ্গে মেলে।
৩ · ISR থেকে task — deferred interrupt processing
পর্ব ৪৩-এর মূল নিয়ম ছিল: ISR ছোট রাখা, জরুরি অংশটুকু করে খবর রেখে যাওয়া, বাকি কাজ পরে। এর নাম deferred interrupt handling. RTOS ছাড়া সেই “পরে” ছিল super loop; RTOS-এ তা একটি task, যার priority নকশাকার ঠিক করেন। ISR আর task-এর মাঝে সেতু একটি queue বা notification.
কিন্তু ISR-এর জন্য দুটি বাড়তি নিয়ম আছে। প্রথমত, ISR কখনো block করতে পারে না: সে কোনো task নয়, তার ঘুমানোর জায়গা নেই। তাই FreeRTOS-এ ISR-এর জন্য আলাদা function, নামের শেষে FromISR, যেমন xQueueSendFromISR; এদের কোনো block time নেই। সাধারণ xQueueSend সম্পর্কে queue.h স্পষ্ট লেখে, এটি ISR থেকে ডাকা যাবে না। দ্বিতীয়ত, ISR যদি এমন task-কে জাগায় যে এখন চলমান task-এর চেয়ে বেশি জরুরি, তাহলে ISR শেষ হওয়ার সঙ্গে সঙ্গেই সেই task-এ যাওয়া উচিত, পরের tick পর্যন্ত অপেক্ষা নয়। এর জন্য FromISR function একটি flag ভরে দেয় (pxHigherPriorityTaskWoken), আর ISR-এর শেষে portYIELD_FROM_ISR সেটি দেখে context switch চায়। Cortex-M-এ এই switch হয় PendSV দিয়ে, যার কথা পর্ব ৩০ আর পর্ব ৫৬-এ।
void UART_IRQHandler(void) /* উদাহরণ, চালানো হয়নি */
{
BaseType_t woken = pdFALSE;
uint8_t b = (uint8_t)UART->DR; /* পড়লেই RXNE মোছে (পর্ব ৪৯) */
if (xQueueSendFromISR(rx_q, &b, &woken) != pdPASS)
rx_drops++; /* ভরা: অপেক্ষার উপায় নেই */
portYIELD_FROM_ISR(woken); /* জাগা task বেশি জরুরি? এখনই */
}Cortex-M-এ priority-র সীমা: FreeRTOS-এর ARM_CM3 port-এর port.c-এর মন্তব্য অনুযায়ী FromISR function শুধু সেই interrupt থেকে ডাকা যায়, যার priority configMAX_SYSCALL_INTERRUPT_PRIORITY-এর সমান বা তার চেয়ে কম জরুরি; আর সংখ্যায় ছোট priority মানে বেশি জরুরি (পর্ব ৩০). এর চেয়ে জরুরি interrupt kernel-এর critical section-এর মধ্যেও ঢুকতে পারে, তাই সে কোনো RTOS function ডাকলে kernel-এর তালিকা নষ্ট হতে পারে। একই port PendSV আর SysTick-কে সবচেয়ে কম জরুরি priority দেয়। AI assistant প্রায়ই এই নিয়ম ভুলে যায়।
Simulator-এ — “ISR” একটি reading রাখে, logic জাগে
rtos_sim.py-এ ISR বলে কিছু নেই, শুধু task. তাই আমি ISR-কে মডেল করেছি সবচেয়ে বেশি priority-র (9) একটি task হিসেবে, যার সব কাজ শূন্য সময়ের: send আর delay. এটি আসল ISR-এর সময় মাপে না, শুধু ক্রম দেখায়: কে কখন জাগে, কে কাকে থামায়। সঙ্গে logic (priority 2, প্রতিটি reading-এ 2 tick) আর একটি background task bg (priority 1, 12 tick-এর লম্বা হিসাব). Reading-গুলো README-র cold room-এর তিনটি গরম মান, শতাংশে: 825, 900, 950.
সত্যিকারের run — python -B rtos_sim.py run wake.json
tick run events
0 bg logic released; bg released; logic blocks: q is empty
2 logic isr released; isr sends 825 to q -> logic receives it;
isr delays 4 tick(s); logic preempts bg
4 bg logic blocks: q is empty
6 logic isr wakes after delay; isr sends 900 to q -> logic receives it;
isr delays 4 tick(s); logic preempts bg
8 bg logic blocks: q is empty
10 logic isr wakes after delay; isr sends 950 to q -> logic receives it;
isr finishes (response 8); logic preempts bg
11 logic (end of tick) logic finishes (response 12)
Gantt (# running, - ready, B blocked, . not active):
0 1
012345678901
isr ..BBBBBBBB..
logic BB##BB##BB##
bg ##--##--##--
| সময় (tick) | |
| CPU-তে | |
| queue q | |
| logic | |
| bg | |
| Gantt logic |
- Logic খালি queue-তে ঘুমায়। Tick 0-এ logic-এর priority বেশি, তাই সে আগে
recvডাকে, কিছু নেই, block (B). এবার CPU পায় bg. অপেক্ষায় থাকা logic কোনো CPU খরচ করে না। - ISR একটি reading রাখল। Tick 2-এ “isr” 825 পাঠায়। Logic আগে থেকেই অপেক্ষায়, তাই মানটি queue-তে জমে না, সরাসরি তার হাতে যায় (simulator লেখে
-> logic receives it). Logic ready হয় আর bg-এর চেয়ে জরুরি বলে সেই tick-এই bg-কে থামায়: “logic preempts bg”. এটিইportYIELD_FROM_ISR-এর ফল। - Logic কাজ করে। Tick 2 আর 3: 825-এর হিসাব (আসল firmware-এ সীমা আর গোনা). bg অপেক্ষার সারিতে (
-), তার হিসাব থেমে আছে কিন্তু হারায়নি। - আবার ঘুম, bg ফেরে। Tick 4-এ logic পরের reading চায়, queue খালি, block. bg যেখানে থেমেছিল সেখান থেকে চলে। Queue কোনো poll ছাড়াই ঠিক করে দিল কে কখন চলবে।
- একই নকশা প্রতিবার। Tick 6-এ 900: logic জাগে, bg-কে থামায়, 2 tick কাজ করে, 8-এ আবার ঘুমায়। ISR থেকে logic-এর কাজ শুরু পর্যন্ত দেরি এখানে 0 tick, কারণ logic-এর ওপরে কেউ ready নেই।
- শেষ reading, হিসাবের ফল। Tick 10-এ 950; logic শেষ হয় 12-এ। bg ১২টির মধ্যে মাত্র ৬ tick পেয়েছে (0, 1, 4, 5, 8, 9), কিন্তু কখনো logic-কে দেরি করায়নি। Gantt-এ isr সারির
Bমানে তারdelay-এর অপেক্ষা; আসল ISR কোনো task নয়, simulator-এর সীমার কারণে এভাবে দেখানো।
ISR থেকে queue-তে byte পাঠানো সবসময় সেরা নয়। 115200 baud-এ প্রতি 86.8 µs-এ একটি byte (পর্ব ৪৯); প্রতিটির জন্য kernel-এর একটি ডাক আর হয়তো একটি context switch অনেক খরচ। তখন ভালো নকশা হলো পর্ব ৪৩ আর ৪৯-এর lock-free ring buffer-এ byte রাখা, আর পুরো লাইন ('\n') এলে task-কে একবার জাগানো, অংশ ৭-এর notification দিয়ে। FreeRTOS-এ এই কাজের জন্য stream buffer আর message buffer নামে আলাদা যন্ত্রও আছে।
৪ · Cold room-এর pipeline — sensor → logic → telemetry
এখন বাজারঘরের cold-storage monitor-কে তিনটি task-এ ভাগ করা যাক। নকশা README থেকে স্থির: reading প্রতি 1 s, HIGH alarm 8.00 °C-এর ওপরে, LOW 0.00 °C-এর নিচে, পরপর 3টি reading-এ নিশ্চিত, 0.50 °C-এর hysteresis (0.50 থেকে 7.50 °C-এর মধ্যে পরপর ৩টিতে alarm বন্ধ), আর প্রতি 10 s-এ telemetry. পর্ব ৫৪-এ দেখেছেন, এখানে alarm-এর deadline hard শ্রেণির, আর telemetry soft. নকশার মূল কথা: এই দুই পথ যেন একে অপরকে আটকাতে না পারে।
ছবি ৫৮.১ — Cold room-এর তিন task, দুই queue আর একটি event group
বড় priority সংখ্যা বেশি জরুরি; queue-র ঘরগুলো capacity দেখায়
Simulator-এ এই pipeline চালাতে 1 tick = 10 ms ধরেছি, reference coldroom.c-এর SysTick-এর মতো (README: 100 tick = 1 s). Sensor প্রতি 100 tick-এ 1 tick কাজ করে README-র script-এর তাপমাত্রা পাঠায়। Logic-এর script আমার lab-এর একটি Python generator README-র নিয়ম থেকে বানিয়েছে, কারণ rtos_sim-এর script-এ শর্ত লেখা যায় না; generator নিজে যাচাই করে যে alarm-এর ঘটনা README-র board run-এর মতো 7, 12 আর 17 s-এ পড়ে। Telemetry প্রতিটি বার্তায় 2 tick নেয়: পর্ব ৫৪-এ হিসাব হয়েছিল, 115200 baud-এ টেলিমেট্রির লাইন পাঠাতে প্রায় 10.33 ms.
সত্যিকারের run — python -B rtos_sim.py run pipe.json (tel-এর লাইন বাছাই করা)
701 logic sensor sends 950 to raw -> logic receives it; sensor delays 99 tick(s)
702 telem logic sends 'ALARM ON HIGH' to tel -> telem receives it; logic blocks: raw is empty
1002 telem logic sends 'TEL seq1 +7.00 HIGH' to tel -> telem receives it; ...
1202 telem logic sends 'ALARM OFF' to tel -> telem receives it; ...
1702 telem logic sends 'ALARM ON LOW' to tel -> telem receives it; ...
2002 telem logic sends 'TEL seq2 -0.50 LOW' to tel -> telem receives it; logic finishes
CPU busy 50 of 2010 ticks (2.5 %)
সব স্বাভাবিক: প্রতিটি বার্তা পাঠানোর সঙ্গে সঙ্গেই নেওয়া হয়েছে, কোনো queue-তে কিছু জমেনি, CPU ২.৫% ব্যস্ত। Alarm-এর বার্তা 7.02 s-এ, board-এর README run-এর ALARM ON লাইনের (7000.06 ms) সঙ্গে একই সেকেন্ডে; বাড়তি 20 ms simulator-এর মোটা tick-এর ফল। আসল পরীক্ষা হয় যখন কিছু ভুল যায়। ধরুন প্রথম বার্তার সময় broker-এর সঙ্গে আবার সংযোগ করতে telemetry-র 6.5 s লাগল (650 tick):
সত্যিকারের run — pipe_slow.json (tel capacity 2)
702 telem logic sends 'ALARM ON HIGH' to tel -> telem receives it; ...
800 sensor sensor wakes after delay; sensor preempts telem
1002 telem logic sends 'TEL seq1 +7.00 HIGH' to tel (1/2); ...
1202 telem logic sends 'ALARM OFF' to tel (2/2); ...
1364 telem telem receives 'TEL seq1 +7.00 HIGH' from tel
1366 telem telem receives 'ALARM OFF' from tel
সত্যিকারের run — pipe_slow1.json (একই, শুধু tel capacity 1)
1202 telem logic blocks: tel is full
1301 telem sensor sends 700 to raw (1/4); sensor delays 99 tick(s)
1363 logic telem receives 'TEL seq1 +7.00 HIGH' from tel; logic unblocks: its
'ALARM OFF' enters tel; logic receives 700 from raw; logic preempts telem
প্রথম run-এ network-এর সমস্যা পুরোটা telemetry-র কাঁধে: sensor প্রতি সেকেন্ডে telemetry-কে থামিয়ে নিজের কাজ করেছে (“sensor preempts telem”), logic সময়মতো alarm বন্ধ করেছে, আর দুটি বার্তা tel queue-তে অপেক্ষা করেছে, ঠিক 2/2. দ্বিতীয় run-এ capacity মাত্র ১: 12 s-এ logic “ALARM OFF” পাঠাতে গিয়ে block, কারণ সে চিরকাল অপেক্ষার ডাক দিয়েছিল। এখন alarm-এর পথ network-এর ওপর নির্ভরশীল: 13.01 s-এর reading raw queue-তে বসে থাকে, logic তা পড়ে 13.63 s-এ, 0.62 s দেরিতে। আরও লম্বা বিভ্রাটে raw-এর ৪টি ঘরও ভরবে, তারপর sensor-ও আটকাবে: backpressure ধাপে ধাপে উৎস পর্যন্ত পৌঁছাবে।
নকশার নিয়ম বেশি জরুরি task কখনো কম জরুরি পথের queue-তে চিরকাল অপেক্ষা করবে না। Logic tel-এ পাঠাবে block time 0 বা ছোট সময় দিয়ে, ব্যর্থ হলে পুরোনো telemetry ফেলে গুনে রাখবে; alarm-এর অবস্থা telemetry-র পরের বার্তায় এমনিতেই যাবে। কোন বার্তা ফেলা চলে আর কোনটি নয়, তা আগেই লিখে রাখুন।
শুধু “সর্বশেষ মান”-এর জন্য (যেমন dashboard-এর বর্তমান তাপমাত্রা) FreeRTOS-এ একটি সুন্দর কৌশল আছে: এক ঘরের queue আর xQueueOverwrite, যা ভরা থাকলেও পুরোনো মান মুছে নতুনটি লেখে, কখনো block করে না। OS-এর ভাষায় এ ধরনের এক-বার্তার জায়গাকে প্রায়ই mailbox বলা হয়।
৫ · Queue-র আকার কত — হিসাব আর simulator
Queue খুব ছোট হলে sender আটকায় বা বার্তা হারায়; খুব বড় হলে RAM নষ্ট হয় আর পুরোনো বার্তা দেরিতে প্রক্রিয়া হয়। আকার ঠিক করার প্রশ্নটি সরল: receiver সবচেয়ে লম্বা কতক্ষণ queue থেকে নিতে পারে না, আর ততক্ষণে কয়টি বার্তা আসে? পর্ব ৪৩-এ ISR-এর ring buffer-এর জন্য একই প্রশ্ন ছিল; এখানে RTOS-এর সঙ্গে নতুন হলো receiver-এর ব্যস্ততায় অন্য task-এর বাধাও যোগ হয়।
উদাহরণ: sensor প্রতি 1 s-এ একটি reading দেয়। Logic মাঝে মাঝে flash-এ একটি log লেখে, যা নিজেই 3.5 s নেয়। Simulator-এ 1 tick = 100 ms ধরলাম (এখানে 10 ms-এর সূক্ষ্মতা দরকার নেই): sensor period 10, C = 1; logic-এর লম্বা কাজ C = 35. Logic-এর ব্যস্ত সময় R হিসাব হয় পর্ব ৫৬-এর response-time analysis-এর ধাঁচে:
# sensor → logic queue-র গভীরতা: logic সবচেয়ে লম্বা সময় ব্যস্ত থাকলে কয়টি reading জমে?
import math
T, C_SENSOR = 10, 1 # sensor: প্রতি 10 tick (1 s)-এ একটি reading, নিজের কাজ 1 tick
C_LONG = 35 # logic-এর সবচেয়ে লম্বা কাজ (যেমন flash-এ log লেখা)
# logic-এর ব্যস্ত সময় R: নিজের 35 tick + sensor-এর বাধা (response-time-এর ধাঁচে)
R = C_LONG
while True:
nxt = C_LONG + math.ceil(R / T) * C_SENSOR
print(f"R = {R:2} -> {C_LONG} + ceil({R}/{T}) x {C_SENSOR} = {nxt}")
if nxt == R:
break
R = nxt
general = math.ceil(R / T) # phase অজানা: সবচেয়ে খারাপে এতগুলো আসে
aligned = R // T # কাজ শুরু হয় ঠিক একটি reading নেওয়ার পরে
print(f"ব্যস্ত সময় R = {R} tick = {R / 10} s (1 tick = 100 ms)")
print(f"জমতে পারে: phase অজানা হলে {general}টি, reading-এর সঙ্গে মিলে শুরু হলে {aligned}টি")
for cap in (1, 2, 3, 4):
ok = "নিরাপদ" if cap >= general else ("এই phase-এ চলে" if cap >= aligned else "sensor আটকাবে")
print(f"capacity {cap}: {ok}")আসল আউটপুট (ব্রাউজারের Python):
R = 35 -> 35 + ceil(35/10) x 1 = 39
R = 39 -> 35 + ceil(39/10) x 1 = 39
ব্যস্ত সময় R = 39 tick = 3.9 s (1 tick = 100 ms)
জমতে পারে: phase অজানা হলে 4টি, reading-এর সঙ্গে মিলে শুরু হলে 3টি
capacity 1: sensor আটকাবে
capacity 2: sensor আটকাবে
capacity 3: এই phase-এ চলে
capacity 4: নিরাপদ
Logic-এর 3.5 s-এর কাজ sensor-এর চারটি বাধায় 3.9 s হয়। Phase অজানা হলে এই সময়ে সর্বোচ্চ ⌈39/10⌉ = 4টি reading আসতে পারে। কিন্তু এই নকশায় logic-এর লম্বা কাজ সবসময় শুরু হয় একটি reading নেওয়ার ঠিক পরে, তাই পরের reading আসে 10, 20, 30 tick পরে, আর 40-এ logic আবার মুক্ত: ⌊39/10⌋ = 3. কোনটি সত্য, তা simulator-কে জিজ্ঞেস করা যায়।
আমার lab-এর phase.py reference rtos_sim-কে (read-only) import করে প্রতিটি capacity-র জন্য sensor-এর ১০টি সম্ভাব্য offset (0 থেকে 9 tick) চালায়। Sensor-এর deadline তার period, 10 tick:
সত্যিকারের run — python -B phase.py (rtos_sim, ১০টি phase)
cap 1: worst sensor response 18 (offset 9), misses at that offset 2, phases with a miss 10/10
cap 2: worst sensor response 9 (offset 9), misses at that offset 0, phases with a miss 0/10
cap 3: worst sensor response 1 (offset 9), misses at that offset 0, phases with a miss 0/10
cap 4: worst sensor response 1 (offset 9), misses at that offset 0, phases with a miss 0/10
| Capacity | Sensor-এর সবচেয়ে খারাপ response | ফল |
|---|---|---|
| 1 | 18 tick (1.8 s) | প্রতিটি phase-এ deadline হারায়; Gantt-এ sensor-এর সারিতে লম্বা BBBB… |
| 2 | 9 tick | deadline রক্ষা, কিন্তু 8 tick block; ১ tick-এর জায়গা বাকি |
| 3 | 1 tick | কখনো block নয়: এই নকশায় যথেষ্ট |
| 4 | 1 tick | সাধারণ সূত্রের নিরাপদ মান; নকশা বদলালেও টেকে |
Capacity 2-এর ফলটি সবচেয়ে শিক্ষণীয়। কোনো miss নেই, তাই শুধু “deadline misses: 0” দেখলে কেউ বলবে ঠিক আছে। কিন্তু sensor-এর response 9, deadline 10: logic-এর কাজ ১ tick বাড়লেই ভাঙবে। Simulator-এর Gantt আর response-এর সংখ্যা, শুধু pass/fail নয়, দেখাই নিয়ম। আমি নকশায় 4 রাখব: হিসাবের সাধারণ সীমা, কারণ “লম্বা কাজ reading-এর ঠিক পরেই শুরু হয়” অনুমানটি পরে কেউ কোড বদলালে ভেঙে যেতে পারে। দাম মাত্র ৪ × 4 = 16 byte data (সঙ্গে kernel-এর queue-র নিজের হিসাবের জায়গা).
- গড় দিয়ে মাপ নয়: গড়ে queue-তে প্রায় কিছুই থাকে না (pipeline-এর run-এ একটিও জমেনি). Little-এর সূত্র গড় দৈর্ঘ্য দেয়, সর্বোচ্চ নয়; আকার ঠিক হয় সবচেয়ে খারাপ ব্যস্ততা থেকে।
- সর্বোচ্চ ভরা মেপে রাখুন: FreeRTOS-এর
uxQueueMessagesWaitingদিয়ে চলার সময় সর্বোচ্চ দেখা দৈর্ঘ্য রাখা যায়, পর্ব ৩৯-এর stack-এর high-water mark-এর মতো। এটি মাপা ফল, প্রমাণ নয়। - ভরা হলে কী, আগেই ঠিক: block (sender-এর deadline না থাকলে), নতুনটি ফেলা আর গোনা, নাকি পুরোনোটি মুছে লেখা। নীরবে হারানো কখনো নয়।
৬ · Event group — একাধিক শর্তে জাগা
Telemetry task-এর একটি সমস্যা আছে যা queue দিয়ে ভালো মেলে না: সে পাঠাতে পারবে শুধু তখন, যখন Wi-Fi চালু, MQTT broker-এর সঙ্গে সংযোগ চালু, আর পাঠানোর সময় হয়েছে। তিনটি আলাদা উৎস, আর শর্ত হলো তিনটিই একসাথে। Event group হলো কয়েকটি বিটের একটি শব্দ: যেকোনো task বা ISR বিট set বা clear করে, আর অপেক্ষারত task বলে “এই বিটগুলোর সবকটি (ALL)” বা “যেকোনো একটি (ANY)” হলে আমাকে জাগাও। সাধারণ বইয়ে এদের event flag-ও বলা হয়।
FreeRTOS-এর event_groups.h অনুযায়ী অপেক্ষার function xEventGroupWaitBits, যার দুটি গুরুত্বপূর্ণ parameter: xWaitForAllBits (ALL না ANY) আর xClearOnExit. দ্বিতীয়টি pdTRUE হলে শর্ত মেলার পরে অপেক্ষার সবকটি বিট মুছে যায়। বিটের সংখ্যা tick-এর মাপের ওপর নির্ভর করে: configTICK_TYPE_WIDTH_IN_BITS 16 বিটের tick-এ 8টি, 32 বিটের tick-এ 24টি, 64 বিটের tick-এ 56টি ব্যবহারযোগ্য বিট (একই header-এর মন্তব্য). rtos_sim.py-এ event group নেই, তাই নিচের মডেল আমি নিজে লিখে চালিয়েছি; এটি FreeRTOS-এর কোড নয়, তার নিয়মের সরল নকল।
# event group-এর ছোট মডেল: বিট set হলে অপেক্ষারত task-এর শর্ত মেলে কি না দেখা
WIFI, MQTT, TEL_DUE = 1 << 0, 1 << 1, 1 << 2
def run(clear_on_exit):
bits, sent = 0, []
want = WIFI | MQTT | TEL_DUE # telemetry task: তিনটিই চাই (ALL)
events = [(10.0, "set", TEL_DUE), (10.4, "set", WIFI), (10.9, "set", MQTT),
(20.0, "set", TEL_DUE), (30.0, "set", TEL_DUE)]
for t, op, b in events:
bits |= b
if bits & want == want: # শর্ত মিলল: task জাগে
sent.append(t)
if clear_on_exit:
bits &= ~want # অপেক্ষার সব বিট মুছে যায়
else:
bits &= ~TEL_DUE # শুধু ঘটনার বিটটি হাতে মোছা
print(f" t={t:4.1f} s set {b:03b} -> bits={bits:03b}"
+ (" telemetry পাঠাল" if sent and sent[-1] == t else ""))
return sent
for coe in (True, False):
print(f"xClearOnExit = {coe}:")
print(f" পাঠানো হলো {len(run(coe))}টি telemetry")
# ANY: alarm task জাগে HIGH বা LOW-এর যেকোনো একটিতে
HIGH, LOW = 1 << 3, 1 << 4
for b in (HIGH, LOW, 0):
print(f"ANY(HIGH|LOW), bits={b:05b}: {'জাগে' if b & (HIGH | LOW) else 'ঘুমায়'}")আসল আউটপুট (ব্রাউজারের Python). বিট ডান থেকে পড়ুন: বিট ০ = WIFI, ১ = MQTT, ২ = TEL_DUE.
xClearOnExit = True:
t=10.0 s set 100 -> bits=100
t=10.4 s set 001 -> bits=101
t=10.9 s set 010 -> bits=000 telemetry পাঠাল
t=20.0 s set 100 -> bits=100
t=30.0 s set 100 -> bits=100
পাঠানো হলো 1টি telemetry
xClearOnExit = False:
t=10.0 s set 100 -> bits=100
t=10.4 s set 001 -> bits=101
t=10.9 s set 010 -> bits=011 telemetry পাঠাল
t=20.0 s set 100 -> bits=011 telemetry পাঠাল
t=30.0 s set 100 -> bits=011 telemetry পাঠাল
পাঠানো হলো 3টি telemetry
ANY(HIGH|LOW), bits=01000: জাগে
ANY(HIGH|LOW), bits=10000: জাগে
ANY(HIGH|LOW), bits=00000: ঘুমায়
দুই রকম বিট আছে, আর এদের আলাদা করাই এখানে শিক্ষা। WIFI আর MQTT হলো অবস্থা: সংযোগ যতক্ষণ আছে, বিট ততক্ষণ 1, মোছার দায়িত্ব যে সংযোগ হারানো টের পায় তার। TEL_DUE হলো ঘটনা: একবার ঘটে, একবার ব্যবহার হয়। xClearOnExit = pdTRUE তিনটিই মুছে দেয়, তাই 10.9 s-এর পরে network চালু থাকা সত্ত্বেও WIFI আর MQTT 0; 20 আর 30 s-এ telemetry আর যায়নি। ঠিক নকশা: অবস্থার বিট রেখে শুধু ঘটনার বিট মোছা (FreeRTOS-এ xEventGroupClearBits দিয়ে), অথবা ঘটনার জন্য আলাদা যন্ত্র। শেষ তিন লাইন ANY-এর নিয়ম: HIGH বা LOW, যেকোনোটিতে জাগা।
| সময় | |
| ঘটনা | |
| bits | |
| চাই ALL 111 | |
| telemetry |
- শুরু: সব বিট 0. Telemetry task
xEventGroupWaitBitsডেকে ঘুমায়, শর্ত ALL: বিট ০, ১ আর ২ তিনটিই চাই। - 10 s: পাঠানোর সময় হলো। Logic task TEL_DUE (বিট ২) set করে: 100. কিন্তু network এখনো চালু হয়নি, তাই শর্ত মেলেনি, task ঘুমিয়েই থাকে। Queue হলে এখানে task জেগে উঠে network দেখত আর আবার ঘুমাত।
- 10.4 s: Wi-Fi চালু। Network task বিট ০ set করে: 101. দুটি হলো, তৃতীয়টি বাকি। Kernel প্রতিটি set-এ শর্ত পরীক্ষা করে, task-কে জাগায় না।
- 10.9 s: MQTT চালু, শর্ত পূর্ণ। 111: telemetry জাগে, পাঠায়, আর হাতে শুধু TEL_DUE মোছে: 011. Wi-Fi আর MQTT-র অবস্থা ঠিকই থাকে।
- 20 s: পরের telemetry. TEL_DUE আবার set, সঙ্গে সঙ্গে 111, task জাগে, পাঠায়, আবার 011. ৩০ s-এও একই, মডেলে মোট ৩টি পাঠানো।
- ভুল নকশা:
xClearOnExit = pdTRUE. 10.9 s-এ তিনটি বিটই মুছে 000 হয়েছিল। 20 s-এ শুধু TEL_DUE: 100, শর্ত মেলে না, network চালু থাকলেও telemetry আর কখনো যায় না। কোনো error নেই, শুধু নীরবতা: এ ধরনের bug মাঠে ধরা পড়ে দিনের পর দিন পরে।
ISR থেকে বিট set করার xEventGroupSetBitsFromISR আছে, কিন্তু একটি সূক্ষ্মতা আছে, যা event_groups.h নিজেই ব্যাখ্যা করে: একটি বিট set করলে কয়টি task জাগবে তা আগে থেকে জানা নেই, আর FreeRTOS এমন অনির্দিষ্ট দৈর্ঘ্যের কাজ ISR বা critical section-এ করতে দেয় না। তাই এই function কাজটি timer daemon task-এ পাঠিয়ে দেয়; ISR-এর সঙ্গে সঙ্গে নয়, সেই task চললে বিট set হয়। Alarm-এর মতো দ্রুত পথে ISR থেকে queue বা notification তাই সাধারণত ভালো। Event group-এর আরেকটি ব্যবহার xEventGroupSync: কয়েকটি task একটি সাক্ষাৎ-বিন্দুতে মিলিত হয়, সবাই না আসা পর্যন্ত কেউ এগোয় না।
৭ · Task notification — নির্দিষ্ট task-কে সরাসরি জাগানো
অনেক সময় দরকার শুধু একটি নির্দিষ্ট task-কে বলা “জাগো, কাজ এসেছে”. তার জন্য পুরো queue বা semaphore বানানো বাড়তি। FreeRTOS-এ প্রতিটি task-এর নিজের একটি ৩২ বিটের notification মান থাকে (V10.4.0 থেকে একটি array, যার মাপ configTASK_NOTIFICATION_ARRAY_ENTRIES; আগে একটি মান). xTaskNotifyGive বা ISR থেকে vTaskNotifyGiveFromISR মানটি এক বাড়ায়; ulTaskNotifyTake মান 0 হলে task-কে ঘুম পাড়ায়, আর 0 না হলে ফেরে। task.h অনুযায়ী ulTaskNotifyTake-এর প্রথম parameter pdTRUE হলে মান শূন্য করে (binary semaphore-এর মতো), pdFALSE হলে এক কমায় (counting semaphore-এর মতো).
FreeRTOS-এর নিজের ওয়েবসাইট দাবি করে, notification দিয়ে task জাগানো binary semaphore-এর চেয়ে ৪৫% পর্যন্ত দ্রুত আর কম RAM নেয়; সাইটের পাদটীকা অনুযায়ী মাপটি একটি পুরোনো (V8.1.2) semaphore-এর সঙ্গে তুলনা, নতুন সংস্করণে পার্থক্য কম। সংখ্যাটি নির্দিষ্ট মাপের পরিস্থিতির, তাই নিজের chip-এ মেপে নেওয়াই নিরাপদ। নিচের মডেল দেখায়, ISR পরপর ৩টি UART frame পেলে, আর task তখনো চলার সুযোগ না পেলে, তিন রকম সংকেতে কী হয়:
# task notification-এর মডেল: প্রতিটি task-এর নিজের একটি 32-বিট মান
class Task:
def __init__(self, name):
self.name, self.value = name, 0
def notify_give(task): # xTaskNotifyGive / ...FromISR: মান + 1
task.value = (task.value + 1) & 0xFFFFFFFF
def notify_take(task, clear_on_exit): # ulTaskNotifyTake: 0 হলে task ঘুমায়
v = task.value
if v:
task.value = 0 if clear_on_exit else v - 1
return v # ফেরত: নেওয়ার আগের মান
# ISR পরপর 3টি UART frame পেল, task তখনো চলার সুযোগ পায়নি
for mode in ("binary semaphore", "take(pdTRUE)", "take(pdFALSE)"):
t, handled, wakeups = Task("logic"), 0, 0
for _ in range(3):
if mode == "binary semaphore":
t.value = 1 # max 1: দ্বিতীয় give হারায়
else:
notify_give(t)
while (v := notify_take(t, mode != "take(pdFALSE)")):
wakeups += 1
handled += v if mode == "take(pdTRUE)" else 1
print(f"{mode:17}: জাগল {wakeups} বার, কাজ হলো {handled}টি frame-এর")আসল আউটপুট (ব্রাউজারের Python):
binary semaphore : জাগল 1 বার, কাজ হলো 1টি frame-এর
take(pdTRUE) : জাগল 1 বার, কাজ হলো 3টি frame-এর
take(pdFALSE) : জাগল 3 বার, কাজ হলো 3টি frame-এর
Binary semaphore-এর সর্বোচ্চ মান 1, তাই দ্বিতীয় আর তৃতীয় সংকেত হারিয়েছে: task একবার জেগে একটি frame প্রক্রিয়া করে আবার ঘুমায়, দুটি frame পড়ে থাকে। Notification গোনে। pdTRUE-তে task একবার জেগে ফেরত মান 3 দেখে, তাই তিনটিই এক দফায় সারে; pdFALSE-তে তিনবার জাগে, প্রতিবার একটি। Frame-এর data কিন্তু notification-এ নেই, শুধু সংখ্যা: data থাকে পর্ব ৪৯-এর ring buffer-এ। আর একটি সহজ বিকল্প সবসময় নিরাপদ: জেগে ring buffer খালি না হওয়া পর্যন্ত পড়া, সংখ্যা যা-ই হোক।
সীমাগুলো জানা দরকার, কারণ notification সবকিছুর বদলি নয়: প্রাপক ঠিক একটি task (পাঠানোর সময় তার handle লাগে); একাধিক data item জমিয়ে রাখা যায় না, শুধু একটি ৩২ বিটের মান; ISR প্রাপক হতে পারে না; আর পাঠানো ব্যক্তি “জায়গা হওয়া পর্যন্ত” অপেক্ষা করতে পারে না। বাছাইয়ের সারাংশ:
| প্রয়োজন | প্রথম পছন্দ | কেন |
|---|---|---|
| প্রতিটি মান ক্রমে পৌঁছাতে হবে | Message queue | Data + ক্রম + গভীরতা |
| ISR থেকে একটি task-কে জাগানো | Task notification | সবচেয়ে হালকা; data ring buffer-এ |
| কয়েকটি শর্তের ALL বা ANY | Event group | বিটে অবস্থা আর ঘটনা |
| শুধু সর্বশেষ মান | এক ঘরের queue + overwrite | কখনো block নয়, পুরোনো মান অর্থহীন |
| একটি জিনিস পালা করে ব্যবহার | Mutex (পর্ব ৫৭) | মালিকানা আর priority inheritance |
| n-টি একই সম্পদ গোনা | Counting semaphore | একাধিক task-এর মধ্যে ভাগ |
আরও গভীরে: FreeRTOS-এ queue-ই আসল ভিত্তি: queue.h-এর queue type-এর তালিকায় mutex, counting আর binary semaphore-ও আছে, অর্থাৎ semaphore হলো শূন্য-মাপের item-এর একটি queue. এ কারণেই semaphore-এর চেয়ে notification দ্রুত হতে পারে: মাঝখানে কোনো আলাদা object নেই, kernel সরাসরি প্রাপকের TCB-তে মান লেখে। অন্য RTOS-এও একই ধারণাগুলো ভিন্ন নামে থাকে, আর গাড়ির জন্য তৈরি OSEK/VDX মানদণ্ডের “event” প্রতি-task বিটের ধারণায় অনেকটা event group-এর মতো, যদিও খুঁটিনাটি আলাদা।
পরীক্ষা ও ইন্টারভিউতে: “ISR থেকে xQueueSend কেন নয়?” → ISR block করতে পারে না; FromISR রূপ আর portYIELD_FROM_ISR. “Queue-তে pointer পাঠালে কী ঝুঁকি?” → buffer বদলে বা stack ছেড়ে গেলে প্রাপক ভুল data পড়ে; মালিকানার নিয়ম লাগে। “Semaphore আর event group-এর পার্থক্য?” → semaphore একটি গোনা; event group কয়েকটি বিট, ALL বা ANY শর্ত। “Queue-র গভীরতা কীভাবে ঠিক করবেন?” → receiver-এর সবচেয়ে লম্বা ব্যস্ততা R (বাধাসহ) ÷ আগমনের period, ওপরে গোল করে, সঙ্গে ভরা হলে কী হবে তার নীতি। “Task notification-এর সীমা?” → একজন প্রাপক, একটি ৩২ বিটের মান, ISR প্রাপক নয়।
৮ · AI-এর যুগে RTOS-এর বার্তার কোড যাচাই
“FreeRTOS-এ ISR থেকে task-এ data পাঠানোর কোড দিন” লিখলে AI assistant দ্রুত চলনসই কোড দেয়, কিন্তু ভুলগুলো এমন জায়গায় থাকে যা compile-এ ধরা পড়ে না। সাধারণ ভুল আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
ISR-এ xQueueSend বা block time দেয় | ISR-এ শুধু …FromISR; header-এর মন্তব্য পড়া |
portYIELD_FROM_ISR বাদ দেয় | Simulator-এ জাগা task কখন চলে দেখা; না দিলে পরের tick পর্যন্ত দেরি |
Interrupt-এর priority configMAX_SYSCALL_INTERRUPT_PRIORITY-এর চেয়ে জরুরি রাখে | NVIC-এর সংখ্যা আর port-এর নিয়ম মিলিয়ে দেখা (পর্ব ৩০); configASSERT চালু রাখা |
| Local buffer-এর pointer queue-তে পাঠায় | Item-এর মাপ sizeof(struct) কি না; pointer হলে মালিকানা কার |
| Queue-র মাপ “10” বা “32” লেখে কোনো হিসাব ছাড়া | R ÷ T-এর হিসাব আর simulator-এ সব phase |
বেশি জরুরি task-কে কম জরুরি queue-তে portMAX_DELAY-এ অপেক্ষা করায় | প্রতিটি অপেক্ষার ডাকের পাশে লিখুন: এটি আটকালে কার deadline ভাঙে? |
Event group-এ অবস্থার বিট xClearOnExit-এ মুছে দেয় | প্রতিটি বিটকে “অবস্থা” না “ঘটনা” চিহ্নিত করা |
প্রসঙ্গ, সংখ্যা আর যাচাইয়ের শর্ত শুরুতেই দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১FreeRTOS-এর queue মান কপি করে, ঠিকানা নয়। ছোট MCU-তে কপি কি অপচয় নয়? কখন pointer পাঠানোই ঠিক, আর তখন কোন নিয়ম মানতে হয়?
FreeRTOS-Kernel-এর queue.h-এ বারবার একই বাক্য: item “queued by copy, not by reference”. এর পেছনের যুক্তি নিরাপত্তা আর সরলতা। কপি হলে পাঠানোর মুহূর্তেই sender আর receiver-এর data আলাদা হয়ে যায়: sender তার local variable বদলাক, stack ছেড়ে যাক, বা একই buffer-এ পরের reading লিখুক, queue-র ভেতরের কপি অক্ষত। এই পর্বের C program ঠিক এটিই দেখাল: কপির পথে 825, 900, 950 যেমন গেছে তেমন এসেছে, pointer-এর পথে তিনবারই 950. Task-রা আলাদা সময়ে চলে বলে pointer-এর ভুল সময়ের ওপর নির্ভর করে, তাই পরীক্ষাগারে প্রায়ই লুকিয়ে থাকে।
কপির দাম কত? Cold room-এর Reading ৪ byte; একটি memcpy কয়েকটি নির্দেশ মাত্র, আর কপির জন্য queue-কে নিজের জায়গা রাখতে হয় (capacity × item-এর মাপ). ছোট মানে এই দাম নগণ্য, আর বিনিময়ে সমস্ত মালিকানা-প্রশ্ন উধাও। কিন্তু পর্ব ৪৬-এর মতো DMA-র ৫১২ byte-এর buffer, বা একটি পুরো network packet, প্রতিবার কপি করলে সময় আর RAM দুটিই নষ্ট।
তখন pointer পাঠানোই ঠিক, কিন্তু একটি স্পষ্ট মালিকানার নিয়মসহ: buffer আসে একটি নির্দিষ্ট মাপের pool থেকে (static, পর্ব ৩৯-এর নীতি), producer পূর্ণ buffer-এর pointer queue-তে পাঠিয়ে আর কখনো তা ছোঁয় না, consumer কাজ শেষে buffer pool-এ ফেরত দেয়। Queue তখন বহন করে ৪ byte-এর একটি pointer, কিন্তু অর্থে বহন করে মালিকানা। এই নকশার নাম zero-copy; Linux-এর network stack-এর buffer, আর অনেক RTOS-এর memory pool এই ধারণায় চলে। ঝুঁকিগুলো জানা: কেউ ফেরত দিতে ভুলে গেলে pool ধীরে ফুরোয় (leak); দুবার ফেরত দিলে একই buffer দুজনের হাতে যায়। তাই pool-এ “কতটি খালি” গোনা আর debug build-এ প্রতিটি buffer-এর মালিক লিখে রাখা ভালো অভ্যাস।
একটি মাঝের পথও আছে: ছোট header (দৈর্ঘ্য, ধরন) কপি করে আর বড় payload-এর pointer পাঠানো। FreeRTOS-এর stream buffer আর message buffer এক লেখক-এক পাঠকের ক্ষেত্রে আরেক বিকল্প।
মূল উপলব্ধি: ছোট মানের জন্য কপিই সেরা, কারণ তা মালিকানার প্রশ্নই মুছে দেয়। বড় buffer-এ pointer পাঠান, কিন্তু pool আর “কে কখন ফেরত দেবে” নিয়মসহ; নিয়ম ছাড়া pointer-এর queue একটি সময়-নির্ভর bug-এর কারখানা।
প্র ০২“ভাগ করা memory দিয়ে যোগাযোগ নয়, যোগাযোগ দিয়ে memory ভাগ” — Go ভাষার এই প্রচলিত উক্তির শিকড় Tony Hoare-এর ১৯৭৮ সালের CSP-তে। ছোট firmware-এ message passing-এর দর্শন কতটা কাজে লাগে?
১৯৭৮ সালে C. A. R. (Tony) Hoare Communications of the ACM-এ “Communicating Sequential Processes” প্রবন্ধে একটি মডেল দেন: স্বাধীন প্রক্রিয়ারা কোনো variable ভাগ করে না, শুধু বার্তা আদান-প্রদান করে। এই CSP পরে occam ভাষা আর Transputer chip-এ সরাসরি রূপ পায় (১৯৮০-এর দশকে), আর অনেক পরে Go-র channel-এ। একই সময়ে আরেক ধারা, Erlang (১৯৮০-এর দশকের শেষে Ericsson-এ, telephone switch-এর জন্য), প্রতিটি process-কে বিচ্ছিন্ন রেখে শুধু বার্তা দিয়ে যুক্ত করে। Operating system-এর দিকে QNX-এর মতো microkernel message passing-কে মূল যোগাযোগ হিসেবে ব্যবহার করে বলে পরিচিত। বিস্তারিত সাল ও দাবি উৎস অনুযায়ী একটু আলাদা হতে পারে।
Message passing-এর মূল লাভ যুক্তির সরলতা। ভাগ করা variable থাকলে প্রতিটি পড়া আর লেখার সম্ভাব্য সব ক্রম ভাবতে হয়; race condition জন্মায় সেখানে। বার্তা থাকলে প্রতিটি task-এর data শুধু তার নিজের; বাইরের জগৎ তাকে ছোঁয় কেবল queue-র মুখে, এক জায়গায়। Cold room-এর pipeline তাই প্রায় স্বয়ংক্রিয়ভাবে বোঝা যায়: alarm-এর অবস্থা থাকে logic-এর ভেতরে, আর কেউ তা সরাসরি বদলায় না।
ছোট firmware-এ এর সীমাও আছে। প্রতিটি বার্তার কপি আর kernel-এর ডাকের খরচ; 115200 baud-এর প্রতিটি byte-এ একটি queue-ডাক অনেক বেশি (অংশ ৩). খুব দ্রুত, সরল ক্ষেত্রে, যেমন একজন লেখক আর একজন পাঠকের ring buffer, ভাগ করা memory আর সতর্ক ক্রমই ভালো, যা পর্ব ৪৩-এ দেখেছেন। আবার কিছু জিনিস স্বভাবতই ভাগ করা: একটি UART, একটি I2C bus. সেখানে হয় একটি mutex, নয়তো একটি “মালিক” task যে ওই hardware-এর একমাত্র ব্যবহারকারী আর অন্যরা তাকে বার্তা পাঠায়; দ্বিতীয়টি CSP-র দর্শন, আর প্রায়ই priority inversion-এর ঝামেলা কমায়।
Bangladesh-এর গার্মেন্টস কারখানার লাইনের কথা ভাবুন: প্রতিটি অপারেটরের সামনে একটি ঝুড়ি, আগের জন সেখানে টুকরো রাখেন। কেউ অন্যের টেবিলে হাত দেন না। লাইন কোথায় আটকাচ্ছে, তা ঝুড়ির উচ্চতা দেখেই বোঝা যায়, এই পর্বের queue-র ভরা থাকার মাপের মতো।
মূল উপলব্ধি: বার্তা দিয়ে যুক্ত task-গুলো আলাদা করে বোঝা, পরীক্ষা আর বদলানো যায়। খরচ বা hardware-এর কারণে যেখানে ভাগ করতেই হয়, সেখানে ভাগের জায়গাটুকু ছোট আর স্পষ্ট রাখুন।
প্র ০৩FreeRTOS ISR থেকে event group-এর বিট সরাসরি set না করে কাজটি timer daemon task-এ পাঠায়। একটি RTOS কেন ইচ্ছা করে নিজের কাজ দেরিতে করে, আর এতে নকশাকারের কী ভাবতে হয়?
FreeRTOS-Kernel-এর event_groups.h-এর মন্তব্য কারণটি সরাসরি বলে: kernel ISR-এ বা critical section-এ অনির্দিষ্ট দৈর্ঘ্যের (nondeterministic) কাজ করতে দেয় না। একটি বিট set করলে কয়টি task-এর শর্ত মিলবে, তা আগে থেকে জানা নেই: শূন্য হতে পারে, দশটিও হতে পারে, আর প্রতিটির জন্য অপেক্ষার তালিকা ঘাঁটতে হয়। এই কাজ ISR-এ করলে interrupt বন্ধ রাখার সময় অপেক্ষারত task-এর সংখ্যার ওপর নির্ভর করবে, আর পুরো system-এর সবচেয়ে খারাপ interrupt latency আর হিসাব করা যাবে না। Real-time-এর মূল প্রতিশ্রুতি, পর্ব ৫৪-এর ভাষায় সবচেয়ে খারাপ অবস্থার সীমা, তখন ভেঙে যায়।
তাই xEventGroupSetBitsFromISR একটি ছোট, নির্দিষ্ট দৈর্ঘ্যের কাজ করে: timer service task-এর command queue-তে একটি অনুরোধ রাখে। আসল set হয় সেই task-এর ভেতরে, যেখানে interrupt বন্ধ না রেখে scheduler-এর তালা দিয়ে কাজ হয়। এটি এই পর্বের অংশ ৩-এর deferred interrupt processing-এর নিয়মই, kernel নিজের ওপর প্রয়োগ করছে।
নকশাকারের জন্য এর তিনটি ফল। এক, ISR থেকে বিট set আর অপেক্ষারত task-এর জাগার মাঝে timer daemon task-এর চলা ঢুকে যায়; তার priority কম হলে দেরি বাড়ে। তাই daemon-এর priority (configTIMER_TASK_PRIORITY) বিবেচনায় রাখতে হয়। দুই, daemon-এর command queue ভরা থাকলে function ব্যর্থতা ফেরায়; header বলে, তখন pdFALSE. সেটি পরীক্ষা না করলে সংকেত নীরবে হারায়। তিন, alarm-এর মতো দ্রুত পথে ISR থেকে সরাসরি notification বা queue সাধারণত ভালো পছন্দ, কারণ তাদের প্রাপক একজন আর কাজ নির্দিষ্ট দৈর্ঘ্যের।
অন্য RTOS এই প্রশ্নের অন্য উত্তর দিতে পারে, যেমন ISR থেকে সরাসরি সীমিত কাজ করে। কোন RTOS কী করে, তা তার নিজের documentation থেকে দেখে নেওয়া দরকার; এক RTOS-এর নিয়ম আরেকটিতে ধরে নেওয়া AI-এর একটি পরিচিত ভুল।
মূল উপলব্ধি: একটি real-time kernel নিজের ISR-এর কাজকেও ছোট আর সীমিত রাখে, প্রয়োজনে একটি task-এ পিছিয়ে দিয়ে। কোন API ISR থেকে আসলে কখন কাজ করে, তা না জেনে latency-র হিসাব সম্পূর্ণ হয় না।
প্র ০৪Task notification-কে FreeRTOS নিজে দ্রুত আর হালকা বলে। তাহলে সবাই সব জায়গায় queue আর semaphore বাদ দিয়ে notification ব্যবহার করে না কেন?
Notification দ্রুত, কারণ এর কোনো মধ্যস্থ object নেই: পাঠানো মানে সরাসরি প্রাপক task-এর নিয়ন্ত্রণ-ব্লকে একটি ৩২ বিটের মান বদলানো আর দরকারে তাকে ready করা। FreeRTOS-এর ওয়েবসাইট বলে, এভাবে task জাগানো binary semaphore-এর চেয়ে ৪৫% পর্যন্ত দ্রুত আর কম RAM নেয়; তাদের পাদটীকা অনুযায়ী তুলনাটি V8.1.2-এর semaphore-এর সঙ্গে, GCC -O2-এ, আর পরের সংস্করণে semaphore নিজেও দ্রুত হয়েছে। FreeRTOS-এর ফোরামের পুরোনো আলোচনা অনুযায়ী notification এসেছিল প্রায় ২০১৫ সালের V8.2.0-তে, আর V10.4.0-তে প্রতি task-এ একটির বদলে notification-এর array হয়েছে (task.h).
কিন্তু হালকা হওয়ার দামই এর সীমা। এক, প্রাপক ঠিক একজন, আর পাঠানোর সময় তার handle জানা থাকতে হবে। “যে worker task খালি আছে সে নিক” এমন নকশা queue ছাড়া হয় না। দুই, একটিই ৩২ বিটের মান: পাঁচটি reading জমিয়ে রাখা যায় না, শুধু গোনা বা একটি মান (বা বিট, event group-এর হালকা রূপ). তিন, প্রেরক “জায়গা হওয়া পর্যন্ত” অপেক্ষা করতে পারে না, তাই backpressure নেই। চার, ISR প্রাপক হতে পারে না।
আরেকটি সূক্ষ্ম বিষয় বোঝার সহজতা। একটি queue-র নাম আছে (raw_q), এবং কোড পড়লে বোঝা যায় কে কোথায় পাঠায়। Notification-এ যোগাযোগটি লুকিয়ে থাকে task-এর handle-এর ভেতরে; একই index-এ দুটি ভিন্ন উৎস notify করলে একে অপরের মান মুছে দিতে পারে। এই কারণে অনেক দল notification রাখে নির্দিষ্ট, ভালোভাবে লেখা জায়গায়: ISR থেকে একটি driver task-কে জাগানো, যেখানে data আলাদা ring buffer-এ। এই পর্বের মডেলও দেখাল, তিনটি UART frame-এ notification গোনে কিন্তু data বহন করে না।
শেষে, কর্মক্ষমতার দাবি সবসময় নিজের পরিস্থিতিতে যাচাইযোগ্য। একটি ঠান্ডা ঘরের monitor-এ, যেখানে CPU ২.৫% ব্যস্ত, কয়েক মাইক্রোসেকেন্ড বাঁচানো কোনো পার্থক্য করে না; স্পষ্টতা সেখানে বেশি মূল্যবান।
মূল উপলব্ধি: Notification একটি বিশেষজ্ঞ যন্ত্র: এক প্রাপক, একটি মান, ISR থেকে task-কে দ্রুত জাগানোর জন্য দারুণ। ক্রমসহ data, একাধিক প্রাপক বা backpressure লাগলে queue-ই সঠিক, আর দ্রুততার দাবি নিজের chip-এ মেপে নিন।
প্র ০৫বড় queue কি সবসময় নিরাপদ? John Little-এর ১৯৬১ সালের সূত্র আর network-এর “bufferbloat” অভিজ্ঞতা firmware-এর queue-র আকার নিয়ে কী শেখায়?
John D. C. Little ১৯৬১ সালে স্থিতিশীল যেকোনো সারির একটি সাধারণ সূত্র প্রমাণ করেন: গড়ে সারিতে থাকা জিনিসের সংখ্যা = গড় আগমনের হার × গড়ে প্রতিটির অপেক্ষার সময়। উল্টো করে পড়লে: সারিতে যত বেশি জিনিস জমে, প্রতিটি তত বেশি অপেক্ষা করে। বড় queue বার্তা হারানো কমায়, কিন্তু যে বার্তা ঢোকে সে দেরিতে পৌঁছায়।
Internet-এর ইতিহাসে এর একটি পরিচিত রূপ “bufferbloat”, ২০১০-এর দশকের শুরুতে Jim Gettys সহ কয়েকজনের লেখায় জনপ্রিয় হওয়া নাম: router আর modem-এ অনেক বড় buffer থাকায় packet হারায় কম, কিন্তু ভিড়ের সময় সেকেন্ডের পর সেকেন্ড অপেক্ষায় থাকে, আর TCP-র ভিড় নিয়ন্ত্রণ দেরিতে সাড়া দেয়। সমাধান হিসেবে পরে সারির দৈর্ঘ্য নয়, অপেক্ষার সময় দেখে packet ফেলার পদ্ধতি এসেছে (যেমন CoDel). বিস্তারিত দাবিগুলো মূল লেখায় মিলিয়ে নেওয়া ভালো।
Firmware-এ একই শিক্ষা খাটে। Cold room-এর raw queue যদি ১০০ ঘরের হতো, network-এর বিভ্রাটে logic আটকে থাকলে sensor নির্বিঘ্নে পাঠাত, কিন্তু logic যখন ফিরত, তখন সে সবচেয়ে পুরোনো reading থেকে শুরু করত: কয়েক মিনিট আগের তাপমাত্রা দেখে alarm-এর সিদ্ধান্ত। এই পর্বের ছোট run-এই 13 s-এর reading 0.62 s দেরিতে পড়া হয়েছে। Alarm-এর জন্য পুরোনো তথ্য প্রায় অর্থহীন; সেখানে ছোট queue, আটকালে block time 0, আর ফেলা বার্তার counter বেশি সৎ নকশা। অন্যদিকে টেলিমেট্রির ইতিহাস (data logging) সংরক্ষণ করতে চাইলে প্রতিটি reading মূল্যবান; সেখানে বড় buffer, এমনকি flash-এ সারি, যুক্তিসংগত।
তাই আকার ঠিক করার প্রশ্ন দুটি: সবচেয়ে খারাপ অবস্থায় কতগুলো জমতে পারে (এই পর্বের R ÷ T), আর সবচেয়ে পুরোনো বার্তা কত দেরিতে পৌঁছালে তার মূল্য থাকে? দ্বিতীয়টি সীমা টানে ওপর থেকে। দুটির মাঝে না মিললে নকশা বদলাতে হয়: receiver-এর লম্বা কাজ ভাঙা, তার priority বাড়ানো, বা পুরোনো মান মুছে নতুনটি রাখা।
মূল উপলব্ধি: Queue হারানো আর দেরির মধ্যে বিনিময় করে। নিচের সীমা আসে সবচেয়ে খারাপ ব্যস্ততা থেকে, ওপরের সীমা আসে বার্তার মূল্য কতক্ষণ টেকে তা থেকে।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। Simulator আর হিসাবের উত্তর reference lab-এর RTOS simulator বা Python-এ চালিয়ে যাচাই করা; FreeRTOS-এর কোড উদাহরণ, চালানো হয়নি।
-
নকশা ও বাস্তবায়ন — logic থেকে telemetry, alarm-এর পথ না আটকে: FreeRTOS-এ logic task প্রতিটি alarm বদল আর প্রতি দশম reading-এ telemetry task-কে একটি
TelMsg(৮ byte) পাঠায়। একটিpost_tel()function লিখুন যা (ক) কখনো block করে না, (খ) queue ভরা থাকলে সবচেয়ে পুরোনো বার্তাটি ফেলে নতুনটি রাখে, (গ) ফেলা বার্তা গুনে রাখে। Queue-টি অন্য কেউ পড়ে না বলে ধরে নিন, শুধু telemetry task./* উদাহরণ, চালানো হয়নি — FreeRTOS API */ static QueueHandle_t tel_q; /* xQueueCreate(2, sizeof(TelMsg)) */ static uint32_t tel_drops; void post_tel(const TelMsg *m) /* শুধু logic task ডাকে */ { if (xQueueSend(tel_q, m, 0) == pdPASS) return; /* জায়গা ছিল */ TelMsg old; if (xQueueReceive(tel_q, &old, 0) == pdPASS) tel_drops++; /* সবচেয়ে পুরোনোটি ফেলা */ if (xQueueSend(tel_q, m, 0) != pdPASS) tel_drops++; /* তবু জায়গা নেই: নতুনটিও গোনা */ }তিনটি ডাকেই block time 0, তাই logic কখনো network-এর জন্য অপেক্ষা করে না: অংশ ৪-এর capacity 1-এর run-এ যে 0.62 s দেরি হয়েছিল, তা এখানে অসম্ভব। পুরোনোটি ফেলা হয় কারণ telemetry-তে নতুন অবস্থাই বেশি মূল্যবান। একটি সূক্ষ্মতা:
xQueueReceiveআর পরেরxQueueSend-এর মাঝে অন্য কোনো sender থাকলে ফাঁকা ঘরটি সে নিয়ে নিতে পারে; প্রশ্নে একজন sender ধরা আছে, তবু শেষ পাঠানোটির ফল পরীক্ষা করে গোনা হয়েছে। Alarm-এর বদলের বার্তা কখনো হারানো চলবে না এমন নীতি হলে, alarm-এর জন্য আলাদা এক ঘরের queue আরxQueueOverwriteদিয়ে “বর্তমান alarm অবস্থা” রাখা ভালো নকশা।tel_dropsনিয়মিত telemetry-তে পাঠান, যাতে dashboard-এ বোঝা যায় network কতটা খারাপ ছিল। -
ভুল খুঁজুন — একটি button ISR: একজন লিখেছেন:
অন্তত তিনটি ভুল দেখান আর ঠিক কোড লিখুন।void EXTI0_IRQHandler(void) { Event e; e.ms = now_ms(); xQueueSend(btn_q, &e, portMAX_DELAY); /* ১ */ EXTI->PR = 1u; /* ২ */ } /* NVIC_SetPriority(EXTI0_IRQn, 0); configMAX_SYSCALL_INTERRUPT_PRIORITY = 5 << 4 */ভুল ১: ISR-এ
xQueueSend.queue.hঅনুযায়ী এটি ISR থেকে ডাকা যাবে না; ISR block করতে পারে না, অথচ এখানেportMAX_DELAYদিয়ে চিরকাল অপেক্ষার কথা। ঠিক:xQueueSendFromISR, block time ছাড়া, আর ফল পরীক্ষা করে ব্যর্থ হলে counter বাড়ানো।ভুল ২:
portYIELD_FROM_ISRনেই। Button-এর task বেশি জরুরি হলেও সে চলবে পরের tick-এ বা পরের কোনো switch-এ, ISR-এর সঙ্গে সঙ্গে নয়।ভুল ৩: NVIC priority 0 মানে সবচেয়ে জরুরি, যা
configMAX_SYSCALL_INTERRUPT_PRIORITY-এর (5) চেয়েও জরুরি। ARM_CM3 port-এর মন্তব্য অনুযায়ী এমন interrupt কোনো FreeRTOS function ডাকতে পারে না; kernel-এর critical section-এর ভেতরে ঢুকে তালিকা নষ্ট করতে পারে। ঠিক: priority 5 বা তার চেয়ে বড় সংখ্যা (পর্ব ৩০).ছোট সমস্যা:
EXTI->PRমোছা শেষে; পর্ব ৪৩-এর নিয়মে উৎস আগে মোছা ভালো, যাতে মাঝের নতুন edge হারায় না। ঠিক রূপ:void EXTI0_IRQHandler(void) { BaseType_t woken = pdFALSE; EXTI->PR = 1u; /* আগে উৎস মোছা */ Event e = { .ms = now_ms() }; if (xQueueSendFromISR(btn_q, &e, &woken) != pdPASS) btn_drops++; portYIELD_FROM_ISR(woken); } /* NVIC_SetPriority(EXTI0_IRQn, 6); */ -
আগে বলুন — consumer বেশি জরুরি হলে: Preemptive fixed-priority scheduler, এক tick-এ এক task, বড় সংখ্যা বেশি জরুরি;
sendআরrecvশূন্য সময়ের, আর কেউ জাগলে scheduler সঙ্গে সঙ্গে আবার বাছে। Queueq-এর capacity 2.prod(priority 1): compute 1, send A, send B, compute 1, send C.cons(priority 2): recv, compute 2, recv, compute 2, recv, compute 1. দুজনই tick 0-এ আসে। (ক) Queue-তে কখনো একসাথে কয়টি item থাকবে? (খ) দুজনের Gantt আর শেষ হওয়ার সময় বলুন।(ক) একটিও জমে না: সর্বোচ্চ 0. Consumer বেশি জরুরি, তাই প্রতিবার সে আগে থেকেই
recv-এ অপেক্ষায়; প্রতিটি item সরাসরি তার হাতে যায় আর সে সঙ্গে সঙ্গে producer-কে থামায়। Capacity এখানে অপ্রাসঙ্গিক। (খ) Reference lab-এরrtos_sim.py run-এর সত্যিকারের ফল:0 prod prod released; cons released; cons blocks: q is empty 1 cons prod sends 'A' to q -> cons receives it; cons preempts prod 3 cons cons blocks: q is empty; prod sends 'B' to q -> cons receives it 5 prod cons blocks: q is empty 6 cons prod sends 'C' to q -> cons receives it; cons preempts prod 0123456789 cons B####B#... prod #----#-... prod released 0 start 0 finish 7 response 7 cons released 0 start 1 finish 7 response 7লক্ষ্য করুন tick 3: cons “A”-এর কাজ শেষ করে আবার
recv-এ block হয়; তখন prod-এর বাকি থাকাsend Bএকই tick-এ চলে, আর B সরাসরি cons-এর হাতে। Prod তাই tick 1 থেকে 4 শুধু অপেক্ষা করেছে (-). শিক্ষা: consumer বেশি জরুরি হলে queue কার্যত শূন্য থাকে আর producer-এর গতি consumer-এর গতিতে বাঁধা; producer বেশি জরুরি হলে (অংশ ২) queue ভরে ধাক্কা শোষে। -
হিসাব — UART frame-এর queue-র গভীরতা: একটি ISR প্রতি 5 ms-এ একটি frame (৮ byte) queue-তে পাঠায়। Frame-প্রক্রিয়াকারী task-এর সবচেয়ে লম্বা নিজের কাজ 23 ms, আর তার চেয়ে বেশি জরুরি একটি task আছে, C = 2 ms, T = 10 ms. (ক) প্রক্রিয়াকারীর ব্যস্ত সময় R কত? (খ) Phase অজানা ধরে queue-র গভীরতা কত, আর data-র জন্য কত byte? (গ) ISR-এর সময় হিসাবে ধরা হয়নি; বাস্তবে এর কী প্রভাব?
(ক) Response-time-এর ধাঁচে: R0 = 23; R1 = 23 + ⌈23/10⌉ × 2 = 23 + 3 × 2 = 29; R2 = 23 + ⌈29/10⌉ × 2 = 29, স্থির। R = 29 ms. (খ) গভীরতা ⌈29/5⌉ = ⌈5.8⌉ = 6টি frame; data-র জন্য 6 × 8 = 48 byte (kernel-এর queue-র নিজের হিসাবের জায়গা আলাদা). Python-এ একই iteration চালিয়ে মেলানো: 23 → 29 → 29, depth 6, 48 byte. (গ) প্রতিটি ISR-ও CPU নেয়, তাই R একটু বাড়ে আর গভীরতা কখনো ৭-এ উঠতে পারে; ISR-এর WCET জানা থাকলে তাকে আরেকটি “বেশি জরুরি task” হিসেবে সূত্রে যোগ করুন (Cisr, T = 5 ms). এছাড়া চলার সময় queue-র সর্বোচ্চ দৈর্ঘ্য মেপে রাখা আর ভরা হলে drop counter, যাতে মাঠে অনুমানটি যাচাই হয়।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমFreeRTOS-এ একটি UART receive interrupt থেকে একটি task-এ byte পৌঁছানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Byte এলে UART interrupt চায়, CPU ISR-এ ঢোকে
- ISR data register পড়ে byte নেয় আর interrupt-এর উৎস মোছে
- ISR
xQueueSendFromISRডাকে, block time ছাড়া - জাগা task বেশি জরুরি হলে ISR-এর শেষে
portYIELD_FROM_ISRswitch চায় - ISR থেকে ফেরার পরে PendSV-তে context switch হয়
- Task
xQueueReceiveথেকে ফিরে byte প্রক্রিয়া করে
একটি C firmware-এ sensor task একই local Reading r-এ বারবার নতুন মান লিখে প্রতিবার &r (ঠিকানা) একটি pointer-queue-তে পাঠায়। Logic task পরে তিনটি pointer পড়ে। সবচেয়ে সম্ভাব্য ফল কী?
- তিনটি আলাদা reading ঠিকঠাক পাওয়া যায়
- Compile-এ error হয়
- Queue ভরে গিয়ে sensor block হয়
- তিনটিতেই একই মান, সাধারণত শেষ লেখা reading
FreeRTOS-এ একটি ISR থেকে queue-তে item পাঠানোর ঠিক উপায় কোনটি?
- xQueueSendFromISR, তারপর portYIELD_FROM_ISR(woken)
- xQueueSend(q, &x, portMAX_DELAY)
- xQueueSend(q, &x, 0)
- একটি global variable-এ লিখে task-কে poll করতে দেওয়া
একটি task-এর receiver সবচেয়ে খারাপে 39 tick ব্যস্ত থাকে (অন্যদের বাধাসহ), আর producer প্রতি 10 tick-এ একটি item পাঠায়। Phase অজানা হলে queue-র ন্যূনতম নিরাপদ গভীরতা কত?
- 1
- 3
- 4
- 39
একটি telemetry task event group-এ WIFI_UP, MQTT_UP আর TEL_DUE তিনটি বিটের ALL-এর জন্য অপেক্ষা করে, xClearOnExit = pdTRUE দিয়ে। Wi-Fi আর MQTT সংযোগ চালু থাকলেও প্রথমবারের পরে আর telemetry যায় না। কারণ কী?
- ALL-এর বদলে ANY দরকার ছিল
- শর্ত মেলার পরে অবস্থার বিট দুটিও মুছে গেছে
- Event group-এ তিনটির বেশি বিট রাখা যায় না
- Telemetry task-এর priority কম বলে কখনো CPU পায় না
একটি ISR পরপর তিনবার vTaskNotifyGiveFromISR দিয়ে একই task-কে notify করে, আর task তখনো চলেনি। Task এরপর একবার ulTaskNotifyTake(pdTRUE, portMAX_DELAY) ডাকলে কী ফেরত পায়?
- 1, আর বাকি দুটি হারিয়ে যায়
- 0, আর task ঘুমিয়ে পড়ে
- 3, আর notification-এর মান 0 হয়ে যায়
- 3, আর notification-এর মান 2 থাকে
একটি ঠান্ডা ঘরের firmware-এ alarm-এর সিদ্ধান্ত নেয় logic task (বেশি জরুরি), আর সে প্রতিটি বার্তা telemetry task-কে একটি ১ ঘরের queue দিয়ে পাঠায়, portMAX_DELAY-এ। Network কয়েক সেকেন্ড বন্ধ থাকলে কী ঝুঁকি?
- শুধু telemetry দেরিতে যাবে, আর কিছু নয়
- Telemetry task logic-কে preempt করবে
- Queue-র পুরোনো বার্তা নষ্ট হয়ে যাবে
- Logic নিজেই আটকে যাবে, ফলে alarm-এর সিদ্ধান্ত দেরি হবে
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Queue = data + ক্রম + অপেক্ষা: মান কপি হয়ে FIFO-তে ঢোকে; ভরা হলে sender, খালি হলে receiver blocked, CPU খরচ ছাড়া। Block time নকশার সিদ্ধান্ত।
- ISR থেকে task: শুধু
…FromISR, কোনো অপেক্ষা নয়, শেষেportYIELD_FROM_ISR; interrupt-এর priority port-এর সীমার মধ্যে। - Pipeline-এ পথ আলাদা: জরুরি task কম জরুরি queue-তে চিরকাল অপেক্ষা করবে না; ভরা হলে ফেলা আর গোনা, বা overwrite.
- আকার: গভীরতা ≥ ⌈R ÷ T⌉, R = receiver-এর সবচেয়ে লম্বা ব্যস্ততা বাধাসহ; simulator-এ সব phase চালিয়ে response দেখুন, শুধু miss নয়।
- Event group আর notification: বিটে ALL বা ANY, অবস্থা আর ঘটনার বিট আলাদা; notification হালকা, কিন্তু এক প্রাপক আর data ছাড়া।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ৪৩ · Interrupt আর ISR নকশাআগের ভিত্তিDeferred work, ISR থেকে main-এ ring buffer আর হারানো জাগরণ।
- পর্ব ৫৬ · RTOS-এর task আর schedulingআগের ভিত্তিTask, priority, context switch আর response-time analysis.
- Operating Systems পর্ব ২৬ · ক্লাসিক সমস্যাপাশের ট্র্যাকProducer-consumer, readers-writers আর dining philosophers-এর তত্ত্ব।
- DSA পর্ব ১৪ · Queue আর dequeপাশের ট্র্যাকQueue-র data structure আর ring-এর মতো ঘোরা index.