সরাসরি পর্বে যান
পর্ব ৪৩ · ৮৫-এর মধ্যে · মডিউল ৭

Interrupt আর ISR নকশা — latency, priority আর shared data

Interrupts and ISR Design — Latency, Priority and Shared Data

Taught in Bangla, this lesson sets rules for short, non-blocking ISRs. On the course's virtual BG-M3 board, heavy work in an ISR delays an equal-priority SysTick by up to 2063 cycles (4–7 once moved to main), and a two-word ISR-to-main pair tears 6 times in 20,000 reads until a critical section or sequence counter fixes it. SysTick measures its own latency and jitter. It covers deferred work with flags and an ISR-to-main ring buffer, the lost-wakeup race before WFI, reentrancy and deadline-based priorities.

এই পর্বে যা শিখবেন

  • একটি ISR-এ কী করা চলে আর কী চলে না, আর প্রতিটি নিয়মের পেছনের কারণ বলতে পারা
  • ISR আর main-এর মধ্যে বহু-word data নিরাপদে ভাগ করা: critical section, sequence counter আর hi-lo-hi পড়া, প্রতিটির খরচসহ
  • Interrupt latency আর jitter-এর উপাদান চেনা, board-এ মাপা আর worst case হিসাব করা
  • Deferred work-এর নকশা: flag, ring buffer আর main loop, আর ঘুমানোর আগে হারানো জাগরণ এড়ানো
  • Reentrant function চেনা, আর বাজারঘরের device-এর interrupt-গুলোর priority যুক্তি দিয়ে বাছাই করা

১ · ISR-এর নিয়ম — ছোট, অবরোধহীন, শুধু খবর রাখা

Interrupt-এর যন্ত্রকৌশল আপনি আগেই দেখেছেন: 8085-এ (পর্ব ১৩), 8086-এ (পর্ব ২০), 8259 PIC-এ (পর্ব ২৬), আর Cortex-M-এর vector table, NVIC, stacking আর tail-chaining (পর্ব ৩০). Architecture-এর তত্ত্ব আছে Computer Architecture পর্ব ৩৮-এ। এই পর্ব সেই যন্ত্রের ওপর নকশার পর্ব: একটি ISR কীভাবে লিখলে পুরো firmware নির্ভরযোগ্য থাকে। এখানে hex লেখা হবে C-ধাঁচে, 0x….

উপমা — বাজারঘরের দরজার ঘণ্টা: ক্যাশিয়ার একজন খদ্দেরের দাম গুনছেন, এমন সময় পেছনের দরজায় ঘণ্টা বাজল: মাল এসেছে। ভালো ক্যাশিয়ার খাতায় এক লাইন লেখেন, “১১টা ৫: আলুর চালান”, তারপর আবার খদ্দেরের কাছে ফেরেন; চালান গোনা হবে পরে, ভিড় কমলে। খারাপ ক্যাশিয়ার খদ্দেরকে দাঁড় করিয়ে রেখে গুদামে গিয়ে বস্তা গুনতে বসেন, আর ততক্ষণে আরেকবার ঘণ্টা বাজলে শুনতেই পান না। ISR হলো সেই এক লাইনের নোট; ভারী কাজ (বস্তা গোনা) main loop-এর।

ISR যতক্ষণ চলে, ততক্ষণ সমান বা কম জরুরি সব interrupt অপেক্ষা করে, আর main-ও থেমে থাকে। তাই প্রতিটি নিয়মের মূল কারণ একটিই: ISR-এর সময় অন্যদের সময় খায়। নিয়মগুলো টেবিলে:

নিয়মকেনবাজারঘরের উদাহরণ
ছোট রাখুন: hardware সামলানো, data কপি, খবর রাখাISR-এর দৈর্ঘ্য অন্যদের latency-তে যোগ হয়UART-এর byte ring buffer-এ রেখে ফেরা; লাইন বোঝা main-এ
অপেক্ষা নয় (busy-wait, delay, “flag আসা পর্যন্ত”)যে ঘটনার অপেক্ষা, সেটি হয়তো আরেকটি interrupt, যা এখন ঢুকতেই পারবে নাISR-এর ভেতরে I2C-র DONE বিটের জন্য ঘোরা নয়
printf, malloc নয়ধীর, আর ভেতরে static অবস্থা থাকে, তাই reentrant নয় (অংশ ৫)Debug বার্তা queue-তে, ছাপা main-এ; খরচের মাপ পর্ব ৩৮-এ
উৎসের pending বিট মোছানা মুছলে handler শেষ হতেই আবার ঢোকেEXTI-এর PR; এই ভুলের run পর্ব ৩০-এ
ভাগ করা data-য় volatile আর সুরক্ষাvolatile শুধু access রাখে, অবিভাজ্যতা দেয় নাভিত্তি পর্ব ৩৪-এ; বহু-word data অংশ ২-এ
Register-এর বিট বদলে সাবধানmain-এর read-modify-write-এর মাঝে ISR এলে বদল হারায়BSRR-এর সমাধান পর্ব ৩৫-এ
Interrupt বন্ধ রাখার সময় মাপাপ্রতিটি critical section সব ISR-এর latency বাড়ায়অংশ ৩-এ board-এ মাপা: 64 word কপি = 151 cycle পর্যন্ত দেরি

শেষ কথা হিসেবে মনে রাখুন, এই নিয়মগুলো “ভালো অভ্যাস” নয়, প্রতিটির পেছনে মাপা যায় এমন ফল আছে। এই পর্বের বাকি অংশে সেই ফলগুলো board-এ মাপা হবে। কোর্সের বাজারঘর board একটি virtual Cortex-M3 (BG-M3), আসল কোনো পণ্য নয়; firmware Clang 22.1.8 দিয়ে আসল Thumb কোডে compile হয় আর Unicorn-এ চলে (পর্ব ০৬).

২ · ভাগ করা বহু-word data — ছেঁড়া পড়া

পর্ব ৩৪-এ দেখেছেন, main আর ISR দুজনে একই counter-এ ++ করলে যোগ হারায়। এখানে আরেক ধরনের bug, যেখানে main কিছুই লেখে না, শুধু পড়ে। লেখক একজন (ISR), পাঠক একজন (main), তবু ফল ভুল হয়, যদি data একটি LDR-এ না আঁটে। এর নাম torn read, ছেঁড়া পড়া: পাঠক অর্ধেক পুরোনো, অর্ধেক নতুন মান পায়।

প্রথমে মাপের প্রশ্ন। Cortex-M3-এ aligned ৩২ বিটের পড়া একটি নির্দেশ, তাই একক-core-এ একজন লেখক থাকলে সেটি ছেঁড়ে না। কিন্তু ৬৪ বিট, struct, বা ৮ বিটের chip-এ ১৬/৩২ বিট? একই C ফাইল Clang 22.1.8-এ দুটি target-এ compile করা হলো:

volatile uint64_t ticks64;     /* SysTick ISR: ticks64++ */
volatile uint32_t ticks32;
uint64_t get_ticks64(void) { return ticks64; }
uint32_t get_ticks32(void) { return ticks32; }
সত্যিকারের run — clang -O2 -S, Clang 22.1.8 (ziglang 0.17.1)
Cortex-M3 (thumbv7m)            ATmega328P (avr)
get_ticks32:                    get_ticks32:
  movw r0, :lower16:ticks32       lds r24, ticks32+2
  movt r0, :upper16:ticks32       lds r25, ticks32+3
  ldr  r0, [r0]     @ একটি        lds r22, ticks32
  bx   lr                         lds r23, ticks32+1   ; চারটি
get_ticks64:                      ret
  ...
  ldm  r0, {r0, r1} @ দুই word

AVR-এ ৩২ বিটের একটি পড়া চারটি lds, আর কোনো দুটির মাঝে interrupt আসতে পারে। Cortex-M3-এ ৬৪ বিট পড়েছে একটি ldm দিয়ে (-O0-এ ldrd). তাহলে কি M3-এ ৬৪ বিট নিরাপদ? নিশ্চিতভাবে বলা যায় না। ARM-এর বর্ণনায় interrupt এলে LDRD বাতিল হয়ে পরে আবার শুরু হয়, কিন্তু LDM মাঝপথ থেকে চলতে পারে (interrupt-continuable), অর্থাৎ এক word interrupt-এর আগে আর এক word পরে পড়া সম্ভব। আর C standard volatile uint64_t-এর পড়াকে অবিভাজ্য বলে না; অন্য compiler বা অন্য optimization দুটি আলাদা ldr-ও দিতে পারে। নকশা তাই compiler-এর এই পছন্দের ওপর ভরসা করে না।

Board-এর সীমা: বাজারঘর board-এ প্রতিটি নির্দেশ অবিভাজ্য: interrupt শুধু দুই নির্দেশের মাঝে নেওয়া হয়, আর তাও নির্দিষ্ট “সীমায়” (Spec decision 20: peripheral বা SCS register-এ লেখার পরে, CPSIE, WFI, SysTick-এর underflow আর script-এর ঘটনায়). তাই ldm-এর ভেতরে ছেঁড়া board-এ দেখা যাবে না। নিচের পরীক্ষায় তাই data দুটি আলাদা variable, যা Clang সবসময় দুটি ldr-এ পড়ে।

Board-এ ছেঁড়া জোড়া — দাম আর ওজন মেলে না

Smart scale-এর একটি ISR প্রতি মাপে দুটি মান লেখে: নেট ওজন আর দাম। README-র সূত্রে 150 g-এর দাম 983 paisa, 1250 g-এর 8188 paisa. আমার lab-এর torn.c-তে SysTick ISR পালা করে এই দুই জোড়া লেখে (প্রতি 1000 cycle, অর্থাৎ 125 µs-এ, শুধু race ঘন ঘন ঘটাতে), আর main তিনভাবে ২০,০০০ বার পড়ে জোড়া মেলায়:

static volatile uint32_t net_g = 150, price_paisa = 983;
static volatile uint32_t seq;              /* ISR প্রতি update-এ ++ */

void SysTick_Handler(void)
{
    uint32_t lat = 1000u - SysTick->VAL;   /* কত দেরিতে এলাম */
    /* ... lat_min/lat_max রাখা ... */
    if (net_g == 150u) { net_g = 1250u; price_paisa = 8188u; }
    else               { net_g = 150u;  price_paisa = 983u;  }
    seq++;
}
    /* ১: সরাসরি */
    n = net_g;  p = price_paisa;
    /* ২: critical section */
    __disable_irq();  n = net_g;  p = price_paisa;  __enable_irq();
    /* ৩: sequence counter */
    do { s1 = seq;  n = net_g;  p = price_paisa;  s2 = seq; }
    while (s1 != s2);
