এই পর্বে যা শিখবেন
- এক লেখক এক পাঠকের ring buffer, bit-field helper, shift-register debouncer আর hysteresis-সহ state machine ২০–৩০ মিনিটে লিখে test করা
- Integer-এ EMA আর Q15 গুণ, CRC-16/MODBUS-এর test vector, আর wrap-নিরাপদ cooperative scheduler লেখা
- volatile বনাম atomic, ISR-এর নিয়ম, integer promotion, alignment, endianness আর stack overflow-এর প্রশ্নে প্রমাণসহ উত্তর দেওয়া
- Priority inversion, mutex বনাম semaphore আর watchdog-এর জায়গা সংখ্যা দিয়ে ব্যাখ্যা করা
- একটি debugging-এর গল্প চার ধাপে বলা, আর battery-চালিত sensor node-এর নকশা power, radio, firmware আর security ধরে সাজানো
১ · এমবেডেড ইন্টারভিউর চার ধরনের প্রশ্ন আর উত্তরের ছক
রিকশা সারাইয়ের দোকানে নতুন মিস্ত্রি নেওয়ার আগে মালিক তিনটি জিনিস দেখেন: হাতে কাজ পারে কি না, কেন কাজটা এভাবে করছে বলতে পারে কি না, আর নষ্ট রিকশা পেলে কোথা থেকে খোঁজা শুরু করে। এমবেডেড বা firmware-এর ইন্টারভিউও এমন। প্রশ্ন সাধারণত চার রকম: জায়গায় বসে কোড (ring buffer, debouncer, CRC), খুঁটিনাটি (“এই কোড কী ছাপবে?”, “volatile কী করে না?”), debugging-এর গল্প (“কঠিনতম bug কোনটি?”) আর নকশা (“battery-তে চলা একটি sensor বানান”)। এই পাতা চার ধরনই অনুশীলন করায়, কোর্সের বাজারঘর-এর smart scale আর cold-storage monitor দিয়ে।
- Spec জিজ্ঞেস করুন: buffer-এর মাপ, ভরা হলে কী, কোন একক, কোন clock. প্রশ্নকর্তা প্রায়ই ইচ্ছা করে অস্পষ্ট রাখেন।
- কে কাকে বাধা দেয়: কোন অংশ ISR-এ, কোনটি main-এ, কে কোন variable লেখে। Firmware-এর বেশির ভাগ bug এখানে।
- কোড:
stdint.h-এর নির্দিষ্ট মাপের type, দরকারেvolatile, কোনোmallocনয়। - সীমার test: খালি, ভরা, wrap, ঋণাত্মক, শূন্য, সবচেয়ে বড় মান।
- খরচ: RAM আর flash-এর byte, প্রতি কাজে কয়টি নির্দেশ, interrupt কতক্ষণ বন্ধ।
- প্রমাণ: “চালিয়ে দেখেছি” বলতে পারা; এই পাতার প্রতিটি ব্লক সেই অভ্যাস।
ছবি ৮৫.১ — কোন অংশে কোন ধরনের প্রশ্ন, আর মূল পর্ব
নীল জায়গায় বসে কোড, বেগুনি খুঁটিনাটি, সবুজ debugging, কমলা নকশা
কোন tool কী দেয়: C-র ব্লক Wandbox-এ GCC দিয়ে চলে, অর্থাৎ একটি সাধারণ কম্পিউটারে (hosted C); Python-এর ব্লক আপনার ব্রাউজারে (Pyodide). Microcontroller-এর আচরণ দেখাতে একই C কোড কোর্সের reference lab-এর virtual “বাজারঘর board”-এ চালানো হয়েছে: এটি কোনো আসল পণ্য নয়, আসল Cortex-M chip-এর আদলে বানানো একটি Cortex-M3 emulator (BG-M3, 8 MHz, Clang 22.1.8 ziglang 0.17.1 থেকে, MIT আর Apache-2.0; Unicorn 2.1.4, binding BSD, engine GPLv2). এখানে hex লেখা হয় C-র রীতিতে (0x48). Board-এ এক নির্দেশ এক cycle ধরা হয়, তাই এর cycle-গণনা আসল chip-এর সময় নয় (Spec decision ১৭)।
8085 আর 8086-এর হাতের হিসাব পর্ব ৮১-এ (8085 আর 8086-এর সমস্যা অনুশীলন), MCQ পর্ব ৮২-এ, তুলনামূলক লিখিত আর ভাইভা প্রশ্ন পর্ব ৮৩-এ, আর timer, baud বা battery-র গাণিতিক সমস্যা পর্ব ৮৪-এ। এখানে সেগুলো আবার নেই।
২ · জায়গায় বসে ring buffer আর register helper
ঝালিয়ে নিন: পর্ব ৪৩ · ISR নকশা আর shared data, পর্ব ৪৯ · UART আর ring buffer, পর্ব ৩৫ · bit manipulation, তত্ত্বের দিক C প্রোগ্রামিং কোর্সের পর্ব ০৯.
“UART-এর ISR থেকে main-এ byte পাঠানোর জন্য একটি buffer লিখুন” প্রায় সব firmware ইন্টারভিউর প্রথম প্রশ্ন। উত্তরের হৃদয় একটি ring buffer, যেখানে এক লেখক আর এক পাঠক: ISR শুধু head লেখে, main শুধু tail. দুজনের কেউ অন্যের variable লেখে না, তাই কোনো critical section লাগে না। দুটি কৌশল লক্ষ করুন: index দুটি কখনো শূন্যে ফেরানো হয় না (৩২ বিটে আপনা থেকে ঘোরে), আর head - tail unsigned বিয়োগে সবসময় ভরা ঘরের সংখ্যা দেয়। নিচের test ইচ্ছা করে wrap-এর চার ধাপ আগে থেকে শুরু করে, কারণ এই ভুল সাধারণ test-এ ধরা পড়ে না। কোডটি reference lab-এর uart_hello.c-এর buffer-এর ছাঁচে।
#include <stdint.h>
#include <stdio.h>
#define RB_SIZE 8u /* 2-এর ঘাত: % হয় একটি AND */
typedef struct { volatile uint8_t buf[RB_SIZE]; volatile uint32_t head, tail; } rb_t;
static int rb_put(rb_t *r, uint8_t c) { /* শুধু producer (UART-এর ISR) ডাকে */
uint32_t h = r->head;
if (h - r->tail == RB_SIZE) return -1; /* ভরা: byte ফেলে দিন, গুনুন */
r->buf[h % RB_SIZE] = c; /* আগে data ... */
r->head = h + 1; /* ... তারপর head প্রকাশ */
return 0;
}
static int rb_get(rb_t *r) { /* শুধু consumer (main) ডাকে */
uint32_t t = r->tail;
if (t == r->head) return -1; /* খালি */
int c = r->buf[t % RB_SIZE];
r->tail = t + 1;
return c;
}
int main(void) {
rb_t r = { .head = 0xFFFFFFFCu, .tail = 0xFFFFFFFCu }; /* wrap-এর ৪ ধাপ আগে */
int drops = 0, c;
for (int i = 0; i < 10; i++) drops += rb_put(&r, (uint8_t)('A' + i)) < 0;
printf("head=0x%08X tail=0x%08X used=%u drops=%d\n",
(unsigned)r.head, (unsigned)r.tail, (unsigned)(r.head - r.tail), drops);
printf("got: "); while ((c = rb_get(&r)) >= 0) putchar(c);
int empty = (r.head == r.tail); /* আলাদা বাক্যে: argument-এর ক্রম unspecified */
printf("\nempty=%d, put after empty=%d\n", empty, rb_put(&r, 'Z'));
return 0;
}আসল আউটপুট (Wandbox-এর GCC):
head=0x00000004 tail=0xFFFFFFFC used=8 drops=2
got: ABCDEFGH
empty=1, put after empty=0
দশটি byte পাঠানো হলো, আটটি ঢুকল, শেষ দুটি (I, J) ফেলে দেওয়া হলো আর গোনা হলো। head ঘুরে 0x00000004, অথচ head - tail = 4 − 0xFFFFFFFC = 8 (232-এর হিসাবে), একদম ঠিক। পড়ার ক্রম ABCDEFGH, অর্থাৎ FIFO ভাঙেনি। একটি সত্যি ঘটনা: এই ব্লকের প্রথম খসড়ায় শেষ printf-এর ভেতরেই r.head == r.tail আর rb_put() ছিল। লেখকের যন্ত্রে Clang-এ এসেছিল empty=1, Wandbox-এর GCC-তে empty=0: function-এর argument কোন ক্রমে হিসাব হবে, C তা বলে না (unspecified), আর GCC আগে rb_put চালিয়েছিল। তাই এখন আলাদা বাক্য। একই কোড virtual board-এ Cortex-M3-এর জন্য compile করে চালালে একই ফল আসে (অংশ ৬-এর শেষে সেই run).
| কাজ | |
| head | |
| tail | |
| used | |
| buf |
- শুরু। দুটি index সমান, তাই খালি। 0xFFFFFFFC % 8 = 4, তাই প্রথম byte বসবে ঘর ৪-এ।
- প্রথম put. A গেল ঘর ৪-এ, তারপর head এক বাড়ল। আগে data, পরে head: head পরে বাড়ে বলে main কখনো অর্ধেক-লেখা ঘর দেখে না।
- Wrap. D-এর পরে head 0xFFFFFFFF থেকে ঘুরে 0x00000000. কিছুই আলাদা করে করতে হলো না, কারণ 232 হলো 8-এর গুণিতক।
- ভরা। E থেকে H গেল ঘর ০–৩-এ। head − tail = 8 = RB_SIZE: আর জায়গা নেই।
- ফেলে দেওয়া। I আর J ঢুকল না;
rb_put−1 দিল, ডাকা অংশ drops গুনল। নীরবে পুরোনো data মুছে ফেলা হয়নি। - প্রথম get. tail-এর ঘর ৪ থেকে A এল, তারপর tail এক বাড়ল; used ৭।
- খালি। বাকি সাতটি B…H. শেষে tail = head = 0x00000004: খালি, আর পরের put আবার সফল (0).
দ্বিতীয় প্রশ্ন প্রায়ই: “একটি register-এর একটি বিট বা একটি field নিরাপদে বদলানোর helper লিখুন।” Mask বানানো, পুরোনো field মোছা, নতুন মান সরিয়ে বসানো, আর বাড়তি বিট কেটে ফেলা: এই চারটি কাজ। নিচে GPIOA-র ODR-এর একটি কপিতে PA5 (LED) আর PA6 (alarm) বদলানো, আর STM32F1-এর GPIOx_CRL-এ pin 5-এর ৪ বিটের field (পর্ব ৪১-এর একই হিসাব)।
#include <stdint.h>
#include <stdio.h>
#define BIT(n) (1u << (n))
#define FMASK(w, s) ((((w) >= 32u) ? 0xFFFFFFFFu : ((1u << (w)) - 1u)) << (s))
static uint32_t fget(uint32_t r, unsigned w, unsigned s) { return (r & FMASK(w, s)) >> s; }
static uint32_t fset(uint32_t r, unsigned w, unsigned s, uint32_t v)
{
return (r & ~FMASK(w, s)) | ((v << s) & FMASK(w, s)); /* বাড়তি বিট কাটা */
}
static void show(const char *what, uint32_t r)
{
printf("%-22s 0x%08X ", what, (unsigned)r);
for (int b = 7; b >= 0; b--) putchar((r >> b) & 1u ? '1' : '0'); /* নিচের ৮ বিট */
putchar('\n');
}
int main(void) {
uint32_t odr = 0; /* GPIOA ODR-এর একটি কপি */
show("start", odr);
odr |= BIT(5); show("set PA5 (LED)", odr);
odr |= BIT(6); show("set PA6 (alarm)", odr);
odr &= ~BIT(5); show("clear PA5", odr);
odr ^= BIT(6) | BIT(0); show("toggle PA6 and PA0", odr);
uint32_t crl = 0x44444444u; /* STM32F1 GPIOx_CRL-এর reset মান */
crl = fset(crl, 4, 20, 0x2); /* pin 5: MODE=10, CNF=00 -> 0x2 */
printf("CRL = 0x%08X, pin5 field = 0x%X, pin4 field = 0x%X\n",
(unsigned)crl, (unsigned)fget(crl, 4, 20), (unsigned)fget(crl, 4, 16));
printf("fset with v=0x12 in 4 bits -> 0x%08X\n", (unsigned)fset(0, 4, 4, 0x12));
return 0;
}আসল আউটপুট (Wandbox-এর GCC):
start 0x00000000 00000000
set PA5 (LED) 0x00000020 00100000
set PA6 (alarm) 0x00000060 01100000
clear PA5 0x00000040 01000000
toggle PA6 and PA0 0x00000001 00000001
CRL = 0x44244444, pin5 field = 0x2, pin4 field = 0x4
fset with v=0x12 in 4 bits -> 0x00000020
প্রতিটি লাইনে শুধু লক্ষ্যের বিট বদলেছে। CRL-এর reset মান 0x44444444 থেকে pin 5-এর field 0x2 (MODE = 10, CNF = 00) হয়ে 0x44244444, পাশের pin 4-এর 0x4 অক্ষত। শেষ লাইনে ৪ বিটের field-এ 0x12 দেওয়া হয়েছিল; helper বাড়তি বিট কেটে শুধু 0x2 রাখল, তাই পাশের field নষ্ট হলো না। FMASK-এ ৩২ বিটের আলাদা শাখা আছে, কারণ C-তে 1u << 32 undefined behavior.
২.১(সহজ) একজন প্রার্থী RB_SIZE 8-এর বদলে 10 করলেন। সাধারণ test পাস করে, কিন্তু wrap-এর কাছে কী হবে?
232 দশের গুণিতক নয়, তাই index ঘোরার মুহূর্তে ঘরের ক্রম লাফ দেয়: 0xFFFFFFFC থেকে পরপর দশটি index-এর ঘর হয় 2, 3, 4, 5, 0, 1, 2, 3, 4, 5. দুটি জীবিত byte একই ঘরে পড়ে, পুরোনোটি মুছে যায়। লেখকের যন্ত্রে একই কোড Python-এ চালিয়ে A থেকে J পাঠালে ফেরত আসে GHIJEFGHIJ. সমাধান দুটি: মাপ ২-এর ঘাত রাখা (তখন % একটি AND-এ নামে, যা ছোট MCU-তে দ্রুতও), অথবা index-কে 0…N−1-এর মধ্যে রেখে “ভরা” আলাদা করে চেনা (একটি ঘর খালি রাখা বা একটি count).
২.২(মাঝারি) rb_put-এর দুই লাইন একজন এক লাইনে লিখলেন: r->buf[r->head++ % RB_SIZE] = c;. মাঝে মাঝে main একটি পুরোনো byte পড়ে। কেন?
এক লাইনে লিখলে C আর data-আগে-head-পরে ক্রমের নিশ্চয়তা দেয় না। পর্ব ৪৯-এ ঠিক এই ধাঁচের একটি TX buffer Clang 22.1.8 -O2-এ compile করা হয়েছিল: আগে head-এর str, পরে data-র strb. দুটির মাঝে interrupt এলে পাঠক নতুন head দেখে, কিন্তু ঘরে তখনো আগের পাকের পুরোনো byte. ঠিক রূপ উপরের কোডের মতো: head একটি local-এ পড়া, data লেখা, তারপর আলাদা বাক্যে head প্রকাশ; দুটি access-ই volatile, তাই compiler ক্রম বদলাতে পারে না। একক-core Cortex-M-এ এটুকুই সাধারণত যথেষ্ট; DMA বা একাধিক core-এর সঙ্গে ভাগ করলে memory barrier (__DMB()) লাগে।
২.৩(মাঝারি) এখন দুটি ISR (UART আর একটি timer, আলাদা priority) একই buffer-এ লেখে। উপরের কোড কি চলবে?
না। এক-লেখক নিয়ম ভাঙল: উঁচু priority-র ISR নিচুটির h পড়া আর head = h + 1-এর মাঝে ঢুকে একই ঘরে লিখতে পারে, তাই একটি byte হারায়, এটি একটি race condition. তিনটি উত্তর: (ক) প্রতিটি লেখকের নিজস্ব buffer, main দুটিই পড়ে, সবচেয়ে সরল; (খ) put-এর ভেতরে অল্প সময় interrupt বন্ধ (PRIMASK), কয়েকটি নির্দেশ মাত্র; (গ) Cortex-M3-এর LDREX/STREX দিয়ে head বাড়ানো, ব্যর্থ হলে আবার চেষ্টা। ইন্টারভিউতে আগে (ক) বলুন, তারপর বাকিগুলোর খরচ।
২.৪(মাঝারি) GPIOA->ODR |= BIT(5); main-এ, আর একটি ISR একই register-এ PA6 বসায়। Helper ঠিক হলেও কী ঝুঁকি, আর হার্ডওয়্যার কী সমাধান দেয়?
|= একটি read-modify-write: পড়া, OR, লেখা। মাঝে ISR এলে main পুরোনো ছবি লিখে ISR-এর বিট মুছে দেয়, অর্থাৎ lost update. পর্ব ৩৫-এর board run-এ ১০০টি alarm-বদলের ২৬টি এভাবে হারিয়েছিল। সমাধান BSRR: একটি store-এ নির্দিষ্ট বিট set বা reset, peripheral নিজে OR করে, তাই মাঝখানে ঢোকার জায়গাই নেই। BSRR না থাকলে ছোট critical section; STM32F103-এর মতো অনেক Cortex-M3 chip-এ bit-band alias আরেকটি পথ।
৩ · Debouncer আর state machine — board-এর ফলের সঙ্গে মিলিয়ে
ঝালিয়ে নিন: পর্ব ৪২ · debouncing, পর্ব ৫৫ · super loop আর state machine, গণনার তত্ত্ব কোর্সের পর্ব ২৪.
“একটি button debounce করুন” প্রশ্নে অনেকে delay_ms(20) লেখেন। ভালো উত্তর নমুনা নেয়: প্রতি 1 ms-এ পিন পড়ে একটি ৮ বিটের history-তে বাঁ দিকে ঢোকানো, আর history পুরো 0xFF হলে চাপ, পুরো 0x00 হলে ছাড়া। এটিই reference lab-এর button.c-এর debouncing, SysTick-এর ISR-এ চলে। নিচের মডেল একই script-এর ১৪টি ঘটনা (দুটি লাফানো চাপ আর একটি 0.2 ms-এর spike) একই নিয়মে চালায়, আর নমুনার সংখ্যা বদলে তুলনা করে।
# button.c-এর shift-register debounce, একই button.json script-এ (প্রতি 1 ms-এ এক নমুনা)
EVENTS = [(100.0, 1), (100.4, 0), (100.9, 1), (101.5, 0), (102.2, 1), (400.0, 0),
(400.3, 1), (400.8, 0), (550.0, 1), (550.2, 0), (700.0, 1), (700.5, 0),
(701.0, 1), (850.0, 0)] # (সময় ms, পিনের মান)
def level_at(t): # t সময়ে পিনের মান
v = 0
for when, lvl in EVENTS:
if when <= t: v = lvl
return v
def debounce(n_samples=8):
full = (1 << n_samples) - 1
history = stable = 0
presses = []
for tick in range(1, 1000): # SysTick: ms_ticks = 1, 2, …
history = ((history << 1) | level_at(tick)) & full
if not stable and history == full:
stable = 1; presses.append(tick) # চাপ গৃহীত
elif stable and history == 0:
stable = 0 # ছাড়া গৃহীত
return presses
edges = sum(1 for (a, x), (b, y) in zip([(0, 0)] + EVENTS, EVENTS) if x != y)
print("raw edges =", edges)
for n in (8, 2, 1):
print(f"{n} samples: presses accepted at t = {debounce(n)} ms")আসল আউটপুট (ব্রাউজারের Python):
raw edges = 14
8 samples: presses accepted at t = [110, 707] ms
2 samples: presses accepted at t = [101, 701] ms
1 samples: presses accepted at t = [100, 103, 550, 700] ms
৮ নমুনায় 110 আর 707 ms, board-এর সত্যিকারের run-এর সঙ্গে হুবহু: press 1 accepted at t=110 ms, press 2 accepted at t=707 ms, raw edges = 14, debounced presses = 2 (README-র expected output). এক নমুনায় চারটি “চাপ”: প্রথম চাপের লাফ দুবার গোনা, আর 550 ms-এর spike-ও চাপ। লক্ষ করুন 707: 700.5 ms-এর ছোট ছাড়াটি দুই নমুনার মাঝে পড়েছিল, তাই debouncer তা দেখেইনি।
| tick (ms) | |
| পিন | |
| history | |
| stable | |
| ফল |
- 100 ms. চাপের শুরু; নমুনা 1, history 0x01. একটি 1 যথেষ্ট নয়।
- 101 ms. 100.4-এ ছাড়া আর 100.9-এ আবার চাপ, কিন্তু 101.0-এর নমুনা দেখে শুধু 1.
- 102 ms. 101.5-এ contact সরে গেছে: নমুনা 0. History-তে একটি 0 ঢুকল; এখন আট ধাপ অপেক্ষা।
- 103 ms. 102.2-এ শেষ চাপ, এখন থেকে স্থির 1. পরপর আটটি 1-এর গোনা আসলে এখানে শুরু।
- 106 ms. চারটি 1 পরপর; বাঁ দিকে এখনো 102-এর 0 আছে।
- 109 ms. সাতটি 1; 102-এর 0 সবচেয়ে বাঁয়ের বিটে, এক ধাপ পরে বেরিয়ে যাবে।
- 110 ms. history = 0xFF, stable 0 থেকে 1: চাপ গৃহীত। Board-এর run-এ
GPIO PA5 LED ON110.0114 ms-এ।
দ্বিতীয় ক্লাসিক: “একটি state machine লিখুন।” বাজারঘরের cold room-এর নিয়ম README-তে বাঁধা: 8.00 °C-এর ওপরে HIGH, 0.00 °C-এর নিচে LOW, পরপর ৩টি পড়ায় alarm চালু, আর 0.50–7.50 °C-এর ভেতরে পরপর ৩টি পড়ায় বন্ধ (0.50 °C hysteresis). তাপমাত্রা sensor-এর এককে, 1/16 °C, তাই কোনো float নেই। নিচে coldroom.c-এর যুক্তি একটি বিশুদ্ধ function-এ, যাতে host-এই test করা যায়।
# cold room-এর alarm FSM (coldroom.c-এর নিয়ম): একক 1/16 °C, HIGH > 8.00, LOW < 0.00,
# পরপর ৩টি পড়ায় চালু, 0.50–7.50 °C-এর ভেতরে পরপর ৩টি পড়ায় বন্ধ
HIGH, LOW, HYST, CONFIRM = 8 * 16, 0, 8, 3
def step(s, t16): # s = (state, high_n, low_n, ok_n)
state, hi, lo, ok = s
hi = hi + 1 if t16 > HIGH else 0
lo = lo + 1 if t16 < LOW else 0
ok = ok + 1 if LOW + HYST <= t16 <= HIGH - HYST else 0
want = state
if hi >= CONFIRM: want = "HIGH"
elif lo >= CONFIRM: want = "LOW"
elif state != "OFF" and ok >= CONFIRM: want = "OFF"
return (want, hi, lo, ok)
def run(name, temps_c):
s = ("OFF", 0, 0, 0)
for t, c in enumerate(temps_c, 1):
new = step(s, round(c * 16))
if new[0] != s[0]: print(f" {name}: t={t} s {s[0]} -> {new[0]}")
s = new
print(f" {name}: শেষ অবস্থা {s[0]}")
# README-র script: প্রতি সেকেন্ডের পড়া, t = 1 … 20 s
readme = [4, 4, 5.5, 5.5, 8.25, 9, 9.5, 9.5, 7.75] + [7] * 5 + [-0.5] * 6
run("README", readme)
run("spike", [4, 9.5, 4, 9.5, 9.5, 4, 4]) # একক spike-এ alarm নয়
run("edge", [8.0, 8.0, 8.0, 8.0625, 8.0625, 8.0625]) # ঠিক 8.00 সীমার ভেতরেআসল আউটপুট (ব্রাউজারের Python):
README: t=7 s OFF -> HIGH
README: t=12 s HIGH -> OFF
README: t=17 s OFF -> LOW
README: শেষ অবস্থা LOW
spike: শেষ অবস্থা OFF
edge: t=6 s OFF -> HIGH
edge: শেষ অবস্থা HIGH
README-র script-এ তিনটি বদল 7, 12 আর 17 s-এ, board-এর run-এর ALARM ON: HIGH (7000 ms), ALARM OFF (12000 ms) আর ALARM ON: LOW (17000 ms)-এর সঙ্গে এক। দুটি বাড়তি test ইন্টারভিউতে নম্বর আনে: একক spike-এ alarm নেই, আর ঠিক 8.00 °C “ওপরে” নয়, তাই প্রথম তিনটি 8.00-তে কিছু হয় না; 8.0625 (এক ধাপ ওপরে) তিনবার পরে HIGH.
৩.১(সহজ) Shift-register আর counter debounce-এর পার্থক্য কী, আর ISR-এ delay_ms(20) কেন ভুল?
Counter-পদ্ধতি পিন 1 হলে গোনা বাড়ায় (সীমা পর্যন্ত), 0 হলে কমায়, সীমায় পৌঁছালে অবস্থা বদলায়; মাঝে মাঝে একটি উল্টো নমুনা সে সহ্য করে। Shift-register চায় শেষ N নমুনা সব সমান; একটি উল্টো নমুনা গোনা আবার শুরু করায় (উপরের 102 ms). দুটিই প্রতি নমুনায় কয়েকটি নির্দেশ, RAM এক byte. ISR-এ delay_ms(20) মানে ২০ ms ধরে সমান বা নিচু priority-র সব interrupt আটকে থাকা, আর delay যদি SysTick-এর গোনার ওপর নির্ভর করে আর ISR-টি সমান বা উঁচু priority-র হয়, তবে গোনা কখনো বাড়ে না: চিরকালের অপেক্ষা (পর্ব ৪২)।
৩.২(মাঝারি) README-র script-এ 9 s-এর পড়া 7.75 °C. এটি alarm বন্ধের গোনায় কেন আসেনি, আর hysteresis না থাকলে কী হতো?
7.75 °C সীমার ভেতরে (8.00-এর নিচে), তাই HIGH-এর গোনা শূন্যে ফেরে; কিন্তু 7.50-এর ওপরে, তাই “ঠিক আছে”-র গোনাও বাড়ে না। এটাই hysteresis-এর ফিতা: সীমার ঠিক নিচে ঘোরাঘুরি করা তাপমাত্রা alarm-কে বারবার চালু-বন্ধ করাতে পারে না। Hysteresis না থাকলে 8.00-এর আশেপাশে দুলতে থাকা ঘরে প্রতি কয়েক সেকেন্ডে ALARM ON আর OFF আসত, আর প্রতিটি বদলে MQTT বার্তা ও buzzer; দোকানদার কয়েক দিনে alarm-কে উপেক্ষা করা শিখতেন, যা আসল বিপদের দিনে সবচেয়ে খারাপ।
৩.৩(মাঝারি) Switch-case না table-driven FSM? আর একটি FSM “সম্পূর্ণ test করা” মানে কী?
Switch-case পড়তে সহজ, প্রতিটি transition-এ আলাদা কাজ রাখা যায়। Table-driven-এ (অবস্থা × ঘটনা → নতুন অবস্থা) সব জোড়া চোখের সামনে, table const হয়ে flash-এ থাকে, আর “কোন জোড়া ভুলে গেছি” একটি loop দিয়েই ধরা যায়। Test-এর ন্যূনতম মান: প্রতিটি অবস্থা × প্রতিটি ঘটনার জোড়া অন্তত একবার, প্রতিটি সীমার মান (ঠিক 8.00, এক ধাপ ওপরে), আর লম্বা এলোমেলো ক্রম। পর্ব ৫৫-এ ২৫টি জোড়ার এমন পূর্ণ পরীক্ষা আছে। এই কারণেই FSM-কে hardware ছাড়া একটি বিশুদ্ধ function বানানো হয়: host-এ মিলিসেকেন্ডে হাজার test (পর্ব ৬৪)।
৪ · Float ছাড়া filter আর CRC-16
“FPU নেই, ADC-র মানে একটি low-pass filter দিন।” সবচেয়ে ছোট উত্তর EMA: y ← y + (x − y) ÷ 8, আর ÷ 8 একটি shift. কিন্তু integer-এ সরাসরি লিখলে একটি লুকানো ভুল আছে। নিচে scale-এর ADC খালি অবস্থার 400 count থেকে 1400 g-এর 1380 count-এ লাফ দেয় (README-র load-cell মডেল); দুটি রূপ পাশাপাশি। শেষে Q15 গুণ, গোল করা আর saturation-সহ।
# EMA, α = 1/8, শুধু integer: scale-এর ADC 400 (খালি) থেকে 1380 (1400 g) লাফ
def ema_naive(y, x): # y += (x - y) / 8, shift দিয়ে
return y + ((x - y) >> 3)
def ema_scaled(acc, x): # acc রাখে 8 × y: ভগ্নাংশ হারায় না
return acc + x - (acc >> 3)
y, acc = 400, 400 << 3
for n in range(1, 81):
y, acc = ema_naive(y, 1380), ema_scaled(acc, 1380)
if n in (1, 8, 16, 40, 80):
print(f"n={n:2}: naive y={y:4} scaled y={acc >> 3:4}")
y, acc = 1380, 1380 << 3
for n in range(80): # এবার উল্টো দিকে: 1380 থেকে 400
y, acc = ema_naive(y, 400), ema_scaled(acc, 400)
print(f"নামার পরে: naive y={y} scaled y={acc >> 3}")
# Q15 গুণ: গোল করা আর saturation (Cortex-M3-এর SSAT-এর কাজ)
def q15_mul(a, b):
p = (a * b + (1 << 14)) >> 15 # অর্ধেক ধাপ যোগ, তারপর ১৫ বিট ডানে
return max(-32768, min(32767, p))
for a, b in ((0x4000, 0x4000), (0x6000, -0x2000), (-32768, -32768)):
r = q15_mul(a, b)
print(f"{a / 32768:+.4f} x {b / 32768:+.4f} = 0x{r & 0xFFFF:04X} = {r / 32768:+.6f}")আসল আউটপুট (ব্রাউজারের Python):
n= 1: naive y= 522 scaled y= 522
n= 8: naive y=1042 scaled y=1043
n=16: naive y=1261 scaled y=1264
n=40: naive y=1372 scaled y=1375
n=80: naive y=1373 scaled y=1380
নামার পরে: naive y=400 scaled y=400
+0.5000 x +0.5000 = 0x2000 = +0.250000
+0.7500 x -0.2500 = 0xE800 = -0.187500
-1.0000 x -1.0000 = 0x7FFF = +0.999969
সরল রূপ 1373-এ আটকে গেল, ৮০টি নমুনার পরেও: x − y আটের নিচে নামলেই (x − y) >> 3 = 0. ওজনে এটি প্রায় ১০ g-এর স্থায়ী ভুল। নামার দিকে সে 400-এ ঠিকই পৌঁছায়, কারণ ঋণাত্মক সংখ্যার arithmetic shift নিচের দিকে কাটে; ভুলটি তাই একমুখী, এক দিকে ঝোঁকা। Accumulator-এ 8 × y রাখলে ভগ্নাংশ হারায় না, আর দুই দিকেই ঠিক মানে পৌঁছায়। Q15-এ −1 × −1 = +1, যা Q15-এ ধরে না; saturation তাকে 0x7FFF-এ আটকে রাখে, wrap করলে হতো −1.
“Modbus বা যেকোনো serial frame-এর CRC লিখুন” প্রশ্নে spec-এর বিট-ধরা পদ্ধতিই যথেষ্ট, সঙ্গে প্রকাশিত test vector. নিচের C কোড CRC-16/MODBUS: শুরু 0xFFFF, LSB আগে, polynomial-এর উল্টো রূপ 0xA001.
#include <stdint.h>
#include <stdio.h>
#include <string.h>
static uint16_t crc16_modbus(const uint8_t *p, size_t n) {
uint16_t crc = 0xFFFFu; /* শুরু: সব 1 */
while (n--) {
crc ^= *p++; /* byte নিচের দিকে XOR */
for (int i = 0; i < 8; i++) /* LSB আগে: ডানে সরানো */
crc = (crc & 1u) ? (uint16_t)((crc >> 1) ^ 0xA001u) : (uint16_t)(crc >> 1);
}
return crc;
}
static void check(const char *name, const uint8_t *p, size_t n) {
printf("%-20s CRC = 0x%04X\n", name, crc16_modbus(p, n)); }
int main(void) {
const uint8_t spec[] = { 0x02, 0x07 };
uint8_t req[8] = { 0x01, 0x03, 0x00, 0x00, 0x00, 0x02 };
check("02 07", spec, 2);
check("\"123456789\"", (const uint8_t *)"123456789", 9);
uint16_t c = crc16_modbus(req, 6);
req[6] = (uint8_t)(c & 0xFF); req[7] = (uint8_t)(c >> 8); /* নিচের byte আগে */
printf("%-20s ", "on the wire");
for (int i = 0; i < 8; i++) printf("%02X ", req[i]);
putchar('\n');
check("frame + its CRC", req, 8);
req[3] ^= 0x01; /* পথে একটি বিট উল্টাল */
check("one bit flipped", req, 8);
return 0;
}আসল আউটপুট (Wandbox-এর GCC):
02 07 CRC = 0x1241
"123456789" CRC = 0x4B37
on the wire 01 03 00 00 00 02 C4 0B
frame + its CRC CRC = 0x0000
one bit flipped CRC = 0xC03D
প্রথম দুটি প্রকাশিত মান: Modbus spec-এর ছোট উদাহরণ (02 07 → 0x1241) আর CRC-16/MODBUS-এর বহুল ব্যবহৃত check মান (“123456789” → 0x4B37). তৃতীয় লাইন পর্ব ৫৩-এর অনুরোধটি, cold room-এর দুটি register পড়া: CRC 0x0BC4, তারে যায় নিচের byte আগে, C4 0B. CRC-সহ পুরো frame-এর CRC শূন্য, গ্রাহক এভাবেই যাচাই করে; একটি বিট উল্টালে আর শূন্য নয়। Virtual board-এ Cortex-M3-এর জন্য compile করা একই function-ও 0x4B37 আর 0x0BC4 দিয়েছে (অংশ ৬-এর run).
৪.১(মাঝারি) Q15-এ দুটি সংখ্যা গুণ করলে ফল কোন বিন্যাসে, আর কেন গোল করা আর saturation দুটিই লাগে?
দুটি Q15 (১৫টি ভগ্নাংশ-বিট)-এর গুণফল ৩২ বিটের Q2.30: ভগ্নাংশ-বিট যোগ হয়ে ৩০. Q15-এ ফেরাতে ১৫ বিট ডানে সরাতে হয়। শুধু সরালে সবসময় নিচের দিকে কাটা হয়, আর একটি filter-এ হাজার গুণে সেই ছোট ঝোঁক জমে; আগে অর্ধেক ধাপ (1 << 14) যোগ করলে নিকটতম মানে গোল হয়। Saturation লাগে একটি মাত্র ক্ষেত্রে, −1 × −1 = +1, কিন্তু সেটি ঘটলে wrap-এর ফল −1, অর্থাৎ চিহ্নই উল্টো; control loop-এ এটি বিপর্যয়। Cortex-M3-এ SSAT এক নির্দেশে এই আটকানো করে (পর্ব ৪০)।
৪.২(মাঝারি) বিট-ধরা CRC না ২৫৬ ঘরের table? আর CRC-এর বদলে সব byte যোগ করলে কী হারাবেন?
বিট-ধরা পদ্ধতি প্রতি byte-এ ৮ পাক, কোনো table নেই; table-পদ্ধতি প্রতি byte-এ একটি lookup আর XOR, কিন্তু ২৫৬ × ২ = ৫১২ byte flash খায়। মাঝামাঝি একটি পথ ১৬ ঘরের nibble-table (৩২ byte, প্রতি byte-এ দুটি lookup). 115200 baud-এ একটি byte আসে প্রতি 86.8 µs-এ, তাই অনেক MCU-তে বিট-ধরা রূপই সময়ে কুলিয়ে যায়; প্রথমে মেপে দেখুন। যোগফল checksum ক্রম-বদল ধরতে পারে না: 01 02 আর 02 01-এর যোগ এক; পর্ব ৪৯-এর XOR checksum-এর একই দুর্বলতা দেখানো আছে। Modbus-এর মাপের frame-এ CRC-16 সব এক-বিট আর দুই-বিটের ভুল, বিজোড় সংখ্যক বিটের যেকোনো ভুল, আর ১৬ বিট পর্যন্ত লম্বা যেকোনো burst error ধরে।
৪.৩(কঠিন) Scale-এর ADC-তে প্রতি 100 ms-এ একটি নমুনা। α = 1/8-এর EMA-র time constant কত, আর দোকানদারের কাছে এর মানে কী?
τ ≈ T × (1 − α) ÷ α = 100 ms × 7 = 700 ms (একই সূত্র পর্ব ৬৮-এ 10 ms-এ 70 ms দেয়)। উপরের run-এও দেখা যায়: ৮টি নমুনা (800 ms) পরে লাফের প্রায় ৬৫%, আর ৪০টি (৪ s) পরেও শেষ কয়েক count বাকি। দোকানদারের কাছে এর মানে, আলু রাখার পরে দাম স্থির হতে কয়েক সেকেন্ড। Reference firmware তাই ভিন্ন পথ নেয়: প্রতি মাপে ৪টি রূপান্তরের গড়, দেরি মাত্র এক মাপ। ইন্টারভিউর শিক্ষা: filter বাছাই নির্ভর করে noise আর দেরির আপসে; “কোন সাড়া-সময় চলবে?” জিজ্ঞেস করুন।
৫ · একটি ছোট scheduler — wrap-নিরাপদ সময়ের তুলনা
“RTOS ছাড়া তিনটি কাজ তিন রকম period-এ চালান।” উত্তর একটি task table আর একটি super loop: SysTick-এর ISR শুধু ms_ticks++ করে, main প্রতিটি task-এর পরের সময় এসেছে কি না দেখে। দুটি সূক্ষ্মতা ইন্টারভিউর আসল পরীক্ষা: তুলনাটি ৩২ বিটের counter ঘুরে গেলেও ঠিক থাকতে হবে, আর পরের সময় হিসাব হবে আগের নির্ধারিত সময় থেকে, এখনকার সময় থেকে নয়। নিচের মডেল বাজারঘরের তিনটি কাজ (scale 100 ms, cold room 1 s, telemetry 10 s) ২০ s চালায়, একবার counter শূন্য থেকে, একবার wrap-এর ঠিক আগে থেকে।
# Time-triggered cooperative scheduler: task table, 1 ms tick, ৩২ বিটের counter
M = 0xFFFFFFFF
TASKS = [("scale", 100), ("coldroom", 1000), ("telemetry", 10000)] # নাম, period ms
def due_naive(now, nxt): return now >= nxt # ভুল: wrap ভোলে
def due_safe(now, nxt): # (int32_t)(now - next) >= 0
return (now - nxt) & M < 0x80000000
def run(due, start, ms=20000):
nxt = [(start + p) & M for _, p in TASKS]
last = [0] * len(TASKS)
stat = [[0, ms, 0] for _ in TASKS] # runs, ছোট ফাঁক, বড় ফাঁক
for k in range(1, ms + 1):
now = (start + k) & M # SysTick ISR: ms_ticks++
for i, (name, p) in enumerate(TASKS): # main-এর super loop
if due(now, nxt[i]):
s, gap = stat[i], k - last[i]
s[0] += 1; s[1] = min(s[1], gap); s[2] = max(s[2], gap)
last[i] = k
nxt[i] = (nxt[i] + p) & M # now + p নয়: drift নেই
return " ".join(f"{n} {s[0]}× ফাঁক {s[1]}–{s[2]}" for (n, _), s in zip(TASKS, stat))
for start in (0, 0xFFFFF000): # দ্বিতীয়টি wrap-এর 4096 ms আগে
print(f"start=0x{start:08X}")
print(" naive:", run(due_naive, start))
print(" safe :", run(due_safe, start))
print(f"1 ms tick-এ ৩২ বিটের counter ঘোরে {2**32 / 1000 / 86400:.2f} দিনে")আসল আউটপুট (ব্রাউজারের Python):
start=0x00000000
naive: scale 200× ফাঁক 100–100 coldroom 20× ফাঁক 1000–1000 telemetry 2× ফাঁক 10000–10000
safe : scale 200× ফাঁক 100–100 coldroom 20× ফাঁক 1000–1000 telemetry 2× ফাঁক 10000–10000
start=0xFFFFF000
naive: scale 200× ফাঁক 1–9505 coldroom 99× ফাঁক 1–1000 telemetry 4095× ফাঁক 1–1
safe : scale 200× ফাঁক 100–100 coldroom 20× ফাঁক 1000–1000 telemetry 2× ফাঁক 10000–10000
1 ms tick-এ ৩২ বিটের counter ঘোরে 49.71 দিনে
শূন্য থেকে শুরু করলে দুটি তুলনা এক, তাই lab-এর ছোট test এই bug কখনো ধরে না। Wrap-এর কাছে সরল now >= next ভেঙে পড়ে: telemetry প্রতি ms-এ চলেছে ৪০৯৫ বার, scale-এর মোট সংখ্যা ঠিক থাকলেও কখনো ১ ms পরপর, কখনো ৯.৫ s কিছুই নয়। মাঠে এটি ঘটে চালু হওয়ার প্রায় ৫০ দিন পরে, যখন কেউ debugger নিয়ে বসে নেই। (int32_t)(now - next) >= 0 পার্থক্য দেখে, তাই ঘোরা নিয়ে মাথাব্যথা নেই, যতক্ষণ দুটি সময়ের ফাঁক 231 ms-এর কম।
৫.১(সহজ) next = now + period লিখলে কী ক্ষতি, যেখানে উপরের কোড লেখে next += period?
Main loop সবসময় একটু দেরিতে পৌঁছায় (অন্য task চলছিল)। now + period সেই দেরি পরের সময়ে যোগ করে দেয়, তাই প্রতিবার একটু সরে যায় (drift): ১০ s-এর telemetry প্রতিবার ৩ ms দেরিতে চললে এক দিনে প্রায় ২৬ s পিছিয়ে যায়, আর dashboard-এর সময়রেখা মেলে না। next += period নির্ধারিত সময়ের গ্রিডে থাকে; দেরি একবারের, জমে না। ব্যতিক্রম: যদি loop এত দেরি করে যে কয়েকটি পালা পার হয়ে গেছে, তবে next += period পরপর কয়েকবার চালাবে; সেটি চাই কি না (ঘাটতি পূরণ, না বাদ দেওয়া), task-ভেদে ঠিক করুন।
৫.২(মাঝারি) Super loop-এ cold room-এর alarm-এর worst-case সাড়া-সময় কীভাবে হিসাব করবেন, আর কখন RTOS-এ যাবেন?
ঘটনা ঠিক তখন এল যখন loop alarm-এর কাজ পেরিয়ে গেছে: অপেক্ষা = এক ঘোরায় বাকি সব কাজের সবচেয়ে খারাপ সময় যোগ alarm-এর নিজের সময়। তাই একটি লম্বা কাজ (ধরুন 300 ms-এর একটি blocking TLS handshake) সবার সাড়া ঠিক করে দেয়। প্রতিকার প্রথমে লম্বা কাজটিকে ছোট ছোট ধাপের state machine বানানো। RTOS-এ যাওয়ার যুক্তি তখন: আলাদা deadline-এর কাজ বেশি, কিছু কাজ সত্যিই blocking (network stack), আর priority দিয়ে জরুরি কাজকে আগে নেওয়া দরকার। দাম: প্রতি task-এর stack-এর RAM, আর mutex, inversion আর stack-মাপের নতুন ঝুঁকি (পর্ব ৫৯)।
৫.৩(কঠিন) তিনটি task, rate monotonic: T1 (C = 1, T = 4), T2 (C = 2, T = 6), T3 (C = 1, T = 8). Response-time analysis-এ প্রতিটির R কত?
U = 1/4 + 2/6 + 1/8 = 0.7083, Liu–Layland-এর তিন task-এর সীমা 0.7798-এর নিচে, তাই যথেষ্ট শর্তেই schedulable; তবু RTA সঠিক সংখ্যা দেয়। R1 = 1. R2: শুরু 2, তারপর 2 + ⌈2/4⌉ × 1 = 3, আবার 2 + ⌈3/4⌉ × 1 = 3, স্থির: R2 = 3 ≤ 6. R3: শুরু 1, তারপর 1 + ⌈1/4⌉ × 1 + ⌈1/6⌉ × 2 = 4, আবার 1 + 1 + 2 = 4: R3 = 4 ≤ 8. Reference lab-এর rtos_sim.py analyze examples/rtos/rm.json-এর সত্যিকারের run-ও বলে R(T1) = 1, R(T2) = 3, R(T3) = 4, আর ২৪ tick-এর hyperperiod-এর simulation একই সবচেয়ে খারাপ সাড়া দেয়।
৬ · C-র খুঁটিনাটি — অনুমান নয়, চালিয়ে দেখা
ঝালিয়ে নিন: পর্ব ৩৪ · volatile আর optimization-এর ফাঁদ, পর্ব ০৫ · endianness, পর্ব ৩৯ · stack-এর আকার, তত্ত্বের দিক C প্রোগ্রামিং কোর্সের পর্ব ৫৪.
“এই কোড কী ছাপবে?” প্রশ্নের নিয়ম: আগে বলুন কোন নিয়ম কাজ করছে, তারপর মান। Integer promotion-এ int-এর চেয়ে ছোট type হিসাবের আগে int হয়ে যায়; usual arithmetic conversions-এ signed আর unsigned মিশলে signed-টি unsigned হয়ে যায়। Struct-এ প্রতিটি সদস্য নিজের মাপের সীমায় বসে, মাঝে padding. নিচের ব্লকে GCC ইচ্ছা করে দুটি warning দেয়; সেগুলোও উত্তরের অংশ।
#include <stdint.h>
#include <stdio.h>
#include <string.h>
struct mixed { uint8_t a; uint32_t b; uint8_t c; uint16_t d; }; /* ঘোষণার ক্রম */
struct sorted { uint32_t b; uint16_t d; uint8_t a; uint8_t c; }; /* বড় থেকে ছোট */
struct __attribute__((packed)) packed { uint8_t a; uint32_t b; uint8_t c; uint16_t d; };
int main(void)
{
uint8_t a = 200, b = 100, x = 0x0F;
uint8_t sum8 = a + b; /* int-এ 300, রাখার সময় কাটা */
printf("a + b = %d, stored in uint8_t = %u\n", a + b, sum8);
printf("~x == 0xF0 ? %s (~x = %d)\n", (~x == 0xF0) ? "yes" : "no", ~x);
printf("(uint8_t)~x == 0xF0 ? %s\n", ((uint8_t)~x == 0xF0) ? "yes" : "no");
printf("-1 < 1u ? %s\n", (-1 < 1u) ? "yes" : "no");
uint16_t u = 0xFFFF;
printf("u + 1 = %d (uint16_t promoted to int)\n", u + 1);
printf("sizeof mixed=%zu sorted=%zu packed=%zu\n",
sizeof(struct mixed), sizeof(struct sorted), sizeof(struct packed));
uint32_t w = 0x12345678u; uint8_t m[4];
memcpy(m, &w, 4); /* মেমরিতে byte-এর ক্রম */
printf("0x12345678 in memory: %02X %02X %02X %02X\n", m[0], m[1], m[2], m[3]);
uint8_t be[4] = { 0x12, 0x34, 0x56, 0x78 }; /* তারে আসা big-endian */
uint32_t v = (uint32_t)be[0] << 24 | (uint32_t)be[1] << 16 | (uint32_t)be[2] << 8 | be[3];
printf("portable decode = 0x%08X\n", (unsigned)v);
return 0;
}আসল আউটপুট (Wandbox-এর GCC):
a + b = 300, stored in uint8_t = 44
~x == 0xF0 ? no (~x = -16)
(uint8_t)~x == 0xF0 ? yes
-1 < 1u ? no
u + 1 = 65536 (uint16_t promoted to int)
sizeof mixed=12 sorted=8 packed=8
0x12345678 in memory: 78 56 34 12
portable decode = 0x12345678
GCC-র দুটি warning, দুটিই -Wsign-compare: “comparison of promoted bitwise complement of an unsigned value with constant” (~x == 0xF0) আর “comparison of integer expressions of different signedness: 'int' and 'unsigned int'” (-1 < 1u). Compiler নিজেই ফাঁদ দুটি দেখিয়ে দিচ্ছে, তাই firmware-এ warning চালু রেখে শূন্য warning-এ build করুন। a + b int-এ 300, uint8_t-এ রাখলে 300 − 256 = 44. ~x-এ x আগে int হয়, তাই 0xFFFFFFF0 = −16, কখনো 0xF0 নয়; cast করে ৮ বিটে কাটলে তবেই মেলে। -1 < 1u-তে −1 হয়ে যায় 0xFFFFFFFF, তাই “না”। 0xFFFF + 1 = 65536, কারণ uint16_t-ও int হয়ে যোগ হয়। Struct-এর মাপ সদস্যের ক্রমে ১২ থেকে ৮; packed-ও ৮, কিন্তু অন্য দামে (৬.৩)। শেষ দুটি লাইন: মেমরিতে ছোট byte আগে (little-endian), আর shift দিয়ে তারের big-endian পড়া যেকোনো CPU-তে একই ফল দেয়।
এগুলো কি শুধু PC-র আচরণ? একই খুঁটিনাটি, ring buffer আর CRC একটি firmware-এ (iv.c) রেখে Cortex-M3-এর জন্য Clang দিয়ে build করে virtual board-এ চালানো হলো। সত্যিকারের run, লেখকের lab-এ (বাজারঘর board BG-M3, Clang 22.1.8 / ziglang 0.17.1, Unicorn 2.1.4):
$ python -B board.py run build/iv.elf
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0894 ms] UART: ring: head=0x00000004 used=8 drops=2 got=ABCDEFGH
[ 0.1245 ms] UART: crc: 123456789=0x4B37 request=0x0BC4
[ 0.1934 ms] UART: promotion: a+b=300 uint8_t=44 ~x=-16 (~x==0xF0)=0
[ 0.2499 ms] UART: sizeof: mixed=12 sorted=8 packed=8 int=4
[ 0.2848 ms] UART: bytes of 0x12345678: 78 56 34 12
[ 0.2855 ms] exit(0) after 2284 cycles
প্রতিটি মান hosted GCC-র সঙ্গে এক, কারণ Cortex-M3-এও int ৩২ বিট আর byte-ক্রম little-endian. কিন্তু এটি সৌভাগ্য, নিয়ম নয়: AVR-এ int ১৬ বিট, তাই সেখানে u + 1-এর মতো হিসাব অন্য ফল দিতে পারে, আর struct-এর মাপও আলাদা। Host-এ test পাস করলে target-এ একবার চালানো তাই বাধ্যতামূলক (পর্ব ৬৪)।
৬.১(সহজ) “ISR আর main দুজনেই একটি counter বাড়ায়; counter volatile. এটি কি নিরাপদ?”
না। volatile বলে “প্রতিটি পড়া-লেখা সত্যিই ঘটবে, register-এ জমিয়ে রাখা চলবে না”; সে বলে না “মাঝে কেউ ঢুকবে না”। counter++ Cortex-M-এ তিনটি নির্দেশ: LDR, ADD, STR. পর্ব ৩৪-এর board run-এ main ১,০০,০০০ বার আর SysTick ৩৪৪০ বার বাড়িয়েছিল; শুধু volatile দিয়ে ২২৮৪টি যোগ হারায়, প্রায় দুই-তৃতীয়াংশ ISR-এর কাজ। cpsid i/cpsie i দিয়ে ঘিরে দিলে শূন্য। এক লাইনে: volatile দৃশ্যমানতার জন্য, atomicity-র জন্য critical section, LDREX/STREX, বা C11-এর _Atomic.
৬.২(সহজ) একটি ভালো ISR-এর পাঁচটি নিয়ম বলুন।
(১) ছোট আর দ্রুত: flag বসানো, byte buffer-এ রাখা, বাকি কাজ main বা task-এ। (২) কোনো অপেক্ষা নয়: delay, blocking UART, mutex নেওয়া নয়; RTOS-এ শুধু “FromISR” রূপের function. (৩) printf আর malloc নয়: ধীর, আর ভেতরে ভাগ করা অবস্থা থাকে বলে reentrant নয়। (৪) Pending বিট ঠিক জায়গায় মোছা (যেমন EXTI->PR = 1), নইলে একই interrupt আবার আসে। (৫) Main-এর সঙ্গে ভাগ করা data volatile, আর বহু-নির্দেশের হালনাগাদ atomic. বোনাস: কোন ISR কোন priority-তে, আর সবচেয়ে লম্বা interrupt-বন্ধ সময় কত, লিখে রাখা (পর্ব ৪৩)।
৬.৩(মাঝারি) Packed struct-এ মাপ কমে ৮ byte. তবু অনেক firmware দল একে এড়ায়। Cortex-M3 আর Cortex-M0-তে ঝুঁকি কী?
Packed struct-এ b (uint32_t) বসে offset 1-এ, অর্থাৎ alignment ভাঙা। ARMv7-M (Cortex-M3/M4)-এ সাধারণ LDR/STR আর halfword access ভাঙা ঠিকানাতেও চলে (ধীরে, আর CCR-এর UNALIGN_TRP চালু না থাকলে), কিন্তু LDM/STM/LDRD সবসময় fault দেয়। ARMv6-M (Cortex-M0)-এ যেকোনো ভাঙা access fault. Compiler packed সদস্য সরাসরি পড়লে নিরাপদ কোড বানায়, কিন্তু কেউ &p.b একটি সাধারণ uint32_t *-এ নিলে সেই জ্ঞান হারায়। নিরাপদ পথ: সদস্য বড় থেকে ছোট সাজানো (উপরের sorted, padding ছাড়াই ৮), আর তারের format byte ধরে পড়া, struct-এ memcpy নয়।
৬.৪(মাঝারি) “Stack overflow কীভাবে ধরবেন?” — চারটি উপায়, খরচসহ।
(১) Static: compiler-এর -fstack-usage থেকে প্রতিটি function-এর frame, call graph-এর সবচেয়ে গভীর পথ, প্রতিটি preemption স্তরে ৮ word (৩২ byte) interrupt frame. Recursion বা function pointer থাকলে হিসাব অসম্পূর্ণ। (২) Painting: শুরুতে stack-এ একটি জানা নকশা (যেমন 0xDEADBEEF) লিখে, চালানোর পরে কতটা ছোঁয়া হয়নি গোনা; সস্তা, কিন্তু ঘটনার পরে জানায়। (৩) Guard: stack-এর নিচে একটি canary word নিয়মিত পরীক্ষা, বা MPU-র একটি নিষিদ্ধ region, যাতে ছোঁয়ামাত্র fault. (৪) ARMv8-M-এ hardware stack-limit register (MSPLIM/PSPLIM). পর্ব ৩৯-এ painting আর হিসাব board-এ মেলানো আছে।
৭ · RTOS আর watchdog — সংখ্যা দিয়ে উত্তর
ঝালিয়ে নিন: পর্ব ৫৭ · semaphore, mutex আর priority inversion, পর্ব ৫৮ · queue আর ISR থেকে বার্তা, পর্ব ৬১ · watchdog আর fault handling, তত্ত্বের দিক Operating Systems কোর্সের পর্ব ২২.
“Priority inversion কী?” প্রশ্নে সংজ্ঞার চেয়ে একটি ছোট টাইমলাইন বেশি জোরালো। Reference lab-এর RTOS simulator-এর ক্লাসিক উদাহরণ: L (priority 1) tick 0-এ mutex S নেয়, H (3) tick 2-এ আসে আর S চায়, M (2) tick 4-এ আসে, S-এর ধার না ধেরেই ৬ tick চলে। সত্যিকারের run, rtos_sim.py demo inversion, বাঁয়ে inheritance ছাড়া, ডানে --inherit দিয়ে (# চলছে, - প্রস্তুত, B আটকে):
0123456789012345 0123456789012345
H ..#BBBBBBBB##... H ..#BB##.........
M ....######...... M ....---######...
L ##-#------#--#.. L ##-##--------#..
H finish 13, response 11 H finish 7, response 5
বাঁয়ে H-এর সঙ্গে S-এর কোনো সম্পর্কহীন M পুরো ৬ tick H-এর আগে চলেছে, কারণ M, L-এর চেয়ে জরুরি, আর H আটকে আছে L-এর তালায়। Priority inheritance-এ L অপেক্ষা শুরুর মুহূর্তেই H-এর priority পায়, তালা ছাড়ে, আর H-এর সাড়া ১১ থেকে ৫ tick. M-এর সাড়া ৬ থেকে ৯-এ বাড়ল: inheritance কারও খরচ ছাড়া আসে না, শুধু খরচটা ঠিক জায়গায় সরায়।
৭.১(সহজ) Mutex আর binary semaphore-এর পার্থক্য কী, আর কোনটি ISR থেকে দেওয়া যায়?
Mutex-এর একজন মালিক আছে: যে নিল, শুধু সে-ই ছাড়ে। মালিক জানা বলেই RTOS priority inheritance দিতে পারে, আর ভুল task-এর ছাড়া ধরতে পারে। Semaphore একটি গোনা বা সংকেত, মালিক নেই: এক task (বা ISR) give করে, অন্য task take করে। তাই “byte এসেছে, এবার কাজের পালা” বলার জন্য ISR থেকে semaphore give (FromISR রূপে) স্বাভাবিক; mutex ISR-এ কখনো নয়, কারণ ISR অপেক্ষা করতে পারে না আর inheritance-এর জন্য কোনো task-মালিকও নেই। সংক্ষেপে: mutex ভাগ করা জিনিস পাহারা দেয়, semaphore ঘটনা জানায়।
৭.২(মাঝারি) Watchdog-এর kick কোথায় বসাবেন? SysTick-এর ISR-এ বসানোর প্রস্তাবে কী বলবেন?
ISR-এ অন্ধ kick ভুল: main বা কোনো task আটকে থাকলেও SysTick চলতে থাকে, তাই watchdog কখনো কিছু ধরে না। পর্ব ৬১-এর board run-এ ঠিক এটি দেখা গেছে: 3 s-এ sensor-এর অপেক্ষায় firmware আটকে গেল, আর ISR-এ kick আর main loop-এর প্রতি পাসে kick, দুই রূপেই 7 s পর্যন্ত watchdog চুপ। Task check-in রূপে প্রতিটি জরুরি কাজ নিজের বিট বসায়, আর একটি supervisor সব বিট পেলেই kick দেয়: একই আটকে যাওয়ায় 3.5 s-এ “SENSOR missing, no kick”, 4.3 s-এ watchdog reset, আর পরের boot-এ কারণ পড়ে fail-safe alarm.
৭.৩(মাঝারি) UART-এর ISR থেকে একটি RTOS task-এ পুরো লাইন পাঠাতে চান। কোন পথ, আর queue কত গভীর?
ISR byte-গুলো অংশ ২-এর মতো ring buffer-এ রাখে, আর লাইনের শেষ (\n) পেলে task-কে একটি notification বা semaphore দেয় (FromISR রূপ, প্রয়োজনে ফেরার আগে context switch চাওয়া)। Queue ব্যবহার করলে প্রতি বার্তায় কপি হয়, তাই ছোট বার্তা বা pointer-এর জন্য ভালো; pointer পাঠালে buffer-এর মালিকানার নিয়ম লাগে। গভীরতা: পাঠকের সবচেয়ে লম্বা ব্যস্ততা (বাধাসহ) ÷ বার্তার ন্যূনতম ব্যবধান, ওপরে গোল করে, আর ভরা হলে কী হবে (ফেলে দেওয়া আর গোনা, না পুরোনো মোছা) আগে থেকে ঠিক করা (পর্ব ৫৮)।
৮ · Debugging-এর চারটি গল্প — কোর্সের সত্যিকারের run থেকে
“আপনার সবচেয়ে কঠিন bug-এর কথা বলুন” প্রশ্নে প্রশ্নকর্তা পদ্ধতি শুনতে চান: লক্ষণ, কীভাবে আবার ঘটালেন, কোন প্রমাণে কারণ ধরলেন, কী ঠিক করলেন আর কীভাবে আবার ঘটা ঠেকালেন। নিচের চারটি গল্প কোর্সের পর্বগুলোর সত্যিকারের board run; নিজের করে বলতে চাইলে আগে পর্বের run আর তার প্রমাণ নিজে খুঁটিয়ে বুঝে নিন, তারপর বলুন। প্রতিটির কাঠামো এক: লক্ষণ → আবার ঘটানো → প্রমাণ → সমাধান → পাহারা।
| গল্প | লক্ষণ | প্রমাণ | সমাধান |
|---|---|---|---|
| হারানো alarm (পর্ব ৩৫) | Alarm 2.0097 ms-এ চালু, ৮ cycle পরে নিজে নিজে বন্ধ | Log: main orr-এর পরে থামল, ISR ODR = 0x60 লিখল, main পুরোনো 0x20 লিখল; ১০০-তে ২৬টি হারানো | BSRR বা critical section |
| HardFault (পর্ব ৬১) | প্রতি boot-এ reset | Stacked PC = 0x08000250 (load_calibration+0x4), R0 = 0x60000000 | Log, ৩ বারে safe mode, pointer ঠিক করা |
| চুপ sensor (পর্ব ৫১) | তাপমাত্রা আসছে না, alarm-ও বাজছে না | ঠিকানা 0x49-এ প্রতি সেকেন্ডে sensor NACK | ৩টি NACK-এ “SENSOR FAULT” alarm |
| ভুল অক্ষর (পর্ব ৪৯) | কখনো ভুল byte, error flag ছাড়াই | 8 MHz-এ 460800 baud-এর ভুল +2.12%; মডেলে +6%-এ 0x54 হয় 0xD4 | Clock বা baud বদলানো, দুই প্রান্তের ভুল হিসাব |
একটি গল্প নিজে আবার চালানো হলো, reference lab-এর hardfault.c, যেখানে একটি নষ্ট pointer (0x60000000, যেখানে board-এ কোনো মেমরি নেই) পড়তেই fault, আর handler stacked frame থেকে register ছাপে। সত্যিকারের run (একই versions):
$ python -B board.py run build/hardfault.elf
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0380 ms] UART: reading through a bad pointer 0x60000000 ...
[ 0.0386 ms] HardFault: Invalid memory read (UC_ERR_READ_UNMAPPED) at PC=0x08000154 read_sensor+0x4
[ 0.1085 ms] UART: HardFault! stacked PC=0x08000154 LR=0x0800013D R0=0x60000000
[ 0.1094 ms] exit(3) after 875 cycles
HardFault: … লাইনটি emulator নিজে ছাপে, বাকিটা firmware. Firmware-এর নিজের ছাপা stacked PC emulator-এর দেখা PC-র সঙ্গে হুবহু এক (0x08000154): HardFault-এর সময় hardware আট word-এর frame-এ R0–R3, R12, LR, PC আর xPSR রাখে, আর frame[6] হলো দোষী নির্দেশ। LR 0x0800013D-এর শেষ বিট 1 মানে Thumb; ফেরার ঠিকানা 0x0800013C, অর্থাৎ যে function read_sensor ডেকেছিল তার ডাকের ঠিক পরের নির্দেশ. R0 নিজেই নষ্ট ঠিকানা, তাই কারণ এক লাইনে। আসল Cortex-M3-এ এর সঙ্গে CFSR আর HFSR পড়লে fault-এর ধরনও জানা যায়; board-এ ওই register নেই (Spec decision ১৯)।
৮.১(মাঝারি) হারানো alarm-এর গল্পটি দুই মিনিটে বলুন, প্রশ্নকর্তা কোথায় থামিয়ে প্রশ্ন করতে পারেন ভেবে।
“Cold room-এর firmware-এ main loop LED-এর বিট বসাত ODR |= LED দিয়ে, আর 2 ms-এর SysTick ISR alarm-এর বিট। Log-এ alarm চালু হয়ে ৮ cycle পরে নিজে নিজে বন্ধ দেখাচ্ছিল। প্রথমে ISR-এর যুক্তি সন্দেহ করেছিলাম, কিন্তু ISR-এর নিজের হিসাবে প্রতি পাকে সে যা লিখেছিল তা পরের পাকে পাওয়া যাচ্ছিল না: ১০০টির ২৬টি। Exception-এ ঢোকার মুহূর্তে main-এর PC আর ODR-এ প্রতিটি লেখা log করে দেখলাম, main orr আর str-এর মাঝে থেমেছিল আর ফিরে এসে পুরোনো ছবি লিখেছে। BSRR-এ বদলে হারানো শূন্য, আর এই log-টি regression test বানিয়েছি।” সম্ভাব্য প্রশ্ন: “২৬% কেন, ৫০% নয়?” উত্তর: loop-এর ছয় নির্দেশের দুটি ফাঁক বিপজ্জনক, প্রায় এক-তৃতীয়াংশ (পর্ব ৩৫)।
৮.২(মাঝারি) চুপ sensor-এর গল্পে আসল শিক্ষা কী, আর আরও খারাপ কোন ভুল এখানে লুকিয়ে থাকতে পারত?
শিক্ষা: মাপতে না পারাও একটি alarm-এর অবস্থা। Reference firmware NACK পেলে শুধু ছাপে আর আবার চেষ্টা করে, তাই sensor হারালে ঘর 9.50 °C হলেও alarm বাজত না, কারণ গোনা চলে শুধু সফল পড়ায়। পর্ব ৫১-এ পরপর তিনটি NACK-এ PA6 আর “SENSOR FAULT” যোগ করে 3 s-এর মধ্যে খবর। আরও খারাপ ভুল: NACK না দেখে DATA পড়া। Board NACK-এ 0xFFFF দেয়, যা ১২ বিটের two's complement-এ −1, অর্থাৎ −0.0625 °C, একটি পুরো বিশ্বাসযোগ্য তাপমাত্রা: ভুল চোখেই পড়ে না। নিয়ম: প্রতিটি bus-কাজের ফেরত-মান দেখা, আর অপেক্ষার loop-এ timeout.
৮.৩(কঠিন) Baud-এর গল্পে প্রেরক 6% দ্রুত হলে ভুল byte আসে কিন্তু কোনো error flag ওঠে না, আর 6% ধীর হলে framing error ওঠে। কেন এই অসমতা?
গ্রাহক start-এর ধারে মিলিয়ে নিজের তালে প্রতিটি বিটের মাঝখানে নমুনা নেয়; শেষ নমুনা (stop) ৯.৫ বিট পরে। প্রেরক দ্রুত হলে frame আগে শেষ হয়, আর stop-এর নমুনা পড়ে frame-এর পরের idle লাইনে, যা 1: stop ঠিক দেখায়, তাই কোনো flag নেই, অথচ D7-এর নমুনা stop-এর 1-এ পড়ায় 0x54 হলো 0xD4. প্রেরক ধীর হলে stop-এর নমুনা পড়ে D7-এর 0-তে: framing error. পর্ব ৪৯-এর মডেল এই দুটিই দেখায়। আদর্শ সীমা ±0.5 ÷ 9.5 ≈ 5.26%, বাস্তবে দুই প্রান্তের মোট ভুল এর অনেক কম রাখতে হয়; নীরব ভুল ধরতে উপরের স্তরে CRC লাগে।
৯ · “একটি device নকশা করুন” — battery-চালিত cold-room sensor
ঝালিয়ে নিন: পর্ব ৬০ · low-power, পর্ব ৬২ · power budget, পর্ব ৭২ · LoRaWAN, পর্ব ৭৬ · IoT security, পর্ব ৭৭ · secure boot আর OTA, পর্ব ৮০ · ক্যাপস্টোন.
প্রশ্ন: “বাজারঘর একটি দূরের গুদামে ঠান্ডা ঘর বসাবে, যেখানে বিদ্যুতের লাইন অনিশ্চিত। তিনটি AA cell-এ চলা একটি তাপমাত্রা-sensor node নকশা করুন।” এখানে কোনো একক সঠিক উত্তর নেই; প্রশ্নকর্তা দেখেন আপনি কোন প্রশ্ন আগে করেন আর সংখ্যা দিয়ে সিদ্ধান্ত নেন কি না। প্রথম প্রশ্নগুলো: alarm কত দ্রুত পৌঁছাতে হবে? Battery বদলানো কত দিন পরপর চলবে? গুদাম থেকে internet কত দূরে? নিচের মডেল দুটি radio আর তিনটি পাঠানোর period তুলনা করে, পর্ব ৬২ আর ৭২-এর budget-এর একই মান দিয়ে (radio-র current দুটিই সেখানে স্পষ্ট লেবেল দেওয়া ধরা মান)।
# বাজারঘরের battery-চালিত cold-room node: কোন radio, কত ঘন ঘন পাঠানো?
# সব মান পর্ব ৬২ আর ৭২-এর budget থেকে (radio-র current দুটিই "ধরা" মান)
C_USE = 1234.8 # mAh: 3টি AA, derating-এর পরে (পর্ব ৬২)
OPTIONS = { # (ঘুমের মেঝে µA, প্রতি বার্তায় charge mA·s)
"Wi-Fi burst": (39.7, 120.0), # 120 mA × 1 s, MCU Stop + sensor + LDO + Wi-Fi ঘুম
"LoRa SF7": (31.7, 4.491), # TX + দুটি RX জানালা (পর্ব ৭২)
}
def life(floor_ua, q_mas, period_s):
avg_ua = floor_ua + q_mas * 1000 / period_s # µA
return avg_ua, C_USE / (avg_ua / 1000) / 24 # গড়, দিন
for radio, (floor, q) in OPTIONS.items():
for period in (10, 60, 300):
avg, days = life(floor, q, period)
print(f"{radio:11} প্রতি {period:3} s: গড় {avg:8.1f} uA -> {days:7.1f} দিন")
# radio বন্ধ থাকলেও মেঝে থেকেই সর্বোচ্চ আয়ু
for radio, (floor, _) in OPTIONS.items():
print(f"{radio:11} শুধু মেঝে: {C_USE / (floor / 1000) / 24:7.1f} দিন")আসল আউটপুট (ব্রাউজারের Python):
Wi-Fi burst প্রতি 10 s: গড় 12039.7 uA -> 4.3 দিন
Wi-Fi burst প্রতি 60 s: গড় 2039.7 uA -> 25.2 দিন
Wi-Fi burst প্রতি 300 s: গড় 439.7 uA -> 117.0 দিন
LoRa SF7 প্রতি 10 s: গড় 480.8 uA -> 107.0 দিন
LoRa SF7 প্রতি 60 s: গড় 106.5 uA -> 482.9 দিন
LoRa SF7 প্রতি 300 s: গড় 46.7 uA -> 1102.4 দিন
Wi-Fi burst শুধু মেঝে: 1296.0 দিন
LoRa SF7 শুধু মেঝে: 1623.0 দিন
প্রথম সারি পর্ব ৬২-এর হিসাবের সঙ্গে মেলে (12.04 mA, প্রায় ৪.২৭ দিন), আর LoRa-র 107.0 ও 1102.4 দিন পর্ব ৭২-এর। শিক্ষা তিনটি। এক, radio-ই খরচের প্রায় সবটা: README-র মতো প্রতি 10 s-এ Wi-Fi-তে পাঠালে battery এক সপ্তাহও টেকে না। দুই, period বাড়ানো radio বদলানোর মতোই শক্তিশালী হাতল। তিন, মেঝে একটি ছাদ: radio পুরো বন্ধ রাখলেও ১৬২৩ দিনের বেশি নয়, তাই sleep current-এর প্রতিটি µA গোনা দরকার। এগুলো মডেল; সিদ্ধান্তের আগে আসল module-এর current মাপতে হবে।
৯.১(কঠিন) পুরো নকশাটি পাঁচ মিনিটে বলুন: hardware, radio, firmware-এর গঠন, alarm-এর latency আর security.
Hardware: Stop mode-এ কয়েক µA-এর একটি Cortex-M MCU, I2C-র TMP102-ধাঁচের sensor (0x48), কম Iq-এর regulator, তিনটি AA. Radio: গুদাম দূরে আর battery-র আয়ু বছরে চাই, তাই LoRaWAN Class A, SF7 যতক্ষণ link চলে। Firmware: RTOS ছাড়া super loop আর অংশ ৩-এর FSM: RTC প্রতি 1 s-এ জাগায়, এক পড়া, FSM-এর এক ধাপ, আবার Stop. Latency: README-র নিয়মে alarm ৩টি পড়ায়, অর্থাৎ প্রায় ৩ s-এ সিদ্ধান্ত; সাধারণ telemetry প্রতি 300 s, কিন্তু alarm-এর বদল সঙ্গে সঙ্গে uplink (1% duty-র নিয়মে SF7-এ ন্যূনতম ব্যবধান প্রায় 5.15 s, পর্ব ৭২)। Security: প্রতি device-এ আলাদা key, LoRaWAN-এর AES-এ এনক্রিপশন আর message integrity, signed firmware আর anti-rollback, debug port বন্ধ, আর watchdog check-in-সহ। শেষে বলুন কী মাপবেন: TX burst আর sleep current.
৯.২(মাঝারি) প্রশ্নকর্তা বললেন, “গুদামে Wi-Fi আছে, LoRa gateway বসানো যাবে না।” নকশায় কী বদলাবেন?
Radio-র খরচ এখন প্রতি বার্তায় ২৭ গুণের মতো বেশি (পর্ব ৭২-এর তুলনা), তাই পাঠানো কমাতে হবে: পড়া প্রতি 1 s চলবে, কিন্তু telemetry একত্র করে (batching) প্রতি 300 s-এ, আর শুধু alarm-এর বদলে সঙ্গে সঙ্গে। মডেলে 300 s-এ ১১৭ দিন, অর্থাৎ বছরে প্রায় তিনবার battery বদল; প্রস্তাব দিন বড় cell, বা লাইনে চলা gateway-তে BLE (পর্ব ৭১)। Wi-Fi-তে TLS-এর handshake নিজেই দামি, তাই প্রতিবার নতুন সংযোগ না করে session resumption বা কম ঘন সংযোগ। আর alarm-এর পথ আলাদা পরীক্ষা করুন: Wi-Fi না পেলে স্থানীয় buzzer (PA6) বাজবেই।
৯.৩(মাঝারি) “এই node-এর security-র ন্যূনতম তালিকা দিন।” প্রতিটির পেছনে একটি করে ঝুঁকি বলুন।
(১) প্রতি device-এ আলাদা credential, firmware-এ লেখা একটি সাধারণ password নয়: একটি device খুললেই সব device-এর চাবি ফাঁস। (২) পরিবহনে এনক্রিপশন আর integrity (TLS বা LoRaWAN-এর session key): নইলে MQTT-এর CONNECT-এ password খোলা চোখে যায়। (৩) Signed update আর secure boot: নইলে যে কেউ নিজের firmware বসাতে পারে। (৪) Anti-rollback: পুরোনো, দুর্বল কিন্তু বৈধ version-এ ফেরানো ঠেকাতে। (৫) Debug port আর readout protection: ঠান্ডা ঘরের দেয়ালে ঝোলানো যন্ত্র হাতে খোলা যায়। (৬) Rate limit আর যুক্তিসঙ্গত পরিসর: 200 °C-এর বার্তা server-এ বাতিল (পর্ব ৭৬, সাইবার নিরাপত্তা কোর্সের পর্ব ৩৫)।
১০ · ব্যাখ্যার প্রশ্ন, সাত দিনের প্রস্তুতি আর কোর্সের সমাপ্তি
কোডের পরে প্রায়ই আসে ব্যাখ্যার অংশ: firmware না জানা একজন সহকর্মীকে আপনি একটি সমস্যা কীভাবে বোঝাবেন। ভালো উত্তর ছোট, একটি উপমা দেয়, প্রমাণ দেয়, আর শেষে পরের কাজ বলে।
১০.১(মাঝারি) Cloud দলের একজন সহকর্মী জিজ্ঞেস করলেন, “Dashboard-এ মাঝে মাঝে একই তাপমাত্রা দুবার আসে কেন?” চার বাক্যে বোঝান।
“আমরা MQTT-তে QoS 1-এ পাঠাই, যার প্রতিশ্রুতি ‘অন্তত একবার’, ঠিক একবার নয়: broker-এর PUBACK পথে হারালে device একই বার্তা আবার পাঠায়। ডাকঘরের রেজিস্ট্রি চিঠির প্রাপ্তিস্বীকার না এলে আবার পাঠানোর মতো। প্রতিটি বার্তায় একটি seq আছে ({"dev":"coldroom-1","seq":1,…}), তাই দুবার এলে আপনার দিকে dev আর seq দেখে দ্বিতীয়টি বাদ দিন। QoS 2 ঠিক একবার দেয়, কিন্তু চারটি packet-এ, যা battery-তে দামি; তাই এই আপস।” পরিভাষা কম, উপমা আছে, প্রমাণ (পর্ব ৭৩-এর packet log) আছে, পরের কাজ আছে।
১০.২(সহজ) “এমন একটি সময়ের কথা বলুন, যখন আপনি একটি কঠিন সমস্যা সমাধান করেছেন।” পেশাদার অভিজ্ঞতা না থাকলে কী বলবেন?
সত্যি ঘটনা বলুন, ছোট হলেও; বানানো গল্প পরের প্রশ্নেই ধরা পড়ে। কাঠামো: পরিস্থিতি, আপনার কাজ, সংখ্যায় ফল, শিক্ষা। এই কোর্সের lab যথেষ্ট উপাদান দেয়: “আমার scheduler সব test পাস করছিল, কিন্তু counter wrap-এর কাছ থেকে চালিয়ে দেখি telemetry প্রতি ms-এ চলছে। তুলনাটি পার্থক্যে বদলে ঠিক করলাম, আর wrap-এর আগে থেকে শুরু হওয়া test স্থায়ী রাখলাম।” এই পাতার যেকোনো ব্লক এমন গল্পের বীজ, যদি আপনি নিজে সেটি বদলে, ভেঙে, আবার ঠিক করে দেখেন।
ইন্টারভিউর আগের সাত দিন
| দিন | কাজ | কোথায় |
|---|---|---|
| ১ | না দেখে ring buffer আর bit-field helper, ঘড়ি ধরে ২০ মিনিট; wrap থেকে test | অংশ ২, পর্ব ৪৩ |
| ২ | Debouncer আর cold room-এর FSM; সীমার মানসহ test | অংশ ৩, পর্ব ৪২, ৫৫ |
| ৩ | Integer EMA, Q15 গুণ, CRC-16 আর তার test vector | অংশ ৪, পর্ব ৪০, ৫৩ |
| ৪ | Wrap-নিরাপদ scheduler; RTA হাতে একটি উদাহরণ | অংশ ৫, পর্ব ৫৬ |
| ৫ | C-র খুঁটিনাটি নিজে চালিয়ে এক বাক্যে নিয়মসহ ব্যাখ্যা; ISR-এর পাঁচ নিয়ম | অংশ ৬, পর্ব ৩৪ |
| ৬ | Inversion, watchdog আর দুটি debugging-এর গল্প জোরে বলা | অংশ ৭–৮ |
| ৭ | একটি device-এর নকশা খাতায়, সংখ্যাসহ; নতুন বিষয় নয়, বিশ্রাম | অংশ ৯–১০ |
আপনি মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT কোর্সের ৮৫টি পর্ব পেরিয়ে এসেছেন: 8085-এর register, flag আর T-state থেকে 8086-এর segment আর interrupt vector, memory আর peripheral-এর interfacing; তারপর Cortex-M-এর NVIC, startup code আর embedded C; GPIO, timer, ADC, UART, I2C আর CAN; RTOS, low-power আর watchdog; sensor, PID, IoT protocol আর security; আর শেষে বাজারঘরের দুটি device, firmware থেকে cloud পর্যন্ত। সবচেয়ে বড় অর্জন একটি অভ্যাস: hardware নিয়ে কোনো দাবির আগে প্রশ্ন করা, “কোন chip, কোন clock, কোন datasheet-এর কোন টেবিল?”, আর ছোট একটি program চালিয়ে উত্তর মেলানো।
এরপর কী করবেন
- আবার ঝালিয়ে নিন: যে প্রশ্নে আটকেছেন, কোর্স হোম থেকে সেই মডিউলে ফিরে যান; পুরো পথের মানচিত্র পর্ব ০১-এ। মডিউল ১৪-এর অন্য পাতা: পর্ব ৮১ · 8085 আর 8086-এর সমস্যা, পর্ব ৮২ · MCQ প্রশ্নব্যাংক, পর্ব ৮৩ · লিখিত ও ভাইভা, পর্ব ৮৪ · এমবেডেড নকশার গাণিতিক সমস্যা।
- পাশের ইন্টারভিউ পাতা: DSA কোর্সের পর্ব ৭১ · কোডিং ইন্টারভিউর সমস্যা আর প্রোগ্রামিং ভাষা ও কম্পাইলার কোর্সের পর্ব ৮৬ · ইন্টারভিউ আর প্রতিযোগিতা.
- নিজের প্রকল্প: পর্ব ৮০-এর ক্যাপস্টোন-এ একটি stretch goal শেষ করুন, প্রতিটি ধাপে test সহ; একটি আসল board পেলে একই firmware-এর current নিজে মাপুন। এটিই আপনার পোর্টফোলিওর সবচেয়ে বিশ্বাসযোগ্য গল্প।
এই পাতা কোনো চাকরি বা পরীক্ষার ফলের নিশ্চয়তা দেয় না। আপনার হাতে যা আছে, তা হলো ছোট firmware নিজে লিখে, চালিয়ে আর ভেঙে দেখার দক্ষতা, chip আর datasheet ধরে কথা বলার অভ্যাস, আর না-জানা জায়গায় সৎভাবে “datasheet না দেখে বলব না” বলার সাহস।
আরও গভীরে: CRC-এর ধারণা W. Wesley Peterson ১৯৬১ সালে প্রকাশ করেন, আর shift register দিয়ে তা হিসাব করার কৌশল তখন থেকেই hardware-এর অংশ; অংশ ৪-এর loop সেই shift register-এর software রূপ। Rate monotonic-এর সীমা Liu আর Layland-এর ১৯৭৩ সালের প্রবন্ধ থেকে। আর priority inversion-এর সবচেয়ে উদ্ধৃত ঘটনা ১৯৯৭ সালের Mars Pathfinder: উঁচু priority-র একটি task একটি ভাগ করা তালার অপেক্ষায় deadline হারাত, আর প্রহরী system reset করত; পৃথিবী থেকে configuration বদলে priority inheritance চালু করে সমাধান হয়েছিল বলে প্রকাশিত বিবরণে জানা যায় (পর্ব ৫৭)।
পরীক্ষা ও ইন্টারভিউতে: “Ring buffer-এ ভরা আর খালি কীভাবে আলাদা করবেন?” — free-running index-এ head − tail, নইলে একটি ঘর খালি রাখা বা count. “volatile কি atomic?” — না; দৃশ্যমানতা দেয়, অবিভাজ্যতা নয়। “Packed struct-এর ঝুঁকি?” — ভাঙা alignment; Cortex-M0-তে fault, M3-এ LDRD/LDM-এ fault. “৩২ বিটের ms counter কখন ঘোরে?” — প্রায় ৪৯.৭১ দিনে; পার্থক্যে তুলনা করুন। “HardFault-এ প্রথম কী দেখবেন?” — stacked PC আর LR, তারপর CFSR আর HFSR.
AI-এর যুগে — নকল ইন্টারভিউ আর AI-এর firmware যাচাই
AI সহকারী একটি ভালো অনুশীলনের সঙ্গী, যদি তাকে প্রশ্নকর্তা বানান আর তার উত্তর যাচাই করেন। এই বিষয়ে তার চেনা ভুল: 8085 আর 8086 (বা Z80)-এর নির্দেশ আর flag মিশিয়ে ফেলা, ভুল T-state বা cycle-গণনা, একটি নির্দিষ্ট microcontroller-এর জন্য বানানো register-এর নাম আর ঠিকানা, ISR-এ volatile ভুলে যাওয়া বা non-atomic read-modify-write, I2C বা SPI-এর mode আর baud-এর অঙ্কে ভুল, ISR-এর ভেতরে blocking function, RTOS API-র ভুল ব্যবহার (ISR থেকে সাধারণ queue-send), আর অনিরাপদ IoT ডিফল্ট: firmware-এ লেখা credential, TLS ছাড়া সংযোগ, signature-হীন update. যাচাইয়ের পথ এই পাতাতেই: simulator বা emulator-এ চালানো, datasheet আর reference manual মেলানো, timing হাতে হিসাব, compiler-এর আসল output পড়া, আর hardware-এর আগে host-এ test.
নকল ইন্টারভিউর একটি কাঠামো; কোনো আসল প্রতিষ্ঠানের প্রশ্ন বা ব্যক্তিগত তথ্য দেবেন না:
AI-এর firmware বা উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
নিজেকে যাচাই করুন
প্রতিটি প্রশ্নে আগে খাতায় ভাবুন, তারপর উত্তর বাছুন। সব তথ্য প্রশ্নের ভেতরেই আছে।
ক্রমমাঠ থেকে আসা একটি firmware bug (“alarm মাঝে মাঝে নিজে বন্ধ হয়”) খোঁজার কাজ ঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- লক্ষণ লিখে রাখা: কখন, কত ঘন ঘন, কোন version
- Lab-এ বা simulator-এ আবার ঘটানো
- সবচেয়ে ছোট উদাহরণে নামানো
- Log বা trace দিয়ে কারণের প্রমাণ জোগাড়
- সমাধান করে আবার চালানো
- সেই ছোট উদাহরণকে স্থায়ী regression test বানানো
(সহজ) একটি ring buffer-এ uint32_t head আর tail কখনো শূন্যে ফেরানো হয় না, মাপ 8. head = 0x00000003, tail = 0xFFFFFFFE. Buffer-এ কয়টি byte আছে?
- −4,294,967,291 (ভুল অবস্থা)
- ৫
- ৩
- ৮ (ভরা)
(সহজ) Cortex-M-এ main আর একটি ISR দুজনেই volatile uint32_t count-এ count++ করে। কোনটি সত্য?
- volatile থাকায় কোনো যোগ হারায় না
- যোগ হারায়, কিন্তু খুব কদাচিৎ, তাই উপেক্ষা করা যায়
- যোগ হারাতে পারে; main-এর হালনাগাদ atomic করতে হবে
- ৩২ বিটের CPU-তে ++ সবসময় এক নির্দেশ
(মাঝারি) Shift-register debouncer প্রতি 1 ms-এ নমুনা নেয় আর পরপর ৮টি 1-এ চাপ মানে। পিন 102.2 ms থেকে স্থির 1, তার আগে 102.0 ms-এর নমুনা ছিল 0. চাপ কোন tick-এ গৃহীত হবে?
- 110 ms
- 109 ms
- 103 ms
- 112 ms
(মাঝারি) uint8_t x = 0x0F; তারপর if (~x == 0xF0). ৩২ বিটের int-এর একটি C compiler-এ শর্তটি কী?
- সত্য, কারণ ~0x0F = 0xF0
- Compile error
- Undefined behavior
- মিথ্যা, কারণ ~x = −16
(মাঝারি) RTOS-এ L (priority 1) একটি mutex ধরে আছে, H (3) সেটির অপেক্ষায়, আর M (2) ৬ tick-এর কাজ নিয়ে আসে, mutex ছোঁয় না। Inheritance থাকলে কী বদলায়?
- M কখনো চলে না
- L সাময়িক H-এর priority পায়, H-এর সাড়া কমে, M-এর বাড়ে
- H-এর priority নেমে 2 হয়
- Deadlock অসম্ভব হয়ে যায়
(মাঝারি) একটি firmware SysTick-এর ISR-এ প্রতি 1 s-এ watchdog kick দেয়। Main loop একটি I2C অপেক্ষায় চিরকাল আটকে গেল। কী হবে?
- Watchdog reset দেবে timeout-এর পরে
- HardFault হবে
- কিছুই হবে না; যন্ত্র আটকে থাকবে, watchdog চুপ
- SysTick-ও থেমে যাবে, তাই reset
(কঠিন) তিনটি AA-তে চলা একটি node-এর ঘুমের মেঝে 31.7 µA, ব্যবহারযোগ্য ক্ষমতা 1234.8 mAh, আর প্রতি LoRa বার্তায় 4.491 mA·s. প্রতি 300 s-এ একটি বার্তা দিলে আয়ু প্রায় কত?
- প্রায় ১১০২ দিন
- প্রায় ১০৭ দিন
- প্রায় ১৬২৩ দিন
- প্রায় ৪ ঘণ্টা
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব শব্দ এখানে একসাথে:
মনে রাখুন
- আগে spec আর কে-কাকে-বাধা-দেয়: কোন অংশ ISR-এ, কে কোন variable লেখে, ভরা হলে কী; test সেখান থেকেই আসে।
- ছোট কোডের চেনা ছাঁচ: এক লেখক এক পাঠকের ring buffer (আগে data, পরে head), mask-এ বাড়তি বিট কাটা, ৮ নমুনার debouncer, বিশুদ্ধ function-এ FSM.
- Float ছাড়া হিসাব: accumulator-এ ভগ্নাংশ রাখা, Q15-এ অর্ধেক ধাপে গোল আর saturation, CRC-এর test vector আর শূন্য residue.
- সময় আর সমান্তরালতা:
(int32_t)(now − next) >= 0, volatile ≠ atomic, inheritance-এ ১১ থেকে ৫ tick, watchdog-এ task check-in. - গল্প আর নকশা: লক্ষণ → আবার ঘটানো → প্রমাণ → সমাধান → পাহারা; নকশায় আগে প্রশ্ন, তারপর power budget-এর সংখ্যা।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর ১৪টি মডিউল; দুর্বল মনে হওয়া মডিউলে ফিরে যান।
- পর্ব ০১ · মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT-এর মানচিত্ররিভিশনতিনটি শেখার পথ আর বাজারঘরের দুটি device-এর পুরো যাত্রা।
- পর্ব ৪৩ · Interrupt আর ISR নকশাআবার পড়ুনLatency, priority, shared data আর ring buffer: অংশ ২ আর ৬-এর পূর্ণ রূপ।
- পর্ব ৮০ · ক্যাপস্টোনপ্রকল্পCold-storage monitor, firmware থেকে dashboard পর্যন্ত, acceptance test সহ।
- পর্ব ৮১ · 8085 আর 8086-এর সমস্যা অনুশীলনপরীক্ষাFlag, delay, physical address আর interfacing-এর সমাধানসহ সমস্যা।
- C প্রোগ্রামিং · পর্ব ৫৪ · এমবেডেড Cভিত্তিvolatile, bit manipulation আর hardware-এর সঙ্গে C-র কথা বলার ভিত্তি।
- DSA · পর্ব ৭১ · কোডিং ইন্টারভিউর সমস্যাপাশের ট্র্যাকপ্যাটার্ন ধরে কোডিং সমস্যার সমাধান; queue, stack আর bit-এর অনুশীলন।