5.5.7 · Coding › Embedded Systems & Real-Time Software
Intuition Ek-sentence ka picture
Ek interrupt ek hardware-triggered function call hai jise CPU force hota hai karne ke liye: jab koi event hota hai (timer expire ho, UART pe byte aaye, GPIO pin toggle kare), hardware current execution context save karta hai aur ek dedicated function (ISR ) pe jump karta hai taaki tumhe cycles barbad karke polling na karni pade. Poori skill yeh hai ki woh jump fast , safe , aur ordered ho.
Intuition Polling vs. interrupt — the WHY
Socho tum pizza ka wait kar rahe ho. Polling = tum har 10 seconds mein darwaza kholke check karte ho. Energy barbad hoti hai aur phir bhi delivery 9 seconds se miss ho sakti hai. Interrupt = doorbell. Tum doosra kaam karte raho, aur doorbell tumhara dhyan force karti hai jis instant pizza aata hai.
Toh interrupts tumhe do cheezein dete hain: (1) low latency (event hote hi react karo) aur (2) CPU efficiency (polling loops barbad nahi → kam power, zyada throughput).
Definition Core vocabulary
ISR (Interrupt Service Routine) ::: woh function jis par hardware jump karta hai jab interrupt fire hoti hai.
NVIC (Nested Vectored Interrupt Controller) ::: ARM Cortex-M peripheral jo decide karta hai kaun si interrupt chalegi, kab , aur kis priority pe; nesting support karta hai (higher-priority IRQ ek chal rahe lower-priority ISR ko preempt kar sakti hai).
Interrupt latency ::: hardware event ke interrupt assert karne se lekar ISR ki pehli instruction execute hone tak ka time.
Vector table ::: ISR addresses ka array; NVIC isme index karta hai yeh jaanne ke liye ki kahan jump karna hai .
Intuition Un nanoseconds mein actually kya hota hai
Peripheral ek interrupt line assert karta hai → NVIC use pending mark karta hai.
NVIC uski priority compare karta hai currently jo chal raha hai usse. Agar zyada hai, toh preemption request karta hai.
CPU current instruction finish karta hai (ya kuch multi-cycle ops ke liye abandon karta hai).
Hardware automatically 8 registers push karta hai (R 0 –R 3 , R 12 , L R , P C , x P S R ) stack pe — yeh stacking hai. Tumhe saved context free mein milta hai.
CPU vector table se ISR address P C mein load karta hai → ISR chalta hai.
Exit pe, hardware unstack karta hai aur interrupted code bilkul wahin se resume hoti hai jahan chhutti thi.
Kyunki caller-saved registers hardware se stack hote hain, tumhara ISR ek normal C function ho sakta hai — compiler callee-saved (R 4 –R 11 ) registers handle karta hai agar tum unhe use karo.
Intuition WHY priority ko structure chahiye
Agar ek saath do interrupts pending hain, kaun jeetega? Tumhe ek ordering chahiye. ARM Cortex-M har priority value ko do fields mein split karta hai taaki tum do alag ideas express kar sako: "kaun kisey preempt karta hai" aur "tie mein kaun jeetega."
Definition Priority grouping
Har interrupt ka ek 8-bit priority register hota hai, lekin chip sirf top N bits implement karta hai (typically N = 3 ya 4 ; e.g. STM32F4 4 implement karta hai → 16 levels). PRIGROUP field un bits ko split karta hai:
Preemption priority (group priority): decide karta hai kaun kisey interrupt kar sakta hai .
Sub-priority : tiebreaker jab do equal-preemption interrupts ek saath pending hon — yeh preemption allow nahi karta .
Lower numeric value = higher urgency (priority 0 sabse urgent hai).
Worked example Worked: STM32F4,
N = 4 , PRIGROUP 3 preempt bits deta hai
Preempt levels = 2 3 = 8 . Yeh step kyun? 3 bits → 8 groups jo ek doosre ko preempt kar sakte hain.
Sub levels = 2 4 − 3 = 2 1 = 2 . Kyun? 1 bacha hua bit → 2 tiebreaker slots.
Toh IRQ-A (preempt=1) IRQ-B (preempt=2) ko mid-execution mein bhi interrupt karta hai . Lekin IRQ-C (preempt=2,sub=0) aur IRQ-D (preempt=2,sub=1): agar dono pending hain, C pehle chalta hai, lekin dono ek doosre ko preempt nahi karte .
Intuition Latency badi ya choti kya banata hai
Latency = kitna time lagega tumhare ISR ki pehli instruction tak. Do sources hain: fixed hardware cost (stacking + vector fetch) aur software-induced blocking (tumne interrupts disable kiye, ya ek higher/equal-priority ISR CPU hogg kar raha hai).
Worked example Worst-case latency compute karo
CPU = 100 MHz → 1 cycle = 10 ns. Hardware part = 12 cycles. Tumhara sabse lamba critical section 50 cycles ke liye IRQs disable karta hai.
t lat,worst = ( 12 + 50 ) × 10 ns = 620 ns
50 kyun add kiya? Agar event bilkul tab fire kare jab tumne interrupts mask kiye, toh woh poora critical section wait karega stacking shuru hone se pehle.
Worked example Tail-chaining ki saving
Do interrupts B phir C pending hain. Naively: B ke baad unstack (~12 cyc) phir C ke liye re-stack (~12 cyc) = 24. Tail-chaining ke saath, hardware unstack+restack skip karta hai aur directly B→C jump karta hai, sirf ~6 cycles costing. Kyun kaam karta hai: saved context already valid hai; same 8 registers ko pop karke turant push karna wasted work hai.
Intuition Golden rule: ISRs SHORT hone chahiye
Jab ISR chal raha hota hai, equal aur lower priority interrupts block ho jaate hain → unki latency badi ho jaati hai. Toh: minimum karo (flag clear karo, data grab karo, ek flag set karo), phir return karo. Heavy work main loop pe defer karo (deferred / bottom-half processing).
Definition ISR design checklist
Interrupt flag early clear karo — warna tum forever re-enter kar sakte ho.
Use short aur bounded rakho (koi printf, koi malloc, koi blocking waits nahi).
ISR + main se touch hone wale shared variables ==volatile== hone chahiye (taaki compiler unhe register mein cache karne ki jagah baar baar re-read kare) aur atomically access hone chahiye (IRQs disable karo ya atomics use karo).
ISR se non-reentrant library functions kabhi call mat karo.
Main ko flag / queue se signal karo → main real kaam kare.
Common mistake Steel-man: "Main kaam directly ISR ke andar karunga — woh faster hai na?"
Kyun sahi lagta hai: data wahin hai , aur main loop ke through ek extra hop wasteful lagta hai. Kyun galat hai: ek lamba ISR har equal/lower-priority interrupt ki latency badhata hai — tum ek timer tick miss kar sakte ho, UART bytes drop kar sakte ho, ya real-time deadlines break kar sakte ho. Fix: ISR byte ring buffer mein grab karta hai aur ek flag set karta hai; main loop parse karta hai. Latency low aur bounded rehti hai.
Common mistake Steel-man: "Mujhe
volatile ki zaroorat nahi — variable obviously change hota hai."
Kyun sahi lagta hai: tum jaante ho ISR use write karta hai, toh update hona chahiye. Kyun galat hai: compiler while(!flag); ko optimize karta hai flag ko ek baar register mein cache karke — woh kabhi ISR ka RAM write nahi dekhta → infinite loop. Fix: ise volatile mark karo taaki har read memory hit kare.
Common mistake Steel-man: "Higher priority number = zyada important."
Kyun sahi lagta hai: everyday life mein "level 10" "level 1" ko beat karta hai. Kyun galat hai: Cortex-M NVIC pe, lower number = higher urgency (0 top hai). Fix: apna sabse time-critical IRQ priority 0 (ya sabse kam number jo tumhara design allow kare) assign karo.
Hardware level pe ISR kya karta hai? Hardware current context save karta hai (auto-stacks 8 registers) aur vector table ke zariye ISR address pe jump karta hai, phir return pe unstack karta hai.
Cortex-M pe, lower ya higher priority number jeetega? Lower number = higher priority (0 sabse urgent hai).
Preemption priority aur sub-priority mein fark? Preemption priority decide karta hai kaun ek running ISR ko interrupt kar sakta hai; sub-priority sirf simultaneously-pending equal-preemption IRQs ke beech ties break karta hai aur kabhi preemption nahi karta.
Agar chip N priority bits implement kare aur p bits preemption ko assign kare, toh kitne preempt aur sub levels honge? 2^p preemption levels aur 2^(N-p) sub-priority levels.
Interrupt latency define karo. Event ke interrupt assert karne se lekar ISR ki pehli instruction execute hone tak ka time.
Cortex-M3/M4 pe no wait states ke saath deterministic hardware latency kitni hai? ~12 cycles (stacking + vector fetch).
ISRs short kyun hone chahiye? Jab ISR chal raha hota hai, equal/lower-priority interrupts block ho jaate hain, unki latency inflate hoti hai aur deadlines miss hone / data drop hone ka risk hota hai.
Tail-chaining kya optimize karta hai? Back-to-back pending interrupts unstack+restack skip karte hain (~6 cycles instead of ~24).
Shared ISR/main variables volatile kyun hone chahiye? Taaki compiler ko force kiya ja sake ki woh unhe har baar memory se re-read kare, register mein stale value cache karne ki jagah.
Cortex-M interrupt entry pe auto-stack kye 8 registers karte hain? R0–R3, R12, LR, PC, xPSR.
Do cheezein batao jo tumhe ISR ke andar KABHI nahi karni chahiye. Blocking/long operations aur non-reentrant functions call karna (e.g. malloc, printf).
Software masking se latency kaunsa term badhata hai? t_blocked — woh time jab interrupts disabled the (critical section / BASEPRI / __disable_irq).
Recall Feynman: ek 12-saal ke bachchon ko samjhao
Tum homework kar rahe ho (main program). Kitchen mein smoke alarm hai (interrupt). Jab woh beep kare, tumhe apna pencil exactly wahin chodna padta hai , smoke deal karna padta hai (ISR), phir pencil uthake wahi word likhna jaari rakhna padta hai. Alarm ka beep karna = hardware event. "Pencil ko exactly wahin chhodna " = CPU ka tumhare registers save karna. Kuch alarms zyada scary hote hain (fire > microwave timer) — yeh priority hai: fire alarm tumhe tab bhi interrupt karta hai jab tum already microwave answer kar rahe ho. Beep aur tumhare actually uthne ke beech ka time yeh latency hai — ise chota rakho aise kaam ke beech mein na phansa ke jo tum pause nahi kar sakte.
Mnemonic ISR rules yaad karo:
"SAVE-Fast"
S hort, A tomic shared access, V olatile flags, E arly-clear the flag, Fast return (kaam defer karo). Aur priority ke liye: "Zero is the hero" (sabse kam number jeetega).
Recall Active recall — note band karo aur jawab do
Derive karo N = 3 bits, 2 preempt bits ke liye kitne preempt/sub levels honge.
CPU 50 MHz pe, hardware latency 12 cycles, sabse lamba critical section 80 cycles — worst-case latency?
volatile stuck while(!flag) loop kyun fix karta hai?
Real-Time Scheduling & Deadlines — latency directly bound karta hai ki deadlines meet hongi ya nahi.
Concurrency & Race Conditions — volatile + atomic access critical-section theory ko mirror karta hai.
ARM Cortex-M Architecture — vector table, stacking, BASEPRI register.
Polling vs Interrupt-driven I/O — efficiency tradeoff jo is poore topic ko motivate karta hai.
Ring Buffers / FIFO Queues — ISRs ke liye standard deferred-processing data structure.
Power Management & Sleep Modes — interrupts CPU ko low-power sleep se jagaate hain.
marks pending, compares priority
splits priority via PRIGROUP
Low latency and CPU efficiency