সত্যিকারের run — board.py run build/torn.elf (BG-M3, Clang 22.1.8 -O2)
[    34.3368 ms] UART: naive    reads=20000 torn=6 retries=0 isr_latency=4..5 cycles
[    78.3649 ms] UART: cpsid    reads=20000 torn=0 retries=0 isr_latency=4..12 cycles
[   127.6436 ms] UART: seqcount reads=20000 torn=0 retries=72 isr_latency=4..5 cycles
[   127.6451 ms] exit(0) after 1021161 cycles

সরাসরি পড়ায় ৬টি ছেঁড়া জোড়া, প্রায় ২৭৪টি update-এর মধ্যে (প্রথম অংশ চলেছে 34.3 ms, প্রতি 125 µs-এ একটি tick). সংখ্যাটি ছোট মনে হলেও, একটি দোকানের scale-এ দিনে লক্ষবার পড়া হয়। আমার lab-এর trace_torn.py board-এর exception-এ ঢোকার মুহূর্তে register পড়ে ধরেছে ঠিক কোথায় ছিঁড়েছে; প্রথমটি নিচে:

mainldr r2,[r5]  @ net_gISRnet_g = 150ISRprice_paisa = 983ISRseq++ ; ফেরাmainldr r3,[r6]  @ pricemainok_pair(r2, r3)?
নির্দেশের পরে
কে চলছে
main-এর r2 (ওজন)
main-এর r3 (দাম)
SRAM: net · price
main-এর জোড়া
  1. main ওজন পড়ল। ldr r2,[r5]: SRAM-এ জোড়া এখন 1250 g আর 8188 paisa, তাই r2 = 1250.
  2. SysTick এল, cycle 34056-এ (4.2570 ms). main 0x08000182-এর ldr r3,[r6]-এর ঠিক আগে থামল। SysTick-এর underflow board-এ একটি সীমা, তাই ISR সেই cycle-এই ঢোকে (VAL = 0).
  3. ISR নতুন জোড়া লিখল। পালা অনুযায়ী এবার 150 g আর 983 paisa, তারপর seq++. ISR-এর লেখা নিজে ঠিক আছে: SRAM-এ জোড়া মেলে।
  4. ISR ফিরে গেল। Hardware frame থেকে R0–R3, R12, LR, PC, xPSR ফেরত দিল। main-এর r2 = 1250 সেই frame-এ নিরাপদ ছিল, তাই অক্ষত ফিরল; main জানেই না যে মাঝে কিছু ঘটেছে।
  5. main দাম পড়ল। ldr r3,[r6] এখন SRAM থেকে পায় 983. main-এর হাতে 1250 g আর 983 paisa: দুটি আলাদা মাপের দুই টুকরো।
  6. জোড়া মেলে না। 1250 g-এর দাম হওয়ার কথা 8188 paisa = 81.88 টাকা; এই জোড়া দেখালে display-তে আসত 9.83 টাকা। ok_pair মিথ্যা, torn = 1. কোনো লেখক ভুল করেনি; ভুল পড়ার ক্রমে।

তিনটি সমাধান আর তাদের দাম

১. Critical section: পড়ার সময় PRIMASK দিয়ে interrupt বন্ধ। ছেঁড়া 0, কিন্তু দাম দেখুন: ISR-এর latency 4–5 থেকে বেড়ে 12 cycle পর্যন্ত। কারণ, interrupt বন্ধ থাকার সময় যে tick আসে, সেটি cpsie পর্যন্ত অপেক্ষা করে। এখানে মাত্র দুটি ldr, তাই দেরি ছোট; কিন্তু critical section-এ যত কাজ, তত দেরি সব ISR-এর।

২. Sequence counter: লেখক প্রতি update-এ একটি counter বাড়ায়; পাঠক আগে-পরে counter পড়ে, না মিললে আবার পড়ে। ছেঁড়া 0, retry 72 বার, আর ISR-এর latency একটুও বাড়েনি (4–5), কারণ পাঠক কখনো interrupt বন্ধ করে না। এই কৌশলের পরিচিত নাম seqlock; Linux kernel-এ ৩২ বিটের CPU-তে ৬৪ বিটের সময় পড়তে এটি ব্যবহার হয়। বহু-core বা বহু-লেখকের জগতে লেখার সময় counter বিজোড় রাখার নিয়ম আর barrier লাগে; একক-core-এ ISR লেখক হলে সরল রূপই যথেষ্ট, কারণ main কখনো ISR-কে মাঝপথে থামাতে পারে না।

৩. Hi-lo-hi: একটি বাড়তে থাকা ৬৪ বিটের counter-এর জন্য আলাদা counter-ও লাগে না: ওপরের word পড়ুন, নিচের word পড়ুন, আবার ওপরেরটি; দুবার একই হলে ফল ঠিক। নিচের ব্লক একটি ms counter নিয়ে মডেলটি চালায়, wrap-এর ঠিক আগে থেকে (232 ms ≈ ৪৯.৭ দিন). ISR প্রতি load-এর পরে ৩০% সম্ভাবনায় আসে; এটি board নয়, শুধু যুক্তির পরীক্ষা।

# ৬৪ বিটের ms counter দুই ৩২ বিটের word-এ; ISR প্রতি tick-এ +1
import random
random.seed(43)
mem = {}
def isr_tick():
    v = (mem["hi"] << 32 | mem["lo"]) + 1
    mem["lo"], mem["hi"] = v & 0xFFFFFFFF, v >> 32
def step():                      # প্রতি load-এর পরে ISR আসতে পারে
    if random.random() < 0.3:
        isr_tick()
def naive():                     # lo, তারপর hi
    lo = mem["lo"]; step()
    hi = mem["hi"]; step()
    return hi << 32 | lo

def hi_lo_hi():                  # hi, lo, আবার hi; না মিললে আবার
    while True:
        h1 = mem["hi"]; step()
        lo = mem["lo"]; step()
        h2 = mem["hi"]; step()
        if h1 == h2:
            return h1 << 32 | lo

for f in (naive, hi_lo_hi):
    mem.update(lo=0xFFFFFFFF - 2, hi=0)   # wrap-এর ৩ tick আগে
    bad, prev = [], 0
    for _ in range(200):
        val = f()
        now = mem["hi"] << 32 | mem["lo"]
        if not prev <= val <= now:        # পেছোল বা ভবিষ্যতে লাফ দিল
            bad.append(f"{val:#x} ({val / 86400000:.1f} দিন, আসলে {now / 86400000:.1f})")
        else:
            prev = val
    print(f"{f.__name__:8}: ভুল পড়া = {bad}")

আসল আউটপুট (ব্রাউজারের Python):

naive   : ভুল পড়া = ['0x1ffffffff (99.4 দিন, আসলে 49.7)']
hi_lo_hi: ভুল পড়া = []

সরাসরি পড়ায় একবার নিচের word পুরোনো 0xFFFFFFFF, ওপরেরটি নতুন 1: যন্ত্রের ঘড়ি হঠাৎ ৪৯.৭ দিন সামনে লাফ দিল। Timeout-এর হিসাবে এর মানে সব অপেক্ষা একসাথে “শেষ”, বা উল্টো ক্রমে পড়লে সময় পেছনে যাওয়া। Hi-lo-hi একবারও ভুল দেয়নি। তিন সমাধানের মধ্যে বাছাইয়ের নিয়ম: data ছোট আর পড়া কম হলে critical section সবচেয়ে সরল; ISR-এর latency জরুরি হলে sequence counter; শুধু-বাড়া counter হলে hi-lo-hi.

৩ · Latency আর jitter — board-এ মাপা

Interrupt latency হলো ঘটনা ঘটা থেকে ISR-এর প্রথম নির্দেশ পর্যন্ত সময়। আর jitter হলো সেই latency-র ওঠানামা: একটি 1 ms tick কখনো 0.5 µs, কখনো 250 µs দেরিতে। Latency-র চারটি উপাদান:

  1. Hardware-এর প্রবেশ: চলতি নির্দেশ শেষ, আট word stack-এ, vector পড়া। ARM-এর প্রকাশিত হিসাবে Cortex-M3/M4-এ zero wait-state মেমরিতে প্রায় ১২ cycle (পর্ব ৩০). Board-এ এটি 0 (Spec decision 17).
  2. Interrupt বন্ধ থাকা: main বা অন্য ISR-এর সবচেয়ে লম্বা critical section.
  3. সমান বা বেশি জরুরি ISR চলতে থাকা: সমান priority কখনো preempt করে না, তাই চলমানটি শেষ হওয়া পর্যন্ত অপেক্ষা।
  4. বেশি জরুরি ISR-এর বাধা: অপেক্ষার মাঝে যতবার বেশি জরুরি কেউ আসে।

Board প্রথমটি দেখায় না, কিন্তু বাকি তিনটি, যেগুলো firmware-এর নকশা থেকে আসে, cycle ধরে মাপা যায়। কৌশলটি সরল: SysTick-এর counter শূন্যে পৌঁছানোর cycle-এই interrupt ওঠে আর counter আবার LOAD থেকে নামে। তাই ISR-এর প্রথম কাজ VAL পড়া; 8000 − VAL বলে underflow-এর কত cycle পরে আমরা এখানে। আমার lab-এর latency.c পাঁচটি 100 ms-এর পর্বে পাঁচ রকম নকশা চালায়; C, D আর E পর্বে script পাঁচবার বোতাম চাপে (EXTI0, rising edge):

void SysTick_Handler(void)               /* priority 2 (E পর্বে 1) */
{
    uint32_t lat = 8000u - SysTick->VAL;  /* প্রথম কাজ */
    if (lat < lat_min) lat_min = lat;
    if (lat > lat_max) lat_max = lat;
    ms++;
}
void EXTI0_IRQHandler(void)              /* priority 2 */
{
    EXTI->PR = 1u;                        /* আগে acknowledge */
    if (mode == 1u) {                     /* D: শুধু queue-তে রাখা */
        uint32_t h = q_head;
        if (h - q_tail < 8u) { q_buf[h & 7u] = ms; q_head = h + 1u; }
        else q_drop++;
    } else {
        total = daily_total();            /* C, E: ৪০০টি বিক্রির দাম যোগ */
    }
}
/* B পর্বে main: */
    __disable_irq();
    for (uint32_t i = 0; i < 64u; i++) snap[i] = log_a[i];
    __enable_irq();
