এই পর্বে যা শিখবেন
- যেকোনো exception বা IRQ-এর নম্বর থেকে vector-এর ঠিকানা আর priority register-এর ঠিকানা বের করা
- Priority byte, implemented বিট আর PRIGROUP দিয়ে preemption আর subpriority আলাদা করা
- Exception-এ ঢোকার সময় stack-এর আট word আর EXC_RETURN-এর মান ধাপে ধাপে বলা
- Nesting, সমান priority-র অপেক্ষা আর tail-chaining কখন হয়, আসল run থেকে প্রমাণসহ ব্যাখ্যা করা
- HardFault-এর stacked frame পড়ে দোষী নির্দেশ আর তখনকার অবস্থা খুঁজে বের করা
১ · Exception কী, আর Cortex-M কেন আলাদা
পর্ব ১৩-এ 8085-এর interrupt দেখেছেন: পাঁচটি pin, ঠিকানা chip-এ বাঁধা, আর ISR-কে নিজেই সব register PUSH করতে হতো। পর্ব ২০-এ 8086 আনল ২৫৬টি type আর RAM-এর একটি টেবিল, আর পর্ব ২৬-এ 8259 PIC বাইরের যন্ত্রগুলোর অগ্রাধিকার সামলাল। ARM Cortex-M এই তিনটি ধারণাকে এক জায়গায় এনেছে: টেবিল, অগ্রাধিকার আর register রাখা, সবই core-এর ভেতরে, hardware-এ। সেই ভেতরের interrupt controller-এর নাম NVIC (Nested Vectored Interrupt Controller).
ARM-এর ভাষায় এই সব ঘটনাই exception: reset, NMI, fault, timer-এর tick, বাইরের যন্ত্রের অনুরোধ। বাইরের peripheral থেকে আসা exception-কে বিশেষভাবে interrupt বা IRQ বলে। প্রতিটির একটি নম্বর আছে, আর সেই নম্বরই সব হিসাবের চাবি: টেবিলের কোন ঘর, IPSR-এ কোন সংখ্যা, debugger কোন নাম দেখাবে।
উপমা — হাসপাতালের জরুরি বিভাগ: রোগী এলে প্রথমে টিকিটে একটি নম্বর বসে, আর দেয়ালের তালিকা বলে কোন নম্বরের রোগী কোন ডাক্তারের কাছে যাবেন (vector table). ডাক্তার একজন রোগী দেখার মাঝে আরও গুরুতর রোগী এলে আগের জনকে বসিয়ে রেখে নতুনজনকে দেখেন (nesting); আগের রোগীর ফাইল টেবিলে গুছিয়ে রাখা থাকে, যাতে ফিরে এসে ঠিক সেখান থেকে শুরু করা যায় (stacking). আর একজনকে বিদায় দেওয়ার মুহূর্তে বাইরে আরেকজন অপেক্ষায় থাকলে ডাক্তার চেয়ার ছেড়ে না উঠেই পরের জনকে ডাকেন (tail-chaining). এই পর্বের প্রতিটি অংশ এই চারটি কাজের একটি।
এই মডিউল থেকে hex লেখা হবে C-এর ধরনে: 0x08000000, 0xE000E100. আগের মডিউলের 2050H-ধাঁচ শুধু 8085/8086-এর জন্য। প্রতিটি register-এর মান, vector, stack-এর word আর UART-এর লাইন এসেছে কোর্সের virtual “বাজারঘর board” BG-M3 থেকে। মনে রাখুন, এটি কোনো আসল পণ্য নয়: Unicorn emulator-এ একটি আসল ARMv7-M CPU, তার চারপাশে Python-এ লেখা STM32-ধাঁচের peripheral, আর firmware আসল C, Clang 22.1.8 দিয়ে thumbv7m-এর জন্য compile করা (পর্ব ০৬)। Register-এর নাম, R0–R12, SP, LR আর xPSR-এর গঠন পর্ব ২৯-এর বিষয়; এখানে শুধু যতটুকু exception-এর জন্য লাগে।
| নম্বর | নাম | Priority | বাজারঘর board-এ |
|---|---|---|---|
| — | (ঘর 0: initial MSP, exception নয়) | — | 0x20005000 |
| 1 | Reset | −3, স্থির | আছে (Spec decision 18) |
| 2 | NMI | −2, স্থির | নেই |
| 3 | HardFault | −1, স্থির | আছে; সব fault এখানে |
| 4, 5, 6 | MemManage, BusFault, UsageFault | বদলানো যায় | নেই (HardFault-এ যায়) |
| 7–10, 13 | সংরক্ষিত | — | — |
| 11 | SVCall (svc নির্দেশ) | বদলানো যায় | নেই |
| 12 | DebugMonitor | বদলানো যায় | নেই |
| 14 | PendSV | বদলানো যায় | নেই |
| 15 | SysTick | বদলানো যায় | আছে |
| 16 + n | IRQn (chip-এর peripheral) | বদলানো যায় | IRQ0 = EXTI0 (16), IRQ1 = UART (17), মোট ৮টি ঘর |
টেবিলের কাঠামো ARM-এর ARMv7-M Architecture Reference Manual আর Cortex-M3-এর Technical Reference Manual (TRM) থেকে। কতটি IRQ থাকবে তা chip-নির্মাতা ঠিক করেন; Cortex-M3 core সর্বোচ্চ ২৪০টি বাইরের interrupt নিতে পারে। বাজারঘর board-এর মডেল কী রাখে আর কী রাখে না, তা README-এর Spec decision 19-এ লেখা: vector table, HardFault, SysTick, আটটি IRQ ঘর, NVIC-এর register, ICSR, VTOR, AIRCR আর SHP আছে; NMI, আলাদা MemManage/BusFault/UsageFault, SVC, PendSV, BASEPRI, FAULTMASK, fault status register, MPU, FPU আর PSP নেই। এই পর্বে যেখানে এগুলোর কথা আসবে, সেখানে তথ্য ARM-এর manual থেকে, run থেকে নয়।
দুটি শব্দ আগে পরিষ্কার করা যাক। Reset-এর পরে main যেখানে চলে, তার নাম thread mode. কোনো handler চললে CPU থাকে handler mode-এ, আর xPSR-এর নিচের ৯টি বিট (IPSR) বলে এখন কোন exception চলছে: thread mode-এ 0, SysTick-এ 15. Handler mode সবসময় MSP (main stack pointer) ব্যবহার করে; thread mode চাইলে দ্বিতীয় stack pointer PSP নিতে পারে, যা RTOS-এর task-এর জন্য (মডিউল ৯)। Board শুধু MSP রাখে।
ইতিহাসের পাতা থেকে: ARM ২০০৪ সালে Cortex-M3 ঘোষণা করে, আর প্রথম chip বাজারে আসে মোটামুটি ২০০৬ সাল নাগাদ। আগের ARM7TDMI-ধাঁচের microcontroller-এ interrupt controller ছিল chip-নির্মাতার নিজস্ব, আর ISR-এর শুরুতে assembly-র একটি “wrapper” লিখে register রাখতে হতো। Cortex-M3-এর নকশার একটি ঘোষিত লক্ষ্য ছিল ISR পুরোপুরি C-তে লেখা যাবে, আর interrupt-এর আচরণ সব নির্মাতার chip-এ একই রকম হবে। NVIC core-এর অংশ হওয়ায় STM32, nRF52 বা RP2040-এর M0+ core, সবখানে মূল register-গুলো একই ঠিকানায়।
২ · Vector table — নম্বর থেকে handler-এর ঠিকানা
Vector table হলো ৩২ বিটের word-এর একটি সারি। ঘর n-এ থাকে exception n-এর handler-এর ঠিকানা; ঘর 0 ব্যতিক্রম, সেখানে reset-এর সময়ের initial MSP. টেবিল কোথায় শুরু তা বলে SCB-এর VTOR register (0xE000ED08). আসল Cortex-M3-এ reset-এর পরে VTOR = 0; STM32-এর মতো chip-এ flash থাকে 0x08000000-এ, কিন্তু boot-এর সময় সেটিই 0x00000000-তেও দেখা যায় (alias), তাই টেবিল খুঁজে পাওয়া যায়। বাজারঘর board-এ README অনুযায়ী VTOR = 0x08000000 (Spec decision 18). তাই exception n-এর ঘর = 0x08000000 + 4 × n.
8086-এর সঙ্গে দুটি পার্থক্য চোখে পড়ার মতো। প্রথমত, টেবিল সাধারণত flash-এ, তাই ভুল করে একটি pointer দিয়ে vector নষ্ট করা যায় না; বদলাতে চাইলে টেবিল SRAM-এ কপি করে VTOR সরাতে হয়, যা bootloader-এর পর্বে (পর্ব ৩২) আসবে। দ্বিতীয়ত, প্রতিটি ঠিকানার bit 0 = 1, কারণ Cortex-M শুধু Thumb নির্দেশ চালায়, আর ARM-এর নিয়মে লাফের ঠিকানার bit 0 বলে Thumb-এ থাকতে হবে। Handler আসলে বসে এক কম জোড় ঠিকানায়।
Reference lab-এর startup.c-এ টেবিলটি C-এর একটি array, linker যাকে flash-এর একেবারে শুরুতে বসায়:
/* 16 system entries + 8 external IRQ slots (IRQ0 = EXTI0, IRQ1 = UART) */
__attribute__((section(".isr_vector"), used))
const vector_t g_vectors[16 + 8] = {
(vector_t)&_estack, /* 0 initial MSP */
Reset_Handler, /* 1 reset */
NMI_Handler, /* 2 */
HardFault_Handler, /* 3 */
/* 4-14: MemManage ... PendSV (0 = reserved) */
SysTick_Handler, /* 15 */
EXTI0_IRQHandler, /* 16 = IRQ0 */
UART_IRQHandler, /* 17 = IRQ1 */
};যে handler firmware লেখেনি, সেটি weak alias হয়ে Default_Handler-এ যায়, যা একটি অসীম loop. Reference firmware nvic_priority.c board-এ build করে টেবিলের word-গুলো ELF থেকে পড়া হয়েছে (আমার lab-এর একটি ছোট logging script, যা board-এর মডেল বদলায় না)। নিচের program সেই আসল word থেকে ঠিকানা আর handler বের করে:
# nvic_priority.elf-এর vector table-এর আসল word (বাজারঘর board, 0x08000000)
VTOR = 0x08000000
words = {0: 0x20005000, 1: 0x080001C5, 2: 0x080001C1, 3: 0x080001C1,
11: 0x080001C1, 14: 0x080001C1, 15: 0x08000091, 16: 0x08000061,
17: 0x080001C1}
names = {0: "initial MSP", 1: "Reset", 2: "NMI", 3: "HardFault",
11: "SVCall", 14: "PendSV", 15: "SysTick", 16: "EXTI0",
17: "UART"}
symbols = {0x080001C4: "Reset_Handler", 0x080001C0: "Default_Handler",
0x08000090: "SysTick_Handler", 0x08000060: "EXTI0_IRQHandler"}
for n, w in words.items():
addr = VTOR + 4 * n # ঘরের ঠিকানা = VTOR + 4 × n
if n == 0:
print(f"{n:2} @0x{addr:08X} 0x{w:08X} {names[n]}: stack-এর শুরু")
continue
thumb = w & 1 # bit 0 = 1 মানে Thumb
code = w & ~1 # handler-এর আসল ঠিকানা
irq = f" (IRQ{n - 16})" if n >= 16 else ""
print(f"{n:2} @0x{addr:08X} 0x{w:08X} {names[n]}{irq}: "
f"T={thumb} -> {symbols[code]}")
# priority কোথায় থাকে: IRQn -> NVIC IP[n], SysTick -> SHP[11]
for n in (0, 1):
print(f"IRQ{n}: priority byte @0x{0xE000E400 + n:08X}")
print(f"SysTick: priority byte @0x{0xE000ED18 + 11:08X}")আসল আউটপুট (ব্রাউজারের Python):
0 @0x08000000 0x20005000 initial MSP: stack-এর শুরু
1 @0x08000004 0x080001C5 Reset: T=1 -> Reset_Handler
2 @0x08000008 0x080001C1 NMI: T=1 -> Default_Handler
3 @0x0800000C 0x080001C1 HardFault: T=1 -> Default_Handler
11 @0x0800002C 0x080001C1 SVCall: T=1 -> Default_Handler
14 @0x08000038 0x080001C1 PendSV: T=1 -> Default_Handler
15 @0x0800003C 0x08000091 SysTick: T=1 -> SysTick_Handler
16 @0x08000040 0x08000061 EXTI0 (IRQ0): T=1 -> EXTI0_IRQHandler
17 @0x08000044 0x080001C1 UART (IRQ1): T=1 -> Default_Handler
IRQ0: priority byte @0xE000E400
IRQ1: priority byte @0xE000E401
SysTick: priority byte @0xE000ED23
SysTick-এর ঘর 0x08000000 + 4 × 15 = 0x0800003C, আর সেখানে 0x08000091: handler বসে 0x08000090-এ, bit 0-এর 1 শুধু Thumb-এর চিহ্ন। এই firmware UART-এর handler লেখেনি, তাই IRQ1-এর ঘরে Default_Handler; সেখানে একটি UART interrupt এলে firmware চুপচাপ অসীম loop-এ আটকে যেত, যা মাঠে খুঁজে পাওয়া কঠিন একটি ত্রুটি। শেষ তিন লাইন পরের অংশের জন্য: IRQ-এর priority থাকে NVIC-এর IP array-তে, আর SysTick-এর মতো system exception-এর priority থাকে SCB-এর SHP-তে।
ছবি ৩০.১ — Vector table থেকে handler, আর SysTick-এ ঢোকার পরের stack
ওপরে flash-এর টেবিল (ঠিকানা ওপর থেকে নিচে বাড়ে); নিচে SRAM-এর stack (ঠিকানা নিচ থেকে ওপরে বাড়ে, frame নিচের দিকে বাড়ে); সব মান nvic_priority-র আসল run থেকে
৩ · Priority আর NVIC-এর register
Cortex-M-এর priority-র নিয়মটি প্রথমবার উল্টো লাগে: সংখ্যা যত কম, তত বেশি জরুরি। Reset (−3), NMI (−2) আর HardFault (−1) ঋণাত্মক, তাই কোনো program-এর বসানো priority তাদের ছাড়াতে পারে না। বাকি প্রতিটির জন্য একটি ৮ বিটের priority byte, 0 থেকে 255. তবে chip-নির্মাতা সব বিট রাখেন না, শুধু উঁচু দিকের কয়েকটি; Cortex-M3-এ ৩ থেকে ৮টি বিট রাখা যায়। ST-এর STM32F1 পরিবার রাখে ৪টি, অর্থাৎ ১৬টি স্তর: 0x00, 0x10, 0x20 … 0xF0. না-রাখা নিচের বিটগুলো পড়লে 0 আসে। বাজারঘর board-ও ৪টি বিট রাখে (Spec decision 19), আর CMSIS-ধাঁচের NVIC_SetPriority(n, p) তাই p-কে ৪ ঘর বাঁয়ে সরিয়ে লেখে।
NVIC-এর register-গুলো memory-mapped, প্রতিটি ARM-এর নির্দিষ্ট ঠিকানায়, সব Cortex-M3/M4-এ একই। প্রতিটি বিট একটি IRQ: বিট n = IRQn.
| Register | ঠিকানা | কাজ |
|---|---|---|
ISER | 0xE000E100 | 1 লিখলে IRQ চালু (set-enable); পড়লে কোনগুলো চালু |
ICER | 0xE000E180 | 1 লিখলে IRQ বন্ধ (clear-enable) |
ISPR | 0xE000E200 | 1 লিখলে software দিয়ে pend করা; পড়লে কোনগুলো pending |
ICPR | 0xE000E280 | 1 লিখলে pending মোছা |
IABR | 0xE000E300 | শুধু পড়া: কোন IRQ-এর handler এখন active (চলছে বা preempt হয়ে অপেক্ষায়) |
IP[n] | 0xE000E400 + n | IRQn-এর priority byte |
ICSR | 0xE000ED04 | VECTACTIVE (বিট ৮–০), PENDSTSET/PENDSTCLR (SysTick pend) |
AIRCR | 0xE000ED0C | PRIGROUP (বিট ১০–৮), SYSRESETREQ; লিখতে বিট ৩১–১৬-এ 0x05FA লাগে |
SHP[k] | 0xE000ED18 + k | system exception-এর priority; SysTick = SHP[11] = 0xE000ED23 |
একটি exception নেওয়া হবে কি না, তা তিনটি শর্তে: enable করা আছে, pending, আর তার priority এখন চলা কাজের priority-র চেয়ে কম সংখ্যার। একসাথে কয়েকটি pending থাকলে সবচেয়ে কম priority সংখ্যারটি আগে; সমান হলে কম exception নম্বরেরটি। আর PRIMASK = 1 থাকলে (C-তে __disable_irq(), Thumb-এ cpsid i) NMI আর HardFault ছাড়া সবাই pending অবস্থায় অপেক্ষা করে।
এবার board-এ সত্যিই দেখা যাক। আমার lab-এ লেখা nvic_tail.c দুটি IRQ (EXTI0 আর UART) চালু করে, IP[0]-এ 0x25 লিখে পড়ে দেখে, তারপর PRIMASK বন্ধ রেখে দুটিকে একসাথে pend করে আর PRIMASK খোলে। প্রতিটি handler ছাপে VECTACTIVE, IABR আর ISPR. মূল অংশ:
void EXTI0_IRQHandler(void) { show(" EXTI0"); } /* exception 16 */
void UART_IRQHandler(void) { show(" UART "); } /* exception 17 */
static void both(uint32_t p_exti, uint32_t p_uart)
{
NVIC_SetPriority(EXTI0_IRQn, p_exti);
NVIC_SetPriority(UART_IRQn, p_uart);
__disable_irq(); /* PRIMASK = 1 */
NVIC->ISPR[0] = (1u << EXTI0_IRQn) | (1u << UART_IRQn);
uart_puts(" pended, ISPR=");
uart_put_u32(NVIC->ISPR[0]);
uart_puts("\r\n");
__enable_irq(); /* PRIMASK = 0 */
}
/* main: ISER = 3; IP[0] = 0x25; both(2, 1); both(2, 2); */সত্যিকারের run (বাজারঘর board BG-M3, Clang 22.1.8 / ziglang 0.17.1, Unicorn 2.1.4):
$ python -B board.py run build/nvic_tail.elf
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0454 ms] UART: ISER=3 IP[0] after writing 0x25 = 32
[ 0.0716 ms] UART: case A: EXTI0 prio 2, UART prio 1
[ 0.0938 ms] UART: pended, ISPR=3
[ 0.1432 ms] UART: UART VECTACTIVE=17 IABR=2 ISPR=1
[ 0.1926 ms] UART: EXTI0 VECTACTIVE=16 IABR=1 ISPR=0
[ 0.2097 ms] UART: case B: both prio 2
[ 0.2319 ms] UART: pended, ISPR=3
[ 0.2814 ms] UART: EXTI0 VECTACTIVE=16 IABR=1 ISPR=2
[ 0.3307 ms] UART: UART VECTACTIVE=17 IABR=2 ISPR=0
[ 0.3317 ms] exit(0) after 2654 cycles
লাইন ধরে পড়ুন। IP[0] after writing 0x25 = 32: 0x25 লেখা হয়েছিল, পড়া গেল 32 = 0x20; নিচের চারটি বিট chip-এ নেই। Case A-তে UART-এর priority 1, EXTI0-র 2, তাই PRIMASK খোলামাত্র আগে UART: VECTACTIVE = 17, IABR = 2 (বিট ১, IRQ1 active), ISPR = 1 (EXTI0 তখনো অপেক্ষায়)। Case B-তে দুটিরই priority 2, তাই নিয়ম অনুযায়ী কম exception নম্বর 16-এর EXTI0 আগে। ICSR-এর VECTACTIVE exception নম্বর দেখায় (16, 17), আর IABR দেখায় IRQ নম্বরের বিট (বিট 0, বিট 1); দুটির মধ্যে ১৬-এর এই পার্থক্য পরীক্ষায় প্রায়ই ভুল হয়।
Preemption আর subpriority — PRIGROUP
ARMv7-M (M3, M4, M7) priority byte-কে দুই ভাগ করতে দেয়, AIRCR-এর PRIGROUP ঘর দিয়ে। এর নাম priority grouping. PRIGROUP = g হলে বিট [7:g+1] হলো group priority, আর বিট [g:0] subpriority. শুধু group priority ঠিক করে কে কাকে থামাতে পারবে (preemption); subpriority শুধু ঠিক করে, দুটি একসাথে pending থাকলে কে আগে যাবে। Reset-এ PRIGROUP = 0, অর্থাৎ বিট [7:1] group; ৪ বিটের chip-এ তার মানে চারটি বিটই preemption-এর। বাজারঘর board PRIGROUP পুরো উপেক্ষা করে, সব বিট preemption বিট ধরে (Spec decision 19); তাই নিচের হিসাব ARM-এর নিয়ম থেকে, board-এর run থেকে নয়।
# ARMv7-M priority grouping: AIRCR.PRIGROUP = g হলে priority byte-এর
# bit [7:g+1] = group (preemption) priority, bit [g:0] = subpriority
IMPL = 4 # chip-এ আসলে কয়টি বিট আছে (উঁচু দিকের)
def stored(byte): # না-থাকা নিচের বিট পড়লে 0
return byte & (0xFF << (8 - IMPL)) & 0xFF
def split(byte, g):
b = stored(byte)
return b >> (g + 1), (b & ((1 << (g + 1)) - 1)) >> (8 - IMPL)
def preempts(new, running, g): # শুধু group priority কম হলে
return split(new, g)[0] < split(running, g)[0]
print("0x25 লিখলে থাকে", hex(stored(0x25)))
for g in (0, 3, 4, 5, 6, 7):
pre = max(0, min(IMPL, 7 - g)) # bit [7:g+1]-এর মধ্যে আসল বিট কয়টি
print(f"PRIGROUP={g}: preemption বিট {pre}, sub বিট {IMPL - pre}")
UART, EXTI0 = 0x50, 0x60 # দুই interrupt-এর priority byte
for g in (3, 5):
print(f"PRIGROUP={g}: UART {split(UART, g)}, EXTI0 {split(EXTI0, g)}")
print(" EXTI0 চলার সময় UART এলে ঢুকবে?", preempts(UART, EXTI0, g))আসল আউটপুট (ব্রাউজারের Python):
0x25 লিখলে থাকে 0x20
PRIGROUP=0: preemption বিট 4, sub বিট 0
PRIGROUP=3: preemption বিট 4, sub বিট 0
PRIGROUP=4: preemption বিট 3, sub বিট 1
PRIGROUP=5: preemption বিট 2, sub বিট 2
PRIGROUP=6: preemption বিট 1, sub বিট 3
PRIGROUP=7: preemption বিট 0, sub বিট 4
PRIGROUP=3: UART (5, 0), EXTI0 (6, 0)
EXTI0 চলার সময় UART এলে ঢুকবে? True
PRIGROUP=5: UART (1, 1), EXTI0 (1, 2)
EXTI0 চলার সময় UART এলে ঢুকবে? False
প্রথম লাইন board-এর আসল run-এর 32-এর সঙ্গে মেলে। PRIGROUP 0 থেকে 3 পর্যন্ত ৪ বিটের chip-এ কোনো পার্থক্য নেই, কারণ subpriority-র ভাগে পড়া বিটগুলো chip-এ নেই-ই। PRIGROUP = 5-এ একই দুটি byte (0x50, 0x60) একই group 1-এ পড়ে, তাই UART আর EXTI0-কে থামাতে পারে না; দুজন একসাথে pending হলে শুধু subpriority 1 বনাম 2 বলে UART আগে যাবে। শিক্ষা: একই priority byte ভিন্ন PRIGROUP-এ ভিন্ন আচরণ দেয়, তাই PRIGROUP পুরো firmware-এ একবার, শুরুতেই, ঠিক করতে হয়।
৪ · ঢোকার সময় stacking — আট word-এর frame আর EXC_RETURN
8085 বা 8086-এর ISR-কে নিজে PUSH করে register রাখতে হতো, আর শেষে IRET বা RET. Cortex-M-এ exception নেওয়ার সময় hardware নিজেই আটটি ৩২ বিটের word চলতি stack-এ রাখে। এটিই exception-এর stack frame, ARM-এর ভাষায় basic frame. ঠিকানা অনুযায়ী, frame-এর শুরু (নতুন SP) থেকে: R0, R1, R2, R3, R12, LR, PC (ফেরার ঠিকানা), xPSR. প্রতিটি ৪ byte, মোট 32 byte. Frame-এর শুরু 8-byte-এ সাজানো রাখা হয়: SP যদি 8-এর গুণিতক না হয়, আগে আরও ৪ byte ফাঁকা রাখা হয়, আর সেই কথা stacked xPSR-এর বিট ৯-এ লেখা থাকে (CCR-এর STKALIGN বিট এটি নিয়ন্ত্রণ করে; board-এ CCR পড়লে 512 = 0x200, অর্থাৎ STKALIGN = 1).
কেন ঠিক এই আটটি? ARM-এর C calling convention (AAPCS) বলে R0–R3, R12 আর LR হলো caller-saved: যেকোনো C function এগুলো বিনা নোটিশে বদলাতে পারে। R4–R11 callee-saved: কোনো C function এগুলো বদলাতে চাইলে নিজেই রেখে ফিরিয়ে দেয়। তাই hardware যদি caller-saved ছয়টি আর PC, xPSR রাখে, তাহলে handler একটি সাধারণ C function হলেও মূল program-এর কিছুই নষ্ট হয় না। ARM-এর calling convention-এর বিস্তারিত Programming Languages & Compilers পর্ব ৭১-এ।
Frame রাখার পরে CPU আরও তিনটি কাজ করে: IPSR-এ exception নম্বর বসায় (handler mode), vector table থেকে handler-এর ঠিকানা PC-তে আনে, আর LR-এ একটি বিশেষ মান বসায়, যার নাম EXC_RETURN. Handler শেষে এই মান PC-তে গেলে (bx lr, PC-সহ pop/ldm, বা PC-তে ldr) CPU বোঝে এটি সাধারণ লাফ নয়: frame তুলে register ফেরত দিতে হবে। ARMv7-M-এর FPU-ছাড়া মানগুলো:
| EXC_RETURN | কোথায় ফেরে | Frame কোন stack-এ | Board-এ |
|---|---|---|---|
0xFFFFFFF1 | Handler mode (nested থেকে ফেরা) | MSP | আছে |
0xFFFFFFF9 | Thread mode | MSP | আছে |
0xFFFFFFFD | Thread mode | PSP | নেই (PSP নেই) |
বিট ৩ = 1 মানে thread mode-এ ফেরা, বিট ২ = 1 মানে PSP. Cortex-M4F-এর মতো FPU-ওয়ালা chip-এ বিট ৪ = 0 হলে বড় (FPU register-সহ) frame বোঝায় (যেমন 0xFFFFFFE9); সেটি এই পর্বের বাইরে। Board-এর মডেল শুধু প্রথম দুটি মান মানে, আর ভুল নেস্টিং স্তরে ভুল মান দিলে run থামিয়ে বলে দেয় (Spec decision 19).
Handler-গুলো যে সত্যিই সাধারণ C function, তা compiler-এর output-এ দেখা যায়। nvic_priority.c-এর EXTI0_IRQHandler, আমার lab-এ clang -S --target=thumbv7m-none-eabi -mcpu=cortex-m3 -O2 দিয়ে (Clang 22.1.8; মন্তব্য আর .cfi লাইন বাদ):
EXTI0_IRQHandler:
push {r7, lr}
movw r0, :lower16:.L.str
movt r0, :upper16:.L.str
bl uart_puts
movw r0, #60676 @ 0xED04
movt r0, #57344 @ 0xE000 -> ICSR
ldr r0, [r0]
bfc r0, #9, #23 @ ICSR & 0x1FF = VECTACTIVE
bl uart_put_u32
movw r0, :lower16:.L.str.1
movt r0, :upper16:.L.str.1
pop.w {r7, lr}
b uart_puts @ tail call
এখানে কোনো বিশেষ “interrupt” নির্দেশ নেই, কোনো __attribute__((interrupt))-ও নেই। শেষ লাইনটি আরও মজার: compiler tail call করেছে, অর্থাৎ pop.w {r7, lr} দিয়ে LR-এ আবার EXC_RETURN ফিরিয়ে এনে সরাসরি uart_puts-এ লাফ দিয়েছে। uart_puts-এর শেষের সাধারণ ফেরাই তখন exception থেকে ফেরা হয়ে যায়। দুটি নির্দেশ (movw/movt) মিলে ICSR-এর ঠিকানা 0xE000ED04 তৈরি করেছে, আর bfc r0, #9, #23 বিট ৯ থেকে ৩১ মুছে VECTACTIVE রেখেছে।
Board-এর মডেল ঢোকা আর ফেরার প্রতিটি মান কীভাবে বসায়, তা দেখতে আমার lab-এ একটি ছোট logging script (xlog.py) board-এর নিজের দুটি function-কে ঘিরে ছাপে: ঢোকার আগে-পরে SP, নতুন LR, আর frame-এর আটটি word. মডেলের কোনো নিয়ম বদলায় না। Reference firmware nvic_priority.c-এর প্রথম SysTick-এ (UART-এর লাইনগুলো বাদ):
$ python -B xlog.py build/nvic_priority.elf
[ 1.0065 ms] ENTER 15 (SysTick) prio=3 SP 0x20005000 -> 0x20004FE0 LR=0xFFFFFFF9 active=[15]
[ 1.0065 ms] frame @0x20004FE0: R0=00000001 R1=20000004 R2=00000000 R3=C0000000
[ 1.0065 ms] R12=00000000 LR=0800014F PC=080001B6 xPSR=81000000 handler=0x08000090 SysTick_Handler+0x0
...
[ 1.0975 ms] RETURN from 15 with EXC_RETURN=0xFFFFFFF9 SP 0x20004FE0 -> 0x20005000 PC=0x080001B6 wait_step+0xE pend=[]
| mode · IPSR | |
| SP | |
| PC | |
| LR | |
| frame |
- Thread mode-এ ঘুম।
mainwait_step-এরWFI-তে ঘুমিয়ে (Spec decision 21). SP = 0x20005000, যা vector table-এর ঘর 0-এর initial MSP; কোনো exception চলছে না, IPSR = 0. - SysTick-এর tick. 1.0065 ms-এ SysTick শূন্যে পৌঁছায়, pending হয়। Priority 3, আর thread mode-এর চলতি স্তর “সবচেয়ে নিচু”, তাই নেওয়া হবে। SP 8-এর গুণিতক, তাই ফাঁকা word লাগবে না (xPSR-এর বিট ৯ = 0).
- Frame-এর নিচের অর্ধেক। SP 32 কমে 0x20004FE0. সেখান থেকে R0 = 1, R1 = 0x20000004, R2 = 0, R3 = 0xC0000000: thread-এর সেই মুহূর্তের register, যা handler-এর C কোড নষ্ট করতে পারে।
- Frame-এর ওপরের অর্ধেক। R12 = 0, LR = 0x0800014F (
main-এ ফেরার ঠিকানা), PC = 0x080001B6 (ঘুম ভাঙার পরের নির্দেশ), xPSR = 0x81000000: বিট ৩১ N = 1, বিট ২৪ T = 1, IPSR = 0. - Handler mode. LR = 0xFFFFFFF9 (thread-এ ফেরা, MSP), IPSR = 15, PC = 0x0800003C-এর ঘর থেকে 0x08000090. Board-এ এই ঢোকা 0 cycle নেয়; আসল chip-এ কয়েক cycle লাগে (Spec decision 17, অংশ ৬)।
- Handler-এর নিজের কাজ। C কোড
push {r7, lr}দিয়ে শুরু, SP = 0x20004FD8. Stack-এ রাখা LR আসলে EXC_RETURN. মাঝখানে একটি nested interrupt-ও আসে, যা পরের stepper-এ। - ফেরা। শেষে LR-এ 0xFFFFFFF9 নিয়ে
bx lr. CPU আট word তুলে R0–R3, R12, LR, PC, xPSR ফেরত দেয়: SP = 0x20005000, PC = 0x080001B6, IPSR = 0. Board-এর log-এ 1.0975 ms-এRETURN from 15.
এই frame-এর সবচেয়ে কাজের word দুটি হলো stacked PC আর stacked xPSR. PC বলে interrupt-এর মুহূর্তে CPU কোথায় ছিল, আর xPSR-এর IPSR বলে তখন কোন exception চলছিল (thread হলে 0). অংশ ৭-এ HardFault খুঁজতে ঠিক এ দুটিই কাজে লাগবে।
৫ · Nesting — চলমান handler-এর ভেতরে বেশি জরুরি interrupt
NVIC-এর নামের “Nested” শব্দটি এই অংশের বিষয়। একটি handler চলার সময় যদি তার চেয়ে কম priority সংখ্যার আরেকটি exception pending হয়, CPU চলমান handler-কেই থামিয়ে দেয়, ঠিক যেভাবে thread-কে থামায়: আরেকটি আট word-এর frame, এবার handler-এর stack-এর ওপরে। এই nested interrupt-এর জন্য 8086-এ ISR-কে নিজে STI দিতে হতো; Cortex-M-এ শুধু priority-র তুলনা।
Reference firmware nvic_priority.c তিনটি ঘটনা দেখায়। SysTick-এর priority 3, EXTI0-র 1. Case 1: SysTick handler নিজে ISPR-এ লিখে EXTI0 pend করে। Case 2: PRIMASK = 1 রেখে EXTI0 pend, তারপর __enable_irq(). Case 3: EXTI0-র priority 3 করে আবার case 1. সত্যিকারের run, README-এর প্রত্যাশিত output-এর সঙ্গে হুবহু মেলে:
$ python -B board.py run build/nvic_priority.elf
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0449 ms] UART: case 1: EXTI0 (prio 1) preempts SysTick (prio 3)
[ 1.0391 ms] UART: SysTick handler: enter, pending EXTI0
[ 1.0762 ms] UART: EXTI0 handler, ICSR.VECTACTIVE=16
[ 1.0962 ms] UART: SysTick handler: exit
[ 1.1311 ms] UART: case 2: PRIMASK holds a pending interrupt
[ 1.1614 ms] UART: pended with PRIMASK=1, nothing yet
[ 1.1983 ms] UART: EXTI0 handler, ICSR.VECTACTIVE=16
[ 1.2174 ms] UART: after __enable_irq()
[ 1.2569 ms] UART: case 3: equal priority (3 and 3) does not preempt
[ 2.0391 ms] UART: SysTick handler: enter, pending EXTI0
[ 2.0596 ms] UART: SysTick handler: exit
[ 2.0971 ms] UART: EXTI0 handler, ICSR.VECTACTIVE=16
[ 2.0984 ms] exit(0) after 16787 cycles
Case 1-এ EXTI0-র লাইন SysTick-এর “enter” আর “exit”-এর মাঝখানে: nesting. Case 2-এ PRIMASK-এর সময় কিছু হয়নি, __enable_irq()-এর পরেই handler, আর “after __enable_irq()” লাইন তার পরে। Case 3-এ সমান priority, তাই EXTI0 অপেক্ষা করেছে আর SysTick-এর “exit”-এর পরে চলেছে। একটি সূক্ষ্মতা: board pending exception পরীক্ষা করে নির্দিষ্ট “সীমায়”, যেমন যেকোনো peripheral বা NVIC register-এ লেখার পরে আর cpsie-র পরে (Spec decision 20). ISPR-এ লেখা আর cpsie দুটিই সেই সীমা, তাই এখানে কোনো দেরি নেই; কিন্তু register পড়ার কারণে বা MSR PRIMASK দিয়ে খোলা interrupt board-এ ২০ ০০০ cycle পর্যন্ত দেরিতে নেওয়া হতে পারে। আসল chip-এ এমন সীমা নেই, প্রতিটি নির্দেশের পরেই পরীক্ষা হয়।
Logging script দিয়ে case 1-এর ভেতরটা দেখা যাক (সময়ের কলাম ছোট করা, মান বদলানো হয়নি):
[ 1.0400 ms] ENTER 16 (IRQ0 EXTI0) prio=1 SP 0x20004FD8 -> 0x20004FB8 LR=0xFFFFFFF1 active=[15, 16]
[ 1.0400 ms] frame @0x20004FB8: R0=E000E200 R1=00000001 R2=40004400 R3=C0000000
[ 1.0400 ms] R12=00000000 LR=080000B3 PC=080000BE xPSR=0100000F handler=0x08000060 EXTI0_IRQHandler+0x0
[ 1.0766 ms] RETURN from 16 with EXC_RETURN=0xFFFFFFF1 SP 0x20004FB8 -> 0x20004FD8 PC=0x080000BE SysTick_Handler+0x2E pend=[]
[ 1.0975 ms] RETURN from 15 with EXC_RETURN=0xFFFFFFF9 SP 0x20004FE0 -> 0x20005000 PC=0x080001B6 wait_step+0xE pend=[]
| active | |
| চলতি স্তর | |
| SP | |
| LR | |
| দেখার মতো |
- SysTick চলছে। অংশ ৪-এর frame #1 আছে 0x20004FE0-এ, handler নিজে আরও ৮ byte রেখেছে, তাই SP = 0x20004FD8. এখন চলতি priority স্তর 3.
- EXTI0 pend করা। Handler
NVIC->ISPR[0] = 1লেখে (str r1, [r0], r0 = 0xE000E200). EXTI0 চালু, priority 1 < 3, তাই এখনই preemption. - দ্বিতীয় frame. SysTick-এর register-গুলো রাখা হয় 0x20004FB8-এ: R0 = 0xE000E200 (যে ঠিকানায় এইমাত্র লেখা হলো), PC = 0x080000BE (str-এর পরের নির্দেশ), xPSR = 0x0100000F: T = 1 আর IPSR = 15, অর্থাৎ থামানো কাজটি নিজেই SysTick handler ছিল।
- EXTI0 চলছে। LR = 0xFFFFFFF1, কারণ ফিরতে হবে handler mode-এ, thread-এ নয়। Handler ছাপে VECTACTIVE = 16. Active এখন দুজন: SysTick (থামানো) আর EXTI0 (চলছে)।
- EXTI0 থেকে ফেরা। 0xFFFFFFF1 PC-তে যেতেই frame #2 ওঠে: SP = 0x20004FD8, PC = 0x080000BE. SysTick ঠিক str-এর পরের নির্দেশ থেকে চলে, আর ছাপে “exit”.
- SysTick থেকে ফেরা। এবার 0xFFFFFFF9: frame #1 ওঠে, SP = 0x20005000, PC = 0x080001B6, thread mode. মোট stack সবচেয়ে গভীরে গিয়েছিল 0x20004FB8 পর্যন্ত, 72 byte.
শেষ ধাপের 72 byte হিসাবটি নকশার কাজে লাগে: প্রতিটি nesting স্তর অন্তত 32 byte frame আর handler-এর নিজের stack চায়। Priority-র যত স্তর একে অপরকে থামাতে পারে, worst case-এ stack ততগুলো frame-এর জন্য জায়গা রাখতে হয়। Stack-এর আকারের হিসাব পর্ব ৩৯ (এমবেডেড memory)-এর বিষয়।
৬ · Tail-chaining আর late arrival
অংশ ৩-এর case A-তে UART শেষ হওয়ার মুহূর্তে EXTI0 তখনো pending ছিল। সাধারণ নিয়মে CPU আগে frame তুলে thread-এ ফিরত, তারপর সঙ্গে সঙ্গে আবার একই আট word রেখে EXTI0-তে ঢুকত: আট word তোলা আর আট word রাখা, দুটিই অর্থহীন, কারণ stack-এ ঠিক একই মান ফিরে যেত। Cortex-M এই অপচয় বাদ দেয়: tail-chaining-এ frame stack-এই থেকে যায়, CPU শুধু নতুন vector পড়ে পরের handler-এ চলে যায়। ARM-এর Cortex-M3 TRM-এর বর্ণনায়, এমন অবস্থায় stack-এর pop আর push বাদ পড়ে, আর পরের ISR আগেরটি শেষ হওয়ার ছয় cycle পরে শুরু হয়।
আরেকটি কৌশল late arrival: একটি কম জরুরি exception-এর frame রাখার কাজ চলার সময় বেশি জরুরি একটি এলে CPU frame রাখা থামায় না, কারণ দুজনের জন্য রাখা register একই; শুধু vector পড়ার সময় নতুনটির ঠিকানা নেয়। TRM অনুযায়ী এটি সম্ভব যতক্ষণ না প্রথম handler-এর প্রথম নির্দেশ execute স্তরে পৌঁছায়। প্রচলিত বর্ণনায় Cortex-M3-এ zero wait-state মেমরি থেকে exception-এ ঢুকতে মোটামুটি ১২ cycle লাগে; flash-এর wait state বা bus-এর ব্যস্ততা থাকলে বেশি। এই সংখ্যাগুলো ARM-এর প্রকাশিত বর্ণনা থেকে, এই কোর্সে মাপা নয়।
Board-এর সীমা, স্পষ্ট করে: Interrupt latency এই board-এ মাপা যায় না। বাজারঘর board-এ প্রতিটি নির্দেশ ১ cycle আর exception-এ ঢোকা ও ফেরা ০ cycle (Spec decision 17). Tail-chaining-এ board ফল ঠিক দেয় (কোন handler কোন ক্রমে, কোন SP আর LR), কিন্তু ভেতরে আসলে frame তুলে আবার রাখে (Spec decision 19). Late arrival board-এ ঘটতেই পারে না, কারণ ঢোকা মুহূর্তেই শেষ। তাই latency, ছয় বা বারো cycle, সবই datasheet আর TRM-এর বিষয়; আসল chip-এ মাপতে হলে GPIO pin টগল করে logic analyzer, বা Cortex-M3-এর DWT cycle counter লাগে।
Logging script tail-chaining চিনতে পারে: আগের handler-এর RETURN আর পরের handler-এর ENTER একই cycle-এ, মাঝে thread-এর একটিও নির্দেশ নেই। nvic_tail.c-এর case A:
$ python -B xlog.py build/nvic_tail.elf (case A-র লাইন, সময় ছোট করা)
[0.0943] ENTER 17 (IRQ1 UART) prio=1 SP 0x20004FF8 -> 0x20004FD8 LR=0xFFFFFFF9 active=[17]
[0.0943] R12=CCCCCCCD LR=080001E9 PC=080001EA xPSR=81000000 handler=0x080000CC UART_IRQHandler+0x0
[0.1436] RETURN from 17 with EXC_RETURN=0xFFFFFFF9 SP 0x20004FD8 -> 0x20004FF8 PC=0x080001EA both+0x42 pend=[16]
[0.1436] ENTER 16 (IRQ0 EXTI0) prio=2 TAIL-CHAIN SP 0x20004FF8 -> 0x20004FD8 LR=0xFFFFFFF9 active=[16]
[0.1436] R12=CCCCCCCD LR=080001E9 PC=080001EA xPSR=80000000 handler=0x08000060 EXTI0_IRQHandler+0x0
[0.1930] RETURN from 16 with EXC_RETURN=0xFFFFFFF9 SP 0x20004FD8 -> 0x20004FF8 PC=0x080001EA both+0x42 pend=[]
একটি অদ্ভুত জিনিস চোখে পড়ে: দ্বিতীয় frame-এর xPSR 0x80000000, প্রথমটির 0x81000000; বিট ২৪ (T) হারিয়েছে। আসল Cortex-M-এ এটি ঘটতে পারে না, কারণ tail-chaining-এ frame আবার লেখাই হয় না, আর থাকে আগের 0x81000000. এটি board-এর মডেলের একটি ছাপ: ফেরার সময় board Unicorn-এর PC-তে bit 0 = 0-সহ ঠিকানা লেখে, যা Unicorn-এ T বিট মুছে দেয়; মাঝে কোনো নির্দেশ না চললে পরের frame সেই মানটি রেখে দেয়। আমার lab-এ দুই লাইনের একটি পরীক্ষায় তা নিশ্চিত হয়েছে (xPSR 0x81000000 লিখে PC লিখলে পড়া যায় 0x80000000). Handler-এর ফলে এর কোনো প্রভাব নেই, কারণ ফেরার পরে board আবার Thumb-এ চালায়; তবে frame পড়ে বিচার করার সময় সাবধান।
| PRIMASK | |
| ISPR · IABR | |
| চলছে | |
| SP | |
| UART লাইন |
- দুজনই অপেক্ষায়। PRIMASK = 1 রেখে ISPR-এ 3 লেখা: বিট 0 (EXTI0) আর বিট 1 (UART) দুটিই pending, কেউ ঢুকতে পারছে না। Handler এখনো কেউ নয়, IABR = 0.
cpsie i-এর পরেই সিদ্ধান্ত। দুই প্রার্থী: (priority 1, exception 17) আর (priority 2, exception 16). কম সংখ্যা জেতে, তাই UART. Frame রাখা হয় 0x20004FD8-এ, LR = 0xFFFFFFF9; ISPR থেকে বিট 1 মুছে IABR-এ বিট 1.- UART handler. ছাপে VECTACTIVE = 17, IABR = 2, ISPR = 1. EXTI0 এখনো pending, কিন্তু priority 2 > 1, তাই UART-কে থামাতে পারে না।
- Tail-chain. UART
bx lrদিতেই NVIC দেখে EXTI0 pending আর thread-এর চেয়ে জরুরি। আসল Cortex-M3 frame না তুলেই EXTI0-র vector পড়ে (TRM: প্রায় ছয় cycle). Board তুলে আবার রাখে, ফল একই: SP = 0x20004FD8, LR = 0xFFFFFFF9. - EXTI0 handler. ছাপে VECTACTIVE = 16, IABR = 1, ISPR = 0: আর কেউ বাকি নেই।
- Thread-এ ফেরা। এবার frame সত্যিই ওঠে: SP = 0x20004FF8, PC = 0x080001EA (
both-এরcpsie-র পরের নির্দেশ)। Case B-তে দুজনের priority 2, তাই কম exception নম্বরের EXTI0 আগে, তারপর UART-এ tail-chain.
এই পর্যন্ত যত নিয়ম দেখলেন, সবগুলো একটি ছোট মডেলে লেখা যায়। নিচের program কোনো timing রাখে না, শুধু সিদ্ধান্ত: কে ঢুকবে, nested না tail-chain. চারটি ঘটনা board-এর চারটি আসল run-এর (nvic_priority-র case 1 ও 3, nvic_tail-এর case A ও B):
# NVIC-এর সিদ্ধান্তের ছোট মডেল: কম সংখ্যা = বেশি জরুরি, সমান হলে exception নম্বর
NAME = {15: "SysTick", 16: "EXTI0", 17: "UART"}
def scenario(title, prio, body, pend_first):
print("==", title)
active, pending, log = [], set(), []
def level(): # এখন যে priority চলছে (thread = 256)
return min([prio[e] for e in active], default=256)
def take(after_return=False):
while pending:
p, e = min((prio[x], x) for x in pending)
if p >= level(): # সমান বা কম জরুরি: অপেক্ষা
return
pending.discard(e)
how = "tail-chain" if after_return and not active else (
"nested" if active else "from thread")
log.append(f"{' ' * len(active)}enter {NAME[e]} ({how})")
active.append(e)
for x in body.get(e, []): # handler নিজে কাউকে pend করে
pending.add(x)
log.append(f"{' ' * len(active)}{NAME[e]} pends {NAME[x]}")
take()
active.pop()
log.append(f"{' ' * len(active)}exit {NAME[e]}")
after_return = True
pending.update(pend_first)
take()
print("\n".join(log))
scenario("SysTick 3 pends EXTI0 1", {15: 3, 16: 1}, {15: [16]}, {15})
scenario("SysTick 3 pends EXTI0 3", {15: 3, 16: 3}, {15: [16]}, {15})
scenario("cpsie: EXTI0 2, UART 1", {16: 2, 17: 1}, {}, {16, 17})
scenario("cpsie: EXTI0 2, UART 2", {16: 2, 17: 2}, {}, {16, 17})আসল আউটপুট (ব্রাউজারের Python):
== SysTick 3 pends EXTI0 1
enter SysTick (from thread)
SysTick pends EXTI0
enter EXTI0 (nested)
exit EXTI0
exit SysTick
== SysTick 3 pends EXTI0 3
enter SysTick (from thread)
SysTick pends EXTI0
exit SysTick
enter EXTI0 (tail-chain)
exit EXTI0
== cpsie: EXTI0 2, UART 1
enter UART (from thread)
exit UART
enter EXTI0 (tail-chain)
exit EXTI0
== cpsie: EXTI0 2, UART 2
enter EXTI0 (from thread)
exit EXTI0
enter UART (tail-chain)
exit UART
চারটি ক্রমই board-এর UART লাইনের ক্রমের সঙ্গে মেলে, আর “tail-chain” চিহ্নগুলো logging script-এর TAIL-CHAIN লাইনের সঙ্গে। দ্বিতীয় ঘটনাটি খেয়াল করুন: nvic_priority-র case 3-এ যা হয়েছিল, সমান priority-র EXTI0 অপেক্ষা করে আর SysTick শেষ হতেই tail-chain-এ ঢোকে। মডেলটি ইচ্ছা করে সরল: PRIGROUP, subpriority, NMI আর PRIMASK নেই; একটি ধরে নেওয়া আছে যে handler-এর কাজ pend করার সঙ্গে সঙ্গেই সিদ্ধান্ত হয়, যা board-এ register লেখার সীমার (Spec decision 20) সঙ্গে মেলে।
৭ · HardFault — ভুলের শেষ ঠিকানা
Firmware যখন এমন কিছু করে যা CPU পারে না, যেমন অস্তিত্বহীন ঠিকানা পড়া, অচেনা নির্দেশ চালানো বা Thumb বিট ছাড়া লাফ, তখন একটি fault exception ওঠে। আসল Cortex-M3-এ এর চারটি রূপ: MemManage (4), BusFault (5), UsageFault (6) আর HardFault (3). প্রথম তিনটি reset-এর পরে বন্ধ থাকে (SCB-এর SHCSR দিয়ে চালু করা যায়); বন্ধ থাকলে, বা নিজের handler চলার সময় আবার fault হলে, সেটি HardFault-এ উঠে যায় (escalation), আর HFSR register-এর FORCED বিট তা জানায়। কারণ জানতে আসল chip-এ CFSR (0xE000ED28), HFSR (0xE000ED2C) আর ভুল ঠিকানার জন্য MMFAR/BFAR পড়তে হয়। বাজারঘর board এর কোনোটিই রাখে না: সব fault সোজা HardFault-এ যায়, আর HardFault-এর ভেতরে আবার fault হলে run থামে, যা আসল chip-এর lockup-এর মতো (Spec decision 19).
Board-এ fault-এর কারণ বলার register না থাকলেও সবচেয়ে কাজের সূত্রটি আছে: stacked frame. Reference firmware hardfault.c একটি খারাপ pointer (0x60000000, যেখানে কিছু নেই) পড়ে, আর naked handler mrs r0, msp দিয়ে frame-এর ঠিকানা C function-কে দেয়:
$ python -B board.py run build/hardfault.elf
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0380 ms] UART: reading through a bad pointer 0x60000000 ...
[ 0.0386 ms] HardFault: Invalid memory read (UC_ERR_READ_UNMAPPED) at PC=0x08000154 read_sensor+0x4
[ 0.1085 ms] UART: HardFault! stacked PC=0x08000154 LR=0x0800013D R0=0x60000000
[ 0.1094 ms] exit(3) after 875 cycles
Board-এর নিজের লাইন (HardFault: …) আর firmware-এর নিজে ছাপা stacked PC একই: 0x08000154. আসল chip-এ board-এর লাইন থাকবে না, firmware-এর ছাপাটুকুই থাকবে, তাই handler-এ frame পড়ার অভ্যাস জরুরি। আমার lab-এ এর একটি বড় রূপ hf_frame.c লেখা হয়েছে, যা পুরো আটটি word আর EXC_RETURN ছাপে; আর hf_isr.c-এ একই খারাপ pointer পড়া হয় SysTick handler-এর ভেতর থেকে:
void hf_report(const uint32_t *frame, uint32_t exc_return)
{ /* frame[0..7] = R0 R1 R2 R3 R12 LR PC xPSR; prints all, then exit(3) */ }
__attribute__((naked)) void HardFault_Handler(void)
{
__asm volatile ("mrs r0, msp\n" /* r0 = frame-এর ঠিকানা */
"mov r1, lr\n" /* r1 = EXC_RETURN */
"b hf_report\n");
}
#ifdef IN_ISR /* hf_isr.c: #define IN_ISR */
void SysTick_Handler(void)
{
uart_puts("SysTick: reading the sensor ...\r\n");
(void)read_sensor((volatile uint32_t *)0x60000000u);
}
#endif$ python -B board.py run build/hf_isr.elf
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 1.0294 ms] UART: SysTick: reading the sensor ...
[ 1.0301 ms] HardFault: Invalid memory read (UC_ERR_READ_UNMAPPED) at PC=0x0800026C read_sensor+0x4
[ 1.0870 ms] UART: HardFault frame at 0x20004FC0, EXC_RETURN=0xFFFFFFF1
[ 1.1110 ms] UART: R0=0x60000000
[ 1.1345 ms] UART: R1=0x00000000
[ 1.1580 ms] UART: R2=0x40004400
[ 1.1815 ms] UART: R3=0xC0000000
[ 1.2058 ms] UART: R12=0x00000000
[ 1.2292 ms] UART: LR=0xFFFFFFF9
[ 1.2528 ms] UART: PC=0x0800026C
[ 1.2777 ms] UART: xPSR=0x8100000F
[ 1.2786 ms] exit(3) after 10229 cycles
Thread থেকে একই fault-এ (hf_frame.elf) frame ছিল 0x20004FE0-এ, EXC_RETURN = 0xFFFFFFF9, stacked LR = 0x08000265 (main-এর ভেতর) আর xPSR = 0x81000000. নিচের program hf_isr-এর frame পড়ে একজন অভিজ্ঞ firmware প্রকৌশলীর মতো সিদ্ধান্ত টানে:
# HardFault-এর stacked frame পড়া: hf_isr.elf-এর আসল run থেকে নেওয়া মান
frame_at = 0x20004FC0
exc_return = 0xFFFFFFF1
words = [0x60000000, 0x00000000, 0x40004400, 0xC0000000,
0x00000000, 0xFFFFFFF9, 0x0800026C, 0x8100000F]
names = ["R0", "R1", "R2", "R3", "R12", "LR", "PC", "xPSR"]
symbols = {0x08000268: "read_sensor", 0x08000250: "SysTick_Handler"}
EXC = {0: "Thread mode", 3: "HardFault", 15: "SysTick", 16: "IRQ0"}
for i, (n, w) in enumerate(zip(names, words)):
print(f"0x{frame_at + 4 * i:08X} {n:4} = 0x{w:08X}")
pc, xpsr, lr = words[6], words[7], words[5]
fn = max(a for a in symbols if a <= pc)
print(f"দোষী নির্দেশ: PC = 0x{pc:08X} = {symbols[fn]}+0x{pc - fn:X}")
ipsr = xpsr & 0x1FF # bit 8..0: তখন কোন exception চলছিল
print(f"xPSR: N={xpsr >> 31} Z={xpsr >> 30 & 1} C={xpsr >> 29 & 1}"
f" T={xpsr >> 24 & 1} IPSR={ipsr} ({EXC[ipsr]}), align-pad={xpsr >> 9 & 1}")
print("stacked LR:", "EXC_RETURN, অর্থাৎ handler থেকে লাফে আসা"
if lr >> 4 == 0x0FFFFFFF else f"0x{lr:08X}")
mode = "Thread" if exc_return & 8 else "Handler"
stack = "PSP" if exc_return & 4 else "MSP"
print(f"EXC_RETURN 0x{exc_return:08X}: ফিরবে {mode} mode-এ, frame {stack}-এ")
print(f"fault-এর আগে SP = 0x{frame_at + 32 + 4 * (xpsr >> 9 & 1):08X}")আসল আউটপুট (ব্রাউজারের Python):
0x20004FC0 R0 = 0x60000000
0x20004FC4 R1 = 0x00000000
0x20004FC8 R2 = 0x40004400
0x20004FCC R3 = 0xC0000000
0x20004FD0 R12 = 0x00000000
0x20004FD4 LR = 0xFFFFFFF9
0x20004FD8 PC = 0x0800026C
0x20004FDC xPSR = 0x8100000F
দোষী নির্দেশ: PC = 0x0800026C = read_sensor+0x4
xPSR: N=1 Z=0 C=0 T=1 IPSR=15 (SysTick), align-pad=0
stacked LR: EXC_RETURN, অর্থাৎ handler থেকে লাফে আসা
EXC_RETURN 0xFFFFFFF1: ফিরবে Handler mode-এ, frame MSP-এ
fault-এর আগে SP = 0x20004FE0
চারটি সূত্র একসঙ্গে একটি গল্প বলে। PC বলে কোন নির্দেশ: read_sensor-এর ভেতরের load. R0 = 0x60000000 বলে কোন ঠিকানা: AAPCS-এ প্রথম argument R0-তে যায়, তাই ভুল pointer-টিই। IPSR = 15 আর EXC_RETURN = 0xFFFFFFF1 বলে fault হয়েছিল SysTick handler চলার সময়, thread-এ নয়। আর stacked LR-এ EXC_RETURN দেখে বোঝা যায় read_sensor-কে SysTick handler bl দিয়ে ডাকেনি, tail call করেছে (Clang-এর output-এ b read_sensor); তাই call-এর ঠিকানা LR-এ নেই। Fault-এর আগে SP = 0x20004FE0, যা SysTick-এর নিজের frame-এর শুরু।
আরও একটি fault, যা অনেকে আশা করেন কিন্তু ঘটে না: শূন্য দিয়ে integer ভাগ। ARMv7-M-এ CCR-এর DIV_0_TRP বিট (বিট ৪) reset-এ 0, আর তখন udiv/sdiv শূন্য দিয়ে ভাগ করলে কোনো fault ছাড়াই ফল 0 দেয়; বিটটি 1 করলে UsageFault হয়। Board-এ 8188 / 0 চালালে সত্যিই 8188/0 = 0 ছাপা হয়েছে (CCR=512); board DIV_0_TRP মডেল করে না। বাজারঘরের scale-এ span বা rate-এর হর কখনো শূন্য হতে পারলে ভাগের আগেই পরীক্ষা করুন, কারণ নীরব 0 ভুল দাম ছাপবে।
আরও গভীরে: NVIC-এর priority-র বিট কেন chip-ভেদে আলাদা? প্রতিটি IRQ-এর প্রতিটি priority বিট silicon-এ flip-flop আর তুলনার যুক্তি চায়, আর ২৪০টি IRQ-এর তুলনা একটি চক্রে শেষ করতে হয়; তাই ছোট chip কম বিট রাখে। ARMv6-M (Cortex-M0/M0+)-এ মাত্র দুটি বিট (চারটি স্তর), PRIGROUP নেই, আর M0-তে VTOR নেই (M0+-এ ঐচ্ছিক)। আরেকটি সূক্ষ্মতা ARMv7-M-এর: exception return-এর ঠিক সময়ে, frame তোলার মাঝে নতুন exception এলে CPU তোলা থামিয়ে সরাসরি নতুনটিতে যেতে পারে, যাকে কোনো কোনো সূত্র “pop pre-emption” বলে; এটিও tail-chaining-এর মতোই অকারণ stack-এর কাজ বাদ দেওয়ার কৌশল।
পরীক্ষা ও ইন্টারভিউতে: “SysTick-এর exception নম্বর আর vector-এর ঠিকানা?” → 15; VTOR + 0x3C. “IRQ5 কোন exception নম্বর?” → 21. “Exception-এ hardware কোন register রাখে?” → R0–R3, R12, LR, PC, xPSR, আট word, R0 সবচেয়ে নিচু ঠিকানায়। “0xFFFFFFF9 মানে?” → thread mode-এ ফেরা, MSP. “Priority 0 আর 15-এর মধ্যে কে জরুরি?” → 0; Reset, NMI, HardFault স্থির −3, −2, −1. “Tail-chaining কী?” → handler শেষে আরেকটি pending থাকলে frame না তুলে সরাসরি পরের handler. “Cortex-M-এ ISR কেন সাধারণ C function হতে পারে?” → hardware AAPCS-এর caller-saved register রাখে, আর EXC_RETURN দিয়ে সাধারণ ফেরাই exception return.
৮ · AI-এর যুগে Cortex-M-এর interrupt যাচাই
NVIC-এর কোড ছোট, তাই AI assistant সহজেই লিখে দেয়; কিন্তু ভুলগুলোও ছোট, আর এমন জায়গায় যেখানে firmware মাঠে গিয়ে মাসে একবার ঝুলে যায়। সবচেয়ে পরিচিত ভুলগুলো আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
| “বড় সংখ্যা = বেশি জরুরি” ধরে priority বসায় (RTOS-এর task priority-র সঙ্গে মিশিয়ে) | Cortex-M-এ কম সংখ্যা জেতে; board-এ দুটি IRQ pend করে ক্রম দেখুন (nvic_tail) |
NVIC->IP[n] = 2 লেখে, shift ছাড়া | ৪ বিটের chip-এ 2 = 0x02 নিচের বিটে পড়ে মুছে যায়, ফল 0 (সবচেয়ে জরুরি); পড়ে দেখুন |
| নির্দিষ্ট chip-এর IRQ নম্বর বা register-এর ঠিকানা বানিয়ে বলে | Chip-এর reference manual-এর vector table আর CMSIS header মেলান |
| EXTI-র pending বিট মোছা ভুলে যায় | Board-এ চালান: handler অবিরাম ঢোকে (অনুশীলন ২) |
ISR-এর ভেতরে printf, delay বা অপেক্ষার loop রাখে | ISR ছোট রাখুন, flag দিন; নিয়মগুলো পর্ব ৪৩-এ |
ISR আর main-এর ভাগ করা ভ্যারিয়েবলে volatile দেয় না, বা read-modify-write-কে atomic ভাবে | Clang-এর -S output পড়ুন; দরকারে PRIMASK দিয়ে critical section |
| EXC_RETURN বা stack frame-এর ক্রম উল্টো বলে; tail-chaining-এর cycle সংখ্যা উৎস ছাড়া দেয় | ARMv7-M ARM আর Cortex-M3 TRM; board-এর frame ছাপা; board timing মাপে না (Spec decision 17) |
AI-কে কাজে লাগাতে প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১8085 আর 8086-এ ISR নিজেই register রাখত, Cortex-M-এ hardware রাখে। ARM কেন এই কাজ silicon-এ নিল, আর এর দাম কী?
8085-এর RST শুধু PC রাখত, 8086 রাখত FLAGS, CS আর IP; বাকি সব ISR-এর দায়িত্ব। এর সুবিধা ছিল সরলতা আর নমনীয়তা: যে ISR দুটি register ছোঁয়, সে দুটিই রাখে। অসুবিধা ছিল দুটি। প্রথমত, ISR-কে assembly-তে লিখতে হতো, বা অন্তত একটি assembly-র মোড়ক লাগত, কারণ C compiler জানে না কোন function-কে interrupt থেকে ডাকা হবে। দ্বিতীয়ত, প্রতিটি ISR-এর শুরুতে PUSH-এর একটি সারি চলত, যা নির্দেশ হিসেবে fetch আর decode হতো, তাই সময় লাগত বেশি।
ARM-এর আগের ARM7TDMI-ধাঁচের core-এ IRQ mode-এর নিজস্ব কয়েকটি register ছিল, কিন্তু interrupt controller ছিল chip-নির্মাতার নিজের, আর ISR-এ ঢোকার পথ একেক chip-এ একেক রকম। Cortex-M3-এর নকশায় ARM দুটি সিদ্ধান্ত একসঙ্গে নিল। NVIC core-এর অংশ হলো, তাই সব chip-এ একই আচরণ। আর exception entry ঠিক সেই register রাখে যা AAPCS অনুযায়ী যেকোনো C function নষ্ট করতে পারে: R0–R3, R12, LR, সঙ্গে PC আর xPSR. R4–R11 রাখার দায় C compiler নিজেই নেয়, কারণ সেগুলো callee-saved. ফলে ISR একটি সাধারণ C function; এই পর্বের Clang-এর output-এ কোনো বিশেষ নির্দেশ ছিল না, এমনকি tail call পর্যন্ত স্বাভাবিকভাবে কাজ করেছে।
Hardware-এ রাখার আরেকটি লাভ গতি আর নির্ভরযোগ্যতা। Stack-এ লেখা চলে bus-এর পূর্ণ গতিতে, আর একই সময়ে vector table পড়া যায়; ARM-এর প্রচলিত বর্ণনায় এই সমান্তরাল কাজের ফলে zero wait-state মেমরিতে প্রবেশ মোটামুটি এক ডজন cycle-এ শেষ হয়। আর late arrival ও tail-chaining সম্ভব হয়েছে কারণ hardware জানে কোন frame কোথায়।
দাম কী? প্রতিটি exception আট word রাখে, এমনকি যে ISR একটি বিট উল্টায় সেও; ছোট ISR-এর জন্য তা বাড়তি stack আর বাড়তি bus-এর কাজ। Stack-এর worst case হিসাবে প্রতিটি nesting স্তরে অন্তত 32 byte ধরতে হয় (FPU-ওয়ালা chip-এ আরও বেশি)। আর silicon-এ যুক্তি বাড়ে। ARM বাজি ধরেছিল যে microcontroller-এর বাজারে C-তে লেখা সহজ আর নির্ধারিত latency এই দামের চেয়ে বেশি মূল্যবান; Cortex-M-এর ব্যাপক ব্যবহার দেখায় সেই বাজি কাজে লেগেছে।
মূল উপলব্ধি: Calling convention-এর caller-saved register আর exception frame-কে একই সেট বানিয়ে ARM interrupt-কে সাধারণ function call-এর মতো করে তুলেছে; দাম হলো প্রতিটি exception-এ নির্দিষ্ট আট word-এর খরচ।
প্র ০২Cortex-M-এ কম সংখ্যা মানে বেশি জরুরি, আর priority-র কয়টি বিট থাকবে তা chip-ভেদে আলাদা। এতে portable firmware লেখায় কী ঝামেলা হয়, আর CMSIS ও RTOS তা কীভাবে সামলায়?
“কম সংখ্যা জেতে” নিয়মের পেছনে একটি সুন্দর যুক্তি আছে: Reset, NMI আর HardFault-কে ঋণাত্মক স্থির priority দিয়ে নিশ্চিত করা হয়েছে যে program-এর কোনো ভুল বসানো মান তাদের ছাড়াতে পারবে না, কারণ program-এর সবচেয়ে জরুরি মানও 0. আর hardware-এ তুলনা সরল: সবচেয়ে ছোট সংখ্যা খোঁজা। কিন্তু মানুষের মন উল্টো ভাবে। FreeRTOS-এর মতো RTOS-এ task-এর priority-তে বড় সংখ্যা বেশি জরুরি (কোর্সের RTOS simulator-ও তাই, Spec decision 32), আর একই firmware-এ দুই নিয়ম পাশাপাশি থাকায় ভুল সহজ।
দ্বিতীয় ঝামেলা বিটের সংখ্যা। ARM শুধু বলে priority byte ৮ বিটের, chip-নির্মাতা উঁচু দিকের কয়টি রাখবেন তা তাঁর ব্যাপার। STM32F1-এ ৪টি, Cortex-M0-ধাঁচের chip-এ ২টি। কেউ যদি সরাসরি IP[n] = 2 লেখেন, ৪ বিটের chip-এ তা নিচের বিটে পড়ে মুছে যায়, আর interrupt নীরবে সবচেয়ে জরুরি (0) হয়ে যায়। এই পর্বের board-এ 0x25 লিখে 0x20 পড়া সেই আচরণেরই প্রমাণ।
CMSIS এর সমাধান দেয় একটি চুক্তি দিয়ে: chip-এর header-এ __NVIC_PRIO_BITS থাকে, আর NVIC_SetPriority() সংখ্যাটিকে নিজেই বাঁয়ে সরায়, যেমন board-এর header-এ prio << 4. তাই firmware লেখে 0 থেকে 15, আর একই কোড ভিন্ন chip-এ ভিন্ন shift পায়। RTOS-এর জন্য সমস্যাটি আরও সূক্ষ্ম। Cortex-M3/M4-এর FreeRTOS port একটি সীমা রাখে (তাদের documentation-এ configMAX_SYSCALL_INTERRUPT_PRIORITY নামে): এর চেয়ে জরুরি interrupt-এ RTOS-এর API ডাকা নিষেধ, কারণ kernel নিজের critical section-এ BASEPRI দিয়ে শুধু ওই সীমা পর্যন্ত interrupt আটকায়। এই সীমা কখনো shift-করা byte হিসেবে, কখনো shift-ছাড়া সংখ্যা হিসেবে লিখতে হয়, আর এখানকার ভুল নিয়ে RTOS-এর forum-এ বহু প্রশ্ন দেখা যায়।
বাজারঘরের device-এর জন্য শিক্ষা: priority-গুলো এক জায়গায়, নাম দিয়ে (PRIO_BUTTON, PRIO_TICK) সংজ্ঞায়িত করুন, CMSIS-এর function দিয়ে বসান, আর বসানোর পরে register পড়ে যাচাই করুন, যেমন অনুশীলন ১-এ IP[0]=16 SHP[11]=48.
মূল উপলব্ধি: NVIC-এর priority-র সংখ্যা “কতটা জরুরি” নয়, “কোন স্তরে” তা বলে; কম সংখ্যা জেতে, আর বিটের সংখ্যা chip-এর, তাই shift আর নামের চুক্তি ছাড়া portable firmware হয় না।
প্র ০৩Tail-chaining আর late arrival real-time নকশায় কেন গুরুত্বপূর্ণ? কোর্সের board এগুলোর timing কেন দেখাতে পারে না, আর আসল chip-এ কীভাবে মাপবেন?
Real-time system-এ গড় সময়ের চেয়ে worst case বেশি জরুরি (পর্ব ৫৪)। একটি motor-controller-এর ভাবুন, যেখানে timer আর ADC-এর interrupt প্রায় একসাথে আসে। Tail-chaining না থাকলে দ্বিতীয় handler-এর আগে আট word তোলা আর আট word রাখা, দুটিই হতো; TRM-এর বর্ণনায় tail-chaining-এ পরের handler আগেরটি শেষ হওয়ার মাত্র ছয় cycle পরে শুরু হয়। Late arrival আরও সূক্ষ্ম সমস্যা মেটায়: কম জরুরি একটির জন্য stacking শুরু হওয়ার পর জরুরিটি এলে তাকে আগেরটির পুরো handler শেষ হওয়া পর্যন্ত অপেক্ষা করতে হয় না, এমনকি আরেকটি stacking-এর সময়ও লাগে না। দুটি কৌশল মিলে জরুরি interrupt-এর worst-case latency ছোট আর অনুমানযোগ্য রাখে।
কোর্সের board এই timing দেখাতে পারে না, আর তা জেনে-বুঝেই। Spec decision 17 অনুযায়ী প্রতিটি নির্দেশ ১ cycle আর exception-এ ঢোকা ০ cycle; Spec decision 19 বলে tail-chaining-এর ফল ঠিক, timing নয়; Spec decision 20 বলে pending exception শুধু নির্দিষ্ট সীমায় পরীক্ষা হয়। একটি emulator যদি cycle-এর সঠিক হিসাব দিতে চায়, তাকে pipeline, bus, flash-এর wait state আর prefetch, সবই মডেল করতে হবে; Unicorn-এর মতো দ্রুত emulator তা করে না। Board-এর শক্তি অন্য জায়গায়: ক্রম, stack, register আর ভুলের ধরন, প্রতিবার একই।
আসল chip-এ latency মাপার প্রচলিত পথ দুটি। প্রথমটি GPIO: interrupt-এর উৎস (যেমন একটি pin-এর edge) আর ISR-এর প্রথম নির্দেশে আরেকটি pin উঁচু করা, তারপর oscilloscope বা logic analyzer দিয়ে দুটি edge-এর ব্যবধান মাপা। এতে pin উঁচু করার নিজের সময়ও যোগ হয়, তা আলাদা করে বাদ দিতে হয়। দ্বিতীয়টি Cortex-M3/M4-এর DWT unit-এর cycle counter (CYCCNT), যা debug-এর অংশ; ISR-এর শুরুতে counter পড়ে, timer-এর counter থেকে উৎসের সময় জেনে পার্থক্য নেওয়া যায়। দুই ক্ষেত্রেই বহুবার মেপে সর্বোচ্চটি দেখতে হয়, কারণ flash-এর cache, অন্য interrupt আর PRIMASK-এর ভেতরের সময় worst case বদলায়।
মূল উপলব্ধি: Tail-chaining আর late arrival অকারণ stack-এর কাজ বাদ দিয়ে worst-case latency কমায়; emulator এগুলোর ক্রম দেখাতে পারে, সময় নয়, আর সময় মাপতে আসল chip, pin আর cycle counter লাগে।
প্র ০৪বাজারঘরের cold-storage monitor বাজারে বসানোর পরে মাসে একবার হঠাৎ reset হয়। HardFault handler-কে কীভাবে নকশা করবেন যাতে পরের বার কারণ জানা যায়?
Reference lab-এর HardFault handler ভুলটি UART-এ ছাপে আর থামে; পরীক্ষাগারে তা যথেষ্ট, কারণ কেউ পর্দার দিকে তাকিয়ে আছেন। কিন্তু বাজারের ঠান্ডা ঘরে কেউ UART দেখছে না, আর থেমে থাকা যন্ত্র মানে মাছ-মাংস নষ্টের ঝুঁকি। তাই মাঠের firmware-এর HardFault handler-এর তিনটি কাজ: প্রমাণ রাখা, নিরাপদ অবস্থায় যাওয়া, আর আবার চালু হওয়া।
প্রমাণ রাখার সবচেয়ে সস্তা জায়গা হলো এমন একটি RAM অংশ, যা reset-এ মোছা হয় না। Reference lab-এর watchdog উদাহরণ ঠিক এটিই করে: .noinit section-এ একটি counter রাখে, যা watchdog বা software reset পেরিয়ে টিকে থাকে (Spec decision 18). HardFault handler সেখানে stacked frame-এর আটটি word, EXC_RETURN, আর আসল chip হলে CFSR, HFSR, BFAR আর MMFAR লিখে রাখতে পারে, সঙ্গে একটি “magic” সংখ্যা যাতে বোঝা যায় তথ্যটি বৈধ। তারপর AIRCR-এর SYSRESETREQ দিয়ে reset. Boot-এর পরে firmware সেই অংশ পড়ে, থাকলে MQTT-তে একটি বার্তা পাঠায়, তারপর মুছে দেয়। এভাবে পরের সকালে dashboard-এ PC আর কারণ দেখা যাবে।
এই পর্বের hf_isr-এর উদাহরণ দেখায় সেই তথ্য কতটা শক্তিশালী: PC বলেছে read_sensor, R0 বলেছে ঠিকানা 0x60000000, IPSR বলেছে SysTick-এর ভেতরে। আসল ঘটনায় হয়তো I2C-এর sensor মাঝে মাঝে সাড়া দেয় না, আর একটি pointer-এর হিসাব সেই অবস্থায় ভুল ঠিকানা দেয়। কয়েকটি log মিলালে নমুনা ধরা পড়ে।
সাবধানতাও আছে। HardFault-এর ভেতরে আবার fault হলে lockup, তাই handler যত সরল সম্ভব: stack ভাঙা থাকলে C function-এর নিজের stack-ই বিপদে, তাই অনেকে প্রথম কয়েকটি নির্দেশ assembly-তে লেখেন, যেমন এই পর্বের naked handler. ধীর flash-এ লেখা handler-এর ভেতরে না করে reset-এর পরে করাই নিরাপদ। আর watchdog চালু রাখুন, যাতে lockup হলেও যন্ত্র ফিরে আসে; সেই নকশা পর্ব ৬১ (Watchdog আর fault handling)-এ।
মূল উপলব্ধি: মাঠের HardFault handler একটি “black box recorder”: frame আর fault register reset-টেকা মেমরিতে রাখুন, নিরাপদে reset দিন, আর পরে সেই তথ্য বাইরে পাঠান।
প্র ০৫একটি interrupt-এর pending বিট মোছা ভুলে গেলে কোর্সের board-এ ৩৭৫ ms-এ চার লাখের বেশিবার একই handler ঢুকেছে। এই “interrupt storm” কেন এত বিপজ্জনক, আর priority-র নকশা দিয়ে এর ক্ষতি কীভাবে সীমিত রাখা যায়?
অনুশীলন ২-এর run-এ button চাপার পরে EXTI0-র handler ৪ ২৮ ৫৭২ বার ঢুকেছে, প্রায় প্রতি ৭ cycle-এ একবার, আর SysTick-এর tick ১২-তে আটকে গেছে। কারণটি সরল: EXTI-র pending বিট peripheral-এ থাকে, NVIC-এ নয়। NVIC নিজের pending বিট মোছে handler-এ ঢোকার সময়, কিন্তু peripheral-এর লাইন তখনো উঁচু, তাই handler শেষ হতেই NVIC আবার pending দেখে আর tail-chain করে। Handler-এর priority 1, SysTick-এর 3, তাই SysTick আর কখনো সুযোগ পায় না, আর main-ও না। যন্ত্র “চালু” দেখায়, কিন্তু কোনো কাজ করে না।
Cortex-M-এর tail-chaining এখানে উল্টো ফল দেয়: চক্রটি এত দ্রুত যে CPU-র প্রায় পুরো সময় খেয়ে ফেলে। আসল chip-এ একই ঘটনা ঘটে noise-ভরা একটি তারে, শর্ট-সার্কিট হওয়া sensor-এ, বা UART-এর একটি ত্রুটি-বিটে যা handler মোছে না। বাজারঘরের cold room-এ এর মানে হতে পারে তাপমাত্রা পড়া বন্ধ, alarm চুপ, আর watchdog-ও হয়তো সেই tick থেকেই খাওয়ানো হচ্ছিল বলে বাঁচাতে পারে না।
নকশায় কয়েকটি স্তরের সুরক্ষা রাখা যায়। প্রথমত, handler-এর প্রথম কাজ উৎসের pending বিট মোছা, reference-এর button.c-এর মতো। দ্বিতীয়ত, priority-র ক্রম ভেবে বসানো: যে উৎস বাইরের জগৎ থেকে আসে আর অবিরাম চলতে পারে (button, বাইরের pin), তাকে অভ্যন্তরীণ জরুরি কাজের (system tick, নিরাপত্তার timer) চেয়ে বেশি জরুরি করবেন না, যদি না সত্যিই দরকার হয়। তৃতীয়ত, watchdog-কে tick-এর ISR থেকে নয়, main-এর loop থেকে খাওয়ানো, যাতে মূল কাজ বন্ধ হলে reset আসে। চতুর্থত, handler-এ একটি গুনতি রেখে অস্বাভাবিক হারে interrupt এলে উৎসটি কিছুক্ষণ বন্ধ রাখা (debounce-এর ধারণা, পর্ব ৪২)।
অনুশীলন ১-এর সঠিক নকশায় button-কে priority 1 দেওয়া হয়েছে, কারণ alarm থামানোর চাপ দ্রুত ধরা দরকার, আর handler প্রথমেই PR মোছে। একই priority ভুল handler-এর সঙ্গে মিলে কী করতে পারে, অনুশীলন ২ তা দেখায়।
মূল উপলব্ধি: NVIC নিজের pending মোছে, peripheral-এর নয়; ভুলে গেলে tail-chaining অসীম চক্র বানায়, আর ভুল priority সেই চক্রকে পুরো যন্ত্রের ওপর চাপিয়ে দেয়।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি firmware-এর উত্তর কোর্সের virtual বাজারঘর board-এ build করে চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — cold room-এর alarm থামানোর button: PA0-র button চাপলে (rising edge) EXTI0 interrupt-এ সেই মুহূর্তের tick সংখ্যা রাখুন। SysTick প্রতি 10 ms-এ একটি tick গোনে। Button-এর priority 1, SysTick-এর 3. 300 ms পরে IP[0], SHP[11] আর রাখা tick ছাপুন। Script: 125 ms-এ চাপ, 180 ms-এ ছাড়া।
static volatile uint32_t ticks; /* 10 ms ticks */ static volatile uint32_t ack_at; /* tick of the last press */ void SysTick_Handler(void) { ticks++; } void EXTI0_IRQHandler(void) { EXTI->PR = 1u; /* write 1 to clear, first */ ack_at = ticks; } int main(void) { uart_init(); EXTI->RTSR = 1u; /* rising edge = press */ EXTI->IMR = 1u; NVIC_SetPriority(EXTI0_IRQn, 1); /* IP[0] = 0x10 */ NVIC_SetPriority(SysTick_IRQn, 3); /* SHP[11] = 0x30 */ NVIC_EnableIRQ(EXTI0_IRQn); /* ISER = 1 */ SysTick->LOAD = SystemCoreClock / 100u - 1u; /* 79999 */ SysTick->VAL = 0; SysTick->CTRL = SysTick_CTRL_CLKSOURCE | SysTick_CTRL_TICKINT | SysTick_CTRL_ENABLE; while (ticks < 30u) __WFI(); /* print IP[0], SHP[11], ack_at; board_exit(0) */ }সত্যিকারের run (
ack.c, scriptack.json):[ 300.0574 ms] UART: IP[0]=16 SHP[11]=48 ack at tick 12, তারপরexit(0) after 2400465 cycles. IP[0] = 16 = 0x10 (priority 1 << 4), SHP[11] = 48 = 0x30. 10 ms-এর tick-এর জন্য LOAD = 8 000 000 / 100 − 1 = 79 999 (README-এর cold room-এর মান)। 125 ms-এ ১২টি tick শেষ, তাই ack_at = 12. নকশার যুক্তি:ticksআরack_atদুটিই ISR আরmain-এর ভাগ করা, তাইvolatile; ISR-এর প্রথম কাজ PR মোছা; আর ISR-এ কোনো ছাপা নেই, ছাপেmain. -
ভুল খুঁজুন — একটি লাইন কম: একজন অনুশীলন ১-এর firmware থেকে
EXTI->PR = 1u;লাইনটি মুছে দিলেন, ভাবলেন “NVIC তো ঢোকার সময় pending মুছে দেয়”। Build ঠিক হলো। একই script-এ চালালে কী হবে, আর কেন?সত্যিকারের run (
ack_bug.c,--cycles 4000000): কোনো UART লাইন আসে না; শেষ লাইন[ 500.0000 ms] stopped: cycle limit (4000000) reached after 4000000 cycles. Logging script দিয়ে গুনলে: EXTI0-তে ঢোকা ৪ ২৮ ৫৭২ বার, SysTick-এ মাত্র ১২ বার (button চাপার আগের ১২টি tick). কারণ: NVIC নিজের pending বিট মোছে, কিন্তু EXTI-র PR বিট peripheral-এ, আর board-এর নিয়মে PR & IMR থাকলে IRQ0-র লাইন উঁচু থাকে (Spec decision 27). তাই handler শেষ হতেই আবার pending, tail-chain, অবিরাম। Priority 1 বলে SysTick (3) কখনো ঢুকতে পারে না,ticks12-তে আটকে,main-এর loop শেষ হয় না। ঠিক রূপ: handler-এর শুরুতেEXTI->PR = 1u;(write-1-to-clear). -
হিসাব — ঠিকানা আর frame: (ক) বাজারঘর board-এ IRQ1 (UART)-এর exception নম্বর, vector-এর ঠিকানা আর priority byte-এর ঠিকানা কত? (খ) Thread mode-এ SP = 0x20004FF8 থাকা অবস্থায় UART interrupt এলে frame কোথায় শুরু হবে, আর stacked PC কোন ঠিকানায় থাকবে? (গ) SP = 0x20004FF4 হলে?
(ক) 16 + 1 = 17; vector 0x08000000 + 4 × 17 = 0x08000044; priority byte 0xE000E400 + 1 = 0xE000E401. (খ) 0x20004FF8 8-এর গুণিতক, ফাঁকা লাগে না: frame = 0x20004FF8 − 32 = 0x20004FD8; PC frame-এর ৭ নম্বর word (offset 0x18), তাই 0x20004FF0. এই মানগুলো
nvic_tail.elf-এর আসল run-এ মিলেছে:ENTER 17 … SP 0x20004FF8 -> 0x20004FD8. (গ) 0x20004FF4 & 4 = 4, তাই আগে ৪ byte ফাঁকা: 0x20004FF0, তারপর − 32 = 0x20004FD0; stacked xPSR-এর বিট ৯ = 1, আর ফেরার সময় SP আবার 0x20004FF4. হিসাবটি board-এর নিজের নিয়মে (Spec decision 19,sp & 4) Python-এ চালিয়ে মেলানো। -
আগে বলুন, তারপর চালান — দুটি pending IRQ: EXTI0-র priority 1, UART-এর 2. PRIMASK = 1 রেখে দুটিকে একসাথে pend করে PRIMASK খোলা হলো। প্রতিটি handler ছাপে
VECTACTIVE,IABRআরISPR(দশমিকে)। দুটি লাইন কী হবে? দ্বিতীয়টি nested না tail-chain?EXTI0 (priority 1) আগে:
EXTI0 VECTACTIVE=16 IABR=1 ISPR=2; UART তখনো pending (বিট ১ = 2), কিন্তু priority 2 > 1, তাই থামাতে পারে না। EXTI0 শেষ হতেই UART tail-chain-এ:UART VECTACTIVE=17 IABR=2 ISPR=0. সত্যিকারের run (nvic_tail2.c,both(1, 2)) ঠিক এই দুটি লাইন ছেপেছে, 0.1432 ms আর 0.1926 ms-এ। Nested নয়, কারণ nesting-এর জন্য নতুনটির priority সংখ্যা চলতিটির চেয়ে কম হতে হয়।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমCortex-M3 thread mode-এ চলার সময় SysTick interrupt এলে কাজগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- SysTick pending হয়, আর তার priority চলতি স্তরের চেয়ে কম সংখ্যার কি না দেখা হয়
- R0–R3, R12, LR, PC আর xPSR চলতি stack-এ রাখা হয়
- LR-এ 0xFFFFFFF9 আর IPSR-এ 15 বসে
- VTOR + 0x3C থেকে handler-এর ঠিকানা PC-তে আসে
- Handler চলে আর শেষে
bx lrদেয় - আটটি word তুলে thread mode-এ আগের জায়গায় ফেরা
একটি Cortex-M3-এ VTOR = 0x08000000. IRQ3-এর handler-এর ঠিকানা vector table-এর কোন ঠিকানায় থাকে?
- 0x0800000C
- 0x0800004C
- 0x08000098
- 0xE000E403
একটি Cortex-M3-এ SysTick-এর priority byte 0x30 আর EXTI0-র 0x10, PRIGROUP = 0. SysTick handler চলার সময় EXTI0 pending হলে কী হয়?
- EXTI0 এখনই SysTick handler-কে থামিয়ে চলে
- EXTI0 অপেক্ষা করে, SysTick শেষ হলে চলে
- EXTI0 হারিয়ে যায়
- HardFault হয়
Cortex-M3-এ exception-এ ঢোকার পরে নতুন SP = 0x20004FE0. 0x20004FF8 ঠিকানায় (SP + 0x18) কোন register-এর stacked মান আছে?
- R0
- LR
- PC (ফেরার ঠিকানা)
- xPSR
একটি Cortex-M3 handler-এর শুরুতে LR = 0xFFFFFFF1. এ থেকে কী বোঝা যায়?
- Handler শেষে thread mode-এ ফিরবে, MSP দিয়ে
- Handler শেষে thread mode-এ ফিরবে, PSP দিয়ে
- Handler শেষে 0xFFFFFFF1 ঠিকানার কোডে লাফ দেবে
- এটি একটি nested exception; শেষে আগের handler-এ ফিরবে, MSP দিয়ে
Cortex-M3-এ একটি handler শেষ হওয়ার মুহূর্তে আরেকটি exception pending, যা thread-এর চেয়ে জরুরি। Tail-chaining-এ কী ঘটে?
- আট word তুলে thread-এ ফিরে আবার আট word রাখা হয়
- Frame stack-এ রেখেই সরাসরি পরের handler শুরু হয়
- Pending exception বাতিল হয়ে যায়
- নতুন handler আগেরটির ভেতরে nested হিসেবে চলে
একটি Cortex-M3 chip-এ priority-র শুধু উঁচু দিকের ৪টি বিট আছে। Firmware NVIC->IP[0] = 0x25 লিখে আবার পড়লে কী পাবে?
- 0x25
- 0x05
- 0x20
- 0x02
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- নম্বর: 1 Reset, 2 NMI, 3 HardFault, 11 SVCall, 14 PendSV, 15 SysTick, 16 + n = IRQn; vector = VTOR + 4 × নম্বর, ঠিকানার bit 0 = 1 (Thumb).
- Priority: কম সংখ্যা জেতে; Reset/NMI/HardFault স্থির −3/−2/−1; শুধু উঁচু দিকের বিট থাকে; PRIGROUP group আর subpriority ভাগ করে, preemption শুধু group-এ।
- NVIC: ISER/ICER চালু-বন্ধ, ISPR/ICPR pend-মোছা, IABR active, IP priority; ICSR-এর VECTACTIVE exception নম্বর দেখায়।
- Stacking: R0–R3, R12, LR, PC, xPSR, 32 byte, 8-byte সাজানো; LR = EXC_RETURN (F9 thread/MSP, F1 nested, FD thread/PSP); ISR সাধারণ C function.
- Nesting, tail-chaining, HardFault: কম সংখ্যার নতুনটি চলমানকে থামায়; সমান হলে অপেক্ষা, তারপর frame রেখেই পরের handler; HardFault-এ stacked PC আর IPSR দোষী জায়গা দেখায়।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ২০ · 8086-এর interruptতুলনার জন্যRAM-এর vector table, INT n আর IRET: Cortex-M-এর আগের প্রজন্মের ব্যবস্থা।
- Computer Architecture পর্ব ৩৮ · Exception আর interruptপাশের ট্র্যাকCPU-র নকশার দিক থেকে precise exception আর trap-এর তত্ত্ব।
- Programming Languages & Compilers পর্ব ৭১ · Calling convention আর ABIপাশের ট্র্যাকCaller-saved আর callee-saved register: hardware কেন ঠিক আটটি word রাখে।
- C প্রোগ্রামিং পর্ব ৫৪ · Embedded Cপাশের ট্র্যাকvolatile, register-এর pointer আর ISR-এর সঙ্গে ভাগ করা data.