এই পর্বে যা শিখবেন
- Firmware debugging-এর প্রতিটি উপায়ের খরচ আর সীমা বলতে পারা, আর কোন bug-এ কোনটি বাছতে হয়
- UART-এ লেখার সময় হিসাব করা, আর ISR-এ printf কেন bug লুকায় বা নতুন bug বানায়, তা ব্যাখ্যা করা
- JTAG, SWD, debug probe, GDB server আর GDB-এর ভূমিকা; breakpoint, watchpoint আর single-step-এর hardware ভিত্তি (FPB, DWT)
- HardFault-এর stacked PC আর LR থেকে map file ও debug info দিয়ে দোষী C লাইন আর ডাকার লাইন খুঁজে বের করা
- assert, LED code, fault log আর logic analyzer দিয়ে মাঠের যন্ত্রের bug ধরার অভ্যাস গড়া
১ · পর্দা ছাড়া debugging — firmware-এর ভেতরে চোখ রাখার উপায়
Desktop-এ program ভাঙলে terminal-এ বার্তা আসে, আর debugger দিয়ে লাইন ধরে চালানো যায় (C পর্ব ৩১-এ gdb, assert আর backtrace). Microcontroller-এর firmware চলে পর্দা ছাড়া, OS ছাড়া (পর্ব ৩৪)। বাজারঘরের smart scale ভুল দাম দেখালে বা cold room-এর alarm না বাজলে যন্ত্র কিছুই বলে না; সে শুধু ভুল কাজটি করে যায়। তাই এমবেডেড debugging মানে প্রথমে ভেতরের খবর বাইরে আনার একটি পথ তৈরি করা।
উপমা — গ্রামের ডাক্তারের যন্ত্রপাতি: রোগী নিজের ভেতরের কথা বলতে পারেন না, তাই ডাক্তার কয়েক রকম যন্ত্র ব্যবহার করেন। জ্বর মাপা সবচেয়ে সহজ, কিন্তু খুব কম বলে (এটি LED code). রোগীকে প্রশ্ন করা বেশি বলে, কিন্তু প্রশ্নের সময় রোগীর নাড়ি একটু বদলে যায় (এটি UART printf). স্টেথোস্কোপ শরীর না ছুঁয়েই ভেতরের শব্দ শোনায় (logic analyzer, oscilloscope). আর অপারেশন টেবিলে রোগীকে অজ্ঞান রেখে ভেতরটা সরাসরি দেখা যায় (debug probe দিয়ে CPU থামানো). প্রতিটির দাম আলাদা, আর ভালো ডাক্তার রোগ বুঝে যন্ত্র বাছেন।
| উপায় | কী লাগে | কী দেখায় | দাম বা ঝুঁকি |
|---|---|---|---|
| LED code | একটি pin আর LED | কয়েকটি সংখ্যা: কোন ধাপে ভুল | খুব কম তথ্য, কিন্তু প্রায় শূন্য খরচ |
| UART-এ printf | TX pin, USB-serial adapter | মান, বার্তা, সময়ের ছাপ | সময় খায়; ISR-এ ভয়ংকর (অংশ ২) |
| Debug probe + GDB | JTAG বা SWD pin | CPU থামানো, register, মেমরি, breakpoint | থামালে বাস্তব সময় থেমে যায়, motor বা যোগাযোগ ভাঙে |
| Semihosting | debug probe সংযুক্ত | host-এর console-এ লেখা, file | প্রতিটি কাজে CPU থামে, খুব ধীর; probe না থাকলে fault |
| ITM/SWO | SWO pin আছে এমন probe | দ্রুত trace বার্তা, সময়সহ | Cortex-M0/M0+-এ সাধারণত নেই |
| Logic analyzer, oscilloscope | pin-এ probe লাগানো | তারের আসল সংকেত আর সময় | firmware ছোঁয় না; ভেতরের variable দেখায় না |
| assert আর fault log | কোড আর একটু SRAM | মাঠে কোথায় ভেঙেছিল | ভাঙার পরেই জানা যায়, আগে নয় |
ছবি ৩৮.১ — বাস্তব একটি debugging-এর টেবিল
বাঁয়ে debug probe-এর পথ (CPU থামানো), ডানে UART আর logic analyzer-এর পথ (CPU না থামিয়ে দেখা)
এই পর্বের সব run কোর্সের virtual বাজারঘর board BG-M3-এ (পর্ব ০৬), যা আসল Cortex-M chip-এর আদলে বানানো একটি শেখার মডেল, বাজারের কোনো board নয়। এখানে কোনো GDB stub নেই, আর আমার কাছে আসল debug probe, logic analyzer বা oscilloscope নেই। তাই সেগুলো ধারণা হিসেবে পড়ানো হবে, আর তাদের কমান্ড “উদাহরণ, চালানো হয়নি” লেবেলে থাকবে। তাদের জায়গায় দাঁড়াবে board-এর নিজের --trace আর আমার lab-এর একটি ছোট Python script, যা board-এর CPU-তে breakpoint আর watchpoint-এর মতো hook বসায়। ঠিকানা এই পর্বে C-ধাঁচে লেখা (0x08000154).
২ · UART-এ printf — সবচেয়ে সহজ, কিন্তু বিনা খরচে নয়
সবচেয়ে পুরোনো আর এখনো সবচেয়ে বেশি ব্যবহৃত পথ: UART-এ লেখা পাঠানো, যা একটি USB-serial adapter দিয়ে কম্পিউটারের terminal-এ আসে। এটি এমবেডেড জগতের printf debugging. বাজারঘরের scale ঠিক এভাবেই নিজের প্রতিটি মাপ ছাপে (raw=1380 gross=1400 g …). সমস্যা একটি: লেখা পাঠাতে সময় লাগে, আর সেই সময় firmware-এর আচরণ বদলে দিতে পারে।
হিসাবটি সরল। 8N1 frame-এ প্রতিটি অক্ষর ১০ বিট (start, ৮ data, stop; বিস্তারিত পর্ব ৪৯-এ). তাই এক অক্ষরের সময় = 10 ÷ baud rate:
- 115200 baud-এ এক অক্ষর = 10 ÷ 115200 s ≈ 86.8 µs.
- Scale-এর পূর্ণ লাইন
raw=1380 gross=1400 g tare=150 g net=1250 g price=81.88 Tkআর\r\nমিলিয়ে ৬০টি অক্ষর। - 60 × 86.8 µs ≈ 5208 µs ≈ 5.21 ms. 9600 baud-এ একই লাইন 62.5 ms.
Main loop থেকে, প্রতি 100 ms-এ একবার, ৫ ms খরচ মেনে নেওয়া যায়। কিন্তু একই লাইন যদি 1 ms-এর SysTick ISR-এর ভেতরে ছাপা হয়? Polled UART-এ (প্রতিটি byte পাঠানোর আগে TXE বিটের অপেক্ষা) ISR তখন পুরো সময় অপেক্ষায় আটকে থাকে, আর অন্য সব interrupt ও main loop থেমে থাকে। পরীক্ষাটি board-এ করা হলো। আমার lab-এর isr_print.c-তে SysTick ISR ঢোকার সময় PA5 তোলে আর বেরোনোর সময় নামায়, যাতে PA5-এর উঁচু থাকার সময়ই ISR-এর দৈর্ঘ্য। এই কৌশলের নাম probe pin; আসল যন্ত্রে এই pin-এ logic analyzer লাগানো হয়। বোতামের EXTI0 ISR-এর priority SysTick-এর সমান (৩), তাই বোতাম চাপলে সেটিকে SysTick শেষ হওয়া পর্যন্ত অপেক্ষা করতে হয় (Spec decision 19: সমান priority কখনো preempt করে না).
void SysTick_Handler(void)
{
GPIOA->BSRR = 1u << LED_PIN; /* probe high: ISR শুরু */
ms_ticks++;
#ifdef PRINT_IN_ISR
uart_puts("tick ");
uart_put_u32(ms_ticks);
uart_puts("\r\n");
#endif
GPIOA->BRR = 1u << LED_PIN; /* probe low: ISR শেষ */
}
void EXTI0_IRQHandler(void) /* বোতাম; priority SysTick-এর সমান */
{
EXTI->PR = 1u;
GPIOA->BSRR = 1u << ALARM_PIN; /* "বোতাম দেখেছি" */
}সত্যিকারের run — board.py (BG-M3), Clang 22.1.8 -O2; c= মানে board-এর cycle
(আমার lab-এর dbg.py --cyc), বোতাম চাপা 2.008 ms-এ
== printf ছাড়া (isr_quiet.elf)
[ 2.0064 ms] c=16051 GPIO PA5 LED ON
[ 2.0070 ms] c=16056 GPIO PA5 LED OFF
[ 2.0080 ms] c=16064 > button pressed
[ 2.0088 ms] c=16070 GPIO PA6 ALARM ON
[ 3.0079 ms] c=24063 exit(0) after 24063 cycles
== ISR-এ printf (isr_print.elf, -DPRINT_IN_ISR)
[ 2.0065 ms] c=16052 GPIO PA5 LED ON
[ 2.0080 ms] c=16064 > button pressed
[ 2.0195 ms] c=16156 UART: tick 2
[ 2.0200 ms] c=16160 GPIO PA5 LED OFF
[ 2.0209 ms] c=16167 GPIO PA6 ALARM ON
[ 3.0209 ms] c=24167 exit(0) after 24167 cycles
| ঘটনা | |
| printf ছাড়া | |
| ISR-এ printf |
- Tick এল। দুটি build-এই SysTick ISR প্রথমে PA5 তোলে: printf ছাড়া cycle 16051-এ, printf সহ 16052-এ। Logic analyzer থাকলে PA5-এর তারে এখানে একটি উঠতি ধার দেখা যেত।
- ISR-এর দৈর্ঘ্য। printf ছাড়া ISR ৫ cycle-এ শেষ (16056).
"tick 2\r\n"বানানো আর পাঠানোর নির্দেশ মিলিয়ে printf সহ ISR ১০৮ cycle (16160 পর্যন্ত). Board-এ UART তাৎক্ষণিক (Spec decision 24), তাই এই খরচ শুধু নির্দেশের, তারের নয়। - বোতাম চাপা হলো, cycle 16064-এ। printf ছাড়া build-এ SysTick আট cycle আগেই শেষ, CPU ঘুমিয়ে আছে। printf সহ build-এ SysTick ISR তখন অক্ষর বানাচ্ছে, আর সমান priority-র EXTI0 শুধু pending হয়ে অপেক্ষা করে।
- বোতামের সাড়া। printf ছাড়া EXTI0 ISR PA6 তুলেছে 16070-এ, অর্থাৎ ৬ cycle-এ। printf সহ 16167-এ, ১০৩ cycle পরে: SysTick শেষ হওয়ার পরেই। বোতামের firmware-এ কেউ একটি অক্ষরও বদলাননি, তবু তার interrupt latency ১৭ গুণ।
- আসল chip-এ। Board 1 নির্দেশ = 1 cycle ধরে আর UART-এর তারের সময় মাপে না (Spec decision 17, 24). আসল polled UART-এ 115200 baud-এ
"tick 10\r\n"-এর ৯টি অক্ষরেই প্রায় 782 µs, 1 ms-এর tick-এর তিন-চতুর্থাংশ। নিচের ব্লক এই হিসাব ২০টি tick ধরে চালায়।
# 1 ms SysTick ISR-এ "tick N\r\n" ছাপলে আসল chip-এ কী হয়? (polled UART, 8N1 = 10 বিট/অক্ষর)
PERIOD_US = 1000.0 # SysTick 1 ms
WORK_US = 5 / 8 # ISR-এর নিজের কাজ: board-এ মাপা 5 নির্দেশ, 8 MHz ধরে
BUF_US = 0.5 # অনুমান: RAM buffer-এ এক byte রাখতে ~4 নির্দেশ
def run(baud, n=20, deferred=False):
char_us = 10 / baud * 1e6
free_at, pending, served, lost, busy, worst = 0.0, False, 0, 0, 0.0, 0.0
def isr(start):
nonlocal free_at, served, busy, worst
served += 1
line = f"tick {served}\r\n"
cost = WORK_US + len(line) * (BUF_US if deferred else char_us)
free_at, busy, worst = start + cost, busy + cost, max(worst, cost)
for k in range(1, n + 1): # k-তম tick আসে k ms-এ
t = k * PERIOD_US
if pending and free_at <= t: # আগের pending tick আগে চলে
pending = False
isr(free_at)
if free_at <= t:
isr(t)
elif pending: # pending বিট একটাই: এই tick হারাল
lost += 1
else:
pending = True
return served, lost, min(100.0, busy / (n * PERIOD_US) * 100), worst
print(f"{'লগের পথ':>18} {'সবচেয়ে লম্বা ISR':>16} {'CPU':>6} {'tick চলল':>9} {'হারাল':>6}")
for baud in (9600, 115200, 921600):
s, lost, cpu, worst = run(baud)
print(f"{f'UART {baud} baud':>18} {worst:>13.1f} µs {cpu:>5.1f}% {s:>6}/20 {lost:>6}")
s, lost, cpu, worst = run(115200, deferred=True)
print(f"{'RAM-এর ring buffer':>18} {worst:>13.1f} µs {cpu:>5.1f}% {s:>6}/20 {lost:>6}")আসল আউটপুট (ব্রাউজারের Python):
লগের পথ সবচেয়ে লম্বা ISR CPU tick চলল হারাল
UART 9600 baud 8334.0 µs 100.0% 3/20 16
UART 115200 baud 781.9 µs 74.3% 20/20 0
UART 921600 baud 98.3 µs 9.3% 20/20 0
RAM-এর ring buffer 5.1 µs 0.5% 20/20 0
এটি একটি সরল মডেল, আসল chip নয়: ধরে নেওয়া হয়েছে প্রতিটি অক্ষর পুরো ১০ বিট সময় নেয় আর ISR চলার সময় SysTick-এর pending বিট একটিই tick ধরে রাখতে পারে (পর্ব ৩০). 9600 baud-এ একটি লাইনই 8.33 ms, আট tick-এর সমান, তাই ২০টির মধ্যে ১৬টি tick হারিয়েছে: যে ঘড়ি দিয়ে debug করছিলেন, printf নিজেই সেটি ভেঙে দিয়েছে। 115200-এ কোনো tick হারায়নি, কিন্তু CPU-র ৭৪% ISR খেয়ে ফেলেছে। শেষ সারি সমাধান: ISR শুধু RAM-এর ring buffer-এ কয়েকটি byte রাখে, আর main loop অবসরে সেগুলো UART-এ পাঠায় (অংশ ৭-এ এর C রূপ).
এর একটি অদ্ভুত পরিণাম আছে। ধরুন একটি race condition (পর্ব ৩৪-এর হারানো যোগের মতো) ঘটছে। আপনি খুঁজতে printf বসালেন, আর সময় বদলে যাওয়ায় bug আর দেখা গেল না। একে বলে heisenbug: যে bug দেখতে গেলেই লুকায়। তাই নিয়ম: ISR-এর ভেতরে কখনো blocking printf নয়; সময়-নির্ভর bug-এ এমন উপায় বাছুন, যা সময় কম বদলায় (probe pin, RAM-এ trace, ITM, logic analyzer).
৩ · LED code আর bisect — একটি মাত্র pin দিয়ে bug-এর ঠিকানা
কখনো UART-ও থাকে না: pin সব ব্যবহৃত, বা board-এ শুধু একটি LED. তখনো একটি শক্তিশালী কৌশল চলে: সন্দেহের এলাকা অর্ধেক করে করে ছোট করা, যাকে বলে bisection (Git-এর git bisect একই কাজ commit-এর ইতিহাসে করে). প্রতিবার মাঝখানে একটি পরীক্ষা বসানো হয়; ফল জানায় LED: স্থির জ্বলা মানে পাশ, n বার জ্বলা-নেভা মানে n নম্বর ধাপে ভুল। একে বলে blink code; বহু যন্ত্রে, যেমন কম্পিউটারের motherboard-এর beep code-এ, এই ধারণাই ব্যবহার হয়।
বাজারঘরের smart scale-এ একটি bug: 2000 g-এর ওজন রাখলে দাম ভুল আসে। Pipeline-এর চারটি ধাপ, README-র সংখ্যা দিয়ে: (১) ADC পড়া, 2000 g-এ raw = 1800 হওয়ার কথা; (২) grams = (raw − 400) × 2000 ÷ 1400 = 2000; (৩) net = grams − tare = 2000; (৪) দাম = (2000 × 6550 + 500) ÷ 1000 = 13100 পয়সা = 131.00 টাকা। আমার lab-এর bisect.c-তে -DCHECK_AT=n দিয়ে n নম্বর ধাপের পরে পরীক্ষা বসে:
int32_t raw = adc_read(); /* ধাপ ১ */
if (CHECK_AT == 1) result(1, raw >= 1798 && raw <= 1802);
int32_t grams = (raw - ZERO_RAW) * (REF_G / SPAN); /* ধাপ ২ */
if (CHECK_AT == 2) result(2, grams >= 1999 && grams <= 2001);
/* ... ধাপ ৩ net, ধাপ ৪ price; result(): পাশ হলে LED স্থির,
না হলে ধাপের সংখ্যার সমান বার জ্বলা-নেভা (200 ms করে) */সত্যিকারের run — board.py run bis_cN.elf --script w2000.json (2000 g)
== CHECK_AT=4 (লক্ষণ) == CHECK_AT=2 (মাঝখানে)
[ 1.0080 ms] GPIO PA5 LED ON [ 1.0076 ms] GPIO PA5 LED ON
[201.0051 ms] GPIO PA5 LED OFF [201.0051 ms] GPIO PA5 LED OFF
... মোট ৪ বার জ্বলা-নেভা [401.0050 ms] GPIO PA5 LED ON
[1601.0051 ms] exit(4) [601.0051 ms] GPIO PA5 LED OFF
[801.0051 ms] exit(2)
== CHECK_AT=1 == CHECK_AT=4, -DFIXED
[ 1.0077 ms] GPIO PA5 LED ON [ 1.0092 ms] GPIO PA5 LED ON
[1001.0053 ms] exit(0) [1001.0053 ms] exit(0)
| Build | |
| LED-এ দেখা | |
| সন্দেহের ধাপ | |
| মান |
- লক্ষণ। শেষ ধাপে পরীক্ষা: দাম 13100 পয়সা নয়, LED চারবার জ্বলে-নেভে (1.0080 ms থেকে 1601.0051 ms,
exit(4)). শুধু জানা গেল কিছু একটা ভুল; সন্দেহ চারটি ধাপেই। - মাঝখানে কাটা। চারটি ধাপের মাঝখানে, ধাপ ২-এর পরে পরীক্ষা: LED দুবার,
exit(2). ধাপ ২-এর পরেই মান ভুল, তাই ধাপ ৩ আর ৪ নির্দোষ। সন্দেহ অর্ধেক হলো। - আবার অর্ধেক। ধাপ ১-এর পরে পরীক্ষা: LED স্থির জ্বলে,
exit(0); raw ঠিক 1800 (README-র load-cell সূত্রে 400 + 0.7 × 2000). তাই ভুল শুধু ধাপ ২-এ। চারটি ধাপের জন্য দুটি পরীক্ষাই যথেষ্ট ছিল (log2 4 = 2). - ধাপ ২ পড়া।
(raw - ZERO_RAW) * (REF_G / SPAN): বন্ধনীর ভেতরে integer ভাগ আগে হয়, 2000 ÷ 1400 = 1 (ভাগশেষ ফেলে দিয়ে). তাই grams = 1400 × 1 = 1400, আর দাম হতো 9170 পয়সা। গুণের আগে ভাগ, integer হিসাবের পুরোনো ফাঁদ। - Fix আর যাচাই। আগে গুণ, তারপর rounding সহ ভাগ:
((raw - 400) * 2000 + 700) / 1400= 2000. শেষ ধাপের পরীক্ষাসহ build-এ LED স্থির,exit(0). Fix-এর পরে সবসময় শুরুর লক্ষণের পরীক্ষাটিই আবার চালানো হয়।
Bisect-এর শক্তি এর গণিতে: n ধাপের pipeline-এ সর্বোচ্চ ⌈log2 n⌉টি পরীক্ষা। ১০০০টি commit-এর ইতিহাসে ১০টি build. দুর্বলতাও আছে: bug যদি দুই ধাপের মিলনে হয়, বা প্রতিবার না ঘটে, তাহলে মাঝখানের পরীক্ষা ভুল দিকে পাঠাতে পারে। আর পরীক্ষাটি নিজে যেন সময় না বদলায়: 200 ms-এর জ্বলা-নেভা শুধু bug-এর জায়গা পাওয়ার পরে শুরু হয়।
৪ · JTAG, SWD, debug probe আর GDB — CPU থামিয়ে ভেতরে দেখা
সবচেয়ে শক্তিশালী উপায় chip-এর ভেতরের debug hardware. প্রায় সব আধুনিক microcontroller-এ একটি debug port থাকে, যা দিয়ে বাইরের একটি যন্ত্র CPU থামাতে, register আর মেমরি পড়তে-লিখতে, flash-এ program বসাতে আর এক নির্দেশ করে চালাতে পারে। দুটি প্রচলিত সংযোগ:
JTAG
IEEE 1149.1 standard (১৯৯০), মূলত circuit board-এর সংযোগ পরীক্ষার (boundary scan) জন্য তৈরি, পরে debug-এর পথও হয়। চারটি সংকেত: TCK, TMS, TDI, TDO (ঐচ্ছিক TRST). একাধিক chip এক শিকলে জোড়া যায়।
SWD
ARM-এর দুই-তারের বিকল্প: SWDIO (দুই দিকের data) আর SWCLK. Cortex-M-এ সবচেয়ে প্রচলিত, কারণ ছোট chip-এ pin দামি। সঙ্গে ঐচ্ছিক SWO pin, যা দিয়ে ITM-এর trace বার্তা বের হয় (অংশ ৫).
Debug probe আর GDB
Probe কম্পিউটারের USB-কে SWD/JTAG-এ রূপান্তর করে। কম্পিউটারে একটি GDB server (যেমন OpenOCD) probe চালায়, আর GDB network-এর মতো একটি সংযোগে সেই server-এর সঙ্গে কথা বলে।
সেশনটি সাধারণত এমন দেখায়। আমার কাছে আসল board বা probe নেই, তাই এটি চালানো হয়নি; কমান্ডগুলো OpenOCD আর GDB-এর documented রূপ, কোনো আউটপুট দেখানো হলো না:
উদাহরণ, চালানো হয়নি — একটি STM32F1-ধাঁচের board আর ST-LINK probe ধরে
$ openocd -f interface/stlink.cfg -f target/stm32f1x.cfg # GDB server, port 3333
$ arm-none-eabi-gdb build/hardfault.elf # -g সহ build
(gdb) target extended-remote localhost:3333
(gdb) monitor reset halt # CPU reset করে থামানো
(gdb) load # flash-এ program লেখা
(gdb) break read_sensor # breakpoint
(gdb) continue
(gdb) stepi # এক নির্দেশ এগোনো
(gdb) info registers pc lr r0
(gdb) watch sc.tare_g # data watchpoint
(gdb) backtrace
এর পেছনের hardware জানা থাকলে সীমাগুলো বোঝা যায়। Flash-এর কোডে breakpoint বসাতে debugger নির্দেশ বদলাতে পারে না (flash লেখা ধীর আর ক্ষয় হয়), তাই Cortex-M3-এর FPB (Flash Patch and Breakpoint unit)-এর comparator ব্যবহার হয়: প্রতিটি comparator একটি ঠিকানা ধরে, আর CPU সেই ঠিকানার নির্দেশ fetch করলেই থামে। পূর্ণ কনফিগারেশনে এমন ৬টি, তাই সপ্তম breakpoint চাইলে GDB আপত্তি জানায়। Watchpoint (“এই variable-এ কেউ লিখলেই থামতে হবে”) আসে DWT (Data Watchpoint and Trace)-এর ৪টি comparator থেকে। আর single-step মানে CPU একটি নির্দেশ চালিয়ে আবার থামে, যা core-এর debug logic করে।
সাবধান — থামানো CPU, চলমান পৃথিবী: Breakpoint-এ CPU থামে, কিন্তু motor ঘোরে, UART-এ byte আসতে থাকে, cold room-এর তাপমাত্রা বদলায়। ফিরে চালালে buffer overflow, watchdog reset (অনেক chip-এ debug-এর সময় watchdog থামানোর আলাদা বিট থাকে) বা H-bridge-এর একটি দিক চালু থেকে যাওয়ার মতো বিপদ ঘটতে পারে। Motor বা mains-এর সঙ্গে যুক্ত যন্ত্রে breakpoint বসানোর আগে নিরাপদ অবস্থা নিশ্চিত করুন।
Board-এ breakpoint আর watchpoint-এর বিকল্প
Board-এর --trace N প্রথম N নির্দেশের ঠিকানা আর symbol ছাপে: single-step-এর একটি রেকর্ড, যা পরে পড়া যায়। Reference hardfault.c-এর trace-এর শেষ অংশ, ঠিক fault-এর আশপাশে:
সত্যিকারের run — board.py run hardfault.elf --trace 900 (৮৮১ লাইনের অংশ)
[ 0.0384 ms] trace PC=0x08000254 uart_puts+0x38
[ 0.0385 ms] trace PC=0x08000138 main+0x10
[ 0.0386 ms] trace PC=0x08000150 read_sensor+0x0
[ 0.0387 ms] trace PC=0x08000154 read_sensor+0x4
[ 0.0386 ms] HardFault: Invalid memory read (UC_ERR_READ_UNMAPPED) at PC=0x08000154 read_sensor+0x4
[ 0.0387 ms] trace PC=0x08000120 HardFault_Handler+0x0
[ 0.0389 ms] trace PC=0x08000124 HardFault_Handler+0x4
[ 0.0390 ms] trace PC=0x08000060 hardfault_report+0x0
(HardFault-এর লাইনে সময় 0.0001 ms কম, কারণ যে নির্দেশ fault দিল, সেটি সম্পূর্ণ হয়নি বলে board তার cycle ফেরত নেয়।) Watchpoint-এর জন্য আমার lab-এ dbg.py লিখেছি: board.py-র একটি কপির Unicorn CPU-তে একটি “মেমরিতে লেখা” hook, যা নির্দিষ্ট variable-এ প্রতিটি লেখার PC ছাপে। এটি GDB নয়, কিন্তু DWT-এর comparator যা করে, সেই ধারণাটি দেখায়। পরীক্ষার bug: scale-এর averaging loop-এ i <= 4, যেখানে samples[4]-এর পরেই struct-এ tare_g বসে আছে, একটি ক্লাসিক off-by-one:
struct scale_state {
int32_t samples[4]; /* শেষ ৪টি ADC reading */
int32_t tare_g; /* TARE বোতাম বসায় */
};
struct scale_state sc;
for (int i = 0; i <= 4; i++) /* BUG: হওয়া উচিত i < 4 (লাইন 25-26) */
sc.samples[i] = adc_read();সত্যিকারের run — dbg.py build/wp.elf --script w1400.json --watch sc (অংশ)
[ 0.0051 ms] watch sc+16 <- 150 (0x96), 4 bytes, by PC=0x0800006E main+0xE
[ 0.0066 ms] watch sc+0 <- 1380 (0x564), 4 bytes, by PC=0x08000128 average_raw+0x30
... sc+4, sc+8, sc+12 একইভাবে
[ 0.0114 ms] watch sc+16 <- 1380 (0x564), 4 bytes, by PC=0x080001D4 average_raw+0xDC
[ 0.0860 ms] UART: raw=1380 gross=1400 g tare=1380 g net=20 g
সত্যিকারের run — a2l.py build/wp.elf 0x080001D4 0x0800006E (pyelftools 0.32)
0x080001D4 average_raw+0xDC wp.c:26
0x0800006E main+0xE wp.c:36
লক্ষণ ছিল “1400 g রেখেও net 20 g”. Watch দেখায়, sc+16 (tare_g) প্রথমে main-এ 150 পেয়েছে (লাইন 36, বাটির ওজন), তারপর average_raw-এর ভেতর থেকে 1380 দিয়ে মুছে গেছে। Startup কোডের .bss শূন্য করার লেখাগুলোও (এখানে বাদ দেওয়া) watch-এ ধরা পড়েছিল। ঠিকানাকে লাইনে আনার কাজটি করেছে আমার lab-এর a2l.py, একটি ছোট addr2line, যা -g build-এর DWARF debug info পড়ে। কোন bug-এ watchpoint সেরা হাতিয়ার, তা এখানেই স্পষ্ট: “কে আমার variable নষ্ট করল?”
৫ · Semihosting আর ITM — debug probe দিয়েই লেখা পাঠানো
UART pin না থাকলেও probe-এর তার দিয়ে লেখা আনা যায়। পথ দুটি, দুটিই এখানে শুধু ধারণা:
Semihosting: firmware একটি বিশেষ breakpoint নির্দেশ চালায় (Cortex-M-এ BKPT 0xAB), R0-তে কাজের নম্বর আর R1-এ argument-এর ঠিকানা রেখে। Debugger CPU থামিয়ে দেখে এটি semihosting-এর অনুরোধ, host-এর কম্পিউটারে কাজটি করে (console-এ লেখা, file খোলা), তারপর CPU ছেড়ে দেয়। সুবিধা: firmware থেকে printf সরাসরি কম্পিউটারের পর্দায়, এমনকি host-এর file পড়াও। দাম: প্রতিটি অনুরোধে CPU থামে, তাই খুব ধীর, আর সময়-নির্ভর কোডে অচল। সবচেয়ে বড় ফাঁদ: probe খুলে নিলে সেই BKPT আর কেউ ধরে না; ARMv7-M-এ debug চালু না থাকলে BKPT একটি fault তোলে, যা সাধারণত HardFault-এ যায়। “টেবিলে চলে, মাঠে প্রথম printf-এই আটকে যায়”, এই অভিযোগের পরিচিত উৎস।
উদাহরণ, চালানো হয়নি — OpenOCD-এ semihosting চালু করা
(gdb) monitor arm semihosting enable
(gdb) continue # firmware-এর printf এখন OpenOCD-এর console-এ
ITM আর SWO: Cortex-M3/M4-এ Instrumentation Trace Macrocell একটি hardware “ডাকবাক্স”: firmware একটি register-এ byte লেখে, আর ITM সেটি SWO pin দিয়ে ধারাবাহিকভাবে বের করে দেয়, CPU না থামিয়ে। একটি word লিখতে মাত্র কয়েকটি নির্দেশ, তাই ISR থেকেও মোটামুটি নিরাপদ। সীমা: Cortex-M0/M0+-এ সাধারণত ITM নেই, আর SWO pin board-এ বের করা থাকতে হয়। আমাদের virtual board-এ semihosting বা ITM কোনোটিই নেই (Spec decision 19-এ debug অংশ মডেল করা হয়নি).
৬ · HardFault বিশ্লেষণ — stacked PC থেকে দোষী C লাইন
মাঠের যন্ত্রে সবচেয়ে দরকারি দক্ষতা: একটি HardFault-এর পরে কোন লাইন দোষী, তা বের করা। Exception-এ hardware যে আট word-এর frame stack-এ রাখে (R0–R3, R12, LR, PC, xPSR) আর naked handler কীভাবে সেটি পড়ে, তা পর্ব ৩০-এ বিস্তারিত (Cortex-M-এর exception আর NVIC, অংশ ৭). এখানে পরের ধাপ: frame-এর সংখ্যা থেকে C-এর লাইনে পৌঁছানো। Reference hardfault.c-এর আসল output:
সত্যিকারের run — board.py run hardfault.elf (reference lab-এর expected output-এর সঙ্গে হুবহু)
[ 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
আসল chip-এ board-এর নিজের HardFault: লাইনটি থাকবে না; থাকবে শুধু firmware-এর ছাপা তিনটি সংখ্যা। সেগুলো থেকে লাইন পেতে তিনটি জিনিস লাগে: map file (কোন function কোথায়), assembly (কোন নির্দেশ), আর debug info (কোন নির্দেশ কোন লাইনের); ELF আর map file তৈরির ধাপগুলো পর্ব ৩৭-এ। শেষটির জন্য একই firmware -g দিয়ে আবার build করলাম; board-এ output আর সব ঠিকানা হুবহু একই এসেছে, কারণ -g machine code বদলায় না, শুধু ELF-এ আলাদা section যোগ করে, যা flash-এ যায় না।
সত্যিকারের run — hardfault_g.map (অংশ) আর clang -S -O2 (Clang 22.1.8)
8000129 8000129 26 1 main
8000151 8000151 8 1 read_sensor
main: read_sensor:
bl uart_init @ 0x08000128 mov.w r0, #1610612736 @ 0x08000150
movw/movt r0, .L.str.4 @ 0x0800012C ldr r0, [r0] @ 0x08000154
bl uart_puts @ 0x08000134 bx lr @ 0x08000156
bl read_sensor @ 0x08000138
bl uart_put_u32 @ 0x0800013C
| হাতে আছে | |
| কোথায় দেখা | |
| ফল |
- তিনটি সংখ্যা। Handler stacked frame থেকে PC (word ৬), LR (word ৫) আর R0 (word ০) ছেপেছে। PC মানে fault-এর মুহূর্তে চলা নির্দেশের ঠিকানা; precise fault-এ এটিই দোষী নির্দেশ।
- Map file.
read_sensorশুরু 0x08000150 (map-এ 0x08000151, Thumb বিটসহ), আকার ৮ byte. 0x08000154 − 0x08000150 = 0x4, তাইread_sensor+0x4, board-এর নিজের লাইনের সঙ্গে মেলে। - Assembly.
read_sensor+0x0-এ ৪ byte-এরmov.w r0, #0x60000000(Clang ধ্রুবক pointer-টি function-এর ভেতরে এনেছে), তারপর +0x4-এldr r0, [r0]: এই load-ই fault দিয়েছে। R0 = 0x60000000 তাই ভুল ঠিকানাটি, যেখানে board-এ কোনো মেমরি নেই। - DWARF.
-gbuild-এর line table-এ 0x08000154 =hardfault.c-এর লাইন 33,return *p;. দোষী লাইন পাওয়া গেল। কিন্তু কে খারাপ pointer দিল? - LR থেকে ডাকার জায়গা। LR = 0x0800013D; Thumb বিট (বিট ০) সরালে ফেরার ঠিকানা 0x0800013C =
main+0x14, লাইন 41. ডাকার নির্দেশ তার ঠিক আগে: ৪ byte-এরbl, 0x08000138, লাইন 40:read_sensor((volatile uint32_t *)0x60000000u). আসল দোষ এখানে, ভুল sensor ঠিকানায়।
একই কাজ নিচের ব্লকে, ছোট একটি addr2line হিসেবে। Symbol আর line table-এর মানগুলো ওপরের সত্যিকারের build থেকে নেওয়া (a2l.py দিয়ে DWARF থেকে পড়া):
# HardFault-এর UART লাইন থেকে দোষী C লাইন: ছোট একটি addr2line (hardfault.c-এর আসল build)
import re
log = "HardFault! stacked PC=0x08000154 LR=0x0800013D R0=0x60000000"
symbols = {"main": (0x08000128, 26), "read_sensor": (0x08000150, 8)} # map file থেকে
lines = [(0x08000128, 38), (0x0800012C, 39), (0x08000138, 40), # -g build-এর
(0x0800013C, 41), (0x08000140, 0), (0x08000150, 32), # DWARF line table
(0x08000154, 33)]
source = {33: " return *p; /* faults when p points to nothing */",
40: " uint32_t v = read_sensor((volatile uint32_t *)0x60000000u);",
41: " uart_put_u32(v);"}
def where(addr):
fn = next(f"{n}+0x{addr - a:X}" for n, (a, s) in symbols.items() if a <= addr < a + s)
line = max((a, ln) for a, ln in lines if a <= addr)[1]
return fn, line
regs = {k: int(v, 16) for k, v in re.findall(r"(\w+)=0x([0-9A-F]+)", log)}
pc = regs["PC"]
fn, ln = where(pc)
print(f"PC 0x{pc:08X} -> {fn:16} line {ln}: {source[ln].strip()}")
ret = regs["LR"] & ~1 # Thumb বিট সরানো = ফেরার ঠিকানা
fn, ln = where(ret)
print(f"ret 0x{ret:08X} -> {fn:16} line {ln}: {source[ln].strip()}")
call = ret - 4 # BL ৪ byte লম্বা: ডাকার নির্দেশ ঠিক আগে
fn, ln = where(call)
print(f"BL 0x{call:08X} -> {fn:16} line {ln}: {source[ln].strip()}")
print(f"R0 0x{regs['R0']:08X}: ldr r0, [r0]-এর ঠিকানা, অর্থাৎ ভুল pointer")আসল আউটপুট (ব্রাউজারের Python):
PC 0x08000154 -> read_sensor+0x4 line 33: return *p; /* faults when p points to nothing */
ret 0x0800013C -> main+0x14 line 41: uart_put_u32(v);
BL 0x08000138 -> main+0x10 line 40: uint32_t v = read_sensor((volatile uint32_t *)0x60000000u);
R0 0x60000000: ldr r0, [r0]-এর ঠিকানা, অর্থাৎ ভুল pointer
দুটি সতর্কতা। এক, ret - 4 শুধু ৩২ বিটের bl-এর জন্য ঠিক; blx r3-এর মতো ১৬ বিটের call হলে −2. দুই, LR সবসময় ডাকার জায়গা নয়। Fault যদি main-এর নিজের ভেতরে হয়, LR-এ থাকে main-এর শেষ ডাকা function-এর পুরোনো ফেরার ঠিকানা; আর tail call হলে (পর্ব ৩০-এর hf_isr উদাহরণ) LR-এ EXC_RETURN বা অন্য কারও ঠিকানা থাকতে পারে। তখন পুরো call chain পেতে stack-এর বাকি অংশ হাঁটতে হয়, যা GDB-এর backtrace DWARF-এর unwind তথ্য দিয়ে করে।
৭ · assert আর fault log — মাঠের যন্ত্রের “black box”
বাজারঘরের scale দোকানে বসানোর পরে কোনো probe লাগানো থাকে না। ভাঙলে watchdog বা fault handler reset করে দেয় (পর্ব ৬১), আর পরের মুহূর্তে যন্ত্র আবার স্বাভাবিক, কোনো চিহ্ন ছাড়া। তাই দুটি অভ্যাস: assert দিয়ে ভুল অনুমান যত আগে সম্ভব ধরা, আর ভাঙার মুহূর্তের তথ্য এমন জায়গায় রাখা, যা reset-এ মোছে না: SRAM-এর .noinit section (পর্ব ৩১), startup কোড যা শূন্যও করে না, কপিও করে না। Board-এ watchdog আর software reset-এর পরে SRAM টিকে থাকে (Spec decision 18). বিমানের flight recorder-এর মতো এটি firmware-এর black box.
struct fault_log { uint32_t magic, kind, line, pc, lr; const char *what; };
__attribute__((section(".noinit"))) static struct fault_log flog;
#define ASSERT(c) do { if (!(c)) assert_fail(__LINE__, #c); } while (0)
static void assert_fail(uint32_t line, const char *what) /* noreturn */
{
flog.kind = 1; flog.line = line; flog.what = what; /* what: flash-এর লেখা */
flog.magic = LOG_MAGIC; /* সবশেষে: log এখন সম্পূর্ণ */
SCB->AIRCR = 0x05FA0004u; /* VECTKEY + SYSRESETREQ */
for (;;) { }
}
void fault_save(const uint32_t *frame) /* naked HardFault_Handler থেকে, R0 = MSP */
{
flog.kind = 2; flog.pc = frame[6]; flog.lr = frame[5];
flog.magic = LOG_MAGIC;
SCB->AIRCR = 0x05FA0004u;
for (;;) { }
}
/* main: boot 1-এ ASSERT(span > 0) ব্যর্থ (calibration লোড হয়নি, span = -400);
boot 2-এ ভুল sensor ঠিকানা পড়া; প্রতিটি boot-এ আগের log থাকলে ছাপা */সত্যিকারের run — board.py run faultlog.elf (-g সহ build)
[ 0.0271 ms] UART: boot #1 (power-on)
[ 0.0321 ms] RESET (software, AIRCR.SYSRESETREQ)
[ 0.0636 ms] UART: boot #2 (software reset)
[ 0.1168 ms] UART: last boot: ASSERT failed, faultlog.c:77 (span > 0)
[ 0.1179 ms] HardFault: Invalid memory read (UC_ERR_READ_UNMAPPED) at PC=0x080001CC main+0x120
[ 0.1207 ms] RESET (software, AIRCR.SYSRESETREQ)
[ 0.1522 ms] UART: boot #3 (software reset)
[ 0.2087 ms] UART: last boot: HardFault PC=0x080001CC LR=0x080001A7
[ 0.2105 ms] exit(0) after 1684 cycles
তিনটি boot-এর গল্প। Boot 1-এ ভাগের আগেই ASSERT(span > 0) ধরেছে যে calibration লোড হয়নি; না ধরলে পর্ব ৩০-এর মতো Cortex-M3-এ শূন্য বা ঋণাত্মক হর দিয়ে নীরবে ভুল ওজন আসত। #c (preprocessor-এর stringize, C-এর preprocessor পর্ব) শর্তটি লেখা হিসেবে flash-এ রেখেছে, আর __LINE__ লাইন 77. Boot 2 সেই log ছেপে মুছেছে, তারপর ভুল ঠিকানা পড়ে HardFault; handler PC আর LR রেখে reset করেছে। Boot 3 ছেপেছে PC=0x080001CC; a2l.py বলে এটি main+0x120, faultlog.c:79, ঠিক ভুল পড়ার লাইন। magic সবশেষে লেখা হয়, যাতে অর্ধেক-লেখা log কখনো বৈধ না দেখায়; আর power-on-এ (RCC-এর PORRSTF) log মুছে ফেলা হয়, কারণ তখন SRAM-এর মান অনির্দিষ্ট।
Desktop-এর assert.h ব্যর্থ হলে abort() ডাকে আর stderr-এ লেখে; firmware-এ দুটির কোনোটিই নেই, তাই নিজের macro. Release build-এ assert বন্ধ রাখা হবে কি না, তা নিয়ে দুই মত আছে: বন্ধ করলে কোড ছোট হয়, কিন্তু মাঠের সবচেয়ে দামি তথ্য হারায়। বহু দল নিরাপত্তা-জরুরি শর্তের assert release-এও রাখে, শুধু লেখার বদলে ছোট code নম্বর রেখে।
ISR থেকে লগ রাখার নিরাপদ রূপটিও দেখা যাক: ISR শুধু একটি ছোট ring buffer-এ ঘটনা রাখে, আর main অবসরে ছাপে। Buffer ভর্তি হলে নতুন ঘটনা ফেলে দিয়ে গুনে রাখা হয়, যাতে ISR কখনো অপেক্ষা না করে। নিচের কোড desktop-এর gcc-তে চলে; “ISR” এখানে একটি loop, কিন্তু head আর tail-এর নিয়ম firmware-এর মতোই (একজন লেখক, একজন পাঠক; data-structure-এর দিক DSA কোর্সে):
#include <stdio.h>
#include <stdint.h>
#define LOG_N 8 /* 2-এর ঘাত, তাই & দিয়ে ঘোরানো */
struct ev { uint32_t t_ms; uint16_t code; int16_t val; };
static struct ev log_buf[LOG_N];
static volatile uint32_t log_head; /* শুধু ISR লেখে */
static volatile uint32_t log_tail; /* শুধু main লেখে */
static uint32_t log_lost;
static void log_ev(uint32_t t, uint16_t code, int16_t val) /* ISR-এ নিরাপদ */
{
if (log_head - log_tail == LOG_N) { log_lost++; return; } /* ভর্তি */
log_buf[log_head & (LOG_N - 1)] = (struct ev){t, code, val};
log_head++;
}
#define ASSERT(c) do { if (!(c)) printf("ASSERT failed, line %d: %s\n", \
__LINE__, #c); } while (0)
int main(void)
{
for (uint32_t ms = 1; ms <= 10; ms++) /* ১০টি "SysTick ISR" */
log_ev(ms, 1, (int16_t)(400 + 50 * (int)ms)); /* 4.50 ... 9.00 C */
printf("in buffer=%u lost=%u\n", (unsigned)(log_head - log_tail),
(unsigned)log_lost);
while (log_tail != log_head) { /* main: সময় নিয়ে ছাপা */
struct ev e = log_buf[log_tail & (LOG_N - 1)];
log_tail++;
printf("t=%2u ms code=%u T=%d.%02d C\n", (unsigned)e.t_ms,
(unsigned)e.code, e.val / 100, e.val % 100);
}
int32_t span = 0 - 400; /* calibration লোড হয়নি */
ASSERT(span > 0);
return 0;
}আসল আউটপুট (Wandbox, gcc):
in buffer=8 lost=2
t= 1 ms code=1 T=4.50 C
t= 2 ms code=1 T=5.00 C
t= 3 ms code=1 T=5.50 C
t= 4 ms code=1 T=6.00 C
t= 5 ms code=1 T=6.50 C
t= 6 ms code=1 T=7.00 C
t= 7 ms code=1 T=7.50 C
t= 8 ms code=1 T=8.00 C
ASSERT failed, line 33: span > 0
দশটি ঘটনার আটটি buffer-এ, শেষ দুটি (9 আর 10 ms, 8.50 আর 9.00 °C) হারিয়েছে, আর lost=2 সেটি সৎভাবে জানাচ্ছে। লক্ষ করুন, হারানো ঘটনা দুটিই cold room-এর alarm-সীমার (8.00 °C) ওপরে: debug log-এর ক্ষতি তাই গুনে রাখতেই হয়, নইলে log মিথ্যা নিশ্চয়তা দেয়। প্রতিটি ঘটনা ৮ byte, একটি ISR-এ মাত্র কয়েকটি নির্দেশ, আগের ব্লকের “RAM-এর ring buffer” সারির ভিত্তি। আসল firmware-এ head বাড়ানোর আগে data লেখা শেষ হওয়া নিশ্চিত করতে compiler barrier লাগে (পর্ব ৩৪-এর “barrier-ও নয়” অংশ).
৮ · Logic analyzer আর oscilloscope — তারের ওপর সত্য
Firmware-এর ভেতরের সব উপায় firmware-এরই কথা বিশ্বাস করে। কিন্তু অনেক bug তারের ওপর: UART-এর baud ভুল, I2C-এর ACK আসছে না, PWM-এর duty cycle অন্যরকম, বোতামের bounce. সেখানে বাইরের যন্ত্র লাগে।
Logic analyzer
কয়েকটি digital তারের 0/1 সময় ধরে রেকর্ড করে। সঙ্গের software UART, SPI, I2C-এর বিট পড়ে byte-এ রূপান্তর (protocol decode) করে। প্রশ্নের ধরন: “কোন byte কখন গেল, দুই ঘটনার মাঝে কত µs?”
Oscilloscope
Voltage-কে সময়ের সঙ্গে আসল আকারে দেখায়: ধীরে ওঠা ধার, ringing, noise, ভুল logic level (3.3 V বনাম 5 V). প্রশ্নের ধরন: “সংকেতটি কি সত্যিই পরিষ্কার 0 আর 1?”
দুটির জন্যই একটি মূল নিয়ম sampling rate: যন্ত্র প্রতি সেকেন্ডে কতবার মাপে। Logic analyzer-এ একটি প্রচলিত হাতের নিয়ম, সবচেয়ে ছোট pulse-এর মধ্যে অন্তত ৪টি, ভালো হলে ১০টি নমুনা। 115200 baud-এর একটি বিট 8.68 µs, তাই অন্তত 4 ÷ 8.68 µs ≈ 0.46 MHz, আরামে 1 MHz-এর বেশি। কম হলে বিটের ধার সরে যায়, আর decode ভুল byte দেখায়: যন্ত্রের ভুল তখন firmware-এর ভুল মনে হয়।
অংশ ২-এর probe pin-এর কৌশল এখানে পুরো অর্থ পায়: ভেতরের একটি ঘটনাকে (ISR চলছে) একটি pin-এ বাইরে আনা, যাতে logic analyzer ভেতরের সময় মাপতে পারে, প্রায় শূন্য খরচে (একটি register লেখা). নিচের ছবি board-এর run-এর cycle সংখ্যা থেকে আঁকা, logic analyzer-এ যেমন দেখাত:
ছবি ৩৮.২ — Probe pin-এর timing: printf ছাড়া আর সহ
PA5 = SysTick ISR চলছে, PA6 = বোতামের ISR চলেছে; বেগুনি দাগ = বোতাম চাপা (cycle 16064)
dbg.py --cyc run থেকে; x-অক্ষ cycle 16048 থেকে 16172. Board-এ 1 নির্দেশ = 1 cycle (Spec decision 17), তাই এগুলো নির্দেশের সংখ্যা, আসল chip-এর সময় নয়; আসল logic analyzer-এ printf-এর ISR UART-এর তারের সময়ের জন্য আরও অনেক লম্বা দেখাত।আরও গভীরে: ARM-এর debug hardware একটি বড় কাঠামোর অংশ, যার নাম CoreSight: Debug Access Port (DAP) বাইরের probe-কে chip-এর ভেতরের bus-এ ঢোকার দরজা দেয়, তাই CPU চলার মধ্যেও probe মেমরি পড়তে পারে (অনেক IDE এভাবেই চলন্ত variable দেখায়). DWT-এর CYCCNT register (যেখানে আছে) CPU-র cycle গোনে, যা দিয়ে কোনো কোডের আসল সময় মাপা যায়, probe pin ছাড়াই। আর উঁচু শ্রেণির chip-এ ETM প্রতিটি নির্দেশের trace বের করে দেয়, যা আমাদের board-এর --trace-এর hardware রূপ। কোনটি কোন chip-এ আছে, তা chip-ভেদে আলাদা; নিজের chip-এর reference manual-এর debug অধ্যায় দেখুন।
পরীক্ষা ও ইন্টারভিউতে: “JTAG আর SWD-এর পার্থক্য?” → JTAG চার-পাঁচ তার আর chain, SWD ARM-এর দুই তার (SWDIO, SWCLK). “Flash-এর কোডে breakpoint কীভাবে?” → FPB-এর hardware comparator, সংখ্যা সীমিত (Cortex-M3-এ ৬টি পর্যন্ত). “ISR-এ printf কেন নয়?” → blocking, latency বাড়ায়, tick হারায়, heisenbug. “HardFault-এ কোন লাইন দোষী কীভাবে?” → stacked PC → map file → disassembly/addr2line; LR থেকে caller. “Probe খুললে firmware আটকে যায়, প্রথম সন্দেহ?” → semihosting-এর BKPT.
৯ · AI-এর যুগে embedded debugging
AI assistant-কে crash log দিলে সে আত্মবিশ্বাসী একটি গল্প বানায়, কিন্তু ঠিকানা আর register-এর জগতে ছোট ভুলই বড় ভুল পথে পাঠায়। কয়েকটি পরিচিত ভুল:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
| stacked PC-এর বদলে LR-কে দোষী নির্দেশ বলে, বা Thumb বিট (বিট ০) না সরিয়ে ঠিকানা খোঁজে | নিজের map file আর -S/disassembly-তে ঠিকানা মেলানো |
| CFSR, HFSR-এর মতো fault register-এর ঠিকানা বা বিট বানিয়ে বলে, বা ARMv6-M chip-এও সেগুলো আছে বলে | ARMv7-M Architecture Reference Manual আর chip-এর manual |
| “debug করতে ISR-এ printf দিন” পরামর্শ দেয় | baud থেকে সময় হিসাব (অংশ ২); ring buffer বা ITM |
| semihosting-এর printf release build-এ রেখে দেয় | probe খুলে board চালিয়ে দেখা; release-এ semihosting বন্ধ |
| breakpoint-এর সংখ্যা অসীম ধরে, বা flash-এ software breakpoint-এর কথা বলে | chip-এর FPB-এর comparator সংখ্যা জানা |
| OpenOCD-এর config file বা GDB কমান্ডের নাম বানায় | নিজের tool-এর version-এর documentation-এ মিলিয়ে নেওয়া |
AI-কে log দেওয়ার সময় প্রসঙ্গ আর প্রমাণের শর্ত দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১JTAG বানানো হয়েছিল circuit board পরীক্ষার জন্য। একটি পরীক্ষার standard কীভাবে প্রায় সব chip-এর debug-এর দরজা হয়ে উঠল?
১৯৮০-এর দশকে circuit board-এ chip-এর pin এত ঘন হয়ে উঠছিল যে পরীক্ষার জন্য “bed of nails” ধাঁচের যন্ত্রে প্রতিটি সংযোগে কাঁটা ছোঁয়ানো কঠিন হয়ে পড়ে, বিশেষত surface-mount chip-এ। Joint Test Action Group (JTAG) নামে শিল্পের একটি দল একটি বিকল্প প্রস্তাব করে: প্রতিটি chip-এর প্রতিটি pin-এর পাশে একটি ছোট cell, যেগুলো একটি shift register-এর মতো শিকলে জোড়া। চারটি তার দিয়ে সেই শিকলে বিট ঢুকিয়ে pin-এ মান বসানো আর পড়া যায়, chip-এর ভেতরের যুক্তি না ছুঁয়ে। এটি boundary scan, আর ১৯৯০ সালে IEEE 1149.1 standard হিসেবে গৃহীত হয়।
চতুর অংশটি ছিল নকশার সাধারণতা। TAP (test access port) নামের ছোট state machine আর instruction register এমনভাবে বানানো হয়েছিল যে chip নির্মাতা নিজেদের instruction যোগ করতে পারেন। নির্মাতারা দ্রুত বুঝলেন, যে দরজা দিয়ে pin পড়া যায়, সেই দরজা দিয়েই CPU-র debug logic-এ ঢোকা যায়: CPU থামানো, register পড়া, মেমরি লেখা। ফলে আলাদা debug pin না রেখেই প্রতিটি chip-এ debug আর flash-এ program লেখার একটি পথ তৈরি হলো, আর আগের দিনের দামি in-circuit emulator (যেখানে chip খুলে একটি বিশেষ যন্ত্র বসাতে হতো) ক্রমে কমে এল।
কিন্তু ছোট microcontroller-এ চার-পাঁচটি pin অনেক। ARM তাই Cortex-M-এর যুগে Serial Wire Debug আনে: দুটি তার, SWDIO আর SWCLK, প্রায় একই ক্ষমতা নিয়ে। বহু chip দুটি পথই রাখে, একই pin ভাগ করে (SWJ-DP). একটি সতর্কতাও এখান থেকে আসে: যে দরজা দিয়ে আপনি debug করেন, আক্রমণকারীও সেই দরজা দিয়ে firmware পড়তে পারে। তাই বাজারের যন্ত্রে debug port বন্ধ করা বা read-out protection চালু করা একটি নিরাপত্তা-সিদ্ধান্ত, যার আলোচনা পর্ব ৭৬ আর ৭৭-এ।
মূল উপলব্ধি: JTAG-এর সাধারণ, সম্প্রসারণযোগ্য নকশা একে পরীক্ষার যন্ত্র থেকে debug-এর মানদণ্ডে তুলেছে; SWD একই ধারণা কম pin-এ, আর এই দরজা বন্ধ রাখা উৎপাদনের নিরাপত্তার অংশ।
প্র ০২“Debugger আছে, তাই printf লাগে না” — অভিজ্ঞ firmware প্রকৌশলীরা কেন এ কথা পুরোপুরি মানেন না?
Debugger-এর শক্তি সময় থামানো: যেকোনো মুহূর্তে CPU থামিয়ে সব register আর মেমরি দেখা। কিন্তু এমবেডেড bug-এর বড় অংশ ঠিক সময়ের ভেতরেই থাকে। একটি UART-এর byte হারানো, I2C-এর timeout, PID loop-এর অস্থিরতা, দুটি interrupt-এর ভুল ক্রম: CPU থামালে এগুলো ঘটেই না, বা অন্যভাবে ঘটে, কারণ বাইরের পৃথিবী থামে না। Breakpoint থেকে ফেরার পরে UART-এর buffer ভরে যায়, watchdog reset করে দেয়, আর আপনি যে bug খুঁজছিলেন তার জায়গায় নতুন একটি দেখেন। এ জন্য সময়-নির্ভর bug-এ “না থামিয়ে দেখা”র উপায় লাগে: log, trace, probe pin আর logic analyzer.
আবার printf-ও সময় বদলায়, এই পর্বের board-এ ISR-এর দৈর্ঘ্য ৫ থেকে ১০৮ cycle আর বোতামের সাড়া ৬ থেকে ১০৩ cycle. তাই প্রশ্ন “printf না debugger” নয়, বরং “কোন উপায় এই bug-এর সময় সবচেয়ে কম বদলায়, আর সবচেয়ে বেশি তথ্য দেয়”। বহু দল তাই তিন স্তরের ব্যবস্থা রাখে: সস্তা আর সবসময় চালু একটি RAM-এর trace buffer (ঘটনা, সময়, একটি মান), জরুরি ঘটনার fault log, আর বিশেষ সন্দেহে debugger বা logic analyzer. Trace buffer-এর সুবিধা হলো, crash-এর পরে debugger লাগিয়ে বা fault log থেকে শেষ কয়েকশো ঘটনা পড়া যায়: ভাঙার আগের মুহূর্তগুলোর একটি ছোট চলচ্চিত্র।
আরেকটি বাস্তবতা: মাঠের যন্ত্রে debugger থাকে না। দোকানে বসানো বাজারঘরের scale যদি সপ্তাহে একবার আটকে যায়, তখন সম্বল শুধু firmware নিজে যা রেখে গেছে: reset-এর কারণ, fault log, গণনা। তাই যিনি শুধু debugger-এর ওপর নির্ভর করেন, তিনি টেবিলের bug ধরেন, মাঠের bug নয়। আর debugger-এর সবচেয়ে বড় দান সম্ভবত watchpoint: “কে এই variable নষ্ট করল” প্রশ্নের উত্তর অন্য কোনো উপায়ে খুব কষ্টের।
মূল উপলব্ধি: প্রতিটি debugging উপায় কিছু না কিছু বদলায়; bug-এর প্রকৃতি দেখে উপায় বাছতে হয়, আর মাঠের জন্য firmware-এর ভেতরেই log রাখার ব্যবস্থা আগে থেকে করতে হয়।
প্র ০৩Semihosting এত সুবিধাজনক হলেও বাজারে যাওয়া firmware-এ একে কেন বিপজ্জনক ধরা হয়?
Semihosting-এর ধারণা পুরোনো: ARM-এর প্রথম দিকের development system-এ, যখন নতুন board-এ কোনো display বা serial port তখনো চালু হয়নি, তখনো যাতে C library-র printf বা file খোলা কাজ করে। কৌশলটি হলো firmware-এর ভেতরে একটি বিশেষ নির্দেশ (Cortex-M-এ BKPT 0xAB), যা debugger-কে বলে “আমার হয়ে host-এ এই কাজটি করে দিন”। R0-তে কাজের নম্বর, R1-এ argument-এর ঠিকানা; debugger মেমরি পড়ে কাজ করে, তারপর CPU ছেড়ে দেয়। নতুন board চালু করার প্রথম দিনগুলোতে, বা host-এর file থেকে test data পড়ে firmware-এর algorithm যাচাইয়ে, এটি সত্যিই কাজের।
বিপদ আসে তিন দিক থেকে। এক, গতি: প্রতিটি অনুরোধে CPU থামে, debugger USB দিয়ে মেমরি পড়ে, host কাজ করে, তারপর আবার চালু; একটি ছোট লাইনেও মিলিসেকেন্ড লাগতে পারে, তাই timing পুরো বদলে যায়। দুই, নির্ভরতা: probe না থাকলে BKPT ধরার কেউ নেই। ARMv7-M-এ halting debug চালু না থাকলে BKPT একটি debug event হিসেবে fault-এ যায়, সাধারণত HardFault; ফলে যে firmware টেবিলে চমৎকার চলছিল, দোকানে প্রথম লগ লাইনেই HardFault দেয়, আর fault handler-ও যদি printf করে, তাহলে আরও খারাপ। তিন, নিরাপত্তা আর অভ্যাস: semihosting-এর file-এর কাজ host-এর file-এ লেখার পথ খোলে, যা উৎপাদনের যন্ত্রে থাকার কথা নয়।
সমাধান সাধারণত build-এর নিয়মে: semihosting শুধু একটি আলাদা debug configuration-এ, যেখানে একটি macro দিয়ে লগ-এর পথ বাছা হয় (semihosting, UART, ITM বা কিছুই না). Release build-এ সেই পথ UART বা ring buffer-এ যায়, আর CI-তে একটি পরীক্ষা নিশ্চিত করে যে release ELF-এ BKPT নির্দেশ নেই। কিছু দল এর বদলে শুরু থেকেই ITM বা RTT-এর মতো CPU না থামানো পথ ব্যবহার করে, যেখানে probe না থাকলে লেখা শুধু হারিয়ে যায়, কিন্তু যন্ত্র আটকে যায় না।
মূল উপলব্ধি: Semihosting debugger-এর ওপর নির্ভর করা একটি সুবিধা; release firmware-এ এমন কোনো পথ রাখা যাবে না, যা probe না থাকলে fault বা আটকে যাওয়ায় শেষ হয়।
প্র ০৪Bisect-কে বলা হয় debugging-এর সবচেয়ে “বোকা কিন্তু নিশ্চিত” পদ্ধতি। এর শক্তি কোথায়, আর কখন এটি ভুল পথে নেয়?
Bisect-এর শক্তি এটি বুদ্ধির ওপর নির্ভর করে না, শুধু একটি সৎ পরীক্ষার ওপর। আপনি জানেন না bug কোথায়, অনুমানও করতে পারছেন না; তবু যদি একটি পরীক্ষা থাকে যা “ভালো” আর “খারাপ” আলাদা করে, তাহলে প্রতিবার সন্দেহের এলাকা অর্ধেক হয়। এই পর্বে চারটি ধাপের pipeline-এ দুটি build-এই ধাপ ২ পাওয়া গেছে। একই যুক্তিতে ১০০০টি commit-এর ইতিহাসে প্রায় ১০টি build, আর Git-এর git bisect এই খোঁজ স্বয়ংক্রিয় করে, এমনকি একটি script দিয়ে প্রতিটি build board-এ চালিয়ে ফল জানাতে পারে। Firmware-এ যেখানে debugger নেই বা UART-ও নেই, সেখানে একটি LED-ই সেই পরীক্ষার ফল দেখানোর জন্য যথেষ্ট।
কিন্তু পদ্ধতির একটি অনুমান আছে: bug-এর একটি নির্দিষ্ট “শুরুর জায়গা” আছে আর পরীক্ষাটি প্রতিবার একই ফল দেয়। অনুমান ভাঙে তিনভাবে। এক, অনিয়মিত bug: race condition বা নির্দিষ্ট সময়ে আসা interrupt-এর bug দশবারে একবার ঘটে; একবার “ভালো” দেখে ভুল দিকে গেলে পুরো খোঁজ নষ্ট। তখন প্রতিটি ধাপে বহুবার চালাতে হয়, বা bug-কে আগে নিয়মিত করতে হয় (চাপ বাড়িয়ে, সময় বদলে)। দুই, পরীক্ষা নিজেই সময় বদলায়: একটি checkpoint যোগ করলে কোডের আকার আর timing বদলায়, আর heisenbug লুকিয়ে যায়। তিন, দুই কারণের মিলন: দুটি আলাদা পরিবর্তন একসঙ্গে থাকলেই bug, আলাদাভাবে নয়; তখন bisect যে commit দেখায় সেটি “শেষ খড়”, আসল কারণ নয়।
বাজারঘরের উদাহরণে bug ছিল নিয়মিত আর একটি ধাপেই, তাই bisect নিখুঁত কাজ করেছে। আর পেয়েছে একটি পুরোনো ফাঁদ: integer-এ গুণের আগে ভাগ। কারণ চিনতে তবু মানুষের পড়া লেগেছে; bisect বলে “কোথায়”, “কেন” বলে না। ভালো অভ্যাস হলো খোঁজার সময় একটি ছোট নোট রাখা: কোন build, কী পরীক্ষা, কী ফল; তাতে ভুল ধাপ পরে ধরা যায়।
মূল উপলব্ধি: Bisect একটি নির্ভরযোগ্য পরীক্ষাকে log2 n ধাপে bug-এর ঠিকানায় রূপান্তর করে; অনিয়মিত বা সময়-নির্ভর bug-এ পরীক্ষা বারবার চালাতে আর ফলকে সন্দেহ করতে হয়।
প্র ০৫GDB-এর জন্ম desktop-এ। একটি desktop debugger কীভাবে একটি ২০ KiB SRAM-এর microcontroller debug করে, আর এই নকশার দুর্বলতা কোথায়?
GDB-এর কাজ শুরু হয় ১৯৮০-এর দশকের মাঝামাঝি, GNU প্রকল্পের অংশ হিসেবে, Richard Stallman-এর হাতে (প্রায়ই ১৯৮৬ বলা হয়). শুরু থেকেই একটি নকশার সিদ্ধান্ত ভবিষ্যৎ ঠিক করে দেয়: GDB নিজে জানে symbol, source লাইন, type আর expression, কিন্তু লক্ষ্য machine-এর সঙ্গে কথা বলার অংশ আলাদা করা যায়। “Remote serial protocol” নামের একটি সরল লেখা-ভিত্তিক protocol দিয়ে GDB অন্য একটি program-কে বলে “register চাই”, “এই ঠিকানার ১৬ byte পড়া”, “এখানে breakpoint”, “চালানো”। সেই অন্য program, GDB server, লক্ষ্যের আসল hardware সামলায়।
Microcontroller-এর ক্ষেত্রে এই server হলো OpenOCD বা probe নির্মাতার নিজের server: তারা protocol-এর অনুরোধকে SWD বা JTAG-এর বিটে রূপান্তর করে, DAP দিয়ে chip-এর ভেতরে ঢোকে, FPB-এ breakpoint বসায়, DWT-তে watchpoint. বিশাল কাজ, অর্থাৎ ELF আর DWARF পড়া, symbol খোঁজা, source দেখানো, সব হয় কম্পিউটারে; microcontroller-এ কিছুই চলে না, তার ২০ KiB SRAM-এর এক byte-ও খরচ হয় না। এটিই নকশার সৌন্দর্য। একই কারণে QEMU-র মতো emulator-ও নিজের ভেতরে একটি GDB stub রাখতে পারে, যাতে hardware ছাড়াই একই GDB দিয়ে debug করা যায়; আমাদের বাজারঘর board-এ এমন stub নেই, তাই এই পর্বে hook-ভিত্তিক বিকল্প।
দুর্বলতাও এই আলাদা থাকায়। GDB যে ELF পড়ছে আর chip-এ যে firmware চলছে, দুটি এক না হলে সব ঠিকানা আর লাইন ভুল দেখায়, কোনো সতর্কতা ছাড়াই: এক লাইন বদলে build করে flash না করলেই এমন হয়। -O2-এর কোডে variable register-এ থাকে বা মুছে যায় (“optimized out”), আর লাইনের ক্রম লাফায়, কারণ DWARF-এর তথ্য অনুবাদ-করা কোডের সঙ্গে নিখুঁত মেলে না। আর সময়: প্রতিটি single-step USB আর SWD পেরিয়ে আসা-যাওয়া, তাই ধীর। তবু এই নকশাই আজ প্রায় সব IDE-র firmware debugging-এর ভিত্তি।
মূল উপলব্ধি: GDB-র বুদ্ধি থাকে কম্পিউটারে আর server ও probe শুধু hardware-এর হাত-পা; তাই ছোট chip-ও পূর্ণ debugger পায়, কিন্তু ELF আর firmware মেলানো ও optimization-এর ছাপ বোঝা আপনার দায়িত্ব।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর কোর্সের virtual board-এ বা Python-এ চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — reset পেরোনো fault log: একটি
ASSERT(c)macro আর তার function লিখুন, যা ব্যর্থ হলে লাইন নম্বর আর শর্তের লেখা এমন জায়গায় রাখে যা software reset-এ মোছে না, তারপর reset করে। পরের boot-এ log একবারই ছাপতে হবে, আর power-on-এ পুরোনো মান বিশ্বাস করা যাবে না। কোন ক্রমে লিখবেন, আর কেন?__attribute__((section(".noinit"))) static struct fault_log flog; #define ASSERT(c) do { if (!(c)) assert_fail(__LINE__, #c); } while (0) static void assert_fail(uint32_t line, const char *what) { flog.kind = 1; flog.line = line; flog.what = what; flog.magic = LOG_MAGIC; /* সবশেষে */ SCB->AIRCR = 0x05FA0004u; /* software reset */ for (;;) { } } /* main-এর শুরুতে: */ uint32_t csr = RCC->CSR; RCC->CSR = RCC_CSR_RMVF; if (csr & RCC_CSR_PORRSTF) flog.magic = 0; /* power-on: অবিশ্বাস্য */ if (flog.magic == LOG_MAGIC) { /* ছাপা */ flog.magic = 0; }.noinit-কে startup কোড ছোঁয় না, তাই reset-এর পরে মান থাকে (board-এ Spec decision 18).magicসবশেষে লেখা হয়, যাতে মাঝপথে কিছু হলে অর্ধেক-লেখা log বৈধ না দেখায়; ছাপার পরে মুছে দেওয়ায় একবারই ছাপা হয়। Power-on-এ SRAM-এর মান অনির্দিষ্ট (আসল chip-এ এলোমেলো), তাই RCC-এর PORRSTF দেখে log বাতিল।what-এ একটি pointer রাখা নিরাপদ, কারণ#c-এর লেখা flash-এ, আর একই firmware-এ ঠিকানা বদলায় না। এই পর্বেরfaultlog.c-এর সত্যিকারের run: boot 2-এlast boot: ASSERT failed, faultlog.c:77 (span > 0). -
ভুল খুঁজুন — cold room-এর debug লগ: একজন লিখেছেন, “alarm দেরিতে বাজে, তাই প্রতি tick-এ তাপমাত্রা দেখতে চাই।” তাঁর কোডে তিনটি ভুল খুঁজুন আর প্রতিটির ফল বলুন। UART 9600 baud, polled.
static uint32_t ms_ticks; /* main-ও পড়ে */ void SysTick_Handler(void) /* প্রতি 1 ms */ { ms_ticks++; printf("t=%u ms T=%d\r\n", ms_ticks, read_temp_i2c()); }(১) ISR-এ blocking printf:
"t=1000 ms T=700\r\n"-এর মতো ১৭টি অক্ষর 9600 baud-এ ১৭ × 1.04 ms ≈ 17.7 ms, অথচ tick প্রতি 1 ms. ISR শেষ হওয়ার আগেই বহু tick আসে, pending বিট একটিই রাখে, তাই tick হারায় আরms_ticksআসল সময়ের চেয়ে অনেক ধীরে বাড়ে (এই পর্বের মডেলে ছোট লাইনেই ২০টির ১৬টি হারিয়েছে). যে দেরি খুঁজছেন, printf নিজেই আরও দেরি বানাচ্ছে। (২) ISR থেকে I2C পড়া: bus-এর লেনদেনও অপেক্ষা করে, আর I2C আটকে গেলে পুরো system আটকায়; ISR শুধু flag তুলবে, পড়া হবে main-এ। (৩)ms_ticksvolatile নয়, অথচ main পড়ে:-O2-এ main-এর loop মুছে যেতে বা আটকে যেতে পারে (পর্ব ৩৪). সঠিক নকশা: ISR-এ শুধুms_ticks++আর প্রতি 1000 tick-এ একটি volatile flag; main flag দেখে sensor পড়ে, আর লগ যায় ring buffer-এ বা main থেকে UART-এ। -
হিসাব — fault log থেকে লাইন: একটি firmware-এর boot log:
last boot: HardFault PC=0x080001CC LR=0x080001A7. Map file-এmain-এর সারি80000ad 80000ad 132 1 main(ঠিকানা আর আকার hex-এ). PC কোন function-এর কত offset-এ? LR-কে কেন এখানে ডাকার জায়গা হিসেবে বিশ্বাস করা যায় না?Map-এ 0x080000AD-এ Thumb বিট সহ, তাই
mainশুরু 0x080000AC, আকার 0x132 byte, অর্থাৎ 0x080000AC থেকে 0x080001DD পর্যন্ত। PC 0x080001CC এর ভেতরে: 0x080001CC − 0x080000AC = 0x120, তাইmain+0x120. Board-এর নিজের লাইনও তা-ই বলেছে (at PC=0x080001CC main+0x120), আর-gbuild-এa2l.py:faultlog.c:79, ভুল sensor ঠিকানা পড়ার লাইন। LR 0x080001A7 → 0x080001A6, এটিওmain-এর ভেতরে,main+0xFA; DWARF-এ এর লাইন 0 (compiler-এর বানানো কোড). কারণ faultmain-এর নিজের নির্দেশে, কোনো function-এ ঢুকে নয়; তাই LR-এ শুধু main-এর আগের কোনোbl-এর পুরোনো ফেরার ঠিকানা পড়ে আছে। LR তখনই ডাকার জায়গা বলে, যখন fault একটি ডাকা function-এর ভেতরে আর সেই function LR বদলায়নি। -
আগে বলুন, তারপর মিলিয়ে দেখুন — ISR-এর latency: একটি board-এ SysTick আর বোতামের EXTI0-এর priority সমান। SysTick ISR printf ছাড়া cycle 16051 থেকে 16056 চলে; printf সহ 16052 থেকে 16160. বোতাম চাপা হয় cycle 16064-এ, আর EXTI0 ISR-এর প্রথম দৃশ্যমান কাজে (PA6 তোলা) printf ছাড়া ৬ cycle লাগে। printf সহ PA6 কখন উঠবে, আন্দাজ করুন। EXTI0-এর priority বেশি (সংখ্যায় কম) হলে কী হতো?
সমান priority-তে EXTI0 SysTick-কে থামাতে পারে না (Spec decision 19), তাই অপেক্ষা করে 16160 পর্যন্ত। তারপর ঢুকে নিজের কাজের মোটামুটি একই কয়েকটি নির্দেশ: আন্দাজ 16160 + ৬-এর কাছাকাছি। Board-এর সত্যিকারের run: PA6 উঠেছে 16167-এ, SysTick শেষের ৭ cycle পরে, অর্থাৎ বোতাম থেকে ১০৩ cycle (printf ছাড়া ৬). EXTI0-এর priority বেশি হলে সেটি SysTick-এর printf-এর মাঝখানেই preempt করত, আর সাড়া printf ছাড়া অবস্থার কাছাকাছি থাকত; কিন্তু তখন SysTick-এর printf-এর লাইনের মাঝে বোতামের ISR ঢুকে পড়ত, আর সেও যদি UART-এ লেখে, লাইন দুটি মিশে যেত। তাই সমাধান priority বদলানো নয়, ISR থেকে printf সরানো।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি Cortex-M firmware মাঠে HardFault দিচ্ছে। দোষী C লাইন খোঁজার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- HardFault handler-এ stacked frame থেকে PC আর LR fault log-এ রাখা
- পরের boot-এ log পড়ে PC আর LR-এর মান পাওয়া
- একই firmware-এর map file-এ PC কোন function-এর কত offset-এ, তা খোঁজা
-gbuild-এর debug info দিয়ে PC-কে source লাইনে রূপান্তর- LR-এর Thumb বিট সরিয়ে ডাকার লাইন খুঁজে কারণ নিশ্চিত করা
একটি Cortex-M3-এর 1 ms SysTick ISR-এ polled UART-এ 115200 baud-এ ৯টি অক্ষরের একটি লাইন ছাপা হয় (8N1). ISR-এর সময় মোটামুটি কত বাড়ে?
- প্রায় 9 µs
- প্রায় 780 µs
- প্রায় 8.3 ms
- নগণ্য, কারণ UART hardware নিজে পাঠায়
একটি Cortex-M3 firmware-এর HardFault handler ছেপেছে stacked PC=0x08000154 LR=0x0800013D. দোষী নির্দেশটি কোথায়?
- 0x0800013D-এ
- 0x0800013C-এ
- 0x08000154-এ, stacked PC
- HardFault_Handler-এর শুরুতে
Cortex-M3-এ flash-এ রাখা কোডে debugger কীভাবে breakpoint বসায়?
- FPB-এর hardware comparator দিয়ে, সংখ্যা সীমিত
- প্রতিটি breakpoint-এ flash-এর নির্দেশ BKPT দিয়ে বদলে
- DWT-এর comparator দিয়ে, অসীম সংখ্যক
- UART-এ একটি বিশেষ byte পাঠিয়ে
একটি firmware debug probe লাগানো অবস্থায় ঠিক চলে, কিন্তু probe খুলে নিলে প্রথম লগ বার্তাতেই আটকে যায় বা HardFault দেয়। সবচেয়ে সম্ভাব্য কারণ কী?
- Probe chip-কে clock দিচ্ছিল
- UART-এর baud rate probe ঠিক করছিল
- Probe খুললে watchdog বন্ধ হয়ে যায়
- লগ semihosting দিয়ে যাচ্ছিল, যার BKPT এখন কেউ ধরে না
একটি scale firmware-এ tare_g হঠাৎ ভুল মান পায়, কিন্তু কোডে তাকে বদলানোর মাত্র একটি জায়গা, আর সেটি ঠিক আছে। কোন debugging হাতিয়ার সবচেয়ে সরাসরি উত্তর দেবে?
- TARE-এর কোডে একটি breakpoint
- tare_g-এর ঠিকানায় একটি data watchpoint
- UART-এর TX তারে oscilloscope
- LED blink code
JTAG আর SWD সম্পর্কে কোন কথাটি সঠিক?
- JTAG দুই তারের, SWD চার তারের
- SWD হলো IEEE 1149.1 standard
- JTAG চার সংকেতের standard, SWD ARM-এর দুই-তারের বিকল্প
- শুধু JTAG দিয়ে flash-এ program লেখা যায়
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- উপায় বাছুন bug দেখে: LED, UART, debug probe, semihosting, ITM, logic analyzer, fault log; প্রত্যেকটি কিছু না কিছু বদলায়, বিশেষ করে সময়।
- ISR-এ printf নয়: একটি অক্ষর = 10 ÷ baud; 1 ms-এর ISR-এ একটি লাইনই tick হারাতে পারে। ISR থেকে লগ যায় RAM-এর ring buffer-এ।
- Bisect: একটি নির্ভরযোগ্য পরীক্ষা থাকলে ⌈log2 n⌉টি build-এ bug-এর ধাপ; একটি LED-ই ফল জানাতে যথেষ্ট।
- Probe আর GDB: JTAG/SWD দিয়ে CPU থামানো; flash-এ breakpoint FPB-এর সীমিত comparator-এ, watchpoint DWT-তে; থামানো CPU বাইরের পৃথিবী থামায় না।
- HardFault থেকে লাইন: stacked PC → map file → disassembly → DWARF; LR থেকে Thumb বিট সরিয়ে ডাকার জায়গা। মাঠের জন্য
.noinit-এ fault log আর assert.
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ৩০ · Cortex-M-এর exception আর NVICআগের ভিত্তিStacked frame, EXC_RETURN আর HardFault-এর ভেতরের কাজ।
- পর্ব ৩১ · Memory map আর linker scriptআগের ভিত্তিMap file পড়া আর .noinit section: fault log-এর ঠিকানা।
- C প্রোগ্রামিং পর্ব ৩১ · Debuggingপাশের ট্র্যাকDesktop-এ gdb, assert, backtrace আর sanitizer: একই ধারণার hosted রূপ।
- Software Testing পর্ব ১৮ · Bug report আর defect lifecycleপাশের ট্র্যাকখুঁজে পাওয়া bug কীভাবে লিখে জানাবেন, যাতে অন্যরা আবার ঘটাতে পারেন।