সত্যিকারের run — board.py run build/latency.elf --script latency.json
[   100.1339 ms] UART: A idle       systick_latency=7..7 exti_isr_max=0 events=0
[   200.1422 ms] UART: B cpsid 64w  systick_latency=4..151 exti_isr_max=0 events=0
[   300.1476 ms] UART: C work@ISR   systick_latency=7..2063 exti_isr_max=2600 events=5
[   400.1360 ms] UART: D deferred   systick_latency=4..7 exti_isr_max=33 events=5
[   500.1408 ms] UART: E prio 1/2   systick_latency=4..7 exti_isr_max=2621 events=5
[   500.1601 ms] UART: queue drops=0
[   500.1609 ms] exit(0) after 4001284 cycles

পড়ার নিয়ম: 4 মানে “একটুও দেরি নেই”, কারণ ISR নিজে VAL পড়ার আগে চারটি নির্দেশ চালায়। A পর্বে main ঘুমিয়ে, তবু 7: ঘুমের কৌশল (অংশ ৪) interrupt বন্ধ রেখে WFI করে, তাই জেগে cpsie পর্যন্ত আরও তিনটি নির্দেশ। B-তে 64 word কপির critical section latency 151 পর্যন্ত টেনেছে। C-তে সবচেয়ে খারাপ: EXTI0-র ২৬০০ cycle-এর হিসাব চলার সময় SysTick এলে, সমান priority বলে সে অপেক্ষা করেছে, সর্বোচ্চ 2063 cycle. সেই একই হিসাব D-তে main-এ সরাতেই latency 4–7, আর EXTI0-র ISR মাত্র 33 cycle. E-তে কাজ আবার ISR-এ, কিন্তু SysTick-এর priority 1: সে EXTI0-র ভেতরেই ঢুকে পড়ে, তাই latency 4–7 (আর EXTI0-র মাপে SysTick-এর সময় যোগ হয়ে 2621).

ছবি ৪৩.১ — একই বোতাম, একই হিসাব: কাজ ISR-এ বনাম main-এ

latency.elf-এর সত্যিকারের run; সময় ms-এ, C পর্বের প্রথম চাপ (210.95 ms) আর D পর্বের প্রথম চাপ (310.95 ms)

কাজ ISR-এ বনাম main-এ, SysTick-এর latency ক) কাজ ISR-এ (C পর্ব) খ) কাজ main-এ (D পর্ব) SysTickEXTI0main SysTickEXTI0main 2622 cycle pending WFI 210.95 211.06 211.28 লাল দাগে underflow; SysTick ঢোকে 1740 cycle (217.5 µs) পরে 55 cycle, queue দেরি 0 daily_total 310.95 311.06 311.29 main-এর কাজ SysTick-এর জন্য থামে, SysTick main-এর জন্য নয়
ছবি ৪৩.১ — সময় আর cycle আমার lab-এর trace_lat.py আর trace_defer.py থেকে, যা board-এর exception-এ ঢোকা-ফেরার মুহূর্ত লেখে। নীল দাগ SysTick handler (২১ cycle), হলুদ EXTI0, সবুজ main, লাল দাগ SysTick-এর underflow.
Board-এর অবস্থা
সময় (cycle)
CPU চালাচ্ছে
SysTick
দেরি জমছে
  1. বোতামের edge, cycle 1687600. Script বোতাম চাপল; EXTI-র PR-এ বিট বসল। CPU তখন WFI-এ ঘুমিয়ে, PRIMASK = 1 রেখে (অংশ ৪-এর ঘুমের কৌশল).
  2. EXTI0 ঢুকল, ৩ cycle পরে। CPU জেগে cpsie পর্যন্ত তিনটি নির্দেশ চালাল, তারপর priority 2-এর EXTI0. SysTick-এর VAL = 882: পরের underflow 882 cycle পরে।
  3. SysTick-এর সময় হলো, cycle 1688485. Counter শূন্যে, SysTick pending. কিন্তু তারও priority 2, আর সমান priority কখনো preempt করে না: সে অপেক্ষার সারিতে।
  4. EXTI0 শেষ, SysTick ঢুকল। ২৬২২ cycle পরে EXTI0 ফিরল, আর SysTick tail-chain হয়ে সঙ্গে সঙ্গে ঢুকল। VAL = 6260, অর্থাৎ underflow-এর 8000 − 6260 = 1740 cycle পরে, 8 MHz-এ 217.5 µs.
  5. ISR নিজের দেরি লিখল। চারটি নির্দেশ পরে VAL পড়ে: lat = 1744, যা 1740 + 4. Board-এর মাপ আর হাতের হিসাব মিলেছে।
  6. পাঁচ চাপের ফল। প্রতিটি চাপ tick-এর আলাদা দূরত্বে পড়েছে, তাই দেরি আলাদা: 1744, 1343, 543, 1903 আর 2063; চাপ ছাড়া tick-গুলোতে 7. Jitter = 2063 − 7 = 2056 cycle ≈ 257 µs. খেয়াল করুন, পরের tick পিছিয়ে যায়নি: SysTick hardware নিজের তালে গোনে, শুধু handler দেরি করে।

একটি সূক্ষ্ম কথা: পরীক্ষায় দেখা সর্বোচ্চ 2063 cycle আসল worst case নয়। Tick যদি EXTI0 ঢোকার ঠিক পরের cycle-এ আসত, অপেক্ষা হতো প্রায় পুরো ২৬২২ cycle. পাঁচটি চাপ সেই মুহূর্ত ধরতে পারেনি, আর মাঠে লক্ষ চাপেও হয়তো পারবে না, যতক্ষণ না একদিন পারে। তাই worst case হিসাব করে বের করতে হয় (অংশ ৬), পরীক্ষা শুধু হিসাব যাচাই করে।

৪ · Deferred work — flag, queue আর main loop

D পর্বের নকশার নাম deferred interrupt handling: ISR জরুরি অংশটুকু করে খবর রেখে যায়, আর বাকি কাজ পরে, interrupt চালু রেখে, অন্য কেউ করে। Linux-এর ভাষায় প্রথম ভাগ top half, পরের ভাগ bottom half (Operating Systems পর্ব ৩৯). RTOS ছাড়া firmware-এ bottom half হলো main-এর super loop; RTOS-এ একটি task, যার কথা পর্ব ৫৬ আর ৫৮-এ।

খবর রাখার তিনটি মাপ। একটি flag (volatile uint32_t): “কিছু হয়েছে”, কতবার তা জানা যায় না; main ধরার আগে দুবার ঘটলে একটি হারায়। একটি counter: কতবার হয়েছে জানা যায়, কিন্তু প্রতিবারের data নয়। একটি queue: প্রতিটি ঘটনা তার data-সহ, ক্রমে। ISR থেকে main-এ queue-র সবচেয়ে প্রচলিত রূপ ring buffer, একজন লেখক আর একজন পাঠকের; এর data structure-এর দিক DSA পর্ব ১৪-এ। নিয়ম তিনটি:

  • ISR শুধু head বদলায়, main শুধু tail. দুজনের কেউ অন্যের index লেখে না, তাই ++-এর race নেই।
  • ISR আগে data লেখে, তারপর head; main আগে data পড়ে, তারপর tail. দুটিই volatile, তাই compiler এই ক্রম রাখে; বহু-core বা DMA থাকলে barrier-ও লাগে (পর্ব ৩৪).
  • ভরা হলে কী হবে, আগে থেকে ঠিক করা: নতুনটি ফেলে দেওয়া আর q_drop গোনা (এখানে), নাকি পুরোনোটি মুছে ফেলা। নীরবে হারানো চলবে না।
ISREXTI->PR = 1u;ISRq_buf[h & 7] = ms;ISRq_head = h + 1;maint = q_buf[q_tail & 7];mainq_tail = q_tail + 1;maintotal = daily_total();maincpsid; WFI; cpsie
ধাপের পরে
সময়
কে চলছে
q_head · q_tail
q_buf[0]
SysTick-এর দেরি
  1. EXTI0 ঢুকল, cycle 2487603. প্রথম কাজ PR-এ 1 লিখে উৎস মোছা, তারপর events++.
  2. Data আগে, head পরে। ৪০ cycle পরে q_buf[0]-এ ঘটনার সময় 310 (ms) লেখা হলো, তারপর q_head = 1. main এখন একটি নতুন ঘটনা দেখতে পাবে, আর তার data আগেই তৈরি।
  3. ISR শেষ, মোট ৫৫ cycle. C পর্বের ২৬২২ cycle-এর তুলনায় প্রায় ৪৮ ভাগের এক ভাগ। কোনো হিসাব হয়নি, শুধু খবর রাখা।
  4. main তুলে নিল। q_tail != q_head, তাই main q_buf[0] পড়ে q_tail = 1 করল আর ৪০০টি বিক্রির হিসাব শুরু করল, এবার interrupt চালু রেখে।
  5. SysTick ঠিক সময়ে। 311.0606 ms-এ underflow, আর SysTick সেই cycle-এই main-কে থামিয়ে ঢুকল (VAL = 0, দেরি 0). ২১ cycle পরে ফিরে গেল, main যেখানে ছিল সেখান থেকে চলল।
  6. কাজ শেষ, ঘুম। 311.2860 ms-এ হিসাব শেষ। Queue খালি, তাই main interrupt বন্ধ করে আবার দেখে, তারপর WFI. মোট কাজ একই, শুধু ক্রমে বদল: জরুরি tick আর অপেক্ষা করে না।

ঘুমানোর আগে হারানো জাগরণ

main-এর loop-এর শেষে একটি ফাঁদ আছে। সরল রূপ: “queue খালি? তাহলে __WFI().” কিন্তু খালি দেখার পরে আর WFI-এর আগে যদি ISR একটি ঘটনা রাখে? main ঘুমিয়ে পড়বে, আর সেই ঘটনা পড়ে থাকবে পরের কোনো interrupt পর্যন্ত (এখানে পরের tick, 1 ms; tick না থাকলে চিরকাল)। সমাধান latency.c-তে যা আছে:

__disable_irq();
if (q_tail == q_head) __WFI();   /* খালি থাকলেই ঘুম */
__enable_irq();                  /* pending ISR এখানে ঢোকে */

