এই পর্বে যা শিখবেন
- Watchdog কী ধরতে পারে আর কী পারে না, আর IWDG ও WWDG-এর পার্থক্য register-এর স্তরে ব্যাখ্যা করা
- LSI-এর পাল্লা মাথায় রেখে IWDG-এর timeout বাছাই, আর WWDG-এর window, EWI ও reset-এর সময় হিসাব করা
- অন্ধ kick আর task check-in-এর পার্থক্য সত্যিকারের board run দিয়ে দেখা, আর একাধিক task-এর জন্য supervisor নকশা করা
- HardFault handler দিয়ে log রেখে reset, পরের boot-এ log পড়া, আর CFSR/HFSR-এর বিট থেকে fault-এর কারণ চেনা
- Reset-এর পরে নিরাপদ অবস্থা, brown-out-এর boot loop আর crash counter-এর backoff দিয়ে বাজারঘরের cold-storage monitor-কে নিরাপদে ফেরানো
১ · Watchdog কেন — যন্ত্র আটকে গেলে কে জাগাবে
বাজারঘরের cold-storage monitor দোকানের পেছনের ঠান্ডা ঘরে বসানো। প্রতি 1 s-এ তাপমাত্রা পড়ে, 8.00 °C-এর ওপরে ৩ বার পরপর গেলে alarm বাজায়, প্রতি 10 s-এ telemetry পাঠায় (পর্ব ৫৫-এ এর super loop দেখেছেন)। এবার ভাবুন, একদিন রাত দুটোয় I2C-এর একটি পড়া কোনো কারণে শেষ হলো না, আর firmware একটি while-এ চিরকাল অপেক্ষা করছে। কেউ কোনো বোতাম চাপবে না, কোনো debugger লাগানো নেই। সকাল পর্যন্ত মাছ-মাংস গরম হতে থাকবে, আর alarm চুপ।
এমন আটকে যাওয়ার কারণ অনেক: এমন একটি flag-এর অপেক্ষা যা কখনো আসে না, দুই task-এর deadlock (পর্ব ৫৭), stack উপচে data নষ্ট হওয়া (পর্ব ৩৯), বিদ্যুতের ঝাঁকুনি বা electrical noise-এ একটি বিট উল্টে যাওয়া, অথবা সাধারণ একটি logic-এর ভুল। সবগুলো আগে থেকে খুঁজে বের করা অসম্ভব। তাই এমবেডেড সিস্টেমে একটি শেষ রক্ষাকবচ রাখা হয়: watchdog timer.
উপমা — রাতের চৌকিদার আর থানার খাতা: পুরোনো দিনের মহল্লায় চৌকিদার প্রতি ঘণ্টায় বাঁশি বাজিয়ে জানাতেন যে তিনি জেগে আছেন। থানার ডিউটি অফিসার জানতেন, এক ঘণ্টার বেশি বাঁশি না শুনলে কিছু একটা গোলমাল, লোক পাঠাতে হবে। Watchdog ঠিক থানার সেই অফিসার: firmware নিয়মিত “বাঁশি” বাজায়, অর্থাৎ counter আবার ভরে দেয়। বাঁশি থামলে watchdog কারণ জিজ্ঞেস করে না, সোজা পুরো chip reset করে। আর একটি সতর্কতা: চৌকিদার যদি ঘুমন্ত অবস্থায় একটি রেকর্ড করা বাঁশি বাজিয়ে রাখেন, অফিসার কিছুই টের পাবেন না। Watchdog-এর সবচেয়ে বড় ভুল ঠিক এটাই, যা অংশ ৪-এ সত্যিকারের run-এ দেখবেন।
যন্ত্রের ভাষায়: watchdog একটি নিচে-গোনা counter. Firmware নির্দিষ্ট সময়ের মধ্যে একটি বিশেষ মান লিখে counter আবার পূর্ণ করে; এই কাজকে বলে kick (feed, refresh বা “watchdog-কে খাওয়ানো” নামেও চলে)। Counter শূন্যে পৌঁছালে system reset হয়, আর reset-এর কারণের register-এ একটি flag বসে, যাতে পরের boot-এ firmware জানতে পারে কী হয়েছিল। Reset-এর কারণ আর তার register-এর খুঁটিনাটি পর্ব ৩৩-এ দেখেছেন; এই পর্বে প্রশ্নটা নকশার: কোন watchdog, কত timeout, কোথায় kick, আর reset বা fault-এর পরে কীভাবে নিরাপদে ফেরা। এই মডিউলে hex লেখা হয় C-এর ধাঁচে, যেমন 0x40003000.
কোর্সের board-এ একটি watchdog reset
কোর্সের virtual “বাজারঘর board” BG-M3 কোনো আসল পণ্য নয়; এটি Unicorn emulator-এর একটি ARMv7-M CPU, চারপাশে Python-এ লেখা STM32-ধাঁচের সরল peripheral (পর্ব ০৬)। এর IWDG-এর register STM32-এর মতোই: KR, PR, RLR, SR, ঠিকানা 0x40003000 থেকে। কিন্তু একটি সরলীকরণ আছে: counter চলে 1 kHz-এ, PR জমা থাকে কিন্তু ব্যবহার হয় না, আর RLR সরাসরি millisecond (Spec decision 28). Reference lab-এর watchdog.c 100 ms-এর watchdog চালু করে, পাঁচবার 20 ms পরপর kick করে, তারপর একটি bug-এ আটকে যায়। Reference lab-এর নিজের build থেকে সত্যিকারের run (Clang 22.1.8, PyPI ziglang 0.17.1, MIT আর LLVM-এর Apache-2.0 license; Unicorn 2.1.4, binding BSD, engine GPLv2; Python 3.13.5):
$ python -B board.py run firmware/build/watchdog.elf
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0403 ms] UART: boot #1, reset cause: POWER-ON
[ 0.0425 ms] watchdog started, timeout 100 ms
[ 20.0556 ms] UART: kick 1
[ 40.0555 ms] UART: kick 2
[ 60.0556 ms] UART: kick 3
[ 80.0555 ms] UART: kick 4
[ 100.0556 ms] UART: kick 5
[ 100.0846 ms] UART: bug: stuck in a loop, no more kicks
[ 200.0431 ms] RESET (watchdog timeout)
[ 200.0816 ms] UART: boot #2, reset cause: WATCHDOG
[ 200.1069 ms] UART: recovered: entering safe state
[ 200.1078 ms] exit(0) after 1600862 cycles
একটি খুঁটিনাটি লক্ষ করুন। Firmware আগে KR-এ 0xAAAA লেখে, তারপর “kick 5” ছাপে; ছাপা শেষ হয় 100.0556 ms-এ, কিন্তু kick-এর লেখাটি হয়েছিল তার একটু আগে, 100.0431 ms-এ। Board-এর deadline = kick-এর মুহূর্ত + RLR, তাই reset ঠিক 100.0431 + 100 = 200.0431 ms-এ। নিচের stepper পুরো গল্পটি ধাপে ধাপে দেখায়।
| সময় | |
| ঘটনা | |
| Watchdog-এ বাকি | |
| RCC_CSR | |
| boot_count (.noinit) |
- চালু। Boot-এ firmware CSR পড়ে (POWER-ON), RMVF দিয়ে মোছে, তারপর KR-এ 0x5555 (তালা খোলা), RLR = 100, KR-এ 0xCCCC. এই মুহূর্ত থেকে watchdog আর বন্ধ করা যায় না।
- প্রথম kick. 20 ms পরে counter-এ প্রায় 80 ms বাকি ছিল; KR-এ 0xAAAA লিখে আবার 100. চৌকিদারের বাঁশি বাজল।
- পঞ্চম kick. KR-এর লেখা 100.0431 ms-এ, তাই নতুন deadline 200.0431 ms. এর পরে আর কোনো kick আসবে না।
- Bug. Firmware একটি খালি loop-এ আটকে গেছে। CPU পুরো গতিতে চলছে, কিন্তু কাজের কিছু করছে না; 150 ms-এ watchdog-এ প্রায় 50 ms বাকি।
- Timeout. Counter শূন্য: board system reset দেয় আর CSR-এ IWDGRSTF (বিট ২৯) বসায়, মান 0x20000000. SRAM মোছে না (Spec decision 18).
- দ্বিতীয় boot. Startup code
.noinitছোঁয় না, তাই boot_count 1 থেকে 2 হলো। CSR বলে WATCHDOG: firmware জানে আগের বার কিছু আটকে গিয়েছিল। - নিরাপদ অবস্থা। স্বাভাবিক কাজে না ফিরে firmware একটি নিরাপদ অবস্থায় যায় আর থামে। আসল যন্ত্রে এখানে log পাঠানো আর সীমিত কাজ চালানো হয় (অংশ ৫ আর ৭).
Watchdog যা পারে না: এটি bug খোঁজে না, সারায়ও না; শুধু আটকে থাকা যন্ত্রকে আবার শুরু করে। যে bug ভুল মান হিসাব করে অথচ loop ঠিকঠাক ঘোরায়, watchdog তা কখনো ধরবে না। আর reset নিজেই একটি ঘটনা: চলমান কাজ হারায়, output এক মুহূর্তের জন্য ছেড়ে যায়। তাই watchdog-এর সঙ্গে চাই plausibility check, reset-এর পরে নিরাপদ অবস্থা আর log, যা এই পর্বের বাকি অংশ।
২ · IWDG আর WWDG — দুই ধরনের পাহারাদার
STM32F1 পরিবারে দুটি watchdog, আর দুটির দর্শন আলাদা। নিচের টেবিল ST-এর STM32F1 reference manual (RM0008)-এর IWDG আর WWDG অধ্যায় থেকে সংক্ষেপ:
| বিষয় | IWDG | WWDG |
|---|---|---|
| Clock | নিজস্ব LSI RC (typ 40 kHz, 30–60 kHz) | APB1-এর PCLK1 ÷ 4096 ÷ 2WDGTB |
| Counter | ১২ বিট, নিচে গোনে; RLR থেকে শুরু | ৭ বিট (T[6:0]), নিচে গোনে |
| Reset কখন | Counter 0 হলে | Counter 0x40 থেকে 0x3F হলে (বিট T6 শূন্য), অথবা counter window-এর মান W-এর চেয়ে বড় থাকতে refresh করলে |
| Kick | KR-এ 0xAAAA | CR-এ নতুন counter মান লেখা |
| চালু | KR-এ 0xCCCC, বা option byte-এ “hardware watchdog” বাছলে reset-এর সঙ্গে নিজে নিজে | CR-এর WDGA বিট |
| বন্ধ করা | একবার চালু হলে reset ছাড়া নয় | একবার চালু হলে reset ছাড়া নয় |
| আগাম সতর্কতা | নেই | Counter 0x40-এ early wakeup interrupt (EWI) |
| কোন ভুল ধরে | খুব দেরি; মূল clock থেমে গেলেও | খুব দেরি আর খুব আগে, অর্থাৎ সময়ের ছন্দ ভাঙা |
IWDG কেন “independent”: এর clock মূল clock tree-এর বাইরে, ভেতরের ধীর LSI থেকে আসে (পর্ব ৩৩-এর clock tree-এর ছবিতে নিচের বাঁ কোণ)। Crystal নষ্ট হোক, PLL ভুল সাজানো হোক, বা CPU কোনো অদ্ভুত অবস্থায় আটকে যাক, IWDG গুনতেই থাকে। RM0008 আরও বলে, register-এ ভুলে লেখা ঠেকাতে PR আর RLR-এ লেখার আগে KR-এ 0x5555 দিয়ে তালা খুলতে হয়, আর একটি option byte-এ “hardware watchdog” বেছে নিলে chip reset-এর সঙ্গে সঙ্গেই IWDG চালু হয়ে যায়, firmware-এর একটি নির্দেশ চলার আগেই। কোর্সের board KR, PR, RLR-এর এই আচরণ মডেল করে, option byte করে না।
WWDG কেন “window”: কিছু bug-এ firmware থামে না, বরং ভুল পথে খুব দ্রুত ঘোরে, আর ঘটনাক্রমে kick-এর লাইনটিও বারবার পার হয়। সাধারণ watchdog তাতে খুশি। WWDG বলে, kick-এর একটি নির্দিষ্ট সময়-জানালা আছে: counter W-এর ওপরে থাকতে kick করলে সেটি “খুব আগে”, তাতেও reset. ফলে firmware-কে একটি নির্দিষ্ট ছন্দে চলতেই হয়। তার দাম হলো, WWDG মূল clock-এর ওপর নির্ভর করে, আর এর timeout মাত্র কয়েক ms থেকে কয়েক দশ ms; অনেক নকশায় তাই দুটিই একসঙ্গে ব্যবহার হয়। নিচের ছবি একটি WWDG-এর জানালা দেখায়, সংখ্যাগুলো এই অংশের Python ব্লকের।
ছবি ৬১.১ — WWDG-এর জানালা: PCLK1 36 MHz, WDGTB = 3, T = 0x7F, W = 0x5F
লাল = refresh নিষেধ (খুব আগে); সবুজ = refresh-এর জানালা; কমলা দাগ = EWI; শেষ দাগ = reset
নিচের ব্লক দুটি হিসাব করে। প্রথমত IWDG-এর উল্টো প্রশ্ন: “সবচেয়ে খারাপ LSI-তেও অন্তত 1800 ms চাই”, তাহলে PR আর RLR কত। সূত্র t = 4 × 2PR × (RLR + 1) ÷ fLSI, যা পর্ব ৩৩-এ এসেছে। দ্বিতীয়ত WWDG-এর প্রতিটি prescaler-এ সীমা আর ছবির জানালা।
# IWDG-এর PR/RLR বাছাই আর WWDG-এর window (STM32F1, RM0008-এর সূত্র)
LSI_MIN, LSI_TYP, LSI_MAX = 30_000, 40_000, 60_000 # Hz, datasheet-এর পাল্লা
def iwdg_ms(pr, rlr, f): # PR 0..6 মানে ÷4 .. ÷256
return 4 * 2**pr * (rlr + 1) / f * 1000
def choose_iwdg(need_ms):
"""সবচেয়ে দ্রুত LSI-তেও timeout >= need_ms; সবচেয়ে ছোট prescaler"""
for pr in range(7):
rlr = -(-need_ms * LSI_MAX // (4 * 2**pr * 1000)) - 1 # ceil − 1
if rlr <= 0xFFF:
return pr, rlr
need = 1800
pr, rlr = choose_iwdg(need)
print(f"IWDG: need >= {need} ms -> PR={pr} (÷{4 * 2**pr}), RLR={rlr}")
for f in (LSI_MAX, LSI_TYP, LSI_MIN):
print(f" LSI {f // 1000} kHz: timeout {iwdg_ms(pr, rlr, f):6.0f} ms")
PCLK1 = 36_000_000 # WWDG চলে APB1-এর clock-এ
for tb in range(4):
step = 4096 * 2**tb / PCLK1 * 1e6 # এক গণনা, µs
print(f"WWDG WDGTB={tb}: step {step:6.2f} us, range {step:6.2f} us"
f" .. {64 * step / 1000:5.2f} ms")
T, W, tb = 0x7F, 0x5F, 3 # reload, window, prescaler
step = 4096 * 2**tb / PCLK1 * 1000 # ms
print(f"T=0x{T:X} W=0x{W:X}: refresh too early before {(T - W) * step:.2f} ms,"
f" EWI at {(T - 0x40) * step:.2f} ms, reset at {(T - 0x3F) * step:.2f} ms")আসল আউটপুট (ব্রাউজারের Python):
IWDG: need >= 1800 ms -> PR=3 (÷32), RLR=3374
LSI 60 kHz: timeout 1800 ms
LSI 40 kHz: timeout 2700 ms
LSI 30 kHz: timeout 3600 ms
WWDG WDGTB=0: step 113.78 us, range 113.78 us .. 7.28 ms
WWDG WDGTB=1: step 227.56 us, range 227.56 us .. 14.56 ms
WWDG WDGTB=2: step 455.11 us, range 455.11 us .. 29.13 ms
WWDG WDGTB=3: step 910.22 us, range 910.22 us .. 58.25 ms
T=0x7F W=0x5F: refresh too early before 29.13 ms, EWI at 57.34 ms, reset at 58.25 ms
প্রথম চার লাইন একটি অপ্রিয় সত্য: “অন্তত 1800 ms” নিশ্চিত করলে একই chip অন্য তাপমাত্রায় বা অন্য একটি নমুনায় 3600 ms পর্যন্ত অপেক্ষা করতে পারে। অর্থাৎ যন্ত্র আটকে গেলে উদ্ধার আসতে দ্বিগুণ সময়ও লাগতে পারে, আর নকশায় সেটাই ধরতে হয়। পরের চার লাইন WWDG-এর সীমা: 36 MHz-এ সবচেয়ে ছোট এক গণনা 113.78 µs আর সবচেয়ে বড় timeout 58.25 ms; ৬৪টি গণনা, কারণ counter 0x7F থেকে 0x40 পর্যন্ত বৈধ। শেষ লাইন ছবি ৬১.১-এর তিনটি সংখ্যা।
| সময় | |
| Counter | |
| Counter > W? | |
| এখন refresh করলে | |
| ঘটনা |
- Refresh-এর মুহূর্ত। CR-এ 0x7F লেখা হলো। এক গণনা 4096 × 23 ÷ 36 MHz = 910.22 µs. Counter W = 0x5F-এর ওপরে, তাই জানালা এখন বন্ধ।
- ১৬টি গণনা পরে। 16 × 0.91022 = 14.56 ms, counter 0x6F, এখনো W-এর ওপরে। কেউ এখন refresh করলে, যেমন ভুল পথে দ্রুত ঘুরতে থাকা কোড, সঙ্গে সঙ্গে reset.
- জানালা খুলল। ৩২টি গণনা পরে, 29.13 ms-এ counter 0x5F = W. এখন থেকে refresh বৈধ; সুস্থ firmware-এর kick এই এলাকায় পড়ার কথা।
- আগাম সতর্কতা। ৬৩টি গণনা পরে, 57.34 ms-এ counter 0x40: EWI চালু থাকলে interrupt আসে। এর ISR-এ ছোট একটি log রাখা যায়; RM0008 এখানে refresh করে reset এড়ানোর সুযোগও রাখে, তবে সেটি অন্ধ kick-এর মতো বিপজ্জনক।
- Reset. ৬৪তম গণনায়, 58.25 ms-এ counter 0x3F: বিট T6 শূন্য, chip reset হয় আর RCC_CSR-এ WWDGRSTF (বিট ৩০) বসে।
৩ · Timeout বাছাই — খুব ছোটও নয়, খুব বড়ও নয়
Timeout বাছাইয়ে দুই দিকের টান। খুব ছোট হলে সুস্থ firmware-ও কখনো কখনো সময়মতো kick করতে পারে না, আর যন্ত্র অকারণে reset হয়; মাঠে একে বলে “phantom reset”, আর এমন যন্ত্রকে কেউ বিশ্বাস করে না। খুব বড় হলে আটকে থাকা যন্ত্র অনেকক্ষণ চুপ থাকে। একটি ব্যবহারিক পদ্ধতি তিন ধাপের:
- নিচের সীমা: সুস্থ অবস্থায় দুই kick-এর মধ্যে সবচেয়ে বড় ফাঁক। শুধু স্বাভাবিক loop নয়, বিরল পথগুলোও: boot-এর শুরু, flash-এর একটি page মোছা, OTA update-এর একটি বড় block লেখা, Wi-Fi-র সংযোগের চেষ্টা। এগুলো মেপে নিতে হয় (পর্ব ৫৪-এর WCET-এর ধারণা)। তার ওপর একটি নিরাপত্তা-ফাঁক, অনেকে ৫০% থেকে ১০০% রাখেন।
- Clock-এর ভুল: IWDG-এর LSI 30–60 kHz-এর যেকোনো জায়গায়, তাই PR আর RLR হিসাব করতে হয় সবচেয়ে দ্রুত LSI (60 kHz) ধরে, যাতে সবচেয়ে ছোট timeout-ও নিচের সীমার ওপরে থাকে। ওপরের ব্লকে ঠিক তাই করা হয়েছে।
- ওপরের সীমা: যন্ত্র কতক্ষণ “অন্ধ” থাকতে পারে। এটি প্রয়োগের প্রশ্ন। Cold room-এ তাপমাত্রা মিনিটে খুব বেশি বদলায় না, তাই কয়েক সেকেন্ডের অন্ধত্ব মেনে নেওয়া যায়; একটি motor-এর নিয়ন্ত্রকে কয়েক ms-ও বেশি হতে পারে। সবচেয়ে ধীর LSI-তে (30 kHz) timeout এই সীমার নিচে থাকা চাই।
বাজারঘরের cold-storage monitor-এ অংশ ৪-এর firmware-এর supervisor প্রতি 1 s-এ একবার kick-এর সিদ্ধান্ত নেয়, আর প্রথমবার নেয় boot-এর 1.5 s পরে। তাই সুস্থ অবস্থায় সবচেয়ে বড় ফাঁক প্রায় 1.5 s, আর timeout বাছা হয়েছে 1800 ms. কোর্সের board-এ RLR সরাসরি ms, তাই সেখানে IWDG->RLR = 1800; আসল STM32F103-এ সমান নিশ্চয়তার জন্য PR = 3, RLR = 3374, যা LSI-ভেদে 1.8 থেকে 3.6 s.
Debugger আর watchdog: Breakpoint-এ CPU থামলেও IWDG নিজের clock-এ গুনতে থাকে, তাই debug করার সময় হঠাৎ reset হয়। STM32-এ DBGMCU_CR register-এর DBG_IWDG_STOP আর DBG_WWDG_STOP বিট দিয়ে CPU থামলে watchdog-ও থামানো যায় (RM0008-এর debug অধ্যায়)। আরেকটি সাবধানতা low-power-এ: STM32F1-এ IWDG Stop আর Standby mode-এও চলে বলে RM0008-এ বর্ণনা পাওয়া যায়, তাই timeout-এর চেয়ে লম্বা ঘুম মানে নিশ্চিত reset; নতুন কিছু পরিবারে option byte দিয়ে ঘুমের সময় IWDG থামানো যায়। ঘুমের নকশা পর্ব ৬০ (Low-power নকশা)-এ।
৪ · কোথায় kick করবেন — অন্ধ kick বনাম task check-in
Watchdog-এর সবচেয়ে প্রচলিত ভুল একটি “সুবিধাজনক” জায়গায় kick বসানো: SysTick-এর ISR-এ, যা প্রতি ms-এ নিশ্চিত চলে, অথবা main loop-এর একেবারে শুরুতে। দুটিই অন্ধ। SysTick-এর ISR তখনো চলে যখন main পুরো আটকে আছে, কারণ interrupt main-এর অবস্থা দেখে না। আর main loop ঘুরছে মানেই প্রতিটি কাজ এগোচ্ছে, এমন নয়: super loop-এ একটি state machine একটি অবস্থায় চিরকাল আটকে থাকতে পারে, অথচ loop দিব্যি ঘোরে (পর্ব ৫৫)।
উত্তর হলো task check-in: প্রতিটি task নিজের একটি কাজ সত্যিই শেষ করার পরে একটি বিট বসিয়ে “হাজিরা” দেয়। একজন supervisor নির্দিষ্ট সময় পরপর দেখে, সবাই হাজিরা দিয়েছে কি না। দিলে kick করে আর খাতা মুছে দেয়; না দিলে kick করে না, কে অনুপস্থিত তা .noinit-এ লিখে রাখে, আর watchdog বাকিটা করে। নিচের ছবি পুরো নকশা দেখায়।
ছবি ৬১.২ — Task check-in watchdog: হাজিরা, supervisor, IWDG আর পরের boot
নীল = task; হলুদ = হাজিরার খাতা আর supervisor; লাল = watchdog আর reset; সবুজ = পরের boot-এর নিরাপদ পথ
checkin.c-এর নকশা। SENSOR শুধু একটি পড়া সত্যিই শেষ হলে হাজিরা দেয়, তাই তার state machine আটকে গেলে loop ঘুরলেও খাতায় তার বিট আর আসে না।তিনটি firmware একই কাঠামোর, পার্থক্য শুধু kick-এর জায়গায়। দুটি task: SENSOR প্রতি 1 s-এ একটি পড়া নেয়, COMM প্রতিটি পাসে চলে। প্রথম boot-এ তৃতীয় পড়াটি শুরু হয় কিন্তু তার “DONE” কখনো আসে না, যেন I2C-এর একটি উত্তর হারিয়ে গেছে; state machine অপেক্ষায় আটকে যায়, অথচ loop ঘুরতেই থাকে। Supervisor-এর অংশটি এমন (আমার lab-এর wd_common.h থেকে, reference-এর watchdog.c-এর ধাঁচে লেখা):
void SysTick_Handler(void)
{
ms_ticks++;
if (ms_ticks < 1500u || ms_ticks % 1000u != 500u) /* 1.5 s, 2.5 s ... */
return;
if (KICK_MODE == 1) {
kick(); /* অন্ধ: কিছু না দেখেই */
} else if (KICK_MODE == 3) {
if (checkins == CHK_ALL) { /* SENSOR আর COMM দুজনই আছে */
kick();
uart_puts("supervisor: all checked in, kick\r\n");
} else {
last_missing = CHK_ALL & ~checkins; /* .noinit-এ */
uart_puts("supervisor: SENSOR missing, no kick\r\n");
}
checkins = 0; /* নতুন সময়-খণ্ডের খাতা */
}
}
/* task_sensor(): একটি পড়া শেষ হলে checkins |= CHK_SENSOR;
task_comm(): প্রতিটি পাসে checkins |= CHK_COMM;
KICK_MODE 2: main loop-এর প্রতিটি পাসে kick() */(Page-এর সংক্ষেপে missing-এর বার্তা একটিই দেখানো; আসল ফাইলে last_missing দেখে SENSOR বা COMM ছাপে।) তিনটি সত্যিকারের run, একই board-এ। প্রথম দুটি অন্ধ kick, 7 s পরে আমরা নিজেরা --cycles দিয়ে থামিয়েছি:
=== kick_isr (SysTick-এর ISR-এ প্রতি 1 s-এ অন্ধ kick)
[ 0.0469 ms] watchdog started, timeout 1800 ms
[ 1000.0702 ms] UART: sensor: reading 1 ok
[ 2000.0715 ms] UART: sensor: reading 2 ok
[ 3000.0856 ms] UART: sensor: reading 3 started, waiting for DONE...
[ 7000.0000 ms] stopped: cycle limit (56000000) reached after 56000000 cycles
=== kick_loop (main loop-এর প্রতিটি পাসে অন্ধ kick)
[ 0.0465 ms] watchdog started, timeout 1800 ms
[ 1000.0707 ms] UART: sensor: reading 1 ok
[ 2000.0709 ms] UART: sensor: reading 2 ok
[ 3000.0847 ms] UART: sensor: reading 3 started, waiting for DONE...
[ 7000.0000 ms] stopped: cycle limit (56000000) reached after 56000000 cycles
দুই ক্ষেত্রেই 3 s থেকে কোনো তাপমাত্রা পড়া হচ্ছে না, অথচ watchdog চুপ। আমরা না থামালে যন্ত্র এভাবেই চিরকাল চলত, cold room অরক্ষিত। এবার check-in, পুরো run:
$ python -B board.py run ~/lab/wdog/build/checkin.elf
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0428 ms] UART: boot #1, reset cause: POWER-ON
[ 0.0469 ms] watchdog started, timeout 1800 ms
[ 1000.0702 ms] UART: sensor: reading 1 ok
[ 1500.0742 ms] UART: supervisor: all checked in, kick
[ 2000.0715 ms] UART: sensor: reading 2 ok
[ 2500.0743 ms] UART: supervisor: all checked in, kick
[ 3000.0856 ms] UART: sensor: reading 3 started, waiting for DONE...
[ 3500.0772 ms] UART: supervisor: SENSOR missing, no kick
[ 4300.0477 ms] RESET (watchdog timeout)
[ 4300.0886 ms] UART: boot #2, reset cause: WATCHDOG
[ 4300.1337 ms] UART: last missing check-in: SENSOR -> fail-safe: alarm ON
[ 4300.1344 ms] GPIO PA6 ALARM ON
[ 4300.1349 ms] exit(0) after 34401079 cycles
| সময় (ms) | |
| ঘটনা | |
| checkins (COMM, SENSOR) | |
| Watchdog-এর deadline | |
| last_missing (.noinit) |
- শুরু। IWDG 1800 ms-এ চালু, deadline প্রায় 1800.05 ms. COMM প্রথম পাসেই হাজিরা দেয় (বিট ১), SENSOR এখনো কোনো পড়া শেষ করেনি।
- প্রথম পড়া। 1 s-এ SENSOR একটি পড়া শেষ করে বিট ০ বসায়: খাতা 0b11. Supervisor এখনো দেখেনি; প্রথম পরিদর্শন 1.5 s-এ, যাতে boot-এর পরে সবাই একবার হাজিরা দেওয়ার সময় পায়।
- প্রথম kick. 1500 ms-এ supervisor দুটি বিটই পায়, KR-এ 0xAAAA লেখে আর খাতা মোছে। নতুন deadline প্রায় 3300.05 ms.
- দ্বিতীয় kick. 2 s-এর পড়ার পরে আবার সবাই হাজির। Kick-এর লেখা 2500.0477 ms-এ, তাই deadline ঠিক 4300.0477 ms; শেষ লাইনের reset-এর সময় থেকেই এটি যাচাই হয়।
- আটকে যাওয়া। 3 s-এ তৃতীয় পড়া শুরু হলো, DONE আর আসে না। SENSOR-এর state machine অপেক্ষায়, তাই তার বিট আর বসে না; COMM প্রতি পাসে হাজিরা দিয়েই যাচ্ছে: খাতা 0b10.
- Supervisor ধরল। 3500 ms-এ খাতায় SENSOR নেই। Kick নয়;
last_missing= SENSOR লেখা হলো.noinit-এ, যা reset পেরিয়ে টিকবে। Deadline বদলায়নি। - Reset আর পরের boot. 4300.0477 ms-এ IWDG reset দেয়। Boot #2 CSR-এ WATCHDOG আর
.noinit-এ SENSOR পায়: sensor-এর ব্যর্থতা মানে cold room-এর তাপমাত্রা অজানা, তাই fail-safe হিসেবে alarm চালু (PA6).
সমস্যা ধরা পড়তে সময় লাগল 3000 থেকে 4300 ms, অর্থাৎ 1.3 s; সবচেয়ে খারাপ ক্ষেত্রে এটি supervisor-এর এক period আর timeout-এর যোগফলের কাছাকাছি। RTOS-এ নকশা একই, শুধু supervisor সাধারণত একটি আলাদা task, আর প্রতিটি task-এর নিজের সময়সীমা থাকে (১০ s-এর telemetry task প্রতি 1 s-এ হাজিরা দেবে না)। Supervisor task-এর priority কম রাখার একটি সুবিধা আছে: বেশি priority-র কোনো task CPU আটকে রাখলে supervisor নিজেই চলতে পারে না, ফলে kick থামে, আর এই starvation-ও ধরা পড়ে। RTOS-এর task আর priority পর্ব ৫৬-এ, queue আর event পর্ব ৫৮-এ।
৫ · Reset-এর পরে — নিরাপদ অবস্থা, কারণ আর .noinit-এর ফাঁদ
Reset-এর পরে firmware-এর প্রথম কয়েকটি নির্দেশের ক্রম গুরুত্বপূর্ণ। Reset-এর মুহূর্তে GPIO-গুলো তাদের reset-অবস্থায় ফেরে, সাধারণত input, অর্থাৎ ভাসমান। একটি relay বা heater-এর লাইন তখন কোন দিকে যাবে, তা বাইরের pull-up বা pull-down resistor ঠিক করে (পর্ব ৪১)। তাই hardware-এর নকশাতেই ঠিক করতে হয় “reset-এ নিরাপদ” মানে কী, আর firmware-এর প্রথম কাজ output-গুলোকে সেই নিরাপদ মানে বসানো, তারপর অন্য কিছু। ওপরের checkin.c-এ main()-এর তৃতীয় লাইনেই alarm-এর pin output করা হয়।
তারপর তিনটি প্রশ্ন: reset কেন হলো (reset cause register, পর্ব ৩৩), আগের বার কী ঘটছিল (.noinit-এর log), আর এখন কী করা নিরাপদ। .noinit অংশটি startup code শূন্যও করে না, flash থেকে ভরেও না; কোর্সের board-এ তা watchdog আর software reset পেরিয়ে টিকে থাকে (Spec decision 18). কিন্তু প্রথম power-on-এ আসল chip-এর SRAM-এ যা খুশি থাকতে পারে, তাই একটি “magic” সংখ্যা দিয়ে যাচাই করা হয়: magic মিললে log বিশ্বাসযোগ্য, না মিললে সব নতুন করে শুরু।
Map file-এ একটি সত্যিকারের ফাঁদ
এই পর্ব লিখতে গিয়ে আমার lab-এর map file-এ (-Wl,-Map, পর্ব ৩৭) একটি অপ্রত্যাশিত জিনিস চোখে পড়ল। Reference-এর watchdog.c-এর আগের সংস্করণে boot_magic ঘোষণা করা ছিল volatile ছাড়া একটি uint32_t, অথচ map বলছিল তার আকার ১ byte:
watchdog.map, আগের সংস্করণ (Clang 22.1.8, -O2), .noinit:
20000004 20000004 8 4 .noinit
20000004 20000004 1 1 boot_magic
20000008 20000008 4 1 boot_count
watchdog.map, এখনকার সংস্করণ (শুধু volatile যোগ করা):
20000004 20000004 4 1 boot_magic
20000008 20000008 4 1 boot_count
কারণ C ভাষার নিয়ম। Static variable-এর শুরুর মান C-তে শূন্য ধরা হয়, আর compiler জানে না যে এই অংশ আসলে শূন্য করা হয় না। boot_magic-এ কোড শুধু একটি ধ্রুবক লেখে আর তার সঙ্গে তুলনা করে, তাই আগের সংস্করণে optimizer সিদ্ধান্ত নিয়েছিল: এর সম্ভাব্য মান মাত্র দুটি, “শূন্য” আর “magic”, একটি bool-ই যথেষ্ট। C-এর হিসাবে এটি সম্পূর্ণ বৈধ রূপান্তর। কিন্তু আসল chip-এ power-on-এর পরে সেই byte-এ যদি এলোমেলো কোনো শূন্য-নয় মান থাকে, firmware ধরে নেবে magic মিলেছে, আর আবর্জনাকে boot counter বা fault log হিসেবে বিশ্বাস করবে। কোর্সের board power-on-এ SRAM শূন্য রাখে, তাই সেখানে এই ভুল ধরা পড়ে না; সমাধান এক শব্দ: .noinit-এর variable-কে volatile করা, যা compiler-কে প্রতিটি পড়া-লেখা সত্যি করতে বাধ্য করে (পর্ব ৩৪)। আরও সতর্ক নকশায় log-এর সঙ্গে একটি CRC রাখা হয়। আমার lab-এর সব firmware তাই volatile দিয়ে লেখা। এই খুঁজে পাওয়ার পরে কোর্সের reference watchdog.c-ও সংশোধন করা হয়েছে: এখন তার boot_magic আর boot_count দুটিই volatile, map-এ boot_magic আবার ৪ byte, আর ওপরের run সেই সংশোধিত firmware-এর।
আরও গভীরে: Watchdog reset-এর পরে SRAM টিকে থাকে কি না, তা chip-ভেদে আলাদা আর সবসময় নিশ্চিত নয়: কিছু chip-এ reset-এর পরে bootloader বা ROM code SRAM-এর অংশ ব্যবহার করে, কিছু নতুন chip-এ নিরাপত্তার জন্য reset-এ SRAM মুছে ফেলার ব্যবস্থা থাকে। তাই মাঠের যন্ত্রে fault log প্রায়ই দুই স্তরে রাখা হয়: দ্রুত লেখার জন্য .noinit SRAM বা backup register (STM32F1-এ VBAT-চালিত ১০টি ১৬ বিটের register, পর্ব ৩৩), আর পরের boot-এ শান্ত অবস্থায় flash-এ স্থায়ী কপি। Fault-এর মুহূর্তে flash-এ লেখা ঝুঁকিপূর্ণ, কারণ তখন system-এর অবস্থাই সন্দেহজনক।
৬ · HardFault — log রেখে reset, আর crash গোনা
Watchdog ধরে “থেমে যাওয়া”; HardFault ধরে “অবৈধ কাজ”: ভুল ঠিকানা পড়া, অচেনা নির্দেশ, ভুল mode-এ লাফ। Cortex-M-এ fault কীভাবে exception হয়, frame কীভাবে stack-এ পড়ে, তা পর্ব ৩০-এ, আর stacked PC থেকে দোষী C লাইন খোঁজা ও fault log রাখা পর্ব ৩৮-এ। এখানে প্রশ্নটা মাঠের: debugger নেই, তাহলে handler কী করবে?
ডিফল্ট handler (reference-এর startup.c-এর Default_Handler) একটি অসীম loop: CPU আটকে থাকে, আর watchdog চালু থাকলে শেষে reset. Debug-এর সময় এটি ভালো, কারণ debugger দিয়ে আটকে থাকা অবস্থাটি দেখা যায়। মাঠে ভালো নকশা চার ধাপের: (১) stacked frame থেকে PC, LR আর কিছু register .noinit-এ রাখা, (২) একটি crash counter বাড়ানো, (৩) watchdog-এর অপেক্ষা না করে সঙ্গে সঙ্গে software reset, (৪) পরের boot-এ log পড়ে সিদ্ধান্ত। আমার lab-এর hf_log.c-এর handler:
typedef struct { uint32_t magic, crashes, pc, lr, r0; } fault_log_t;
__attribute__((section(".noinit"))) static volatile fault_log_t flog;
void hardfault_save(const uint32_t *frame) /* R0 = MSP, frame-এর শুরু */
{
if (flog.magic != LOG_MAGIC) { flog.magic = LOG_MAGIC; flog.crashes = 0; }
flog.crashes++;
flog.pc = frame[6]; /* stacked PC: দোষী নির্দেশ */
flog.lr = frame[5]; /* stacked LR: কে ডেকেছিল */
flog.r0 = frame[0]; /* প্রথম argument */
uart_puts("HardFault handler: log saved, software reset\r\n");
SCB->AIRCR = 0x05FA0004u; /* VECTKEY + SYSRESETREQ */
for (;;) { }
}
__attribute__((naked)) void HardFault_Handler(void)
{
__asm volatile ("mrs r0, msp\n"
"b hardfault_save\n");
}
/* main(): flog-এ crash থাকলে ছাপে; crashes >= 3 হলে SAFE MODE,
নইলে নষ্ট calibration pointer (0x60000000) পড়ে আবার fault */গল্পটি এমন: cold-storage monitor-এর calibration table-এর pointer কোনো কারণে নষ্ট হয়ে 0x60000000-এ দাঁড়িয়েছে, যেখানে board-এ কোনো মেমরি নেই, তাই প্রতি boot-এ পড়তে গেলেই HardFault. একটি সত্যিকারের run, যেখানে HardFault: Invalid memory read … লাইনটি emulator নিজে ছাপে (firmware নয়), বাকিটা firmware-এর UART:
$ python -B board.py run ~/lab/wdog/build/hf_log.elf
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0374 ms] UART: boot #1, reset cause: POWER-ON
[ 0.0570 ms] UART: loading calibration...
[ 0.0576 ms] HardFault: Invalid memory read (UC_ERR_READ_UNMAPPED) at PC=0x08000250 load_calibration+0x4
[ 0.0955 ms] UART: HardFault handler: log saved, software reset
[ 0.0965 ms] RESET (software, AIRCR.SYSRESETREQ)
[ 0.1333 ms] UART: boot #2, reset cause: SOFTWARE
[ 0.2091 ms] UART: fault log: crash 1 PC=0x08000250 LR=0x080001CF R0=0x60000000
[ 0.2288 ms] UART: loading calibration...
... (boot #2 আর #3-এ একই fault, একই PC)
[ 0.4760 ms] UART: boot #4, reset cause: SOFTWARE
[ 0.5519 ms] UART: fault log: crash 3 PC=0x08000250 LR=0x080001CF R0=0x60000000
[ 0.5962 ms] UART: 3 crashes in a row: SAFE MODE, alarm ON, no calibration
[ 0.5969 ms] GPIO PA6 ALARM ON
[ 0.5971 ms] exit(0) after 4777 cycles
| সময় (ms) | |
| Boot | |
| ঘটনা | |
| flog.crashes | |
| flog.pc · lr | |
| PA6 alarm |
- প্রথম boot. Magic মেলে না (power-on), তাই log খালি ধরে crash counter শূন্য। Firmware calibration লোড করতে যায়।
- Fault.
load_calibration+0x4-এ 0x60000000 থেকে পড়া: অবৈধ ঠিকানা, CPU HardFault-এ ঢোকে আর আট word-এর frame MSP-তে রাখে (পর্ব ৩০)। - Log আর reset. Naked handler MSP-কে R0-তে দিয়ে
hardfault_save-এ যায়: crashes = 1, PC 0x08000250, LR 0x080001CF (main-এর ভেতরে, Thumb বিট ১), R0 0x60000000, যা ঠিক নষ্ট pointer. তারপর AIRCR-এ software reset. - দ্বিতীয় boot. CSR বলে SOFTWARE, log-এর magic মেলে। Firmware log ছাপে, যা মাঠে telemetry-তে পাঠানো হবে। crashes ১ < ৩, তাই আরেকবার চেষ্টা।
- আবার ভাঙা। একই PC, একই fault; crashes = 2, আবার reset. নষ্ট pointer flash বা configuration-এ থাকলে প্রতিবার একই ফল।
- তৃতীয়বার। crashes = 3, আবার reset. এখানে না থামালে যন্ত্র প্রতি কয়েক ms-এ reset হতো, চিরকাল: একটি boot loop.
- Safe mode. Boot #4 দেখে crashes ৩: calibration ছাড়া, ঝুঁকির কাজ বাদ দিয়ে graceful degradation, আর cold room-এর জন্য fail-safe হিসেবে alarm চালু। যন্ত্র “জীবিত” থেকে নিজের সমস্যা জানাতে পারে। সুস্থ boot-এ counter আবার শূন্য করা হয়।
আসল Cortex-M3-এ fault-এর কারণ — CFSR আর HFSR
কোর্সের board-এ সব fault সরাসরি HardFault-এ যায়, আর fault status register মডেল করা নেই (Spec decision 19). আসল Cortex-M3-এ (ARMv7-M) তিনটি আলাদা fault আছে: MemManage (MPU-র নিয়ম ভাঙা), BusFault (bus-এ ভুল ঠিকানা) আর UsageFault (অচেনা নির্দেশ, ভুল state, ঐচ্ছিকভাবে শূন্য দিয়ে ভাগ)। এদের handler চালু না থাকলে, যা reset-এর পরের ডিফল্ট, সবগুলো HardFault-এ “escalate” হয়, আর তখন HFSR-এর FORCED বিট বসে। কারণের বিস্তারিত থাকে CFSR-এ (0xE000ED28): নিচের ৮ বিট MemManage, পরের ৮ বিট BusFault, ওপরের ১৬ বিট UsageFault; আর HFSR (0xE000ED2C) বলে HardFault নিজে কেন। BusFault-এর ঠিকানা থাকে BFAR-এ (0xE000ED38), যদি CFSR-এর BFARVALID বিট ১ হয়। একটি ভালো fault handler এই register-গুলোও log-এ রাখে। নিচের ব্লক কয়েকটি পরিচিত মান খোলে; বিটের নাম ARMv7-M Architecture Reference Manual-এর, মানগুলো উদাহরণ:
# Cortex-M3-এর CFSR আর HFSR খোলা (ARMv7-M-এর বিট; কোর্সের board-এ এরা নেই)
CFSR = {0: "IACCVIOL", 1: "DACCVIOL", 3: "MUNSTKERR", 4: "MSTKERR",
7: "MMARVALID", 8: "IBUSERR", 9: "PRECISERR", 10: "IMPRECISERR",
11: "UNSTKERR", 12: "STKERR", 15: "BFARVALID", 16: "UNDEFINSTR",
17: "INVSTATE", 18: "INVPC", 19: "NOCP", 24: "UNALIGNED",
25: "DIVBYZERO"}
HFSR = {1: "VECTTBL", 30: "FORCED", 31: "DEBUGEVT"}
def group(bit):
return "MemManage" if bit < 8 else "BusFault" if bit < 16 else "UsageFault"
def decode(cfsr, hfsr):
c = [f"{group(b)}.{n}" for b, n in CFSR.items() if cfsr >> b & 1]
h = [n for b, n in HFSR.items() if hfsr >> b & 1]
return " + ".join(c) or "-", " ".join(h) or "-"
cases = [("bad pointer read", 0x00008200, 0x40000000),
("x / 0 (DIV_0_TRP = 1)", 0x02000000, 0x40000000),
("call via even address", 0x00020000, 0x40000000),
("stack overflow on entry", 0x00001000, 0x40000000),
("bad vector table entry", 0x00000000, 0x00000002)]
for label, c, h in cases:
cf, hf = decode(c, h)
print(f"{label:24} CFSR=0x{c:08X} HFSR=0x{h:08X}")
print(f" {cf} | HFSR: {hf}")আসল আউটপুট (ব্রাউজারের Python):
bad pointer read CFSR=0x00008200 HFSR=0x40000000
BusFault.PRECISERR + BusFault.BFARVALID | HFSR: FORCED
x / 0 (DIV_0_TRP = 1) CFSR=0x02000000 HFSR=0x40000000
UsageFault.DIVBYZERO | HFSR: FORCED
call via even address CFSR=0x00020000 HFSR=0x40000000
UsageFault.INVSTATE | HFSR: FORCED
stack overflow on entry CFSR=0x00001000 HFSR=0x40000000
BusFault.STKERR | HFSR: FORCED
bad vector table entry CFSR=0x00000000 HFSR=0x00000002
- | HFSR: VECTTBL
প্রথম সারি hf_log.c-এর ঘটনার আসল-chip রূপ: একটি “precise” BusFault, অর্থাৎ ঠিক যে নির্দেশ পড়েছিল তার PC-ই stacked, আর BFAR-এ 0x60000000 থাকত (কোন ঠিকানায় আসলে bus error হবে, তা chip-এর memory map-এর ওপর নির্ভর করে)। দ্বিতীয় সারি মনে করিয়ে দেয়, Cortex-M3-এ শূন্য দিয়ে ভাগ ডিফল্টভাবে fault নয়, ফল ০; CCR-এর DIV_0_TRP চালু করলে তবেই UsageFault. তৃতীয়টি function pointer-এর Thumb বিট ০ থাকার ক্লাসিক ভুল। চতুর্থটি exception-এ ঢোকার সময়ই stack-এ লিখতে না পারা, যা প্রায়ই stack overflow-এর চিহ্ন (পর্ব ৩৯)। শেষটিতে CFSR শূন্য, কারণ vector table থেকে handler-এর ঠিকানাই পড়া যায়নি।
Handler-এর ভেতরে সাবধান: HardFault handler-এর ভেতরে আবার fault হলে Cortex-M lockup-এ যায়: CPU থামে, শুধু reset বা debugger বের করতে পারে (কোর্সের board-এও run থেমে যায়, Spec decision 19). তাই handler যত সম্ভব ছোট: stack-এর ওপর ভরসা না করা (stack overflow-ই হয়তো কারণ), বড় library ডাকা নয়, UART-এ একটি ছোট বার্তার বেশি নয়, আর flash-এ লেখা তো নয়ই। নিরাপদ পথ: ঠিকানা-নির্দিষ্ট .noinit-এ কয়েকটি word লেখা আর reset.
৭ · Boot loop, brown-out আর backoff
Reset সমাধান হয় তখনই, যখন সমস্যাটি সাময়িক: একটি হারানো উত্তর, একটি electrical noise. কিন্তু কারণ যদি স্থায়ী হয়, যেমন নষ্ট configuration, ভাঙা sensor বা ভুল firmware update, reset শুধু একই ভুল আবার ঘটায়। Brown-out-এ আরেকটি পরিচিত চক্র আছে: দুর্বল battery-র একটি যন্ত্র boot করে, radio চালু করে বড় current টানে, battery-র voltage এক মুহূর্তে নেমে যায়, brown-out reset, আবার boot, আবার radio. Battery বিশ্রামে voltage ফেরে বলে চক্রটি চলতেই থাকে, আর প্রতিবার battery-র বাকি শক্তিও খরচ হয়। Brown-out-এর hardware-এর দিক পর্ব ৩৩-এ; firmware-এর উত্তর তিনটি:
- গোনা:
.noinit-এ crash বা reset-এর counter, magic-সহ আরvolatile. একটি নির্দিষ্ট সময় সুস্থ চললে (যেমন ৬০ s) counter শূন্য। - পিছিয়ে আসা: প্রতিবার ব্যর্থতার পরে আবার চেষ্টার আগে অপেক্ষা বাড়ানো, যাকে বলে exponential backoff: 1 s, 2 s, 4 s … Brown-out-এর ক্ষেত্রে বড় load চালুর আগে supply মাপাও এর অংশ (STM32-এ PVD, পর্ব ৩৩)।
- থামা আর জানানো: সীমা পেরোলে safe mode: শুধু ন্যূনতম, নিরাপদ কাজ, আর একটি স্পষ্ট সংকেত (alarm, LED-এর ধরন, বা telemetry-তে “SAFE MODE”), যাতে মানুষ এসে দেখে।
নিচের C ব্লক সিদ্ধান্তের অংশটি host-এ চালায়: সাতটি boot-এর একটি কাল্পনিক ক্রম, যেখানে মাঝে একবার যন্ত্র সুস্থ চলেছে। আসল যন্ত্রে crashes থাকবে .noinit-এ, আর “wait” হবে কাজ শুরুর আগে ঘুম।
#include <stdio.h>
#include <stdint.h>
/* boot-loop guard: the crash counter lives in .noinit on the real device */
enum { RUN_NORMAL, RUN_DELAYED, SAFE_MODE };
static const char *name[] = {"normal", "delayed retry", "SAFE MODE"};
static int decide(uint32_t crashes)
{
return crashes >= 3 ? SAFE_MODE : crashes ? RUN_DELAYED : RUN_NORMAL;
}
static uint32_t backoff_ms(uint32_t crashes) /* 0, 1000, 2000, 4000 ... */
{
return crashes == 0 ? 0 : 1000u << (crashes - 1);
}
int main(void)
{
/* 1 = this boot crashed (watchdog or HardFault), 0 = ran 60 s healthy */
const int crashed[] = {1, 1, 0, 1, 1, 1, 1};
uint32_t crashes = 0;
for (int b = 0; b < 7; b++) {
int d = decide(crashes);
printf("boot %d: crashes=%u -> %-13s", b + 1, (unsigned)crashes, name[d]);
if (d == SAFE_MODE) {
printf(" stay safe, report\n");
break;
}
printf(" wait %4u ms", (unsigned)backoff_ms(crashes));
crashes = crashed[b] ? crashes + 1 : 0;
printf(" -> %s\n", crashed[b] ? "crashed" : "healthy, counter = 0");
}
return 0;
}আসল আউটপুট (Wandbox-এর gcc):
boot 1: crashes=0 -> normal wait 0 ms -> crashed
boot 2: crashes=1 -> delayed retry wait 1000 ms -> crashed
boot 3: crashes=2 -> delayed retry wait 2000 ms -> healthy, counter = 0
boot 4: crashes=0 -> normal wait 0 ms -> crashed
boot 5: crashes=1 -> delayed retry wait 1000 ms -> crashed
boot 6: crashes=2 -> delayed retry wait 2000 ms -> crashed
boot 7: crashes=3 -> SAFE MODE stay safe, report
তৃতীয় boot সুস্থ চলায় counter শূন্যে ফিরেছে; একটি সাময়িক সমস্যা তাই যন্ত্রকে safe mode-এ ঠেলে দেয়নি। পরে টানা তিনবার ভাঙায় সপ্তম boot-এ যন্ত্র থেমেছে। অপেক্ষা 1000 ms থেকে দ্বিগুণ হয়ে 2000 ms; বাস্তবে একটি ওপরের সীমা আর অনেক যন্ত্র একসঙ্গে থাকলে একটু এলোমেলো যোগ (jitter) রাখা হয়, যাতে বিদ্যুৎ ফেরার পরে সব যন্ত্র একই মুহূর্তে server-এ ঝাঁপিয়ে না পড়ে।
৮ · পরীক্ষার ধাঁচে — একটি পূর্ণ watchdog-এর হিসাব
বিশ্ববিদ্যালয়, চাকরি আর ইন্টারভিউর পরীক্ষায় watchdog-এর প্রশ্ন সাধারণত দুই রকম: timeout-এর সংখ্যা আর “কোথায় kick করবেন” ধরনের নকশা। একটি পূর্ণ উদাহরণ, ধাপে ধাপে, এককসহ:
প্রশ্ন: একটি STM32F103-এর main loop সুস্থ অবস্থায় সর্বোচ্চ 400 ms-এ একবার ঘোরে, আর ৫০% নিরাপত্তা-ফাঁক চাই। (ক) IWDG-এর timeout-এর নিচের সীমা কত? (খ) PR = 3 (÷32) ধরে সবচেয়ে দ্রুত LSI (60 kHz)-এ সেই সীমা নিশ্চিত করতে RLR কত? (গ) সবচেয়ে ধীর LSI (30 kHz)-এ আসল timeout কত? (ঘ) একই chip-এ WWDG, PCLK1 = 36 MHz, WDGTB = 3, T = 0x7F, W = 0x5F হলে kick-এর জানালা কখন খোলে আর বন্ধ হয়?
- নিচের সীমা = 400 ms × 1.5 = 600 ms.
- t = 4 × 2PR × (RLR + 1) ÷ f, তাই RLR + 1 = 600 ms × 60 000 Hz ÷ (4 × 8) = 36 000 ÷ 32 = 1125; RLR = 1124, যা ১২ বিটে (সর্বোচ্চ 4095) আঁটে।
- 30 kHz-এ: 4 × 8 × 1125 ÷ 30 000 = 36 000 ÷ 30 000 = 1.2 s. অর্থাৎ নিশ্চয়তা 600 ms-এর, কিন্তু উদ্ধার আসতে 1.2 s-ও লাগতে পারে।
- WWDG-এর এক গণনা = 4096 × 23 ÷ 36 MHz = 910.22 µs. জানালা খোলে counter 0x5F-এ: (0x7F − 0x5F) = ৩২ গণনা = 29.13 ms. বন্ধ হয় counter 0x3F-এ: ৬৪ গণনা = 58.25 ms, আর তার এক গণনা আগে, 57.34 ms-এ EWI.
(গ) আর (ঘ)-এর সংখ্যা অংশ ২-এর Python ব্লকের সূত্রের সঙ্গে মেলে; (খ)-এর হিসাব একই ব্লকের choose_iwdg(600) দিয়েও যাচাই করা যায়। তিনটি পরিচিত ফাঁদ: “+1” ভুলে যাওয়া (RLR-এ N − 1 লিখলে N গণনা), typical 40 kHz ধরে নিশ্চয়তা দেওয়া, আর WWDG-এ “খুব আগে” kick-ও যে reset দেয় তা ভুলে যাওয়া।
পরীক্ষা ও ইন্টারভিউতে: “Watchdog timer কী আর কেন?” → firmware নিয়মিত reload না করলে system reset করা counter; আটকে যাওয়া যন্ত্রকে নিজে নিজে ফেরানোর জন্য। “IWDG আর WWDG-এর পার্থক্য?” → IWDG নিজস্ব LSI-তে চলে, শুধু দেরি ধরে; WWDG APB clock-এ চলে, খুব আগে আর খুব দেরি দুটিই ধরে, আর EWI দেয়। “SysTick-এর ISR-এ watchdog kick করলে সমস্যা কী?” → main বা কোনো task আটকে থাকলেও ISR চলে, তাই watchdog কিছুই ধরে না; task check-in লাগে। “HardFault handler-এ কী করবেন?” → stacked PC/LR আর CFSR/HFSR .noinit-এ রেখে reset, পরের boot-এ পড়া। “Reset-এর পরে বারবার crash হলে?” → crash counter, backoff, আর সীমা পেরোলে safe mode.
৯ · AI-এর যুগে watchdog আর fault handling যাচাই
“STM32-এ watchdog চালু করার কোড দিন” বললে AI assistant কয়েক সেকেন্ডে কাজ চলার মতো কোড দেয়, আর প্রায়ই kick বসায় SysTick-এর ISR-এ, কারণ “সেখানে নিশ্চিত চলবে”. কোড চলবে, test-এ reset-ও হবে না; কিন্তু সেটাই সমস্যা। কয়েকটি পরিচিত ভুল আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
| Kick বসায় timer-এর ISR-এ বা main loop-এর শুরুতে, অন্ধভাবে | ইচ্ছা করে একটি task আটকে দিয়ে চালানো; কোর্সের board-এ kick_isr 7 s-এও reset দেয়নি |
| Timeout হিসাব করে typical LSI (40 kHz) ধরে, বা “+1” বাদ দেয় | 30 আর 60 kHz দুই প্রান্তে হিসাব; সূত্র RM0008-এ মেলানো |
| WWDG-কে IWDG-এর মতো ব্যবহার করে, window-এর নিয়ম ভুলে যায়, বা 7 বিটের counter-এ 0x40-এর নিচের মান লেখে | Counter-এর সময়রেখা আঁকা: কখন W, কখন 0x40, কখন 0x3F |
| অন্য পরিবারের register বা বিটের নাম মেশায় (STM32F4/L4-এর WINR বা option byte F1-এ), বা ঠিকানা বানিয়ে বলে | নিজের chip-এর reference manual-এ প্রতিটি register আর বিট খোঁজা |
| HardFault handler-এ printf, malloc বা flash-এ লেখা রাখে; stack-এর ওপর ভরসা করে | Handler-এর কোড পড়া; stack overflow-এর পরিস্থিতি simulator-এ চালানো |
.noinit-এর log-এ magic বা CRC রাখে না, বা volatile দেয় না | Map file-এ variable-এর আকার দেখা; power-on-এর এলোমেলো SRAM ধরে নিয়ে যুক্তি করা |
| Boot loop-এর কথা ভাবে না: প্রতিবার fault-এ শুধু reset | একটি স্থায়ী fault দিয়ে চালানো, যেমন hf_log.c-এর নষ্ট pointer; safe mode আসে কি না |
AI-কে কাজে লাগাতে chip, নকশার নিয়ম আর যাচাইয়ের শর্ত শুরুতেই দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১১৯৯৭ সালে মঙ্গলগ্রহে Mars Pathfinder বারবার নিজে নিজে reset হচ্ছিল। এই ঘটনা watchdog আর reset-এর নকশা নিয়ে কী শেখায়?
Mars Pathfinder ১৯৯৭ সালের জুলাইয়ে মঙ্গলে নামে। কয়েক দিনের মধ্যে মহাকাশযানের computer মাঝে মাঝে পুরো system reset করতে শুরু করে, আর প্রতিবার সেদিনের কিছু data হারায়। পরে দলের প্রকৌশলী Glenn Reeves-এর বিবরণ থেকে যা জানা যায় (খুঁটিনাটি উৎসভেদে সামান্য আলাদা), তা মোটামুটি এমন: RTOS (VxWorks)-এ একটি কম priority-র task একটি shared resource-এর mutex ধরে রেখেছিল, একটি বেশি priority-র task সেই mutex-এর অপেক্ষায় আটকে ছিল, আর মাঝারি priority-র task-গুলো কম priority-রটিকে চলতে দিচ্ছিল না। এটি ক্লাসিক priority inversion, যা পর্ব ৫৭-এ কোর্সের RTOS simulator-এ দেখেছেন।
এই পর্বের জন্য আকর্ষণীয় দিক হলো কে সমস্যাটি ধরল। Software-এ একটি পর্যায়ক্রমিক পরীক্ষা ছিল: নির্দিষ্ট সময়ের মধ্যে একটি গুরুত্বপূর্ণ কাজ শেষ হয়েছে কি না। শেষ না হলে system “কিছু ভয়ংকর ভুল হয়েছে” ধরে পুরো reset দিত। অর্থাৎ এটি একধরনের task-ভিত্তিক watchdog, ঠিক এই পর্বের check-in-এর মতো: কেউ সময়মতো কাজ শেষ করেনি, তাই reset. এই ব্যবস্থা মহাকাশযানটিকে চিরকালের জন্য আটকে থাকা থেকে বাঁচিয়েছে, কারণ reset-এর পরে system আবার কাজ শুরু করত।
কিন্তু reset সমস্যা সারায়নি, কারণটি থেকেই গিয়েছিল। সমাধান এল পৃথিবী থেকে: দলটি ল্যাবের একটি নকল system-এ ঘটনাটি আবার ঘটাতে পেরেছিল, কারণ software-এ trace চালু রাখার ব্যবস্থা ছিল; তারপর সেই mutex-এর priority inheritance চালু করার একটি ছোট পরিবর্তন দূর থেকে পাঠানো হয়।
শিক্ষা তিনটি। এক, watchdog বা deadline-এর পরীক্ষা যন্ত্রকে বাঁচায়, কিন্তু শুধু reset করে থেমে গেলে একই ঘটনা বারবার ঘটে; reset-এর কারণ আর অবস্থা log করা জরুরি, যাতে কেউ পরে বুঝতে পারে। দুই, পরীক্ষাটি task-এর কাজের ওপর ছিল, কোনো timer ISR-এর ওপর নয়; অন্ধ kick থাকলে সমস্যাটি হয়তো ধরা পড়ত না, মহাকাশযান “জীবিত” কিন্তু অকেজো থাকত। তিন, মাঠের যন্ত্রে পরে কিছু বদলানোর পথ (এখানে দূর থেকে patch) নকশার অংশ, যার আধুনিক রূপ OTA update (পর্ব ৭৫)।
মূল উপলব্ধি: Task-ভিত্তিক watchdog যন্ত্রকে আটকে থাকা থেকে বাঁচায়, আর log সেই reset-কে একটি bug-এর ঠিকানায় পরিণত করে; দুটি একসঙ্গে না থাকলে একটি অন্যটির অর্ধেক।
প্র ০২“যে watchdog সবসময় kick পায়, সে কোনো watchdog নয়।” SysTick-এর ISR বা main loop-এর শুরুতে kick এত প্রচলিত কেন, আর এর ক্ষতি কতটা গভীর?
প্রচলিত হওয়ার কারণ সহজ: সুবিধা। Watchdog চালু করার পরে প্রথম যে সমস্যা আসে, তা হলো অকারণ reset. Flash মোছার সময়, Wi-Fi-র সংযোগের চেষ্টায়, বা debug-এর একটি লম্বা printf-এর সময় main loop দেরি করে, আর watchdog reset দেয়। দ্রুত সমাধান: kick এমন জায়গায় বসানো যা “নিশ্চিত চলবে”, যেমন 1 ms-এর SysTick-এর ISR. অকারণ reset বন্ধ, সবাই খুশি। কিন্তু এর সঙ্গে watchdog-এর আসল কাজটিও বন্ধ হয়ে গেল।
এই পর্বের সত্যিকারের run তা স্পষ্ট দেখায়। kick_isr-এ SENSOR task-এর state machine 3 s-এ আটকে গেছে, আর 7 s-এ আমরা নিজেরা থামানো পর্যন্ত watchdog একবারও reset দেয়নি। Cold room-এর জন্য এর মানে তাপমাত্রা আর পড়া হচ্ছে না, alarm-এর সিদ্ধান্ত নেওয়ার কেউ নেই, অথচ যন্ত্র বাইরে থেকে “চালু”; COMM task-ও হয়তো পুরোনো মান পাঠাতে থাকবে।
গভীর ক্ষতিটি মানসিক। Watchdog থাকা মানে দলের সবাই নিশ্চিন্ত থাকে যে “আটকে গেলে watchdog বাঁচাবে”, আর এই ভরসায় অন্য সুরক্ষা, যেমন প্রতিটি অপেক্ষায় সময়সীমা, বাদ পড়ে। অথচ বাস্তবে watchdog কিছুই দেখছে না। এমন ভুল test-এ ধরা পড়ে না, কারণ test-এ সাধারণত কেউ ইচ্ছা করে একটি task আটকে দেয় না; ধরা পড়ে মাঠে, বিরল একটি ঘটনায়। নিরাপত্তা-সংবেদনশীল ক্ষেত্রের নির্দেশিকায় তাই প্রায়ই চাওয়া হয় যে watchdog-এর সেবা প্রোগ্রামের প্রবাহের সঙ্গে যুক্ত থাকবে, শুধু সময়ের সঙ্গে নয়।
সঠিক পথে অকারণ reset-এর সমস্যারও উত্তর আছে: timeout-কে লম্বা পথ মেপে বাছাই (অংশ ৩), flash মোছার মতো জানা লম্বা কাজকে ছোট টুকরোয় ভাগ করে মাঝে হাজিরা দেওয়া, আর প্রতিটি task-এর নিজের সময়সীমা। আর একটি অভ্যাস: প্রতিটি release-এর আগে একটি “task আটকে দেওয়া” test, যেখানে reset আসতেই হবে।
মূল উপলব্ধি: Watchdog যা দেখে তা-ই রক্ষা করে; অন্ধ kick শুধু timer-এর বেঁচে থাকা দেখে, task check-in প্রতিটি কাজের অগ্রগতি দেখে।
প্র ০৩“খুব আগে” kick করলে reset দেওয়ার ধারণাটি অদ্ভুত শোনায়। Window watchdog কোন ভুল ধরে, আর বাইরের watchdog chip কেন ব্যবহার হয়?
সাধারণ watchdog একটি প্রশ্ন করে: “শেষ kick-এর পরে বেশি সময় গেছে কি?” কিন্তু কিছু ব্যর্থতায় firmware থামে না, বরং ভুল পথে খুব দ্রুত ঘোরে। ধরুন একটি নষ্ট function pointer বা stack-এর গোলমালে CPU একটি ছোট loop-এ পড়েছে, আর সেই loop-এর ভেতরে ঘটনাক্রমে kick-এর লাইনটি আছে; অথবা একটি bug সময় মাপার গণনাকে এত ছোট করেছে যে প্রতিটি “1 s”-এর কাজ আসলে কয়েক ms-এ চলছে। সাধারণ watchdog এগুলো দেখে খুশি থাকে, কারণ kick আসছে, আরও ঘন ঘন। Window watchdog দ্বিতীয় প্রশ্নটিও করে: “kick কি প্রত্যাশিত সময়ের আগেই এসেছে?” STM32F1-এর WWDG-এ counter W-এর ওপরে থাকতে refresh করলেই reset, তাই firmware-কে একটি নির্দিষ্ট ছন্দে চলতে হয়, একটি নির্দিষ্ট পাল্লার ভেতরে।
এর আরেকটি সুবিধা EWI: reset-এর ঠিক আগে একটি interrupt, যেখানে firmware একটি ছোট log রাখতে পারে বা output নিরাপদ করতে পারে। অসুবিধাও আছে: WWDG মূল clock-এ চলে, তাই clock থেমে গেলে সেও থামে; আর এর পাল্লা ছোট (36 MHz-এ সর্বোচ্চ 58.25 ms), তাই লম্বা loop-এ ব্যবহার কঠিন। সেজন্য নকশায় প্রায়ই দুটিই রাখা হয়: IWDG “আটকে যাওয়া” ধরে, WWDG “ছন্দ ভাঙা” ধরে।
আরও এক ধাপ এগিয়ে কিছু নকশায় watchdog chip-এর বাইরে রাখা হয়: একটি আলাদা supervisor বা watchdog IC, যার নিজের oscillator আর নিজের reset লাইন। কারণ chip-এর ভেতরের watchdog আর CPU একই silicon, একই supply আর অনেক সময় একই reset ব্যবস্থা ভাগ করে; একটি সাধারণ কারণের ব্যর্থতা (common-cause failure) দুটিকেই একসঙ্গে বিকল করতে পারে। বাইরের অনেক watchdog IC-তে window-এর ধারণা থাকে, কিছুতে একটি প্রশ্ন-উত্তরের ব্যবস্থা থাকে যেখানে CPU-কে প্রতিবার সঠিক উত্তর দিতে হয়, শুধু একটি pulse নয়। Functional safety-এর মানদণ্ড (যেমন IEC 61508, গাড়িতে ISO 26262) সরাসরি কোনো একটি watchdog চাপিয়ে দেয় না, কিন্তু ঝুঁকির মাত্রা অনুযায়ী ব্যর্থতা ধরার স্বাধীন ব্যবস্থার প্রমাণ চায়; সেখানে এমন নকশা প্রচলিত। এর বিস্তার পর্ব ৬৩ (নির্ভরযোগ্যতা আর safety)-এ।
মূল উপলব্ধি: সাধারণ watchdog দেরি ধরে, window watchdog ছন্দ ধরে, আর বাইরের watchdog chip-এর নিজের ব্যর্থতা থেকেও আলাদা থাকে; ঝুঁকি যত বেশি, পাহারাদার তত স্বাধীন।
প্র ০৪১৯৬৯ সালে Apollo 11 চাঁদে নামার মুহূর্তে computer “1202” alarm দিচ্ছিল, তবু অবতরণ থামেনি। এই ঘটনা fault-এর পরে নিরাপদে ফেরার নকশা নিয়ে কী বলে?
Apollo 11-এর lunar module চাঁদে নামার শেষ কয়েক মিনিটে Apollo Guidance Computer কয়েকবার 1202 আর 1201 alarm দেয়। সাধারণভাবে যা বর্ণনা করা হয়: একটি radar-এর সংযোগের কারণে computer-এর ওপর প্রত্যাশার চেয়ে বেশি কাজ এসে পড়ছিল, আর executive, অর্থাৎ ছোট scheduler-টি, নতুন কাজের জন্য জায়গা পাচ্ছিল না। প্রথম প্রজন্মের embedded computer-এর জন্য এটি একটি ভয়ংকর মুহূর্ত হতে পারত। কিন্তু software-টি, যার নকশায় Margaret Hamilton-এর নেতৃত্বাধীন MIT-র দলের বড় ভূমিকা ছিল বলে সাধারণত বলা হয়, এমন অবস্থার জন্য প্রস্তুত ছিল।
Computer একটি “restart” করত: বর্তমান কাজগুলো ফেলে দিয়ে, কিন্তু আগে থেকে চিহ্নিত গুরুত্বপূর্ণ কাজগুলোর অবস্থা রক্ষিত জায়গা থেকে তুলে নিয়ে আবার শুরু। কম গুরুত্বের কাজ বাদ পড়ত, অবতরণের নিয়ন্ত্রণ চলতে থাকত। মাটিতে নিয়ন্ত্রণকক্ষের দল দ্রুত সিদ্ধান্ত নেয় যে alarm-টি এই অবস্থায় “চালিয়ে যাওয়া যায়” ধরনের, আর অবতরণ সফল হয়। সূত্রভেদে খুঁটিনাটি সামান্য আলাদা, তবে মূল ধারণা নিয়ে মতভেদ কম।
এই পর্বের ভাষায় এখানে তিনটি নকশার নীতি একসঙ্গে। এক, fault-এর পরে পুরো system থেমে যায় না, নিয়ন্ত্রিতভাবে আবার শুরু হয়, যেমন hf_log.c HardFault-এ থেমে না থেকে reset দেয়। দুই, যে অবস্থা reset পেরিয়ে টিকে থাকা দরকার, তা আগে থেকে আলাদা জায়গায় রাখা থাকে, ঠিক আমাদের .noinit-এর log আর counter-এর মতো; আর যা রক্ষা করা হয়নি, তা হারালে ক্ষতি নেই বলে নকশাতেই ঠিক করা। তিন, ফেরার পরে সব কাজ একসঙ্গে নয়: গুরুত্বের ক্রমে, কম জরুরি কাজ বাদ দিয়ে, যাকে আজ graceful degradation বলি। আরেকটি শিক্ষা মানুষের দিকে: alarm-এর অর্থ মানুষ আগে থেকে জানত, তাই সঠিক সিদ্ধান্ত দ্রুত এসেছে; মাঠের যন্ত্রের log আর reset-এর কারণ পরিষ্কার না হলে সেই সিদ্ধান্ত নেওয়া যায় না।
মূল উপলব্ধি: ভালো fault handling মানে ভাঙা থেকে নিয়ন্ত্রিতভাবে ফেরা: জরুরি অবস্থা রক্ষা, অপ্রয়োজনীয় কাজ বাদ, আর পরিষ্কার সংকেত, যাতে মানুষ জানে কী ঘটছে।
প্র ০৫Reset-এর পরে টিকে থাকা ছোট একটি log বা counter কেন এত ভঙ্গুর? Compiler, power-on আর brown-out মিলে কোন কোন ভুল ঘটাতে পারে?
.noinit-এর ধারণাটি সরল: SRAM-এর এমন একটি জায়গা, যা startup code ছোঁয় না, তাই watchdog বা software reset-এর পরেও আগের মান থাকে। কিন্তু এই সরলতার নিচে তিন স্তরের অনিশ্চয়তা।
প্রথম স্তর ভাষার। C-এর abstract machine-এ একটি static variable program শুরুর আগে শূন্য; “এই variable reset পেরিয়ে টিকে থাকে” ধারণাটি C জানে না। ফলে compiler এমন অনুমান করতে পারে যা আমাদের উদ্দেশ্যের বিরুদ্ধে। এই পর্বের map file-এ ঠিক তাই দেখা গেছে: Clang 22.1.8 reference-এর watchdog.c-এর আগের সংস্করণে ৪ byte-এর boot_magic-কে ১ byte-এর একটি bool বানিয়েছিল, কারণ C-এর হিসাবে তার মান কেবল শূন্য বা magic হতে পারে। volatile যোগ করতেই আকার ৪ byte-এ ফিরেছে, আর প্রতিটি পড়া-লেখা আসল হয়েছে; reference firmware এখন তাই volatile দিয়েই লেখা। এটি compiler-এর ভুল নয়; এটি এমন একটি জায়গা যেখানে আমরা ভাষার নিয়মের বাইরে কাজ করছি, তাই compiler-কে স্পষ্ট করে বলতে হয়।
দ্বিতীয় স্তর hardware-এর। প্রথম power-on-এ SRAM-এর প্রতিটি বিট কোন মান নেবে, তা নির্দিষ্ট নয়; একটি ৩২ বিটের magic ঘটনাক্রমে মিলে যাওয়ার সম্ভাবনা খুব কম, কিন্তু ১ বিটের bool-এর ক্ষেত্রে তা প্রায় আধাআধি। কিছু chip-এ reset-এর পরে ROM-এর bootloader SRAM-এর অংশ ব্যবহার করে, কিছুতে নিরাপত্তার জন্য reset-এ SRAM মোছা যায়। তাই নিজের chip-এর manual-এ দেখে নিতে হয় কোন reset-এ কী টিকে থাকে।
তৃতীয় স্তর সময়ের। Brown-out-এর সময় voltage নামতে নামতে SRAM-এ লেখার মাঝপথে reset আসতে পারে: struct-এর অর্ধেক নতুন, অর্ধেক পুরোনো। পর্ব ৩৮-এর fault log তাই magic সবশেষে লেখে, যাতে অসম্পূর্ণ log বৈধ না দেখায়; আরও মজবুত পথ পুরো log-এর ওপর একটি CRC, আর প্রয়োজনে দুটি কপি। খুব নিচু voltage-এ SRAM-এর মান নিজেও নষ্ট হতে পারে, তাই brown-out-এর পরে log-কে সন্দেহের চোখে দেখা ভালো।
মূল উপলব্ধি: Reset পেরিয়ে টিকে থাকা তথ্য ভাষা, hardware আর সময় তিনটিরই বাইরে; volatile, যথেষ্ট বড় magic, সবশেষে লেখা আর CRC দিয়ে তাকে প্রমাণ করতে হয়, ধরে নেওয়া যায় না।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর কোর্সের virtual board-এ, host-এর C-তে বা Python-এ চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — তিন task-এর supervisor: Cold-storage monitor-এ এখন তিনটি task: SENSOR (প্রতি 1 s-এ পড়া), TELEMETRY (প্রতি 10 s-এ পাঠানো) আর DISPLAY (প্রতি 100 ms-এ হালনাগাদ)। একটি বিটের হাজিরা আর চলে না, কারণ TELEMETRY প্রতি 1 s-এ হাজিরা দেবে না। প্রতিটি task-এর নিজের সময়সীমাসহ একটি check-in আর প্রতি 100 ms-এ চলা supervisor-এর C function লিখুন, আর IWDG-এর timeout কত রাখবেন বলুন।
প্রতিটি task নিজের শেষ হাজিরার সময় রাখে; supervisor দেখে কেউ নিজের সীমা পেরিয়েছে কি না:
#define NTASK 3 static const uint32_t limit_ms[NTASK] = {2000, 15000, 300}; /* SENSOR, TELEM, DISPLAY */ static volatile uint32_t last_seen[NTASK]; void checkin(int id) { last_seen[id] = ms_ticks; } /* কাজ শেষ হলে */ void supervisor_100ms(void) { for (int i = 0; i < NTASK; i++) if (ms_ticks - last_seen[i] > limit_ms[i]) { wd_missing = (uint32_t)i; /* .noinit, volatile */ return; /* kick নয় */ } IWDG->KR = 0xAAAAu; }সীমাগুলো প্রতিটি period-এর দেড় থেকে দুই গুণ (1 s → 2 s, 10 s → 15 s, 100 ms → 300 ms). ৩২ বিটের একটি word-এর লেখা Cortex-M3-এ একটি নির্দেশ, তাই
last_seen-এ lock লাগে না; বিয়োগ unsigned বলেms_ticksঘুরে গেলেও ঠিক থাকে। Supervisor প্রতি 100 ms-এ চলে, তাই IWDG 500 ms রাখা যায় (সবচেয়ে দ্রুত LSI ধরে)। আমার lab-এ host-এর C-তে এই function একটি নকল সময়রেখায় চালানো হয়েছে: SENSOR 24 s-এর পরে থেমে গেলে supervisor 26050 ms-এ তাকে অনুপস্থিত পায় (26050 − 24000 = 2050 > 2000), শেষ kick 25950 ms-এ, আর 500 ms-এর watchdog reset 26451 ms-এ, অনুপস্থিত task 0 (SENSOR), ততক্ষণে ২৬০টি kick. Clang 22.1.8-এ-Wall -Wextra-তে কোনো warning নেই। -
ভুল খুঁজুন — সুস্থ যন্ত্রে watchdog reset:
checkin.c-এর প্রথম সংস্করণে supervisor চলত প্রতি 1 s-এ, 500 ms থেকে (if (ms_ticks % 1000u != 500u) return;), আর IWDG ছিল 1500 ms. SENSOR প্রথম পড়া নেয় 1000 ms-এ। কোনো task আটকানোর আগেই board-এর সত্যিকারের run এমন এল:
দুটি ভুল কী, আর কীভাবে সারাবেন?[ 0.0464 ms] watchdog started, timeout 1500 ms [ 500.0763 ms] UART: supervisor: SENSOR missing, no kick [ 1000.0705 ms] UART: sensor: reading 1 ok [ 1500.0464 ms] RESET (watchdog timeout) [ 1500.0871 ms] UART: boot #2, reset cause: WATCHDOGভুল ১, startup-এর ছাড় নেই: supervisor-এর প্রথম পরিদর্শন 500 ms-এ, অথচ SENSOR-এর প্রথম পড়া 1000 ms-এ। তাই সুস্থ firmware-ও “অনুপস্থিত”, কোনো kick হয়নি, আর watchdog চালুর ঠিক 1500 ms পরে, 1500.0464 ms-এ reset. ভুল ২, timeout প্রথম ফাঁকের সমান: শুধু 1500 ms থেকে পরিদর্শন শুরু করলেও কাজ হয় না; আমার lab-এ সেই সংস্করণও চালানো হয়েছে, আর 1500.0464 ms-এ reset এসেছে, কারণ watchdog-এর deadline (চালু 0.0464 + 1500) SysTick-এর 1500তম tick-এর ISR-এর আগেই পড়ে। সংশোধন, যা অংশ ৪-এর firmware-এ আছে: প্রথম পরিদর্শন 1.5 s-এ (
ms_ticks < 1500uহলে ফিরে যাওয়া), আর timeout 1800 ms, প্রথম ফাঁক 1.5 s-এর ওপরে একটি নিরাপত্তা-ফাঁকসহ। তখন kick আসে 1500 আর 2500 ms-এ, আর reset শুধু আসল আটকে যাওয়ায়, 4300.0477 ms-এ। এই অনুশীলনের শিক্ষা: watchdog-এর timeout সবচেয়ে বড় সুস্থ ফাঁক দিয়ে ঠিক হয়, আর boot-এর শুরুটা প্রায়ই সেই সবচেয়ে বড় ফাঁক। -
হিসাব — WWDG-এর জানালা: STM32F1-এর WWDG-এ PCLK1 = 36 MHz, WDGTB = 2, refresh-এ counter T = 0x7F, window W = 0x50. (ক) এক গণনা কত µs? (খ) Refresh-এর পরে কখন থেকে আবার refresh বৈধ? (গ) EWI আর reset কখন? (ঘ) কোনো bug-এ firmware refresh-এর 10 ms পরে আবার refresh করল; কী হবে? 25 ms পরে করলে?
(ক) 4096 × 22 ÷ 36 000 000 Hz = 455.11 µs. (খ) Counter W = 0x50-এ নামলে: 0x7F − 0x50 = ৪৭ গণনা × 0.45511 ms = 21.39 ms. (গ) EWI counter 0x40-এ: ৬৩ গণনা = 28.67 ms; reset 0x3F-এ: ৬৪ গণনা = 29.13 ms. (ঘ) 10 ms-এ পূর্ণ গণনা হয়েছে ২১টি, counter 0x7F − 21 = 0x6A, যা W = 0x50-এর চেয়ে বড়: খুব আগে, তাই reset, RCC_CSR-এ WWDGRSTF. 25 ms-এ ৫৪টি গণনা, counter 0x49 ≤ 0x50, তাই বৈধ, counter আবার 0x7F. আমার lab-এর Python-এ যাচাই:
window opens 21.39 ms, EWI 28.67, reset 29.13,refresh at 10 ms: counter 0x6A -> RESET (too early),refresh at 25 ms: counter 0x49 -> ok. কোর্সের board-এ WWDG নেই, তাই এটি board-এ চালানো যায়নি। -
আগে বলুন, তারপর মিলিয়ে দেখুন — crash-এর সীমা ২:
hf_log.c-এ শুধু#define MAX_CRASH 3uবদলে2uকরা হলো; বাকি সব হুবহু, safe mode-এর বার্তার লেখাও। Calibration pointer আগের মতোই নষ্ট। কোন boot-এ safe mode আসবে, মোট কয়টি HardFault হবে, আর safe mode-এর লাইনে কী ছাপা হবে?Boot #1-এ fault (crashes = 1), boot #2 log পড়ে (১ < ২) আবার চেষ্টা করে আর fault (crashes = 2), boot #3 log-এ crashes ২ দেখে safe mode-এ যায়। মোট ২টি HardFault. কোর্সের board-এ সত্যিকারের run-এ ঠিক তাই:
boot #3, reset cause: SOFTWARE,fault log: crash 2 PC=0x08000250 LR=0x080001CF R0=0x60000000, তারপর 0.4249 ms-এ বার্তা, 0.4255 ms-এGPIO PA6 ALARM ON. কিন্তু বার্তাটি বলে3 crashes in a row: SAFE MODE, alarm ON, no calibration, কারণ “3” লেখায় বাঁধা, constant থেকে আসে না। Log মিথ্যা বলছে, আর মাঠে কেউ এটি পড়ে ভুল সিদ্ধান্ত নিতে পারে। শিক্ষা: বার্তায় সংখ্যা ছাপুন variable বা constant থেকে (uart_put_u32(flog.crashes)), কখনো হাতে লিখে নয়।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি cold-storage monitor-এর firmware reset-এর পরে যা যা করে, সেগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Output pin (alarm, relay) নিরাপদ মানে বসানো
- RCC_CSR পড়ে একটি variable-এ রাখা, তারপর RMVF দিয়ে মোছা
- .noinit-এর log-এর magic যাচাই করে fault log আর crash counter পড়া
- Crash counter দেখে স্বাভাবিক, দেরিতে চেষ্টা নাকি safe mode, তা ঠিক করা
- IWDG চালু করা (KR = 0x5555, RLR, KR = 0xCCCC)
- Task চালানো আর supervisor দিয়ে check-in দেখে kick
একটি firmware SysTick-এর 1 ms-এর ISR-এ প্রতিবার watchdog kick করে। Main loop-এর একটি task একটি flag-এর অপেক্ষায় চিরকাল আটকে গেল। কী হবে?
- Timeout পেরোলে watchdog reset দেবে
- Main আটকে গেলে SysTick-এর ISR-ও থেমে যাবে, তাই reset হবে
- কোনো reset হবে না, যন্ত্র অকেজো অবস্থায় চলতেই থাকবে
- CPU HardFault-এ যাবে
STM32F1-এর independent watchdog (IWDG) মূল system clock থেমে গেলেও কাজ করে কেন?
- কারণ এটি বাইরের HSE crystal-এ চলে
- কারণ এটি নিজস্ব ভেতরের LSI oscillator-এ চলে
- কারণ এটি APB1-এর clock-এ চলে
- কারণ software প্রতি ms-এ তার counter কমায়
STM32F1-এর WWDG-এ refresh-এর পরে counter 0x7F, window W = 0x5F. Counter যখন 0x6A, তখন firmware আবার refresh করল। ফল কী?
- Refresh বৈধ, counter আবার 0x7F
- EWI interrupt আসবে
- কিছুই হবে না, refresh উপেক্ষা হবে
- খুব আগে refresh, তাই সঙ্গে সঙ্গে reset
STM32F103-এর IWDG-এ PR = 3 (÷32) আর RLR = 3374. Timeout = 4 × 2PR × (RLR + 1) ÷ fLSI, আর LSI 30–60 kHz-এর যেকোনো মান হতে পারে। Timeout-এর পাল্লা কত?
- 1.8 s থেকে 3.6 s
- ঠিক 2.7 s, সব chip-এ
- 0.9 s থেকে 1.8 s
- 3.374 s, কারণ RLR-ই ms
একটি Cortex-M3-এর HardFault-এর পরে HFSR = 0x40000000 আর CFSR = 0x00008200. এর অর্থ কী?
- Vector table থেকে handler-এর ঠিকানা পড়া যায়নি
- শূন্য দিয়ে ভাগের UsageFault
- একটি precise BusFault HardFault-এ escalate হয়েছে, ঠিকানা BFAR-এ আছে
- Exception-এ ঢোকার সময় stack-এ লেখা যায়নি
একটি firmware প্রতি HardFault-এ log রেখে software reset দেয়। একটি নষ্ট configuration-এর কারণে প্রতি boot-এ একই fault হচ্ছে। সবচেয়ে ভালো নকশা কোনটি?
- প্রতিবার reset দিয়ে আবার চেষ্টা চালিয়ে যাওয়া
- Crash counter আর backoff, সীমা পেরোলে safe mode আর সংকেত
- Watchdog বন্ধ করে দেওয়া, যাতে reset কম হয়
- Handler-এর ভেতরেই পুরো flash মুছে ফেলা
Clang -O2-এ build করা একটি firmware-এ __attribute__((section(".noinit"))) static uint32_t boot_magic;, আর কোড এতে শুধু একটি ধ্রুবক লেখে আর তার সঙ্গে তুলনা করে। Map file-এ এর আকার দেখা গেল ১ byte. কেন, আর সমাধান কী?
- Linker .noinit-এ সব variable ১ byte-এ ছোট করে
- Cortex-M3-এ uint32_t ১ byte
- Optimization বন্ধ করাই একমাত্র উপায়
- Optimizer C-এর শূন্য-শুরুর নিয়ম ধরে একে bool বানিয়েছে; volatile দিতে হবে
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Watchdog: kick না পেলে reset দেওয়া counter; আটকে যাওয়া যন্ত্রকে ফেরায়, bug সারায় না। Board-এ reset আসে kick-এর মুহূর্ত + RLR ms-এ (watchdog.c: 100.0431 → 200.0431 ms).
- IWDG বনাম WWDG: IWDG নিজস্ব LSI-তে (30–60 kHz), দেরি ধরে, বন্ধ করা যায় না; WWDG APB1-এ, খুব আগে আর খুব দেরি দুটিই ধরে, EWI দেয় (36 MHz-এ সর্বোচ্চ 58.25 ms).
- Timeout: সবচেয়ে বড় সুস্থ ফাঁক (boot-সহ) + নিরাপত্তা-ফাঁক, হিসাব সবচেয়ে দ্রুত LSI-তে; সবচেয়ে ধীর LSI-তে তা প্রয়োগের সহ্যসীমার নিচে।
- Kick-এর জায়গা: ISR বা loop-এর শুরুতে অন্ধ kick নয়; task check-in, supervisor সবাইকে পেলে kick, অনুপস্থিতের নাম .noinit-এ।
- Fault-এর পরে: output নিরাপদ, CSR আর log পড়া; HardFault-এ PC/LR (আসল chip-এ CFSR/HFSR) রেখে reset; crash counter, backoff আর safe mode; .noinit volatile, magic-সহ।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ৩৩ · Clock, reset আর power domainভিত্তিLSI, reset-এর কারণ, RCC_CSR আর brown-out-এর hardware-এর দিক।
- পর্ব ৩৮ · এমবেডেড debuggingপাশের পর্বStacked PC থেকে দোষী C লাইন আর মাঠের যন্ত্রের black box log.
- পর্ব ৫৫ · Super loop আর state machineপাশের পর্বযে loop ঘোরে অথচ একটি state machine আটকে থাকতে পারে।
- Computer Architecture পর্ব ৩৮ · Exception আর interruptপাশের ট্র্যাকPrecise exception আর pipeline-এ ব্যতিক্রম সামলানোর তত্ত্ব।
- C প্রোগ্রামিং পর্ব ৪৮ · Undefined Behavior ও নিরাপদ কোডিংপাশের ট্র্যাকযে C-এর ভুলগুলো মাঠে HardFault হয়ে ফেরে।