PRIMASK = 1 থাকলেও WFI pending interrupt-এ জেগে ওঠে, শুধু handler-এ ঢোকে না; ঢোকে cpsie-র পরে। ARMv7-M-এর এই আচরণ board-ও মানে (Spec decision 21: জাগে যদি এমন কেউ pending থাকে যে PRIMASK বাদ দিলে preempt করতে পারত). তাই খালি দেখা আর ঘুমানোর মাঝে কোনো ফাঁক থাকে না। দাম তিনটি নির্দেশ, যা A পর্বের 7-এ দেখেছেন।

Queue কত বড় হবে? ধরুন scale UART-এ কমান্ড পায়, 115200 baud-এ প্রতি byte 86.8 µs (১০ বিট ÷ 115200). main যদি 1 ms একটানা অন্য কাজে থাকে, ততক্ষণে ১১টি byte আসে। নিচের মডেল দুই মাপের buffer চালায়; index দুটি ইচ্ছা করে 232-এর ঠিক আগে থেকে শুরু, যাতে wrap-ও পরীক্ষা হয়:

# ISR → main ring buffer: একজন লেখক, একজন পাঠক; head শুধু ISR, tail শুধু main
M = 0xFFFFFFFF                                 # index দুটি free-running uint32

class Ring:
    def __init__(self, size, start=0):
        self.size, self.buf = size, [None] * size
        self.head = self.tail = start
        self.drops = 0
    def put(self, x):                          # ISR-এর দিক
        if (self.head - self.tail) & M == self.size:
            self.drops += 1                    # ভরা: নতুনটি ফেলে গুনে রাখা
            return
        self.buf[self.head % self.size] = x    # আগে data
        self.head = (self.head + 1) & M        # পরে head
    def get(self):                             # main-এর দিক
        if self.tail == self.head:
            return None
        x = self.buf[self.tail % self.size]
        self.tail = (self.tail + 1) & M
        return x

# প্রতি 86.8 us-এ একটি byte; main 1 ms একটানা ব্যস্ত, তারপর পড়ে
msg = b"TARE\nRATE 6550\n"
for size in (8, 16):
    r = Ring(size, start=0xFFFFFFFC)           # wrap-এর ৪ ঘর আগে
    t, got = 0.0, bytearray()
    for b in msg:
        r.put(b)
        t += 86.8
        if t >= 1000:
            while (x := r.get()) is not None:
                got.append(x)
    while (x := r.get()) is not None:
        got.append(x)
    print(f"SIZE={size:2}: head=0x{r.head:08X} drops={r.drops} got={bytes(got)!r}")

আসল আউটপুট (ব্রাউজারের Python):

SIZE= 8: head=0x00000007 drops=4 got=b'TARE\nRAT50\n'
SIZE=16: head=0x0000000B drops=0 got=b'TARE\nRATE 6550\n'

৮ ঘরের buffer-এ চারটি byte হারিয়েছে, আর “RATE 6550” হয়ে গেছে “RAT50”: parser এটি অচেনা কমান্ড বলে ফেলে দেবে, অথবা খারাপ parser হলে ভুল দর বসাবে। ১৬ ঘরে সব ঠিক। দুই ক্ষেত্রেই head 0xFFFFFFFC থেকে 0-র ওপারে গিয়ে 7 আর 0xB হয়েছে, তবু ভরা-খালির হিসাব ঠিক, কারণ head − tail unsigned বিয়োগ, আর মাপ ২-এর ঘাত বলে % size wrap-এর দুই পাশে একই ঘর দেয়। মাপ বাছাইয়ের নিয়ম: সবচেয়ে লম্বা ব্যস্ততা × সবচেয়ে দ্রুত আগমন, তার ওপরে নিরাপত্তার জায়গা, আর drops সবসময় গোনা।

৫ · Reentrancy — দুজনে একই function ডাকলে

ISR যে function ডাকে, main-ও যদি সেটি ডাকে, তাহলে main-এর ডাক মাঝপথে থাকা অবস্থায় ISR-এর ডাক শুরু হতে পারে। যে function এমন অবস্থাতেও ঠিক কাজ করে, তাকে বলে reentrant. শর্ত মোটামুটি: নিজের static বা global অবস্থা বদলায় না, সব কাজ argument আর stack-এর local variable-এ, আর যে function ডাকে সেগুলোও reentrant. ফাঁদটি সাধারণত লুকিয়ে থাকে “সুবিধার” static buffer-এ। বাজারঘরের দাম ছাপার একটি function দিয়ে দেখা যাক; ISR-কে নকল করা হয়েছে একটি hook দিয়ে, যা ঠিক মাঝপথে একবার ডাকা হয়, তাই ফল প্রতিবার একই:

#include <stdio.h>
#include <stdint.h>
static void (*irq)(void);          /* নকল interrupt: মাঝপথে একবার আসে */

/* paisa -> "81.88"; ফল লেখে ডাকনেওয়ালার buf-এ */
static const char *fmt_r(uint32_t paisa, char buf[16])
{
    int i = 15;
    buf[i] = '\0';
    buf[--i] = (char)('0' + paisa % 10); paisa /= 10;
    buf[--i] = (char)('0' + paisa % 10); paisa /= 10;
    buf[--i] = '.';
    if (irq) { void (*h)(void) = irq; irq = 0; h(); }   /* ISR এখানে ঢুকল */
    do { buf[--i] = (char)('0' + paisa % 10); paisa /= 10; } while (paisa);
    return &buf[i];
}
/* reentrant নয়: সবার জন্য একটিই static buffer */
static const char *fmt_static(uint32_t paisa)
{
    static char shared[16];
    return fmt_r(paisa, shared);
}

static void isr_a(void) { printf("  ISR : %s\n", fmt_static(983)); }
static void isr_b(void) { char b[16]; printf("  ISR : %s\n", fmt_r(983, b)); }

int main(void)
{
    char b[16];
    irq = isr_a;
    printf("  main: %s  (static buffer)\n", fmt_static(8188));
    irq = isr_b;
    printf("  main: %s  (caller buffer)\n", fmt_r(8188, b));
    return 0;
}

আসল আউটপুট (Wandbox-এর C compiler):

  ISR : 9.83
  main: 81.83  (static buffer)
  ISR : 9.83
  main: 81.88  (caller buffer)

main 8188 paisa থেকে “.88” লিখে ফেলেছিল, তখন ISR একই shared buffer-এ “9.83” লিখল, শেষ দুই ঘর “.83” দিয়ে মুছে। main ফিরে বাকি “81” বসাল, ফল 81.83 টাকা: খদ্দের ৫ paisa কম দিলেন, আর কেউ টের পেল না। নিজের buffer-এর রূপ একই কোড, শুধু জায়গা ডাকনেওয়ালার stack-এ, তাই দুই ডাক একে অপরকে ছোঁয় না। C library-র অনেক function এই কারণে ISR-এ নিরাপদ নয়: strtok (ভেতরে static pointer), printf-পরিবারের অনেক বাস্তবায়ন, malloc (heap-এর ভাগ করা তালিকা). POSIX-এর জগতে signal handler থেকে কোন function ডাকা যায়, তার তালিকার নাম async-signal-safe; firmware-এ নিজের তালিকা নিজেকে বানাতে হয়।

Reentrancy আর অবিভাজ্যতা আলাদা প্রশ্ন। fmt_r reentrant, কিন্তু সে যদি একটি ভাগ করা global জোড়া পড়ত, তাহলে অংশ ২-এর ছেঁড়া পড়ার ঝুঁকি তবু থাকত। আবার critical section দিয়ে ঘেরা function reentrant নয়, শুধু “ঢুকতে না দেওয়া”; সেখানে আরেকটি ফাঁদ: ভেতরের function যদি নিজে __enable_irq() ডাকে, বাইরের critical section সময়ের আগেই খুলে যায় (অনুশীলন ২).

৬ · বাজারঘরের device-এর priority আর latency budget

Cortex-M-এ priority-র সংখ্যা যত কম, তত জরুরি; board-এ ব্যবহার হয় priority byte-এর ওপরের ৪টি বিট (Spec decision 19), আর সমান priority কখনো preempt করে না। যন্ত্রের নিয়ম পর্ব ৩০-এ; এখানে প্রশ্ন, কাকে কোন সংখ্যা দেবেন। প্রচলিত যুক্তির নাম deadline-monotonic: যার deadline যত ছোট, তার priority তত বেশি। “গুরুত্বপূর্ণ” কাজকে উঁচু priority দেওয়ার প্রবৃত্তি প্রায়ই ভুল: alarm সবচেয়ে গুরুত্বপূর্ণ, কিন্তু তার deadline সেকেন্ডে; UART-এর byte কম গুরুত্বপূর্ণ, কিন্তু deadline মাইক্রোসেকেন্ডে।

উৎসকী ঘটেDeadlinePriority
UART RX (IRQ1)কমান্ডের একটি byte; RX FIFO-হীন chip-এ পরের byte আগেরটি মুছে দেয় (overrun)86.8 µs (115200 baud)1
SysTick (15)1 ms tick (scale) বা 10 ms tick (cold room); সময়, debounce-এর sampleপরের tick-এর আগে2
EXTI0 বোতাম (IRQ0)Tare; মানুষের হাত, দশ ms-এর ব্যাপারদশ ms3
main / bottom halfADC গড়, দাম, I2C তাপমাত্রা, alarm, telemetry100 ms (মাপ), 1 s (তাপমাত্রা)সবার নিচে

Worst case হিসাবের সূত্রটি real-time তত্ত্বের response-time analysis, যার পূর্ণ রূপ Operating Systems পর্ব ২০-এ। ISR i-এর জন্য, যার নিজের সময় Ci:

Ri = E + Bi + Ci + Σj উঁচু ⌈Ri ÷ Tj⌉ × (Cj + E)

E প্রবেশের খরচ, Bi সবচেয়ে বড় বাধা (দীর্ঘতম critical section, অথবা সমান priority-র দীর্ঘতম ISR), Tj বেশি জরুরি ISR j-এর দুই আগমনের ন্যূনতম ব্যবধান। নিচের ব্লকে C-গুলো board-এ মাপা: UART-এর এক byte-এর ISR ২৯ cycle (আমার lab-এ reference-এর uart_hello.c কপি করে মাপা), SysTick ২১, ভারী EXTI0 ২৬২২, হালকা ৫৫; দীর্ঘতম critical section 147 (B পর্বের 151 − 4). E = 12 ধরা হলো আসল Cortex-M3-এর মতো; বাকি সংখ্যা board-এর, আসল chip-এর নয় (Spec decision 17), তাই এটি পদ্ধতির উদাহরণ:

# ISR-এর worst-case response: R = E + B + C + Σ ceil(R/Tj)·(Cj + E), উঁচু priority-র j-এর ওপর
# সংখ্যাগুলো cycle-এ (8 MHz); C-গুলো virtual board-এ মাপা, E = আসল M3-এর প্রবেশ (ধরা)
from math import ceil
E, CRIT = 12, 147               # প্রবেশ খরচ; main-এর দীর্ঘতম cpsid অংশ

def analyse(name, isrs):
    print(name)
    for i in isrs:
        pr, c = i["prio"], i["C"]
        # একই priority-র অন্য কেউ চলতে থাকলে তার শেষ পর্যন্ত অপেক্ষা
        same = [j["C"] for j in isrs if j is not i and j["prio"] == pr]
        b = max([CRIT] + same)
        higher = [j for j in isrs if j["prio"] < pr]
        r = E + b + c
        while True:
            nr = E + b + c + sum(ceil(r / j["T"]) * (j["C"] + E) for j in higher)
            if nr == r or nr > 10 * i["D"]:
                break
            r = nr
        ok = "OK  " if r <= i["D"] else "MISS"
        print(f"  {i['n']:8} prio {pr}  B={b:4}  R={r:5} cycles = {r/8:7.1f} us"
              f"  D={i['D']/8:7.1f} us  {ok}")

uart = dict(n="UART RX", C=29, T=694, D=694)        # 115200 baud: 86.8 us প্রতি byte
tick = dict(n="SysTick", C=21, T=8000, D=8000)      # 1 ms
heavy = dict(n="EXTI0", C=2622, T=160000, D=400000) # ISR-এই ভারী কাজ
light = dict(n="EXTI0", C=55, T=160000, D=400000)   # শুধু queue-তে রাখে

analyse("A: সবাই priority 2, EXTI0-তে ভারী কাজ",
        [dict(uart, prio=2), dict(tick, prio=2), dict(heavy, prio=2)])
analyse("B: UART 1, SysTick 2, EXTI0 3, কাজ main-এ",
        [dict(uart, prio=1), dict(tick, prio=2), dict(light, prio=3)])

আসল আউটপুট (ব্রাউজারের Python):

A: সবাই priority 2, EXTI0-তে ভারী কাজ
  UART RX  prio 2  B=2622  R= 2663 cycles =   332.9 us  D=   86.8 us  MISS
  SysTick  prio 2  B=2622  R= 2655 cycles =   331.9 us  D= 1000.0 us  OK
  EXTI0    prio 2  B= 147  R= 2781 cycles =   347.6 us  D=50000.0 us  OK
B: UART 1, SysTick 2, EXTI0 3, কাজ main-এ
  UART RX  prio 1  B= 147  R=  188 cycles =    23.5 us  D=   86.8 us  OK
  SysTick  prio 2  B= 147  R=  221 cycles =    27.6 us  D= 1000.0 us  OK
  EXTI0    prio 3  B= 147  R=  288 cycles =    36.0 us  D=50000.0 us  OK

নকশা A-তে SysTick-এর latency-র সীমা E + B = 12 + 2622 = 2634 cycle; board-এ C পর্বে দেখা সর্বোচ্চ 2063 এর নিচে, যেমন হওয়া উচিত (board-এ E = 0, তাই আসল সীমা 2622 + 4). আসল বিপদ UART-এর: ভারী EXTI0 চলার সময় byte এলে 333 µs অপেক্ষা, অথচ 86.8 µs পরেই পরের byte; FIFO-হীন chip-এ নিশ্চিত overrun. নকশা B-তে তিনজনই সীমার অনেক ভেতরে। লক্ষ্য করুন, B-তে দুটি জিনিস একসাথে বদলেছে: priority আর কাজের জায়গা। শুধু priority বদলালে (UART 1, ভারী EXTI0 3) UART বাঁচত, কিন্তু ২৬২২ cycle main থেমে থাকত, আর priority 3-এর অন্য কোনো ISR এলে সেও অপেক্ষা করত।

Cold-storage monitor-এ একই যুক্তি: README-র নকশায় SysTick 10 ms (LOAD = 79 999), তাপমাত্রা প্রতি 1 s, alarm-এর জন্য পরপর ৩টি reading; এর কোনোটিই মাইক্রোসেকেন্ডের deadline নয়। তাই সেখানে I2C-র পড়া, hysteresis আর telemetry সবই main-এ, আর interrupt শুধু tick আর UART-এর। আরেকটি নিয়ম মনে রাখুন: priority-র স্তর হাতে গোনা (board-এ ১৬টি, অনেক chip-এ কম), তাই প্রতিটি ISR-কে আলাদা স্তর না দিয়ে deadline-এর দলে ভাগ করুন, আর কয়েকটি স্তর ফাঁকা রাখুন পরে নতুন উৎসের জন্য।

আরও গভীরে: PRIMASK সব configurable interrupt একসাথে বন্ধ করে, তাই প্রতিটি critical section সবচেয়ে জরুরি ISR-এরও latency বাড়ায়। ARMv7-M (Cortex-M3/M4)-এ BASEPRI register একটি সীমা দেয়: শুধু সেই সংখ্যা বা তার চেয়ে কম জরুরি interrupt আটকায়, বেশি জরুরিরা চলতে থাকে। FreeRTOS-এর Cortex-M3/M4 port এভাবেই critical section বানায়: configMAX_SYSCALL_INTERRUPT_PRIORITY-এর চেয়ে জরুরি interrupt কখনো বন্ধ হয় না, কিন্তু সেগুলো RTOS-এর কোনো API ডাকতে পারে না। ARMv6-M (Cortex-M0/M0+)-এ BASEPRI নেই। কোর্সের board BASEPRI মডেল করে না (Spec decision 19), তাই এখানে শুধু PRIMASK.

পরীক্ষা ও ইন্টারভিউতে: “ISR-এ printf কেন নয়?” → ধীর, প্রায়ই blocking, আর ভেতরে ভাগ করা অবস্থা থাকে, তাই reentrant নয়। “Interrupt latency কী দিয়ে গঠিত?” → hardware প্রবেশ + দীর্ঘতম interrupt-বন্ধ সময় + চলমান সমান বা বেশি জরুরি ISR + বেশি জরুরিদের বাধা। “৮ বিটের MCU-তে ৩২ বিটের counter পড়ার সমস্যা?” → চারটি load-এর মাঝে ISR এলে ছেঁড়া মান; critical section বা দুবার পড়ে মেলানো। “ISR থেকে main-এ data পাঠানোর নিরাপদ পথ?” → এক লেখক এক পাঠকের ring buffer: ISR শুধু head, main শুধু tail. “Cortex-M-এ priority 1 আর 3, কে জেতে?” → 1, কম সংখ্যা বেশি জরুরি।

৭ · AI-এর যুগে ISR নকশা যাচাই

AI assistant একটি ISR চাইলে প্রায়ই চলনসই কোড দেয়, যা বেঞ্চে কাজ করে, কারণ race আর worst-case latency সাধারণ পরীক্ষায় ধরা পড়ে না। পরিচিত ভুলগুলো আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
ISR-এর ভেতরে printf, delay, বা peripheral-এর flag-এর জন্য ঘোরাISR-এর প্রতিটি loop-এর শেষ হওয়ার শর্ত আর সর্বোচ্চ cycle হিসাব; board-এ ISR-এর সময় মাপা
বহু-word data বা AVR-এ ৩২ বিট সুরক্ষা ছাড়া পড়ে-S output-এ load-এর সংখ্যা গোনা; এই পর্বের torn.c-এর মতো জোড়া মেলানো পরীক্ষা
“volatile দিলেই ISR-safe” বলেপর্ব ৩৪-এর lost-update আর এখানকার ছেঁড়া পড়া, দুটিই volatile-সহ ঘটেছে
Priority-র সংখ্যার দিক উল্টো ধরে (বড় সংখ্যা = জরুরি)Cortex-M-এ কম সংখ্যা জেতে; RTOS-এর task priority-র নিয়ম আলাদা (পর্ব ৩০)
Nested critical section-এ ভেতরে __enable_irq()PRIMASK আগে সংরক্ষণ করে পরে ফেরানো; প্রতিটি cpsie খুঁজে দেখা
Latency বা cycle-এর সংখ্যা উৎস ছাড়া দেয়Chip-এর TRM আর datasheet; নিজের হিসাব; board-এর cycle আসল chip-এর নয়

প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:

আমি Cortex-M3-এ bare-metal C লিখছি (Clang -O2, RTOS নেই, একক core). একটি UART RX ISR আর main-এর মধ্যে কমান্ডের byte পাঠাতে চাই। ১. এক লেখক এক পাঠকের ring buffer লেখো: ISR শুধু head, main শুধু tail বদলাবে। কোন variable-এ volatile লাগবে, আর data ও index লেখার ক্রম কেন জরুরি, বলো। ২. Buffer ভরা হলে কী হবে, আর হারানো byte কীভাবে গুনবে, দেখাও। ৩. ISR-এ কোনো printf, delay বা অপেক্ষা রাখবে না। ISR-এর সর্বোচ্চ নির্দেশ-সংখ্যা মোটামুটি কত, অনুমান করো আর বলো কীভাবে মাপব। ৪. main-এর ঘুমানোর কোডে "খালি দেখা" আর WFI-এর মাঝের ফাঁক কীভাবে বন্ধ করবে? ৫. কোনো cycle সংখ্যা বা register-এর নাম দিলে উৎস বলো; নিশ্চিত না হলে সেটি স্পষ্ট করে বলো।

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১Linux kernel interrupt-এর কাজ “top half” আর “bottom half”-এ ভাগ করে। একটি ছোট microcontroller-এর firmware-এ এই ভাগ কতটা দরকার, আর কেন?

Linux-এর ভাগের পেছনে বাস্তব চাপ ছিল। একটি network card-এ প্রতি সেকেন্ডে হাজার হাজার packet আসে; প্রতিটির পুরো প্রক্রিয়া (checksum, protocol, socket-এ পাঠানো) interrupt handler-এ করলে সেই সময় অন্য interrupt আটকে থাকত, আর একই CPU-র বাকি সব কাজ থেমে যেত। তাই handler শুধু card-কে acknowledge করে, packet-টি একটি তালিকায় রাখে, আর পরের কাজের সূচনা করে। সেই পরের কাজের জন্য kernel বছরের পর বছর কয়েকটি ব্যবস্থা এনেছে: softirq, tasklet, workqueue, আর ২০০৯ সালের দিকে (kernel 2.6.30) threaded interrupt handler, যেখানে bottom half একটি সাধারণ kernel thread হিসেবে scheduler-এর অধীনে চলে। প্রতিটি ধাপের লক্ষ্য একই: interrupt বন্ধ থাকার সময় যত সম্ভব কমানো।

এই পর্বের D পর্ব একই নীতির সবচেয়ে ছোট রূপ। EXTI0-র ISR ৫৫ cycle-এ শুধু ঘটনার সময় queue-তে রাখে; ৪০০টি বিক্রির হিসাব main করে, যখন SysTick চাইলেই ঢুকতে পারে। ফল মাপা গেছে: SysTick-এর সর্বোচ্চ দেরি 2063 থেকে নেমে 7 cycle. RTOS থাকলে bottom half হবে একটি task, যাকে ISR একটি semaphore বা queue দিয়ে জাগায় (পর্ব ৫৭, ৫৮); FreeRTOS-এ এর জন্য “FromISR” নামের আলাদা API আছে, কারণ ISR থেকে সাধারণ blocking API ডাকা চলে না।

তাহলে কি সবসময় ভাগ করা উচিত? না। ভাগের নিজের খরচ আছে: queue-র মেমরি, ভরা হলে কী হবে তার নিয়ম, আর ঘটনা থেকে কাজ শেষ হওয়া পর্যন্ত বাড়তি সময় (D পর্বে হিসাব শেষ হয়েছে চাপের প্রায় 0.34 ms পরে, C-তে 0.33 ms; সামান্য বেশি, কারণ SysTick মাঝে ঢুকেছে)। যে কাজ কয়েক ডজন নির্দেশের, যেমন একটি byte buffer-এ রাখা বা একটি counter বাড়ানো, তা ISR-এই থাকে। নিয়মটি তাই সংখ্যায় ভাবা: ISR-এর worst-case সময় × তার কারণে যারা অপেক্ষা করে, তাদের deadline-এর সঙ্গে মিলিয়ে দেখা।

মূল উপলব্ধি: Top half আর bottom half-এর ভাগ যেকোনো আকারের system-এর নীতি: জরুরি অংশ interrupt-এ, ভারী অংশ এমন জায়গায় যেখানে অন্যরা তাকে থামাতে পারে। কতটা ভাগ, তা ঠিক করে deadline আর মাপা সময়।

প্র ০২Therac-25 দুর্ঘটনাগুলোকে প্রায়ই race condition-এর সবচেয়ে মর্মান্তিক উদাহরণ বলা হয়। এমন bug পরীক্ষায় ধরা পড়ে না কেন, আর firmware লেখক কী শিখবেন?

Therac-25 ছিল একটি radiation therapy যন্ত্র; ১৯৮৫ থেকে ১৯৮৭ সালের মধ্যে এতে ছয়টি ঘটনায় রোগীরা অত্যধিক মাত্রার বিকিরণ পান, কয়েকজন মারা যান। Nancy Leveson আর Clark Turner ১৯৯৩ সালে IEEE Computer-এ এর বিস্তারিত বিশ্লেষণ প্রকাশ করেন। মূল কারণগুলোর একটি ছিল একসঙ্গে চলা কাজের মধ্যে ভাগ করা data-র race condition: অভিজ্ঞ অপারেটর খুব দ্রুত চিকিৎসার তথ্য সম্পাদনা করলে, একটি কাজ পুরোনো মান দিয়ে যন্ত্র সাজিয়ে ফেলত, অথচ পর্দায় নতুন মান দেখাত। আগের মডেলে hardware interlock এই ভুল আটকাত, Therac-25-এ সেই দায়িত্ব software-এর ওপর ছিল। বিশ্লেষণে শুধু একটি bug নয়, পুরো প্রক্রিয়ার দুর্বলতা দেখানো হয়েছে: অপর্যাপ্ত পরীক্ষা, অস্পষ্ট ত্রুটি-বার্তা আর প্রথম ঘটনাগুলোর পরেও কারণ খুঁজে না পাওয়া।

এমন bug পরীক্ষায় কেন লুকায়, তা এই পর্বের সংখ্যায় দেখুন। torn.c-তে প্রায় ২৭৪টি update-এর মধ্যে মাত্র ৬টি জোড়া ছিঁড়েছে, তাও শুধু তখন, যখন tick দুটি নির্দিষ্ট ldr-এর মাঝখানে পড়েছে। একটি manual পরীক্ষায় scale-এ কয়েকবার ওজন রেখে দাম দেখলে প্রায় নিশ্চিতভাবে সব ঠিক আসবে। Therac-25-এ ভুলটি ঘটত শুধু খুব দ্রুত হাতের অপারেটরের ক্ষেত্রে, যা পরীক্ষকেরা সম্ভবত কখনো করেননি। Race-এর সংজ্ঞাই এমন: ফল নির্ভর করে সময়ের ওপর, আর সময় পরীক্ষায় নিয়ন্ত্রিত থাকে, মাঠে থাকে না।

তাই শিক্ষা দুটি। এক, ভাগ করা data নকশার সময়েই চিহ্নিত করুন: কে লেখে, কে পড়ে, কয়টি নির্দেশে, আর কী দিয়ে সুরক্ষিত। এটি একটি কাগজের তালিকা, যা review-তে যাচাই করা যায়। দুই, পরীক্ষাকে race খোঁজার জন্য সাজান: interrupt-এর হার ইচ্ছা করে বাড়ান (torn.c-তে tick 125 µs করা হয়েছিল ঠিক এ কারণেই), deterministic simulator-এ প্রতিটি নির্দেশের সীমায় interrupt ঢুকিয়ে দেখুন, আর data-র সামঞ্জস্য (ওজন আর দাম মেলে কি না) নিজে যাচাই করুন। চিকিৎসা বা গাড়ির মতো জায়গায় safety standard এই ধরনের বিশ্লেষণ বাধ্যতামূলক করে (পর্ব ৬৩)।

মূল উপলব্ধি: Race condition সময়ের bug, আর সাধারণ পরীক্ষা সময় নিয়ন্ত্রণ করে না; নকশায় ভাগ করা data-র তালিকা আর race-খোঁজা পরীক্ষাই একমাত্র ভরসা।

প্র ০৩“৪৯.৭ দিন পরে যন্ত্র আটকে যায়” — এমন bug কীভাবে জন্মায়? Counter-এর মাপ, wrap আর ছেঁড়া পড়া একসাথে ভাবুন।

232 ms = 4 294 967 296 ms ≈ ৪৯.৭ দিন। একটি ৩২ বিটের ms counter এই সময় পরে 0-তে ফেরে। Microsoft-এর একটি পরিচিত support নিবন্ধ (১৯৯৯) Windows 95 আর 98-এর একটি সমস্যা বর্ণনা করে, যেখানে কম্পিউটার টানা ৪৯.৭ দিন চললে আটকে যেতে পারত, কারণ সময়ের একটি ৩২ বিটের counter উপচে পড়ত। Windows সাধারণত এত দিন বন্ধ ছাড়া চলত না, তাই সমস্যাটি অনেক দিন অজানা ছিল। এমবেডেড যন্ত্রের ক্ষেত্রে ঝুঁকি বেশি, কারণ সেগুলো মাসের পর মাস চলে। প্রকাশিত প্রতিবেদন অনুযায়ী ২০১৫ সালে মার্কিন FAA একটি নির্দেশনা জারি করে, কারণ Boeing 787-এর generator control unit টানা ২৪৮ দিন চালু থাকলে একটি software counter উপচে পড়ে নিরাপদ অবস্থায় চলে যেতে পারত; প্রতিবেদনগুলোর ব্যাখ্যায় ২৪৮ দিন একটি signed ৩২ বিটের counter-এর সীমার সঙ্গে মেলে।

Wrap নিজে bug নয়; bug হলো wrap-এর হিসাব ভুল করা। ৩২ বিটের counter-এর সঠিক ব্যবহার unsigned বিয়োগ: now − start wrap পেরোলেও ঠিক পেরোনো সময় দেয় (পর্ব ৩৪-এর অনুশীলনে board-এ দেখানো, পর্ব ৪৪-এ timer-এর সঙ্গে আবার)। ভুল আসে if (now > deadline)-এর মতো তুলনায়। অনেকে তাই ৬৪ বিটের counter নেন, যা কোটি বছরেও উপচায় না। কিন্তু এখানে এই পর্বের দ্বিতীয় সমস্যা ঢোকে: ৩২ বিটের CPU-তে ৬৪ বিটের counter দুটি word, আর ISR বাড়ায় ঠিক যখন নিচের word wrap করে, তখনই ওপরের word বদলায়। সরাসরি পড়লে tear64.py-র মতো একবার 0x1FFFFFFFF, অর্থাৎ ঘড়ি ৪৯.৭ দিন সামনে লাফ দেয়।

লক্ষ্য করুন, এই ছেঁড়া পড়া ঘটে শুধু wrap-এর মুহূর্তে, অর্থাৎ যন্ত্র চালুর প্রায় ৪৯.৭ দিন পরে, একবার। কোনো পরীক্ষাগারে এটি দেখা যায় না, যদি না পরীক্ষক counter-এর শুরুর মান ইচ্ছা করে wrap-এর কাছে বসান, যেমন এই পর্বের মডেলে 0xFFFFFFFF − 2. এটি একটি সাধারণ কৌশল: সময়, sequence number আর index-এর counter পরীক্ষায় wrap-এর কাছ থেকে শুরু করা (ring.py-ও তাই করেছে)। আর ৬৪ বিটের পড়ায় hi-lo-hi বা sequence counter, যার একটি রূপ Linux ৩২ বিটের যন্ত্রে নিজের ৬৪ বিটের tick counter পড়তে ব্যবহার করে।

মূল উপলব্ধি: ৩২ বিটের counter-এ wrap-safe বিয়োগ, ৬৪ বিটের counter-এ ছেঁড়া-নিরাপদ পড়া; আর দুটির পরীক্ষাই শুরুর মান wrap-এর কাছে বসিয়ে।

প্র ০৪Board-এ পাঁচটি চাপে দেখা সর্বোচ্চ latency 2063 cycle, অথচ হিসাবের সীমা 2634. Real-time যন্ত্রে মাপা সংখ্যা আর হিসাবের সংখ্যার মধ্যে কোনটির ওপর ভরসা করবেন?

মাপা সংখ্যা বলে “অন্তত এতটা খারাপ হতে পারে”; হিসাবের সংখ্যা বলে “এর চেয়ে খারাপ হতে পারে না”, যদি হিসাবের ধরে নেওয়া কথাগুলো সত্য হয়। Board-এর C পর্বে পাঁচটি চাপ tick-এর বিভিন্ন দূরত্বে পড়েছে: EXTI0 ঢোকার মুহূর্তে পরের tick ছিল 882, 1282, 2082, 722 আর 562 cycle দূরে (trace-এ দেখা VAL). সবচেয়ে খারাপটি সবচেয়ে কম দূরত্বের, 562 cycle, যেখানে দেরি হয়েছে 2063. চাপ যদি tick-এর এক cycle আগে পড়ত, দেরি হতো প্রায় পুরো EXTI0-র সময়, ২৬২২ cycle. মানুষের হাত সেই মুহূর্ত বেছে নেয় না, কিন্তু লক্ষ যন্ত্রে লক্ষ চাপে কোনো একদিন পড়বেই।

Safety-জরুরি শিল্পে তাই দুটি পথ একসাথে চলে। এক, পরিমাপ: GPIO pin উল্টে logic analyzer-এ দেখা, বা Cortex-M3/M4-এর DWT cycle counter দিয়ে লক্ষবার মাপা, নানা লোডে। এটি ধরা পড়া সমস্যা দেখায়, আর হিসাবের ধরে নেওয়া কথা যাচাই করে। দুই, বিশ্লেষণ: প্রতিটি ISR আর critical section-এর worst-case execution time (WCET), তারপর অংশ ৬-এর মতো response-time হিসাব। WCET নিজে বের করা কঠিন, কারণ আসল chip-এ flash-এর wait state, cache আর pipeline সময় বদলায়; এর জন্য বাণিজ্যিক static analysis tool আছে, আবার অনেকে পরিমাপের সর্বোচ্চের ওপর একটি নিরাপত্তা-গুণক বসান। কোনটি যথেষ্ট, তা ঠিক করে প্রয়োগের ঝুঁকি।

Board-এর ক্ষেত্রে আরেকটি সতর্কতা: এর cycle আসল chip-এর নয়। প্রতিটি নির্দেশ ১ cycle, প্রবেশ ০ (Spec decision 17), তাই 2063 সংখ্যাটি নকশার তুলনার জন্য, datasheet-এর দাবির জন্য নয়। কিন্তু board-এর একটি বড় সুবিধা আছে: এটি deterministic. একই firmware আর script প্রতিবার একই cycle দেয়, তাই চাপের সময় ধাপে ধাপে সরিয়ে (যেমন tick-এর 1, 2, 3 … cycle আগে) worst case খুঁজে বের করা যায়, যা আসল hardware-এ বহু কঠিন। হিসাব আর সেই খোঁজ মিললে আস্থা বাড়ে।

মূল উপলব্ধি: পরীক্ষা নিচের সীমা দেয়, বিশ্লেষণ ওপরের সীমা; real-time যন্ত্রের প্রতিশ্রুতি দাঁড়ায় বিশ্লেষণের ওপর, আর পরীক্ষা সেই বিশ্লেষণের অনুমান যাচাই করে।

প্র ০৫Interrupt না polling? বাজারঘরের scale-এর বোতাম, UART আর ADC-র জন্য কোনটি কেন, আর কখন interrupt নিজেই সমস্যা হয়ে দাঁড়ায়?

Polling মানে main নিজে নিয়মিত দেখে; interrupt মানে ঘটনা নিজে ডাকে। Interrupt-এর লাভ দুটি: ছোট latency, আর অপেক্ষার সময় CPU ঘুমাতে পারে (পর্ব ৬০-এর low-power নকশার ভিত্তি)। দাম: প্রতিটি interrupt-এ প্রবেশ-প্রস্থানের খরচ, ভাগ করা data-র সব সমস্যা (এই পর্ব), আর কতবার আসবে তার ওপর নিয়ন্ত্রণ নেই। Polling-এ ঠিক উল্টো: সরল, কোনো race নেই, প্রতি কাজের খরচ জানা, কিন্তু latency polling-এর ব্যবধানের সমান আর CPU জেগে থাকে।

বাজারঘরের scale-এ reference firmware নিজেই একটি মিশ্র নকশা দেখায়। ADC-র মাপ প্রতি 100 ms, আর board-এ রূপান্তর সঙ্গে সঙ্গে শেষ (Spec decision 25), তাই main-এ SysTick-এর সময় ধরে poll করা যথেষ্ট; interrupt-এর ঝামেলা অকারণ। বোতাম reference-এর button.c-তে দুভাবে দেখানো: EXTI0-র কাঁচা edge গুনলে একটি চাপে বহু edge (bounce), আর SysTick-এ প্রতি 1 ms-এ sample নিয়ে 8 ms-এর shift-register debounce করলে ঠিক দুটি চাপ (পর্ব ৪২-এ বিস্তারিত)। অর্থাৎ বোতামের জন্য periodic polling প্রায়ই interrupt-এর চেয়ে ভালো। UART-এ উল্টো: byte আসে 86.8 µs পরপর, আর FIFO-হীন chip-এ একটি byte হারানো মানে কমান্ড নষ্ট, তাই সেখানে interrupt (বা DMA, পর্ব ৪৬) প্রায় বাধ্যতামূলক।

Interrupt নিজে সমস্যা হয় যখন হার নিয়ন্ত্রণের বাইরে যায়, একে বলে interrupt storm. একটি ভাঙা বা noise-ভরা তার থেকে প্রতি কয়েক µs-এ edge এলে CPU-র পুরো সময় ISR-এ যায়, main আর চলে না; পর্ব ৩০-এ একটি না-মোছা pending বিটের ফলও একই রকম দেখা গেছে। প্রতিরক্ষা কয়েকটি: edge interrupt-কে প্রথম ঘটনার পরে সাময়িক বন্ধ রাখা (debounce-এর সময়), হার গুনে সীমা পেরোলে polling-এ চলে যাওয়া, আর watchdog এমন জায়গা থেকে খাওয়ানো যা ISR-এর ঝড়ে না চলে (পর্ব ৬১)। Linux-এর network driver-এর NAPI ঠিক এই নীতিতে চলে বলে বর্ণনা করা হয়: চাপ বাড়লে interrupt বন্ধ করে polling, চাপ কমলে আবার interrupt.

মূল উপলব্ধি: Interrupt দ্রুত সাড়া আর ঘুমের জন্য, polling সরলতা আর নিয়ন্ত্রিত হারের জন্য; ভালো নকশা প্রতিটি উৎসের হার আর deadline দেখে বাছে, আর ঝড়ের জন্য পথ খোলা রাখে।

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর কোর্সের virtual board-এ, Clang-এ বা Python-এ চালিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — cold room-এর telemetry record: SysTick ISR (10 ms) প্রতি 1 s-এ একটি record লেখে: temp16 (0.0625 °C-এর একক), alarm (0, 1 = HIGH, 2 = LOW) আর t_s (সেকেন্ড)। main প্রতি 10 s-এ telemetry পাঠায়। main-এর জন্য একটি read_record() লিখুন যা কখনো ছেঁড়া record দেয় না আর ISR-এর latency বাড়ায় না। কেন critical section এখানে খারাপ পছন্দ নয়, অথচ আপনার সমাধান ভালো?
    typedef struct { int32_t temp16; uint32_t alarm, t_s; } rec_t;
    static volatile rec_t rec;
    static volatile uint32_t rec_seq;          /* শুধু ISR বাড়ায় */
    
    /* ISR-এর ভেতরে, প্রতি 1 s-এ: */
        rec.temp16 = t16;  rec.alarm = a;  rec.t_s = secs;
        rec_seq++;                              /* সব লেখার পরে */
    
    static rec_t read_record(void)
    {
        rec_t r;
        uint32_t s1, s2;
        do {
            s1 = rec_seq;
            r.temp16 = rec.temp16; r.alarm = rec.alarm; r.t_s = rec.t_s;
            s2 = rec_seq;
        } while (s1 != s2);                     /* মাঝে ISR লিখলে আবার */
        return r;
    }

    এটি torn.c-এর তৃতীয় পদ্ধতির হুবহু কাঠামো, যা board-এ ২০,০০০ পড়ায় 0 ছেঁড়া আর ISR-এর latency 4–5 cycle (সরাসরি পড়ার সমান) দিয়েছে; critical section-এ latency 12 পর্যন্ত বেড়েছিল। Cortex-M3-এ ISR লেখার মাঝে main ঢুকতে পারে না, তাই counter একবার বাড়ানোই যথেষ্ট; বহু-core হলে বিজোড়-জোড় নিয়ম আর barrier লাগত। এখানে record তিন word আর পড়া হয় প্রতি 10 s-এ একবার, তাই critical section-এ দেরি মাত্র কয়েকটি নির্দেশ: সেটিও গ্রহণযোগ্য, আর অনেক দল সরলতার জন্য সেটিই নেয়। Sequence counter ভালো হয় যখন data বড় (কপি লম্বা), পড়া ঘন ঘন, বা ISR-এর latency কঠোর।

  2. ভুল খুঁজুন — nested critical section: নিচের Cortex-M3 কোডে log_event() একা ডাকলে ঠিক চলে। কিন্তু update_price()-এর ভেতর থেকে ডাকলে একটি race ফিরে আসে। কোথায়, আর ঠিক রূপ কী?
    void log_event(uint32_t code)
    {
        __disable_irq();
        log_buf[log_n++ & 63u] = code;
        __enable_irq();
    }
    void update_price(uint32_t net_g)
    {
        __disable_irq();
        net = net_g;
        log_event(1);                   /* দর বদলের লগ */
        price = (net_g * 6550u + 500u) / 1000u;
        __enable_irq();
    }

    log_event()-এর শেষের __enable_irq() বাইরের critical section-ও খুলে দেয়: PRIMASK এক বিট, এর কোনো গণনা নেই। ফলে net লেখা আর price লেখার মাঝে interrupt চালু, আর ঠিক সেই ফাঁকে ISR জোড়াটি পড়লে পায় নতুন ওজন আর পুরোনো দাম, অংশ ২-এর ছেঁড়া জোড়া। ঠিক রূপ: আগের অবস্থা রেখে ফেরানো।

    static inline uint32_t irq_save(void)
    {
        uint32_t pm;
        __asm volatile ("mrs %0, primask\n cpsid i" : "=r"(pm) :: "memory");
        return pm;
    }
    static inline void irq_restore(uint32_t pm)
    {
        __asm volatile ("msr primask, %0" :: "r"(pm) : "memory");
    }
    /* log_event-এ: uint32_t pm = irq_save(); ...; irq_restore(pm); */

    বাইরের ডাকে PRIMASK আগে থেকেই 1, তাই irq_restore 1-ই রাখে। Board-এর একটি খুঁটিনাটি: MSR PRIMASK দিয়ে interrupt খুললে pending interrupt পরের “সীমা” পর্যন্ত, সর্বোচ্চ ২০,০০০ cycle দেরিতে নেওয়া হতে পারে (Spec decision 20), যা আসল chip-এ হয় না; board-এ latency মাপতে চাইলে বাইরের স্তরে cpsie ব্যবহার করুন। CMSIS-এ একই কাজের জন্য __get_PRIMASK() আর __set_PRIMASK() আছে।

  3. হিসাব — 72 MHz-এর chip-এ latency budget: একটি Cortex-M3, 72 MHz. UART 115200 baud (১০ বিটের frame), RX FIFO নেই। UART RX ISR-এর priority 2, চলে 60 cycle. একই priority-র একটি ADC ISR চলে 4000 cycle, আর main-এর দীর্ঘতম critical section 900 cycle. প্রবেশ 12 cycle. (ক) UART-এর একটি byte-এর সময় কত cycle? (খ) UART-এর worst-case response কত, overrun হবে কি? (গ) UART-কে priority 1 দিলে?

    (ক) এক byte = 10 ÷ 115200 s = 86.81 µs; 72 MHz-এ 86.81 × 72 = 6250 cycle. (খ) B = max(900, 4000) = 4000, তাই R = 12 + 4000 + 60 = 4072 cycle = 56.6 µs < 86.8 µs: এই হিসাবে overrun হবে না, তবে মার্জিন মাত্র ৩০ µs; ADC ISR একটু বাড়লে বা বেশি জরুরি কেউ যুক্ত হলে ভাঙবে। (গ) Priority 1 হলে ADC ISR আর বাধা দেয় না, B = 900: R = 12 + 900 + 60 = 972 cycle = 13.5 µs. হিসাবগুলো অংশ ৬-এর budget.py-র সূত্রে Python-এ চালিয়ে মেলানো (উঁচু priority-র কেউ না থাকায় Σ অংশ শূন্য)। লক্ষ্য করুন, একই firmware 8 MHz-এ চললে ADC ISR-এর 4000 cycle হতো 500 µs, আর UART নিশ্চিত হারাত: clock-এর বদলে deadline-এর হিসাব আবার করতে হয়।

  4. আগে বলুন — ৮ বিটের chip-এ ছেঁড়া counter: AVR-এ একটি ১৬ বিটের volatile uint16_t ticks, মান 0x00FF. main দুই byte দুটি আলাদা lds-এ পড়ে, আর ঠিক মাঝে ISR ticks++ করে (নতুন মান 0x0100). (ক) main আগে নিচের byte, পরে ওপরের byte পড়লে কী পায়? (খ) উল্টো ক্রমে? (গ) দুই ক্ষেত্রে পড়া মান সত্যিকারের মান থেকে কত দূরে?

    (ক) নিচের byte পুরোনো 0xFF, ওপরের byte নতুন 0x01: 0x01FF = 511, অথচ আসলে 255 বা 256; প্রায় ২৫৫ tick সামনে লাফ। (খ) ওপরের byte পুরোনো 0x00, নিচের byte নতুন 0x00: 0x0000 = 0, প্রায় ২৫৬ tick পেছনে। (গ) +255/+256 আর −255/−256: ভুলের মাপ নিচের byte-এর পুরো পরিসর, আর ঘটে ঠিক প্রতিবার নিচের byte wrap করার মুহূর্তে। হিসাবটি একটি ছোট Python মডেলে দুই ক্রমেই চালিয়ে মেলানো, আর অংশ ২-এর Clang-এর AVR output দেখায় এমন পড়া সত্যিই আলাদা lds-এ হয় (সেখানে ৩২ বিটের জন্য চারটি). সমাধান: পড়ার সময় interrupt বন্ধ (cli/sei, বা avr-libc-র ATOMIC_BLOCK), অথবা দুবার পড়ে মিল পাওয়া পর্যন্ত আবার পড়া।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমএকক-core Cortex-M-এ একটি বোতামের ISR ভারী কাজ main-এ পাঠায় একটি ring buffer দিয়ে (ISR শুধু head, main শুধু tail বদলায়)। একটি ঘটনার পথের ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. ISR উৎসের pending বিট মোছে (যেমন EXTI-এর PR)
  2. ISR ঘটনার data buffer-এর ঘরে লেখে
  3. ISR head এক ঘর বাড়ায়
  4. main head আর tail আলাদা দেখে ঘরের data পড়ে
  5. main tail এক ঘর বাড়ায়, তারপর ভারী কাজ করে
  6. main interrupt বন্ধ রেখে খালি দেখে WFI, তারপর interrupt চালু করে

একটি Cortex-M firmware-এ ISR দুটি volatile uint32_t লেখে: net_g আর price_paisa, যা সবসময় মিলে থাকার কথা। main দুটি পরপর পড়ে। main কিছুই লেখে না। কোন কথাটি ঠিক?

  • লেখক একজন আর দুটিই volatile, তাই কোনো সমস্যা নেই
  • দুই পড়ার মাঝে ISR এলে ছেঁড়া জোড়া আসতে পারে; সুরক্ষা লাগবে
  • শুধু main লিখলে সমস্যা হয়, পড়লে নয়
  • Cortex-M3-এ ৩২ বিটের পড়া অবিভাজ্য, তাই জোড়াও অবিভাজ্য

একটি Cortex-M-এ SysTick আর একটি বোতামের ISR দুজনেরই priority 2. বোতামের ISR ২৬০০ cycle চলে। SysTick-এর latency সম্পর্কে কোনটি ঠিক?

  • SysTick বোতামের ISR-কে থামিয়ে সঙ্গে সঙ্গে ঢোকে
  • SysTick-এর exception নম্বর ছোট, তাই সে জিতবে
  • বোতামের ISR চলার সময় এলে প্রায় ২৬০০ cycle পর্যন্ত দেরি হতে পারে
  • SysTick-এর সেই tick হারিয়ে যায়

ISR আর main-এর মধ্যে এক লেখক এক পাঠকের ring buffer-এ (ISR head, main tail) কোন নিয়মটি অপরিহার্য?

  • ISR আগে data লেখে, তারপর head বাড়ায়
  • main আর ISR দুজনকেই head আর tail লিখতে critical section লাগে
  • Index কখনো 2^32-এ wrap করতে দেওয়া যাবে না
  • Buffer ভরা হলে ISR জায়গা না হওয়া পর্যন্ত অপেক্ষা করবে

একটি function একটি static char buf[16]-এ দাম লিখে pointer ফেরত দেয়। main আর একটি ISR দুজনেই এটি ডাকে। কী হতে পারে?

  • প্রতিটি ডাক নিজের stack-এ আলাদা buf পায়, তাই কিছু হয় না
  • Compiler error দেয়, কারণ ISR থেকে static ব্যবহার নিষেধ
  • Stack overflow হয়
  • main-এর ফল ISR-এর লেখায় মিশে ভুল হতে পারে, কারণ function-টি reentrant নয়

একটি scale-এ তিনটি interrupt: UART RX (115200 baud, FIFO নেই), 1 ms-এর SysTick আর একটি বোতাম। deadline-monotonic নিয়মে Cortex-M-এর priority-র সংখ্যা (কম = জরুরি) কীভাবে দেবেন?

  • বোতাম 1, SysTick 2, UART 3
  • UART 1, SysTick 2, বোতাম 3
  • সবাইকে 2, যাতে কেউ কাউকে না থামায়
  • UART 3, SysTick 2, বোতাম 1, কারণ বড় সংখ্যা বেশি জরুরি

main একটি ৬৪ বিটের ms counter পড়ে (৩২ বিটের CPU, ISR একমাত্র লেখক)। নিচের কোন পদ্ধতি interrupt বন্ধ না করেই সঠিক মান দেয়?

  • আগে নিচের word, তারপর ওপরের word পড়া
  • দুটি word-কেই volatile করে যেকোনো ক্রমে পড়া
  • ওপরের word, নিচের word, আবার ওপরের word; মিল না পাওয়া পর্যন্ত আবার
  • Counter-কে ৩২ বিট করে দেওয়া

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. ISR-এর কাজ: উৎস সামলানো, data কপি, খবর রাখা; অপেক্ষা, printf, malloc আর ভারী হিসাব নয়। ISR-এর সময় অন্যদের latency.
  2. বহু-word data: এক লেখক থাকলেও আলাদা load-এ পড়া ছিঁড়তে পারে; critical section (সরল, latency বাড়ায়), sequence counter (latency বাড়ায় না), শুধু-বাড়া counter-এ hi-lo-hi.
  3. Latency = প্রবেশ + interrupt-বন্ধ সময় + চলমান সমান/বেশি জরুরি ISR + বেশি জরুরিদের বাধা; jitter তার ওঠানামা। পরীক্ষা নিচের সীমা দেয়, হিসাব ওপরের সীমা।
  4. Deferred work: flag, counter বা ring buffer (ISR head, main tail; data আগে, index পরে; ভরা হলে গোনা), আর ঘুমানোর আগে cpsid → খালি দেখা → WFI → cpsie.
  5. Reentrancy আর priority: ISR যে function ডাকে তাতে static অবস্থা নয়; priority deadline দেখে, Cortex-M-এ কম সংখ্যা বেশি জরুরি।

পরের পর্বে: পর্ব ৪৪ (Timer আর counter — prescaler, overflow, input capture আর output compare). SysTick-এর period-এর হিসাব, STM32-ধাঁচের general-purpose timer-এর PSC আর ARR, input capture দিয়ে frequency মাপা আর wrap-safe সময়ের হিসাব।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান