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

8085-এর interrupt — TRAP, RST, SIM আর RIM

8085 Interrupts — TRAP, RST, SIM and RIM

Taught in Bangla, this lesson covers the 8085's five interrupt lines, their priority, triggering, masks and vector addresses. It follows one interrupt from request to return in the course's 8085 simulator (12 T-states of CPU work), explains EI, DI, SIM and RIM byte by byte, and handles simultaneous requests and INTR with INTA. In-page Python decodes SIM and RIM bytes and sends serial bits on SOD at 2400 baud. It ends with ISR design rules and latency calculation.

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

  • 8085-এর পাঁচটি interrupt line-এর ট্রিগার, mask, vector আর অগ্রাধিকার বলা
  • একটি interrupt-এর অনুরোধ থেকে ISR হয়ে ফেরা পর্যন্ত PC, SP আর stack ধাপে ধাপে মেলানো
  • প্রয়োজন থেকে SIM-এর byte বানানো আর RIM-এর byte পড়ে অর্থ বের করা
  • নির্ভুল ISR লেখা আর interrupt latency হিসাব করা
  • SID/SOD দিয়ে software-এ serial বিট পাঠানো আর তার সময় মেলানো

১ · Interrupt কেন — বারবার দেখা বনাম কলিং বেল

বাজারঘরের দোকানদারের কথা ভাবুন। গুদামঘরে কেউ এসেছে কি না জানার দুটি উপায়। প্রথম উপায়: প্রতি মিনিটে কাজ ফেলে দরজায় গিয়ে দেখা। কেউ না এলেও হাঁটাহাঁটি চলতেই থাকে, আর মাঝের সময়ে কেউ এসে চলে গেলে টেরই পাওয়া যায় না। দ্বিতীয় উপায়: দরজায় একটি কলিং বেল। দোকানদার নিজের হিসাব নিয়ে বসে থাকেন; বেল বাজলে হাতের লাইনটুকু শেষ করে, কোন পাতায় ছিলেন মনে রেখে দরজায় যান, তারপর ফিরে ঠিক সেই লাইন থেকে আবার শুরু করেন।

প্রথম উপায়ের নাম polling: CPU একটি loop-এ বারবার যন্ত্রের অবস্থা পড়ে দেখে। দ্বিতীয়টি interrupt: যন্ত্র নিজেই CPU-র একটি pin-এ সংকেত দেয়, আর CPU চলতি নির্দেশ শেষ করে একটি নির্দিষ্ট program-এ চলে যায়। সেই program-এর নাম ISR (interrupt service routine). ISR শেষ হলে CPU আগের কাজে ঠিক আগের জায়গায় ফেরে, যেন কিছুই ঘটেনি। Interrupt আর exception-এর তত্ত্ব, অর্থাৎ pipeline-এ কোথায় থামাতে হয় আর কেন, Computer Architecture পর্ব ৩৮-এ আছে, আর polling, interrupt আর DMA-র তুলনা পর্ব ৫২-এ। এখানে আমরা একটি নির্দিষ্ট chip-এর pin, নির্দেশ আর ঠিক কয়টি T-state লাগে, সেই স্তরে কাজ করব।

বাজারঘরের দুটি device-কে 8085 যুগে কল্পনা করলে দুটি স্বাভাবিক interrupt চোখে পড়ে। Smart scale-এ tare বোতাম: ক্রেতা ঝুড়ি রাখলেন, দোকানদার বোতাম চাপলেন, ঝুড়ির ওজন জমা থাকল। বোতাম কখন চাপা হবে কেউ জানে না, আর CPU-কে সারাক্ষণ বোতামের দিকে তাকিয়ে থাকতে হলে ওজনের হিসাব পিছিয়ে যায়। Cold-storage monitor-এ তাপমাত্রা 8.00 °C ছাড়ালে একটি comparator circuit-এর output উঁচু হয়; সেটিই হতে পারে একটি interrupt. দুটি ক্ষেত্রেই ঘটনা বিরল আর অনিশ্চিত, কিন্তু সাড়া দ্রুত চাই। Interrupt ঠিক এই কাজের জন্য।

উপমা — রেলস্টেশনের ঘোষণা: স্টেশনমাস্টার টিকিট বিক্রির হিসাব করছেন। মাইকে ঘোষণা এলে (interrupt) তিনি হাতের টিকিটটি কেটে শেষ করেন (চলতি নির্দেশ শেষ), খাতায় একটি দাগ দিয়ে রাখেন কোথায় ছিলেন (PC যায় stack-এ), ঘোষণা অনুযায়ী প্ল্যাটফর্মে যান (ISR), ফিরে দাগ দেখে আবার শুরু করেন (RET). কয়েকটি ঘোষণা একসাথে এলে আগে যায় সবচেয়ে জরুরিটি (অগ্রাধিকার), আর আগুন লাগার ঘণ্টা কোনো অবস্থাতেই উপেক্ষা করা যায় না (TRAP).

লেখার নিয়ম আগের পর্বগুলোর মতোই। সব সংখ্যা Intel-এর ধরনে, শেষে H: 2050H, 0FFH. Program শুরু 2000H-এ, data 2050H থেকে, stack-এর শুরু 2800H. CPU-র clock 3 MHz (6 MHz crystal), তাই এক T-state = 0.333 µs. প্রতিটি program, register আর T-state কোর্সের reference lab-এর sim8085.py চালিয়ে পাওয়া (lab-এর পরিচয় পর্ব ০৬-এ)। Simulator-এ interrupt দেওয়া হয় ;@irq T LINE লাইন দিয়ে: মোট T-state যখন T ছোঁয়, তখন line উঁচু হয়; পরীক্ষা হয় প্রতিটি নির্দেশের পরে (Spec decision 7, 8). Pin-এর তথ্য Intel-এর 8085AH datasheet (order number 231718) থেকে, যেমন পর্ব ০৮-এ।

২ · পাঁচটি interrupt line — ট্রিগার, mask, vector আর ক্রম

8085-এর ৪০টি pin-এর মধ্যে পাঁচটি interrupt-এর input: pin ৬ TRAP, ৭ RST 7.5, ৮ RST 6.5, ৯ RST 5.5, ১০ INTR; আর pin ১১ INTA একটি output, INTR-এর জবাব দেওয়ার জন্য। নিচের ছবিতে প্রতিটি line-এর পথ: কোন ধরনের সংকেত লাগে, কোথায় আটকানো যায়, শেষে কোথায় লাফ।

ছবি ১৩.১ — 8085-এর পাঁচটি interrupt line-এর পথ

বাঁ থেকে ডানে: pin → ট্রিগারের ধরন → mask → IE-এর দরজা → অগ্রাধিকার আর vector

8085-এর পাঁচটি interrupt line-এর পথ pin · ট্রিগারmaskIEক্রম · vector TRAPRST 7.5RST 6.5RST 5.5INTR edge + leveledge, latchlevellevellevelmask, IE নেই M7.5M6.5M5.5 ১ 0024H২ 003CH৩ 0034H৪ 002CH৫ INTA নেওয়া হলে: IE = 0, PC → stack,PC = vector; INTR-এ যন্ত্র দেয় RST n
ছবি ১৩.১ — TRAP-এর পথে কোনো দরজা নেই, তাই তাকে কেউ থামাতে পারে না। তিনটি RST line-এর নিজের নিজের mask আছে, আর তার পরে চারটি maskable line একটিই সাধারণ দরজা পেরোয়: IE. ছবিটি Intel-এর datasheet-এর interrupt অংশ আর কোর্সের simulator-এর নিয়ম (Spec decision 7) মিলিয়ে আঁকা, প্রকৃত gate-এর হুবহু নকশা নয়।
Line (pin)ট্রিগারMaskVectorক্রম
TRAP (৬)edge আর level দুটোইনেই, IE-ও মানে না0024H১
RST 7.5 (৭)উঠন্ত edge, ভেতরে latchM7.5 + IE003CH২
RST 6.5 (৮)উঁচু levelM6.5 + IE0034H৩
RST 5.5 (৯)উঁচু levelM5.5 + IE002CH৪
INTR (১০)উঁচু levelশুধু IEযন্ত্রের দেওয়া RST n৫

যে interrupt-এর লাফের ঠিকানা আগে থেকে স্থির, তাকে বলে vectored interrupt, আর সেই ঠিকানাটি তার interrupt vector. 8085-এ নামের মধ্যেই ঠিকানা লুকানো: vector = নম্বর × 8. RST 7.5 → 7.5 × 8 = 60 = 3CH; RST 6.5 → 52 = 34H; RST 5.5 → 44 = 2CH; TRAP-কে বলা হয় RST 4.5: 36 = 24H. এই নামের কারণ আছে। 8080 থেকে আসা আটটি software নির্দেশ RST n (restart) এক byte-এর CALL-এর মতো কাজ করে, আর লাফ দেয় n × 8 ঠিকানায়:

নির্দেশopcodeঠিকানানির্দেশopcodeঠিকানা
RST 0C70000HRST 4E70020H
RST 1CF0008HRST 5EF0028H
RST 2D70010HRST 6F70030H
RST 3DF0018HRST 7FF0038H

Opcode-এর বিট-নকশা 11 NNN 111: মাঝের তিন বিট n, তাই ঠিকানা = opcode AND 38H. নতুন তিনটি hardware RST এই আটটির ঠিক মাঝখানে বসেছে, প্রতিটির জন্য মাত্র ৪ byte জায়গা: 0024H-এর পরে 0028H-এ RST 5. তাই vector-এ সাধারণত একটিই নির্দেশ থাকে, JMP আসল ISR-এ (৩ byte). RST n যেহেতু ১ byte-এর CALL, একে software interrupt হিসেবেও ব্যবহার করা যায়: debugger-এর breakpoint প্রায়ই RST 7 (FFH) বসিয়ে বানানো হতো।

এবার ট্রিগারের তিনটি ধরন, কারণ এখান থেকেই সবচেয়ে বেশি বাস্তব ভুল আসে।

  • Edge-triggered, RST 7.5: line 0 থেকে 1-এ ওঠার মুহূর্তটিই অনুরোধ। CPU-র ভেতরে একটি flip-flop মুহূর্তটি ধরে রাখে, line আবার নেমে গেলেও। Mask বন্ধ থাকলেও flip-flop বসে যায় (Spec decision 7); পরে mask খুললে পুরোনো সেই চাপ হঠাৎ কাজ করে। Flip-flop মোছে তিনভাবে: অনুরোধ নেওয়া হলে, RESET IN-এ, আর SIM-এর বিট ৪ দিয়ে। বোতামের মতো ক্ষণিকের ঘটনার জন্য এটি উপযুক্ত, তাই tare বোতাম এখানে।
  • Level-triggered, RST 6.5, 5.5 আর INTR: line যতক্ষণ উঁচু, অনুরোধ ততক্ষণ। CPU কিছু মনে রাখে না; অনুরোধ নেওয়ার আগে line নেমে গেলে অনুরোধটিই হারিয়ে যায়। আবার ISR শেষে line তখনো উঁচু থাকলে CPU আবার ISR-এ ঢোকে। Simulator এদের মডেল করে “নেওয়া পর্যন্ত ধরে রাখা অনুরোধ” হিসেবে, যেন যন্ত্র সেবা পেয়ে line নামিয়ে নেয় (Spec decision 7). Cold room-এর comparator, যার output অবস্থা বোঝায়, এখানে মানানসই।
  • Edge আর level দুটোই, TRAP: datasheet অনুযায়ী TRAP-কে উঠতে হয় আর নেওয়া পর্যন্ত উঁচু থাকতে হয়; আবার নিতে হলে নেমে আবার উঠতে হয়। দুই শর্ত একসাথে রাখায় ক্ষণিকের noise-এর ঝাঁকুনিতে TRAP চলে না, আবার একটানা উঁচু line-এ ISR বারবারও চলে না।

TRAP হলো 8085-এর NMI (non-maskable interrupt). এর প্রচলিত কাজ বিদ্যুৎ চলে যাওয়ার সতর্কতা: supply-এর voltage পড়তে শুরু করলে একটি circuit TRAP দেয়, আর capacitor-এর জমা শক্তিতে CPU যে কয়েক মিলিসেকেন্ড পায়, তাতে জরুরি data নিরাপদ জায়গায় লেখা হয়। লোডশেডিংয়ের দেশে এই নকশার মূল্য সহজেই বোঝা যায়।

৩ · একটি interrupt-এর পুরো যাত্রা — অনুরোধ থেকে ফেরা পর্যন্ত

এবার tare বোতামটি সত্যি চালানো যাক। Main program দুটি ওজন পড়ে: port 01H থেকে gross ওজন (10 g এককে এক byte; ঝুড়িসহ ১৫০ g = 0FH), তা থেকে 2050H-এ রাখা tare বাদ দিয়ে net ওজন 2051H-এ। RST 7.5-এর vector 003CH-এ JMP TARE. ISR এখনকার gross পড়ে tare-এ রাখে। Simulator-এ বোতামের উঠন্ত edge আসে T = 70-এ। Stepper-টি ধাপে ধাপে চালিয়ে দেখুন, বিশেষ করে SP, stack আর IE.

1LXI SP,2800H2MVI A,0BH  ; 7.5 খোলা3SIM4EI5MVI C,02H6LOOP: IN 01H7LXI H,2050H8SUB M9STA 2051H10DCR C11JNZ LOOP12HLT13003CH: JMP TARE14TARE: PUSH PSW15IN 01H16STA 2050H17POP PSW18EI19RET
PC, SP, IE আর stack
PC · SP
IE · 7.5 latch
27FC..27FF
tare · net
মোট T
  1. প্রস্তুতি. SP = 2800H. MVI A,0BH আর SIM শুধু RST 7.5-এর mask খোলে (byte-এর হিসাব পরের অংশে)। তারপর EI. কিন্তু IE এখনো 0: EI-এর প্রভাব আসে পরের নির্দেশ শেষ হলে (Spec decision 7). মোট ২৫ T-state.
  2. MVI C,02H. এই নির্দেশ শেষ হতেই IE = 1. এখন থেকে খোলা line-এর অনুরোধ নেওয়া যাবে। ৩২ T.
  3. প্রথম ওজন. IN 01H দেয় 0FH (১৫০ g), tare এখনো 0, তাই net = 0FH. STA 2051H চলার মাঝে, T = 70-এ, বোতাম চাপা হলো: edge-টি 7.5-এর latch-এ জমা। CPU কিন্তু চলতি নির্দেশ শেষ না করে থামে না; STA শেষ হয় T = 72-এ।
  4. Acknowledge, CPU নিজে. নির্দেশ শেষে পরীক্ষা: latch = 1, M7.5 খোলা, IE = 1, আর কেউ বেশি জরুরি নয়। CPU তখন IE = 0 করে, latch মোছে, ফেরার ঠিকানা 2012H (পরের নির্দেশ DCR C) stack-এ রাখে: 27FFH = 20, 27FEH = 12, SP = 27FEH; তারপর PC = 003CH. খরচ ১২ T, মোট ৮৪.
  5. ISR-এ ঢোকা. Vector-এর JMP TARE (১০ T), তারপর PUSH PSW: main-এর A (0FH) যায় 27FDH-এ, flag-এর byte (14H: AC = 1, P = 1) 27FCH-এ, SP = 27FCH. ISR এখন A নষ্ট করলেও main টের পাবে না।
  6. ISR-এর আসল কাজ. IN 01H আর STA 2050H: tare = 0FH = ১৫০ g. কাজটি ইচ্ছা করে ছোট; ISR-এ দীর্ঘ হিসাব বা অপেক্ষা নয়। মোট ১২৯ T.
  7. ফেরা. POP PSW A আর flag ফেরায় (SP = 27FEH), EI, তারপর RET stack থেকে 2012H তুলে নেয়, SP = 2800H. RET শেষ হলে তবেই IE = 1, তাই ISR-এর ভেতরে আরেকটি interrupt ঢোকার ফাঁক থাকে না। ১৫৩ T.
  8. Main আবার চলে. DCR C, JNZ, দ্বিতীয় ওজন: gross ১৫০ g − tare ১৫০ g = net 00H, ঠিক README-র “TARE set to 150 g … net=0 g”-এর মতো। HLT-সহ মোট ২২৩ T. Stack-এর ঘরে পুরোনো byte রয়ে গেছে, কিন্তু SP সরে যাওয়ায় সেগুলো আর ব্যবহার হবে না।

একই program reference lab-এর simulator-এ, সত্যিকারের run (python -B sim8085.py trace tare.asm, Python 3.13.5; লাইনগুলো লম্বা, পাশে সরিয়ে দেখুন; ওপরের অংশ বাদ):

~/lab$ python -B sim8085.py trace tare.asm
...
200F  32 51 20  STA 2051H      A=0F B=00 C=02 D=00 E=00 H=20 L=50 SP=2800 PC=2012 S=0 Z=0 AC=1 P=1 CY=0  T=13 total=72
---- interrupt RST7.5 acknowledged -> vector 003CH (12 T)  total=84
003C  C3 17 20  JMP 2017H      A=0F B=00 C=02 D=00 E=00 H=20 L=50 SP=27FE PC=2017 S=0 Z=0 AC=1 P=1 CY=0  T=10 total=94
2017  F5        PUSH PSW       A=0F B=00 C=02 D=00 E=00 H=20 L=50 SP=27FC PC=2018 S=0 Z=0 AC=1 P=1 CY=0  T=12 total=106
2018  DB 01     IN 01H         A=0F B=00 C=02 D=00 E=00 H=20 L=50 SP=27FC PC=201A S=0 Z=0 AC=1 P=1 CY=0  T=10 total=116
201A  32 50 20  STA 2050H      A=0F B=00 C=02 D=00 E=00 H=20 L=50 SP=27FC PC=201D S=0 Z=0 AC=1 P=1 CY=0  T=13 total=129
201D  F1        POP PSW        A=0F B=00 C=02 D=00 E=00 H=20 L=50 SP=27FE PC=201E S=0 Z=0 AC=1 P=1 CY=0  T=10 total=139
201E  FB        EI             A=0F B=00 C=02 D=00 E=00 H=20 L=50 SP=27FE PC=201F S=0 Z=0 AC=1 P=1 CY=0  T=4  total=143
201F  C9        RET            A=0F B=00 C=02 D=00 E=00 H=20 L=50 SP=2800 PC=2012 S=0 Z=0 AC=1 P=1 CY=0  T=10 total=153
...
A=00 B=00 C=00 D=00 E=00 H=20 L=50 SP=2800 PC=2017
Flags: S=0 Z=1 AC=1 P=1 CY=0   (F=54H)
Memory 2050H..2051H:
  2050H: 0F 00
Memory 27FCH..27FFH:
  27FCH: 14 0F 12 20
Instructions: 25   T-states: 223

---- লাইনটি simulator-এর acknowledge-এর চিহ্ন: “RST7.5 নেওয়া হলো, vector 003CH, ১২ T”. শেষে 27FCH থেকে চারটি byte 14 0F 12 20, stepper-এর সঙ্গে হুবহু এক। নিচের ব্লক একই program-এর প্রতিটি নির্দেশের পরে শুধু PC, SP, IE আর মোট T ছাপে। ;@irq 70 বদলে 30 বা 200 করে চালিয়ে দেখুন: interrupt কোথায় ঢোকে আর net কী হয়।

# tare বোতাম RST 7.5-এ: interrupt-এর আগে, ভেতরে আর পরে (sim85 = reference-এর sim8085.py)
from sim85 import assemble, run, pragma_args, disasm_one, fmt_imm
SRC = """;@in 01H 0FH
;@irq 70 RST7.5
        ORG 003CH       ; RST 7.5-এর vector
        JMP TARE
        ORG 2000H
MAIN:   LXI SP,2800H
        MVI A,0BH       ; শুধু RST 7.5 খোলা
        SIM
        EI
        MVI C,02H       ; দুটি reading
LOOP:   IN 01H          ; gross, 10 g এককে
        LXI H,2050H
        SUB M           ; net = gross - tare
        STA 2051H
        DCR C
        JNZ LOOP
        HLT
TARE:   PUSH PSW        ; ISR: main-এর A আর flag বাঁচানো
        IN 01H
        STA 2050H       ; tare = এখনকার gross
        POP PSW
        EI
        RET
        END MAIN
"""
def show(cpu, pc, op, cost):
    if pc is None:                      # interrupt স্বীকার হলো
        print(f"---- {op} -> {cost:04X}H")
    else:
        text = fmt_imm(disasm_one(lambda a: cpu.mem[a & 0xFFFF], pc)[0])
        print(f"{pc:04X} {text:12} SP={cpu.SP:04X} IE={int(cpu.ie)} T={cpu.tstates}")
cpu = run(prog := assemble(SRC), *pragma_args(prog)[1:], trace=show)
print("tare =", f"{cpu.mem[0x2050]:02X}H", " net =", f"{cpu.mem[0x2051]:02X}H")

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

2000 LXI SP,2800H SP=2800 IE=0 T=10
2003 MVI A,0BH    SP=2800 IE=0 T=17
2005 SIM          SP=2800 IE=0 T=21
2006 EI           SP=2800 IE=0 T=25
2007 MVI C,02H    SP=2800 IE=1 T=32
2009 IN 01H       SP=2800 IE=1 T=42
200B LXI H,2050H  SP=2800 IE=1 T=52
200E SUB M        SP=2800 IE=1 T=59
200F STA 2051H    SP=2800 IE=1 T=72
---- RST7.5 -> 003CH
003C JMP 2017H    SP=27FE IE=0 T=94
2017 PUSH PSW     SP=27FC IE=0 T=106
2018 IN 01H       SP=27FC IE=0 T=116
201A STA 2050H    SP=27FC IE=0 T=129
201D POP PSW      SP=27FE IE=0 T=139
201E EI           SP=27FE IE=0 T=143
201F RET          SP=2800 IE=1 T=153
2012 DCR C        SP=2800 IE=1 T=157
2013 JNZ 2009H    SP=2800 IE=1 T=167
2009 IN 01H       SP=2800 IE=1 T=177
200B LXI H,2050H  SP=2800 IE=1 T=187
200E SUB M        SP=2800 IE=1 T=194
200F STA 2051H    SP=2800 IE=1 T=207
2012 DCR C        SP=2800 IE=1 T=211
2013 JNZ 2009H    SP=2800 IE=1 T=218
2016 HLT          SP=2800 IE=1 T=223
tare = 0FH  net = 00H

তিনটি জিনিস লক্ষ করুন। এক, EI-এর লাইনে IE = 0, পরের লাইনে 1. দুই, -----এর পরে প্রথম নির্দেশেই IE = 0 আর SP দুই কমেছে; এটি CPU-র নিজের কাজ, কোনো নির্দেশ লেখা হয়নি। তিন, RET-এর লাইনে IE = 1 আর পরের লাইন 2012H. এই ব্লকের sim85.py reference-এর sim8085.py-র হুবহু কপি, শুধু command line অংশ বাদ; লেখকের lab-এ এই পর্বের ১৩টি program-এর run আর trace, মোট ২৬টি তুলনা, অক্ষরে অক্ষরে মিলেছে।

লক্ষ করুন, interrupt আসলে একটি “অপ্রত্যাশিত CALL”: ফেরার ঠিকানা stack-এ যাওয়া, SP দুই কমা, RET-এ ফেরা, সবই সাধারণ subroutine-এর মতো। Stack, CALL/RET আর PUSH/POP-এর পুরো আলোচনা পর্ব ১২-এ, আর loop ও array-র পুরো program পর্ব ১১-এ। পার্থক্য একটাই, কিন্তু বড়: CALL কোথায় হবে program জানে, interrupt কোথায় ঢুকবে জানে না। তাই ISR-কে এমনভাবে লিখতে হয় যেন যেকোনো দুটি নির্দেশের মাঝখানে ঢুকেও কিছু নষ্ট না করে।

নিয়ম

Interrupt নেওয়ার সময় 8085 নিজে শুধু চারটি কাজ করে: চলতি নির্দেশ শেষ করা, IE = 0, PC stack-এ রাখা, vector-এ লাফ। Register আর flag বাঁচায় না। তাই ISR-এর কাঠামো প্রায় সবসময় একই: শুরুতে PUSH PSW (আর যে register বদলাবে, তার PUSH), শেষে উল্টো ক্রমে POP, তারপর EI আর RET.

৪ · EI, DI, SIM আর RIM — দরজা খোলা, mask লেখা, অবস্থা পড়া

Maskable interrupt আটকানোর দুটি স্তর আছে। ওপরের স্তর একটি একক বিট, IE (interrupt enable flip-flop): EI (FBH, ৪ T) একে 1 করে, DI (F3H, ৪ T) 0. DI সঙ্গে সঙ্গে কাজ করে, EI একটি নির্দেশ পরে। Reset, আর যেকোনো interrupt নেওয়া, IE-কে 0 করে। নিচের স্তরে তিনটি RST line-এর আলাদা mask; একে বলে interrupt masking. Reset-এর পরে simulator-এ, Intel-এর বর্ণনা মেনে, তিনটি mask-ই বন্ধ (Spec decision 6). Mask লেখার নির্দেশ SIM (set interrupt mask, 30H, ৪ T): A-র byte দেখে কাজ করে।

বিটD7D6D5D4D3D2D1D0
নামSODSDE—R7.5MSEM7.5M6.5M5.5
অর্থserial বিট1 = SOD-এ লেখাব্যবহার নেই1 = 7.5 latch মোছা1 = mask লেখা1 = বন্ধ, 0 = খোলা

দুটি “enable” বিট সবচেয়ে গুরুত্বপূর্ণ। MSE = 0 হলে D2–D0 যা-ই থাকুক, mask বদলায় না; SDE = 0 হলে D7 উপেক্ষিত। তাই একটি SIM দিয়ে শুধু serial বিট, বা শুধু mask, বা দুটোই বদলানো যায়। Cold room-এর জন্য একটি প্রয়োজন দিয়ে byte বানানো যাক: RST 6.5 (comparator) খোলা, 7.5 আর 5.5 বন্ধ, আর আগে জমে থাকা কোনো 7.5 চাপ মুছে ফেলা; serial pin-এ হাত নয়।

1RIM         ; আগের অবস্থা2MVI A,1DH   ; 0001 11013SIM4RIM5EI6NOP7RIM
SIM-এর byte আর RIM-এর উত্তর
D7 D6 D5 D4
D3 D2 D1 D0
A
RIM
  1. শুরুর অবস্থা. Reset-এর পরে, mask বন্ধ থাকা অবস্থাতেই, বোতামে একবার চাপ পড়েছিল (simulator-এ T = 5). RIM পড়ে 47H = 0100 0111: বিট ৬ (7.5 অপেক্ষায়) = 1, IE = 0, তিনটি mask-ই 1. এই চাপটি এখন অবাঞ্ছিত।
  2. D7, D6: serial. SOD-এ কিছু পাঠানোর নেই, তাই SDE = 0; তখন D7 উপেক্ষিত, 0 লেখাই প্রচলিত।
  3. D5. ব্যবহার নেই; 0.
  4. D4: R7.5 = 1. জমে থাকা 7.5 চাপ মুছে ফেলার আদেশ। এটি না দিলে পরে কখনো 7.5 খুললেই পুরোনো চাপে ISR চলত।
  5. D3: MSE = 1. এবারের SIM সত্যিই mask লিখবে। MSE = 0 দিলে নিচের তিন বিটের কোনো অর্থ থাকত না।
  6. D2–D0 = 1 0 1. M7.5 = 1 (বন্ধ), M6.5 = 0 (খোলা), M5.5 = 1 (বন্ধ). পুরো byte 0001 1101 = 1DH.
  7. SIM, তারপর RIM. উত্তর 05H = 0000 0101: অপেক্ষায় কেউ নেই (পুরোনো চাপ মুছে গেছে), IE = 0, mask 7.5 আর 5.5 বন্ধ, 6.5 খোলা। Mask খোলা হলেও এখনো কিছু ঢুকবে না, কারণ IE = 0.
  8. EI, NOP, RIM. উত্তর 0DH: বিট ৩ (IE) এখন 1. এই প্রথম 6.5-এর অনুরোধ সত্যিই ISR চালাতে পারবে। পুরো run-এর সত্যিকারের ফল: 2070H: 47 05 0D, ১২টি নির্দেশ, ৮৫ T-state.

উল্টো দিকের নির্দেশ RIM (read interrupt mask, 20H, ৪ T) A-তে এই byte আনে:

বিটD7D6D5D4D3D2D1D0
নামSIDI7.5I6.5I5.5IEM7.5M6.5M5.5
অর্থserial input pin1 = অনুরোধ অপেক্ষায় (pending)IE-এর মান1 = বন্ধ

নিচের তিন বিট SIM আর RIM-এ একই জায়গায়, তাই পড়া mask সরাসরি আবার লেখা যায়। যে অনুরোধ এসেছে কিন্তু এখনো নেওয়া হয়নি, তাকে বলে pending interrupt; RIM-এর বিট ৬–৪ তাদের দেখায়। একটি সূক্ষ্ম নিয়ম: TRAP নেওয়ার পরে প্রথম RIM-এর বিট ৩ দেখায় TRAP-এর আগের IE (Spec decision 7), যাতে TRAP-এর ISR জানতে পারে ফেরার সময় EI দেওয়া উচিত কি না। এর ব্যবহার পরের অংশে।

নিচের ব্লকে একটি ছোট SIM-byte বানানোর যন্ত্র। প্রয়োজন লিখলে byte বানায়, তারপর simulator-এ একটি পুরোনো 7.5 চাপসহ SIM আর RIM চালিয়ে উত্তরের অর্থ ছাপে। নিজের প্রয়োজন যোগ করে দেখুন।

# SIM-এর byte বানানো আর RIM-এর byte পড়া, তারপর simulator-এ যাচাই (sim85 = sim8085.py)
from sim85 import assemble, run

def sim_byte(open_=None, reset75=False, sod=None):
    """open_ = যে line-গুলো খোলা থাকবে; None হলে mask ছোঁয়া হবে না (MSE = 0)"""
    m = {"7.5": 4, "6.5": 2, "5.5": 1}
    masks = 0 if open_ is None else 0x08 | sum(b for k, b in m.items() if k not in open_)
    serial = 0 if sod is None else (sod << 7 | 0x40)    # SOD, SDE
    return serial | (0x10 if reset75 else 0) | masks

def rim_text(a):
    pend = [n for n, b in (("7.5", 6), ("6.5", 5), ("5.5", 4)) if a >> b & 1]
    masked = [n for n, b in (("7.5", 2), ("6.5", 1), ("5.5", 0)) if a >> b & 1]
    return f"pending={pend} IE={a >> 3 & 1} masked={masked}"

def check(byte):   # reset-এর পরে একটি পুরোনো 7.5 চাপ (T = 0), তারপর SIM আর RIM
    src = f" ORG 2000H\n MVI A,0{byte:02X}H\n SIM\n RIM\n HLT"
    return run(assemble(src), irqs=[(0, "RST7.5", None)]).A

for need, kw in [("শুধু 7.5 খোলা", dict(open_=("7.5",))),
                 ("শুধু 7.5, পুরোনো চাপ মোছা", dict(open_=("7.5",), reset75=True)),
                 ("শুধু 6.5, পুরোনো চাপ মোছা", dict(open_=("6.5",), reset75=True)),
                 ("সব খোলা", dict(open_=("7.5", "6.5", "5.5"))),
                 ("শুধু SOD = 1", dict(sod=1))]:
    b = sim_byte(**kw)
    r = check(b)
    print(f"{need:26} SIM {b:02X}H = {b:08b}b")
    print(f"{'':26} RIM {r:02X}H: {rim_text(r)}")

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

শুধু 7.5 খোলা              SIM 0BH = 00001011b
                           RIM 43H: pending=['7.5'] IE=0 masked=['6.5', '5.5']
শুধু 7.5, পুরোনো চাপ মোছা  SIM 1BH = 00011011b
                           RIM 03H: pending=[] IE=0 masked=['6.5', '5.5']
শুধু 6.5, পুরোনো চাপ মোছা  SIM 1DH = 00011101b
                           RIM 05H: pending=[] IE=0 masked=['7.5', '5.5']
সব খোলা                    SIM 08H = 00001000b
                           RIM 40H: pending=['7.5'] IE=0 masked=[]
শুধু SOD = 1               SIM C0H = 11000000b
                           RIM 47H: pending=['7.5'] IE=0 masked=['7.5', '6.5', '5.5']

প্রথম দুই সারির তুলনাটিই মূল শিক্ষা। 0BH দিয়ে 7.5 খুললে RIM দেখায় 7.5 অপেক্ষায় (43H): EI দেওয়ামাত্র সেই পুরোনো চাপে ISR চলবে, যেন কেউ এইমাত্র tare চেপেছেন। 1BH (বিট ৪ = 1) দিলে অপেক্ষার তালিকা খালি (03H). শেষ সারিতে MSE = 0, তাই C0H শুধু SOD = 1 করে, mask তিনটি reset-এর মতোই বন্ধ থাকে (47H). সব সারিতে IE = 0, কারণ এই পরীক্ষায় EI নেই।

সবচেয়ে সাধারণ ভুল: SIM সবসময় A-র পুরো byte দেখে। হিসাবের কোনো মান A-তে রেখে ভুলে SIM চালালে D3 বা D4 হঠাৎ 1 হয়ে mask বদলে যেতে পারে, বা জমা 7.5 চাপ মুছে যেতে পারে। Serial বিট পাঠানোর সময় এই ভুল সবচেয়ে বেশি হয়, তাই সেখানে ANI 80H দিয়ে আগে বাকি বিট শূন্য করা হয় (অংশ ৭)। আর RIM A-র আগের মান মুছে দেয়: ISR-এর ভেতরে লাগলে আগে PUSH PSW.

৫ · অগ্রাধিকার — দুটি বা পাঁচটি অনুরোধ একসাথে এলে

একসাথে কয়েকটি অনুরোধ pending থাকলে কোনটি আগে, তা ঠিক করে interrupt priority: TRAP, তারপর 7.5, 6.5, 5.5, শেষে INTR. তবে মনে রাখতে হবে দুটি জিনিস। প্রথমত, অগ্রাধিকার শুধু সেই মুহূর্তের বাছাই; ISR চলার সময় IE = 0, তাই বেশি জরুরি অনুরোধও (TRAP ছাড়া) অপেক্ষা করে। দ্বিতীয়ত, বন্ধ mask-এর line প্রতিযোগিতাতেই নেই। নিচে cold room-এর alarm (RST 6.5) আর tare বোতাম (RST 7.5) ঠিক একই মুহূর্তে, T = 40-এ। প্রতিটি ISR নিজের চিহ্ন 2060H-এর খাতায় লেখে; 7.5-এর ISR ভেতর থেকে একবার RIM-ও পড়ে।

1LXI SP,2800H2LXI D,2060H3MVI A,08H ; সব খোলা4SIM5EI6NOP7NOP8HLT9ISR75: PUSH PSW10RIM / STA 2062H11MVI A,75H12STAX D / INX D13POP PSW / EI / RET14ISR65: … 65H …
অপেক্ষার তালিকা আর খাতা
pending 7.5 · 6.5
IE
SP · PC
2060H খাতা
মোট T
  1. দুটি অনুরোধ, দরজা বন্ধ. SIM (08H: MSE = 1, তিনটি mask খোলা) শেষ হলো T = 41-এ; তার আগেই T = 40-এ দুটি line উঁচু। 7.5-এর latch আর 6.5-এর line দুটোই pending, কিন্তু IE = 0, তাই কিছুই ঘটে না।
  2. EI, তারপর একটি NOP. EI শেষেও অনুরোধ নেওয়া হলো না; NOP শেষে (T = 49) IE = 1. EI-এর এই এক নির্দেশের দেরি এখানে চোখে দেখা যায়।
  3. বাছাই: 7.5. দুটি pending-এর মধ্যে 7.5-এর ক্রম আগে। CPU ফেরার ঠিকানা 200BH (দ্বিতীয় NOP) stack-এ রাখে, SP = 27FEH, IE = 0, 7.5-এর latch মোছে, ১২ T পরে vector 003CH, সেখান থেকে JMP করে ISR75-এ (T = 71).
  4. ISR-এর ভেতর থেকে RIM. PUSH PSW-এর পরে RIM = 20H = 0010 0000: শুধু বিট ৫ (I6.5) = 1, IE = 0, কোনো mask বন্ধ নয়। অর্থাৎ 6.5 দরজায় দাঁড়িয়ে, কিন্তু IE বন্ধ বলে ঢুকতে পারছে না। মানটি 2062H-এ রাখা হলো (T = 100).
  5. 7.5-এর ISR শেষ. খাতায় 75, POP PSW, EI, RET: PC = 200BH, SP = 2800H, আর RET শেষে IE = 1 (T = 144).
  6. Main একটি নির্দেশও পায় না. IE খোলামাত্র 6.5 নেওয়া হয়, 200BH-এর NOP চলার আগেই: আবার 200BH stack-এ, vector 0034H (T = 156). তার ISR খাতায় 65 লিখে ফেরে (T = 222).
  7. শেষ. এবার main-এর NOP আর HLT, মোট ২৩১ T. খাতা 75 65: ক্রমটি অগ্রাধিকার মেনেছে, আর দুটি ISR পরপর চলেছে, একটির ভেতরে আরেকটি নয়। সত্যিকারের run-এর শেষ: 2060H: 75 65 20, ২৭টি নির্দেশ।

একটি ISR-এর ভেতরে আরেকটি interrupt নেওয়াকে বলে nested interrupt. 8085-এ এটি নিজে থেকে হয় না; চাইলে ISR-এর শুরুতেই, register বাঁচানোর পরে, EI দিতে হয়। তখন বেশি জরুরি line ঢুকতে পারে, কিন্তু 8085-এর hardware “কম জরুরি line আটকাও” জানে না: একই বা কম ক্রমের level line-ও ঢুকে পড়তে পারে। তাই nesting চাইলে ISR-এর শুরুতে SIM দিয়ে নিজের আর নিচের line-গুলো বন্ধ করাই প্রচলিত কৌশল। এবার পাঁচটি line একসাথে। প্রতিটি vector-এ ৮ byte-এর একটি ছোট ISR, যা JMP ছাড়াই vector-এর জায়গায় বসেছে।

# পাঁচটি line একই মুহূর্তে (T = 30): কে আগে সেবা পায়? (sim85 = reference-এর sim8085.py)
from sim85 import assemble, run

# প্রতিটি vector-এ ৮ byte-এর ছোট ISR: নিজের চিহ্ন DE-র খাতায় লেখে
ISR = " ORG {}\n PUSH PSW\n MVI A,{}\n STAX D\n INX D\n POP PSW\n EI\n RET\n"
VECS = [("0010H", "02H"),    # INTR, device দেয় RST 2 (D7H)
        ("0024H", "0FFH"),   # TRAP
        ("002CH", "55H"),    # RST 5.5
        ("0034H", "65H"),    # RST 6.5
        ("003CH", "75H")]    # RST 7.5
SRC = "".join(ISR.format(v, c) for v, c in VECS) + """
        ORG 2000H
MAIN:   LXI SP,2800H
        LXI D,2060H     ; খাতার শুরু
        MVI A,08H       ; MSE = 1, তিনটি mask-ই খোলা
        SIM
        EI
        HLT
        HLT
        END MAIN
"""
LINES = [("RST5.5", None), ("INTR", 0xD7), ("RST6.5", None), ("TRAP", None), ("RST7.5", None)]

def show(cpu, pc, op, cost):
    if pc is None:
        print(f"T={cpu.tstates:3}  {op:6} -> {cost:04X}H  SP={cpu.SP:04X}")

cpu = run(assemble(SRC), irqs=[(30, ln, op) for ln, op in LINES], trace=show)
print("খাতা 2060H:", " ".join(f"{cpu.mem[0x2060 + i]:02X}" for i in range(5)),
      "| মোট T:", cpu.tstates)

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

T= 43  TRAP   -> 0024H  SP=27FE
T=111  RST7.5 -> 003CH  SP=27FE
T=179  RST6.5 -> 0034H  SP=27FE
T=247  RST5.5 -> 002CH  SP=27FE
T=315  INTR   -> 0010H  SP=27FE
খাতা 2060H: FF 75 65 55 02 | মোট T: 380

খাতায় FF 75 65 55 02: TRAP, 7.5, 6.5, 5.5, INTR, ঠিক ক্রম মেনে, প্রতিটির মধ্যে ৬৮ T. INTR-এর জন্য simulator-এ যন্ত্র দিয়েছে D7H = RST 2, তাই লাফ 0010H-এ। কিন্তু একটি জিনিস চমকে দেওয়ার মতো: TRAP নেওয়া হয়েছে T = 43-এ, main-এর EI চলার আগে. তারপর TRAP-এর ISR শেষে যে EI দিয়েছে, তাতেই বাকি চারটি ঢুকে পড়েছে, যদিও main তখনো interrupt চালুই করেনি। প্রতিটি ISR-এর শেষে অন্ধভাবে EI লেখা এখানে ভুল ফল দিল।

সমাধানের পথ Intel আগেই রেখেছে: TRAP-এর পরে প্রথম RIM-এর বিট ৩ = TRAP-এর আগের IE. TRAP-এর ISR তাই এভাবে লেখা নিরাপদ:

TRISR:  PUSH PSW
        ...             ; জরুরি কাজ
        RIM             ; বিট ৩ = TRAP-এর আগে IE কী ছিল
        ANI 08H
        JZ TOFF         ; আগে বন্ধ ছিল: বন্ধই থাকুক
        POP PSW
        EI
        RET
TOFF:   POP PSW
        RET

একই পরিস্থিতিতে (TRAP আর 7.5 দুটোই T = 30-এ, main-এর EI আসে পরে) লেখকের lab-এ সত্যিকারের run: TRAP-এর ISR RIM-এর বিট ৩ = 0 পেয়ে EI ছাড়াই ফেরে, 7.5 অপেক্ষা করে main-এর EI পর্যন্ত, আর নেওয়া হয় T = 154-এ; খাতা FF 75, মোট ২২৫ T.

৬ · INTR আর INTA — বাইরের যন্ত্র নিজেই নির্দেশ দেয়

চারটি স্থির vector অনেক সময় যথেষ্ট নয়: keyboard, printer, timer, serial chip, সবাই interrupt চাইতে পারে। এর জন্য INTR, সবচেয়ে কম ক্রমের, শুধু IE দিয়ে নিয়ন্ত্রিত line. INTR নেওয়ার সময় CPU memory থেকে opcode পড়ে না; তার বদলে INTA pin নামিয়ে জানায় যে এখন data bus-এ একটি নির্দেশ চাই। এই সাড়াকে বলে interrupt acknowledge. যে যন্ত্র অনুরোধ করেছে, সে তখন data bus-এ একটি নির্দেশের byte রাখে, সাধারণত একটি RST n. CPU সেটিকেই চালায়: PC stack-এ, লাফ n × 8-এ।

Intel-এর manual-এর বর্ণনায় RST n এলে acknowledge-এ একটি INTA cycle আর stack-এ দুটি লেখা লাগে, মোট ১২ T-state; যন্ত্র চাইলে তিন byte-এর CALL-ও দিতে পারে, তখন CPU আরও দুটি INTA cycle-এ ঠিকানার দুটি byte নেয় আর খরচ হয় ১৮ T. কোর্সের simulator শুধু RST n মডেল করে (;@irq T INTR 0EFH মানে যন্ত্র দিল EFH = RST 5; কিছু না বললে FFH), খরচ ১২ T (Spec decision 7). একটি ছোট সত্যিকারের পরীক্ষা: SP = 2800H, EI, তিনটি NOP; T = 20-এ INTR আর EFH. ফল: দ্বিতীয় NOP-এর পরে CPU 0028H-এ পৌঁছায়, stack-এ 27FEH: 06 20, অর্থাৎ ফেরার ঠিকানা 2006H; সেখানে রাখা HLT-সহ মোট ৩৯ T.

অনেক যন্ত্র একটি INTR ভাগ করলে কে RST n দেবে, তা ঠিক করতে আলাদা hardware লাগে। দুটি প্রচলিত পথ। এক, daisy chain: INTA সংকেত যন্ত্র থেকে যন্ত্রে শিকলের মতো যায়, প্রথম যে যন্ত্রের অনুরোধ আছে সে-ই সাড়া দেয়; শিকলে অবস্থানই অগ্রাধিকার। দুই, একটি interrupt controller chip, Intel-এর 8259 PIC: আটটি line নেয়, তাদের অগ্রাধিকার আর mask রাখে, আর INTA-এর সময় ঠিক vector-টি bus-এ দেয়। এর পুরো programming পর্ব ২৬ (8259 PIC — interrupt priority, ICW আর OCW)-এ। আর 8086-এ এই ধারণাটিই বড় হয়েছে ২৫৬টি entry-র vector table-এ, পর্ব ২০ (8086-এর interrupt — vector table, INT আর ISR)-এ।

8085 এসেছে ১৯৭৬ সালে, 8080-এর (১৯৭৪) উত্তরসূরি হিসেবে। 8080-এ interrupt line ছিল একটিই, INTR, আর acknowledge-এর সংকেত তৈরিতে সাধারণত 8228-এর মতো একটি সহায়ক chip লাগত। 8085-এ Intel ভেতরে নিয়ে এলো তিনটি vectored RST line, TRAP, INTA pin আর serial-এর দুটি pin; নির্দেশ তালিকায় নতুন যোগ মাত্র দুটি, RIM আর SIM, যারা বসেছে 8080-এর দুটি নথিভুক্ত-নয় ঘরে (20H, 30H). লক্ষ্য ছিল একই কাজ কম chip-এ করা, যা ছোট control board-এর জন্য বড় সুবিধা।

৭ · SID আর SOD — একই দুটি নির্দেশে serial

SIM আর RIM-এর বিট ৭ দুটি আলাদা pin-এর সঙ্গে জোড়া: SOD (serial output data, pin ৪) আর SID (serial input data, pin ৫). SIM-এ SDE = 1 দিলে A-র বিট ৭ SOD pin-এ বসে আর পরের SIM পর্যন্ত থাকে; RIM SID pin-এর মান A-র বিট ৭-এ আনে। এর বেশি কিছু নয়: কোনো baud rate, কোনো frame, কোনো buffer নেই। সব timing software-কে T-state গুনে বানাতে হয়। একে বলে bit-banging.

একটি UART-ধরনের frame-এ প্রথমে একটি start বিট (0), তারপর ৮টি data বিট, ছোটটি আগে, শেষে একটি stop বিট (1). ২৪০০ baud মানে প্রতি সেকেন্ডে ২৪০০ বিট, তাই এক বিটের সময় = 1 ÷ 2400 = 416.67 µs = 3,000,000 ÷ 2400 = ১২৫০ T-state. নিচের program বাজারঘরের “B” অক্ষর (42H) পাঠায়। পুরো frame আগে থেকে HL-এ বানানো: 0284H = stop বিট | 42H << 1 | start বিট, আর প্রতি পাকে HL এক বিট ডানে সরে। প্রতি পাকের নির্দেশগুলোর যোগফল 72 + 14N T; N = 83 দিলে ১২৩৪, তাই চারটি NOP (১৬ T) মিলিয়ে ঠিক ১২৫০।

# SOD pin দিয়ে software serial: একটি byte, 2400 baud (sim85 = sim8085.py)
from sim85 import cli

SRC = """
; SOD দিয়ে 'B' (42H) পাঠানো: 2400 baud, 1 start + 8 data (LSB আগে) + 1 stop
        ORG 2000H
        LXI H,0284H     ; frame: stop(1) | 42H | start(0)
        MVI C,0AH       ; ১০টি bit
NEXT:   MOV A,L
        RRC             ; bit 0 -> D7
        ANI 80H         ; শুধু D7 রাখা (MSE, R7.5 = 0)
        ORI 40H         ; SDE = 1
        SIM             ; SOD <- D7
        MOV A,H         ; HL >> 1
        ORA A           ; CY = 0
        RAR
        MOV H,A
        MOV A,L
        RAR
        MOV L,A
        MVI D,83        ; bit-এর বাকি সময়
WAIT:   DCR D
        JNZ WAIT
        NOP
        NOP
        NOP
        NOP
        DCR C
        JNZ NEXT
        HLT
"""
cpu = cli(SRC)
bits = [b for t, b in cpu.sod_log]
print("bit:", bits, "| ফাঁক:", {b[0] - a[0] for a, b in zip(cpu.sod_log, cpu.sod_log[1:])}, "T")

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

A=00 B=00 C=00 D=00 E=00 H=00 L=00 SP=0000 PC=2022
Flags: S=0 Z=1 AC=1 P=1 CY=1   (F=55H)
SOD changes: T=43:0, T=1293:0, T=2543:1, T=3793:0, T=5043:0, T=6293:0, T=7543:0, T=8793:1, T=10043:0, T=11293:1
Instructions: 1853   T-states: 12519
bit: [0, 0, 1, 0, 0, 0, 0, 1, 0, 1] | ফাঁক: {1250} T

SOD changes লাইনটি simulator-এর SOD-এর খাতা (Spec decision 7): প্রতিটি SIM কোন T-তে কী বসাল। বিটগুলো 0 (start), তারপর 42H-এর বিট ছোটটি আগে 0 1 0 0 0 0 1 0, শেষে 1 (stop). দুটি পরপর বিটের ফাঁক সবসময় ১২৫০ T = 416.67 µs, অর্থাৎ ঠিক ২৪০০ baud. শেষ বিটটি HLT পর্যন্ত ধরে রাখা হয়েছে; আসল program-এ stop বিটের জন্য আরও এক বিট-সময় অপেক্ষা লাগে। ANI 80H লাইনটি মুছে চালিয়ে দেখুন: RRC-এর পরে A-র অন্য বিট থেকে MSE আর mask-এর বিট বসে যায়, তখন এক byte পাঠাতে গিয়ে interrupt-এর mask নীরবে বদলে যায়।

এই কৌশলের দুর্বলতা হলো timing-এর ওপর পুরো নির্ভরতা। পাঠানোর মাঝে একটি interrupt এলে, ISR যতক্ষণ চলে, বিটটিও ততক্ষণ লম্বা হয়ে যায়, আর গ্রাহক ভুল byte পড়ে। তাই bit-banging-এর সময় সাধারণত DI দিয়ে interrupt বন্ধ রাখা হয়, যার দাম বাকি সব interrupt-এর latency বেড়ে যাওয়া। এই কারণেই পরে আলাদা serial chip এসেছে: 8251 USART, পর্ব ২৭ (8251 USART আর 8237 DMA controller)-এ, আর আজকের microcontroller-এর UART hardware, পর্ব ৪৯ (UART — baud rate, frame, parity আর ring buffer)-এ।

৮ · ISR নকশার নিয়ম আর latency-র হিসাব

ওপরের সব উদাহরণ থেকে একটি ছোট নিয়মের তালিকা দাঁড়ায়। প্রতিটি নিয়মের পেছনে একটি বাস্তব ভুল আছে, যা simulator-এ চালিয়ে দেখা।

  1. যা বদলাবেন, তা বাঁচান. CPU flag আর register বাঁচায় না। Main-এর CPI আর JZ-এর মাঝখানে interrupt এলে, আর ISR flag নষ্ট করলে, main ভুল দিকে লাফ দেবে। তাই PUSH PSW, প্রয়োজনে PUSH B, PUSH D, PUSH H, আর উল্টো ক্রমে POP.
  2. ফেরার আগে EI, তারপর RET. Acknowledge IE বন্ধ করেছে; ফেরার আগে না খুললে পরের কোনো maskable interrupt আর কখনো আসবে না (অনুশীলন ২-এ সত্যিকারের run). আর EI-এর এক নির্দেশের দেরির কারণে EI, RET জোড়ার মাঝে কিছু ঢুকতে পারে না, ফলে stack নিরাপদে খালি হয়। ব্যতিক্রম TRAP: আগের IE দেখে সিদ্ধান্ত।
  3. ISR ছোট রাখুন. ISR চলার সময় অন্য সব maskable interrupt অপেক্ষায়। দীর্ঘ হিসাব, delay loop বা আরেকটি ঘটনার জন্য অপেক্ষা ISR-এ নয়; ISR শুধু একটি চিহ্ন বা মান রাখবে, main loop বাকি কাজ করবে।
  4. ভাগ করা data রক্ষা করুন. Main যদি দুই byte-এর একটি মান (যেমন পয়সায় দাম) দুই ধাপে লেখে, আর ISR মাঝখানে সেটি পড়ে, তবে ISR পায় অর্ধেক নতুন, অর্ধেক পুরোনো মান। কোডের এমন অংশকে বলে critical section; 8085-এ এর সহজ সুরক্ষা DI … EI, যাতে কাজটি ISR-এর চোখে atomic হয়। C-তে একই সমস্যা আর volatile-এর ভূমিকা C প্রোগ্রামিং পর্ব ৫৪-এ।
  5. Level line-এর কারণ মুছুন, বা line বন্ধ করুন. 6.5 বা 5.5-এর line ISR শেষেও উঁচু থাকলে CPU আবার ISR-এ ঢোকে, তারপর আবার: interrupt storm. হয় ISR যন্ত্রকে বলে line নামাবে, নয়তো SIM দিয়ে সেই line বন্ধ রাখবে, যতক্ষণ না main অবস্থা দেখে আবার খোলে (অনুশীলন ১).
  6. ISR-এর জায়গা আলাদা রাখুন. লেখকের lab-এ একটি ভুলে ISR বসেছিল ঠিক main-এর শেষ HLT-এর পরে। ISR-এর RET ফিরল HLT-এর পরের ঠিকানায়, অর্থাৎ ISR-এর নিজের শুরুতেই; দ্বিতীয় RET stack-এর ফাঁকা জায়গা থেকে 0000H তুলে নিল। সেখান থেকে শূন্য byte (NOP) চলতে চলতে CPU পৌঁছাল vector-এর JMP-এ, আবার ISR, আবার RET; চক্রটি চলল যতক্ষণ না simulator ১০ লক্ষ নির্দেশে থামাল (Spec decision 11).

এবার সময়ের হিসাব। যন্ত্র সংকেত দেওয়া থেকে ISR-এর প্রথম নির্দেশ শুরু হওয়া পর্যন্ত সময় হলো interrupt latency. 8085-এ এর তিনটি অংশ: চলতি নির্দেশের বাকি অংশ (সবচেয়ে বেশি CALL বা নেওয়া শর্তযুক্ত CALL, ১৮ T), acknowledge (১২ T), vector-এর JMP (১০ T). সবচেয়ে খারাপ ক্ষেত্রে, IE খোলা থাকলে:

  1. চলতি নির্দেশ: সর্বোচ্চ 18 T.
  2. Acknowledge: 12 T (Spec decision 7).
  3. Vector-এর JMP: 10 T.
  4. মোট 18 + 12 + 10 = 40 T; 40 × 0.333 µs = 13.33 µs.

এর ওপর যোগ হয় অন্য ISR চলার সময় আর DI দিয়ে বন্ধ রাখা সময়, যা প্রায়ই অনেক বড়। CPU HLT-এ থাকলে চলতি নির্দেশ নেই: 12 + 10 = 22 T = 7.33 µs. আধুনিক Cortex-M-এ register বাঁচানোর কাজ hardware নিজে করে আর latency-র নিজস্ব হিসাব আছে; সেটি পর্ব ৩০ (Cortex-M-এর exception আর NVIC — vector table, priority আর tail-chaining)-এ, আর ISR নকশার আধুনিক রূপ পর্ব ৪৩ (Interrupt আর ISR নকশা — latency, priority আর shared data)-এ।

Reference lab-এর নিজের উদাহরণ interrupt.asm (README-র 8085-টেবিলের শেষ সারি) এই সব নিয়ম একসাথে দেখায়: SIM দিয়ে 7.5 খোলা, EI, HLT-এ অপেক্ষা, ISR-এ PUSH PSW, counter বাড়ানো, POP PSW, EI, RET; দুটি 7.5 ঘটনা আসে T = 100 আর 300-এ। HLT অবস্থায় simulator-এর clock সরাসরি পরের ঘটনার সময়ে লাফ দেয় (Spec decision 8). সত্যিকারের run:

~/lab$ python -B sim8085.py run examples/8085/interrupt.asm
A=0B B=00 C=00 D=00 E=00 H=00 L=00 SP=2800 PC=2019
Flags: S=0 Z=1 AC=1 P=1 CY=0   (F=54H)
Memory 2050H..2051H:
  2050H: 02 0B
Instructions: 34   T-states: 437

Counter 2050H = 02, আর শেষে RIM-এর মান 2051H = 0BH: IE = 1, শুধু 7.5 খোলা। মোট ৪৩৭ T, README-র সংখ্যার সঙ্গে হুবহু এক।

আরও গভীরে: Datasheet অনুযায়ী 8085 interrupt line-গুলো দেখে প্রতিটি নির্দেশের শেষ দিকের একটি নির্দিষ্ট clock-এ, আর কোনো line-এর অনুরোধ নিলে ভেতরে একটি RST-এর মতো নির্দেশ তৈরি হয়; তাই TRAP আর তিনটি RST line-এর acknowledge-এর খরচ সাধারণ RST নির্দেশের সমান। HOLD দিয়ে bus অন্য কেউ (যেমন DMA controller) নিলে CPU সেই সময় interrupt-এর জবাব দিতে পারে না, তাই DMA-ও latency বাড়ায়। আর RST 7.5-এর ভেতরের latch-এর জন্য datasheet একটি ন্যূনতম pulse width বেঁধে দেয়; খুব সরু spike তাই নির্ভরযোগ্যভাবে ধরা পড়ে না, আবার যান্ত্রিক বোতামের একাধিক লাফ (bounce) একাধিক edge হয়ে ISR বারবার চালাতে পারে। Debouncing-এর পুরো আলোচনা পর্ব ৪২-এ।

পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:

  • RST 7.5-এর vector কেন 003CH? 7.5 × 8 = 60 = 3CH; একইভাবে 6.5 → 34H, 5.5 → 2CH, TRAP (4.5) → 24H.
  • কোন interrupt mask করা যায় না? TRAP; এটি edge আর level দুটোতেই সাড়া দেয় আর IE-ও মানে না।
  • শুধু RST 5.5 খোলা আর 7.5 latch মোছার SIM byte? 0001 1110 = 1EH.
  • RIM = 2AH মানে? 6.5 অপেক্ষায়, IE = 1, কিন্তু M6.5 = 1 (বন্ধ), তাই 6.5 আপাতত ঢুকবে না।
  • ISR-এর শেষে EI না দিলে? পরের কোনো maskable interrupt আর আসবে না; শুধু TRAP আসবে।

৯ · AI-এর যুগে 8085-এর interrupt যাচাই

Interrupt-এর প্রশ্নে AI assistant-এর ভুলগুলো বেশ নির্দিষ্ট। 8085, 8086, Z80 আর আধুনিক microcontroller-এর interrupt-ব্যবস্থা একসাথে শিখেছে বলে সে নিয়ম মেশায়, আর বিটের ক্রম উল্টে দেয়। কয়েকটি পরিচিত উদাহরণ আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
8085-এর ISR শেষ করে IRET বা RETI দিয়ে (এগুলো 8086 আর Z80-এর)Simulator-এ assemble করুন; 8085-এ EI আর RET
SIM-এর বিটের ক্রম উল্টায়, বা MSE বিট ভুলে যায়Byte-টি SIM দিয়ে লিখে RIM দিয়ে পড়ে মিলিয়ে দেখুন
Vector ভুল বলে, যেমন RST 6.5 = 0030H (ওটি software RST 6)নম্বর × 8 হিসাব; trace-এর ---- লাইনের vector
ISR-এ PUSH PSW বা শেষে EI বাদ দেয়দুইবার interrupt দিয়ে চালান; দ্বিতীয়টি কাজ করে কি না, flag ঠিক আছে কি না
RST 7.5-কে level বা 6.5-কে edge বলে; latch-এর কথা বলে নাIntel-এর datasheet; mask বন্ধ রেখে চাপ দিয়ে RIM
Latency বা acknowledge-এর T-state অনুমানে বলেTrace-এর মোট T থেকে নিজে বিয়োগ করুন

AI-কে কাজে লাগাতে আগে প্রসঙ্গ আর যাচাইয়ের পথ বেঁধে দিন:

আমি Intel 8085 assembly লিখছি; 8086 বা Z80 নয়। Intel-এর mnemonic আর 2050H ধরনের সংখ্যা চাই, program শুরু হবে 2000H-এ আর SP-তে থাকবে 2800H. ১. RST 6.5-এ একটি ISR লেখো, যা port 02H-এ 01H পাঠায় আর 2060H-এর counter এক বাড়ায়। main-এ কোন SIM byte দিতে হবে, প্রতিটি বিট আলাদা করে ব্যাখ্যা করো। ২. ISR-এ কোন register বাঁচাতে হবে আর কেন, আর শেষে কোন দুটি নির্দেশ কোন ক্রমে লাগবে, বলো। ৩. 6.5-এর line ISR শেষেও উঁচু থাকলে কী হবে, আর তা কীভাবে ঠেকাবে, বলো। ৪. যে নির্দেশ 8085-এ নেই, তা ব্যবহার করবে না। T-state বা vector নিয়ে নিশ্চিত না হলে অনুমান কোরো না, বলো।

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

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

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

প্র ০১TRAP-কে edge আর level দুটোই কেন লাগে? শুধু একটি হলে কী সমস্যা হতো, আর আজকের chip-এ এর উত্তরসূরি কী?

TRAP-এর কাজ এমন ঘটনা জানানো, যা উপেক্ষা করা চলে না: বিদ্যুৎ চলে যাওয়ার সতর্কতা, memory-র parity ত্রুটি, বা একটি জরুরি বন্ধের বোতাম। এমন line-এর দুটি বিপরীত ঝুঁকি আছে। প্রথম ঝুঁকি মিথ্যা সংকেত: কারখানার মোটর চালু হওয়ার মুহূর্তে বা বজ্রপাতের সময় তারে একটি সরু spike আসতে পারে। শুধু edge-triggered হলে এমন একটি spike-এই TRAP-এর ISR চলত, আর সেই ISR প্রায়ই নাটকীয় কাজ করে, যেমন সব কাজ থামিয়ে data বাঁচানো। দ্বিতীয় ঝুঁকি বারবার চলা: বিদ্যুৎ চলে যাওয়ার সংকেত একবার এলে বেশ কিছুক্ষণ উঁচু থাকে। শুধু level-triggered হলে, আর TRAP-কে যেহেতু mask বা DI দিয়ে থামানো যায় না, ISR শেষ হতেই CPU আবার TRAP-এ ঢুকত, তারপর আবার; program আর কখনো সামনে এগোত না।

Intel দুটি শর্ত জুড়ে দিয়ে দুটি ঝুঁকিই কমিয়েছে। Line-কে উঠতে হবে (edge), আর acknowledge পর্যন্ত উঁচু থাকতে হবে (level): ক্ষণিকের spike দ্বিতীয় শর্ত পূরণ করে না। আবার নেওয়ার পরে line উঁচু থাকলেও নতুন করে নেওয়া হয় না, যতক্ষণ না line নেমে আবার ওঠে। ফলে প্রতিটি সত্যিকারের ঘটনায় ISR ঠিক একবার চলে।

এর পরেও TRAP-এর একটি দুর্বলতা থাকে, যা এই পর্বের পাঁচ-line পরীক্ষায় দেখা গেছে: TRAP আসে IE-এর অবস্থা না দেখেই, আর acknowledge IE = 0 করে। ISR শেষে অন্ধভাবে EI দিলে যে interrupt main তখনো চালু করেনি, তা চালু হয়ে যায়। Intel তাই RIM-এ TRAP-এর আগের IE দেখানোর ব্যবস্থা রেখেছে। আজকের ARM Cortex-M-এ TRAP-এর উত্তরসূরি NMI: এর অগ্রাধিকার স্থির আর প্রায় সবার ওপরে, PRIMASK দিয়ে বন্ধ হয় না, আর hardware নিজেই ফেরার সময় আগের অবস্থা ফিরিয়ে আনে, তাই IE-এর এই ধাঁধা সেখানে নেই (পর্ব ৩০)। Watchdog, clock ব্যর্থতা আর brown-out-এর সতর্কতা সাধারণত এই NMI-তেই আসে।

মূল উপলব্ধি: যে interrupt থামানো যায় না, তার ট্রিগার হতে হয় সবচেয়ে কঠোর; আর তার ISR-কে ফেরার সময় বাকি ব্যবস্থার অবস্থা ঠিক আগের মতো রেখে যেতে হয়।

প্র ০২RST 7.5 edge-এ latch করে, অথচ 6.5 আর 5.5 level মানে। একই chip-এ দুই নিয়ম কেন, আর কোন যন্ত্র কোন line-এ জোড়া উচিত?

কারণ বাস্তব যন্ত্র দুই রকম সংকেত দেয়। কিছু যন্ত্র একটি ঘটনা জানায়, যা এক মুহূর্তের: বোতাম চাপা, একটি pulse-ভিত্তিক sensor-এর টিক, real-time clock-এর প্রতি সেকেন্ডের একটি ছোট pulse. এমন সংকেত CPU হয়তো ঠিক তখন দেখতে পারছে না (IE বন্ধ, অন্য ISR চলছে), আর ততক্ষণে pulse শেষ। RST 7.5-এর ভেতরের latch এই মুহূর্তটি মনে রাখে, mask বন্ধ থাকলেও। তাই tare বোতাম 7.5-এ। এর দাম দুটি: latch একটি মাত্র বিট, তাই অপেক্ষার সময় দুটি চাপ এলে একটি হারায়; আর পুরোনো, অবাঞ্ছিত চাপও মনে থেকে যায়, যা এই পর্বে SIM-এর বিট ৪ দিয়ে মুছতে হয়েছে।

অন্য যন্ত্র একটি অবস্থা জানায়: “আমার কাছে data আছে”, “তাপমাত্রা সীমার বাইরে”। Line ততক্ষণ উঁচু, যতক্ষণ অবস্থা সত্য। এখানে level-trigger স্বাভাবিক: CPU যখনই পারুক, line দেখে বুঝবে কাজ বাকি। আর একাধিক যন্ত্র একটি line ভাগ করলে (wired-OR), একজনের অনুরোধের পরে আরেকজনের অনুরোধও হারায় না, কারণ line উঁচুই থাকে। দাম হলো ISR-কে অবশ্যই কারণ মুছতে হবে; নইলে interrupt storm. Cold room-এর comparator এই ধরনের, তাই 6.5-এ, আর অনুশীলন ১-এ ISR নিজের line বন্ধ করে।

Computer Architecture-এর ভাষায় এটি edge বনাম level-triggered interrupt-এর পুরোনো আপস, যা আজও প্রতিটি interrupt controller-এ আছে: STM32-এর EXTI-তে প্রতিটি line-এর rising বা falling edge বাছা যায় আর একটি pending বিট latch-এর কাজ করে; ARM-এর NVIC-এ peripheral-এর interrupt সাধারণত level, আর ISR-কে peripheral-এর flag মুছতে হয়। কোর্সের বাজারঘর board-এ EXTI0 বোতামের edge latch করে (Spec decision 27), ঠিক 8085-এর 7.5-এর আধুনিক রূপ। আর যান্ত্রিক বোতামের bounce একাধিক edge বানায়, তাই edge-line-এ বোতাম জুড়লে debounce লাগে, hardware-এ বা software-এ।

মূল উপলব্ধি: ঘটনা জানাতে edge আর latch, অবস্থা জানাতে level; প্রতিটির নিজের হারানো আর বারবার-চলার ঝুঁকি আছে, আর যন্ত্রের সংকেতের ধরন দেখে line বাছাই নকশার প্রথম সিদ্ধান্ত।

প্র ০৩8085 interrupt নেওয়ার সময় IE বন্ধ করে, আর EI কাজ করে এক নির্দেশ পরে। এই দুটি নিয়ম না থাকলে কী ঘটত? 8086 আর Cortex-M কীভাবে একই সমস্যা মিটিয়েছে?

প্রথম নিয়মটি ভাবুন level-triggered line দিয়ে। RST 6.5-এর line উঁচু, CPU ISR-এ ঢুকল। Acknowledge যদি IE বন্ধ না করত, তবে ISR-এর প্রথম নির্দেশ শেষ হতেই, line তখনো উঁচু বলে, CPU আবার একই ISR-এ ঢুকত, আবার stack-এ দুই byte; ISR কখনো শেষই হতো না, stack নিচে নামতে নামতে data আর program মুছে ফেলত। IE বন্ধ করে CPU ISR-কে একটি নিরাপদ শুরু দেয়: register বাঁচানো আর যন্ত্রের কারণ মোছার সময়।

দ্বিতীয় নিয়মটি ফেরার মুহূর্তের জন্য। ISR-এর শেষে EI দিতেই হবে, কিন্তু EI যদি সঙ্গে সঙ্গে কাজ করত, তবে EI আর RET-এর মাঝখানে অপেক্ষমাণ একটি interrupt ঢুকে পড়ত। Stack-এ তখনো আগের ফেরার ঠিকানা আছে, নতুনটি তার ওপরে বসত। ঘন ঘন interrupt এলে এই স্তূপ বাড়তেই থাকত। এক নির্দেশের দেরি নিশ্চিত করে যে RET আগে শেষ হবে, stack খালি হবে, তারপর নতুন interrupt. এই পর্বের stepper-এ ঠিক সেটিই দেখা গেছে: 7.5-এর RET শেষ হওয়ার পরে 6.5 এসেছে, SP আবার 2800H থেকে।

8086 একই সমস্যা মিটিয়েছে একটি নির্দেশে: interrupt নেওয়ার সময় CPU FLAGS (IF-সহ), CS আর IP stack-এ রাখে আর IF = 0 করে; IRET এই তিনটি একসাথে ফেরায়, তাই IF-এর পুরোনো মানও একই মুহূর্তে ফেরে, কোনো ফাঁক থাকে না (পর্ব ২০)। Cortex-M আরও এগিয়েছে: hardware নিজেই আটটি register stack-এ রাখে, ISR একটি সাধারণ C ফাংশন হতে পারে, আর অগ্রাধিকার দিয়ে ঠিক হয় কে কাকে থামাতে পারে, IE-এর মতো একটি সাধারণ সুইচের দরকারই কম। ধারাবাহিকতা স্পষ্ট: 8085-এ প্রোগ্রামারের দায়িত্ব, 8086-এ একটি নির্দেশের, Cortex-M-এ hardware-এর।

মূল উপলব্ধি: Interrupt-ব্যবস্থার সবচেয়ে বিপজ্জনক মুহূর্ত ঢোকা আর বেরোনোর সীমানা; 8085 সেখানে দুটি ছোট নিয়ম দিয়ে stack-কে নিরাপদ রাখে, আর পরের CPU-গুলো একই কাজ hardware-এ সরিয়ে নিয়েছে।

প্র ০৪Interrupt কি সবসময় polling-এর চেয়ে ভালো? কখন polling-ই ঠিক পথ, আর HLT এই হিসাবে কোথায় বসে?

সবসময় নয়। প্রতিটি interrupt-এর একটি স্থির খরচ আছে। 8085-এ acknowledge ১২ T, vector-এর JMP ১০ T, PUSH PSW ১২, POP PSW ১০, EI ৪, RET ১০: আসল কাজ শুরুর আগে আর পরে মিলিয়ে প্রায় ৫৮ T. এই পর্বের tare ISR-এ main-এর STA শেষ (T = 72) থেকে ISR-এর RET শেষ (T = 153) পর্যন্ত ৮১ T, যার মধ্যে আসল কাজ (IN আর STA) মাত্র ২৩ T. বিরল ঘটনার জন্য এটি কিছুই নয়। কিন্তু যন্ত্র যদি খুব ঘন ঘন data দেয়, যেমন প্রতি ১০০ T-এ একটি byte, তবে প্রতিটি byte-এর জন্য interrupt নিলে CPU-র বেশিরভাগ সময় ঢোকা-বেরোনোয় যায়। তখন একটি টানা polling loop কম খরচে বেশি byte নেয়।

Polling সঠিক আরও দুটি ক্ষেত্রে। এক, timing-এর পূর্বানুমান: polling loop-এর প্রতিটি পাকের T-state জানা, তাই কখন কী হবে নিশ্চিত বলা যায়; interrupt-ভিত্তিক program-এর আচরণ ঘটনার মুহূর্তের ওপর নির্ভর করে, যা পরীক্ষা করা কঠিন। Safety-critical কিছু নকশা এই কারণে ইচ্ছা করে polling বা স্থির সময়সূচি বেছে নেয়। দুই, CPU-র আর কোনো কাজ না থাকলে: শুধু একটি যন্ত্রের অপেক্ষাই যদি সব হয়, polling-এর সরলতা যথেষ্ট। খুব দ্রুত ধারার data-র জন্য তৃতীয় পথ DMA, যেখানে CPU একেবারেই থাকে না (পর্ব ২৭, পর্ব ৪৬).

HLT দুই জগতের মাঝখানে। Polling-এ CPU পূর্ণ গতিতে চলে, কিছু না পেলেও। EI আর HLT দিলে CPU থেমে থাকে, আর interrupt এলে মাত্র ২২ T-তে ISR-এ পৌঁছায়। এটিই আজকের sleep mode-এর পূর্বপুরুষ: ARM-এর WFI নির্দেশ CPU-র clock বন্ধ করে, আর ব্যাটারিতে চলা device-এর বিদ্যুৎ খরচ বহুগুণ কমায় (পর্ব ৬০)। বাজারঘরের cold-room monitor সেকেন্ডে একবার মাপে; বাকি সময় ঘুমিয়ে থাকাই তার জন্য সঠিক নকশা।

মূল উপলব্ধি: বিরল আর অনিশ্চিত ঘটনায় interrupt, খুব ঘন ঘটনায় polling বা DMA, আর অপেক্ষার সময় ঘুম; সিদ্ধান্তটি ঘটনার হার আর প্রতিটি interrupt-এর স্থির খরচের তুলনা।

প্র ০৫Interrupt-এর mask আর serial pin, দুটি সম্পূর্ণ আলাদা কাজ একই SIM/RIM-এ কেন? আর bit-banging আজ কোথায় টিকে আছে?

উত্তর লুকিয়ে আছে 8080-এর opcode-মানচিত্রে। 8085-কে 8080-এর program চালাতে হতো, তাই নতুন নির্দেশ বসানোর জায়গা ছিল শুধু 8080-এর অব্যবহৃত ঘরগুলো। Intel দুটি ঘর নিল, 20H আর 30H, আর ঠিক করল এই দুটি নির্দেশ দিয়েই সব নতুন hardware-এর কাজ চলবে: তিনটি mask, 7.5-এর latch মোছা, SOD লেখা; আর উল্টো দিকে অপেক্ষার তালিকা, IE, mask আর SID পড়া। এক byte-এ আটটি বিট, প্রতিটির আলাদা অর্থ, আর MSE ও SDE-এর মতো “enable” বিট দিয়ে অংশগুলো আলাদা রাখা। নকশাটি কৃপণ, কিন্তু ঝুঁকিও এখান থেকেই: serial বিট পাঠাতে গিয়ে ভুল byte দিলে mask বদলে যায়, যা এই পর্বের SOD-উদাহরণে ANI 80H না দিলে ঘটে।

SID আর SOD রাখার কারণও chip কমানো। সেই সময় একটি ছোট control board-এ একটি LED বা একটি terminal-এর জন্য আলাদা serial chip (8251) বসানো খরচ আর জায়গা দুটোই বাড়াত। দুটি pin আর software দিয়ে ধীর serial যোগাযোগ বা একটি status বাতি চালানো যেত। Intel-এর নিজের সহায়ক chip-গুলো (8155, 8355, 8755: RAM বা ROM, I/O port আর timer একসাথে) মিলিয়ে কয়েকটি chip-এই পুরো একটি ছোট computer হতো; প্রশিক্ষণ kit-গুলো এভাবেই তৈরি।

Bit-banging আজও বেঁচে আছে, যেখানে hardware নেই বা protocol অদ্ভুত। Microcontroller-এর একটি GPIO pin দিয়ে 1-Wire temperature sensor পড়া, রঙিন LED strip-এর সরু timing-এর সংকেত, বা অতিরিক্ত একটি UART: সবই প্রায়ই software-এ হয়। আধুনিক chip এর জন্য বিশেষ সাহায্যও এনেছে, যেমন RP2040-এর programmable I/O, যা ছোট state machine দিয়ে নিখুঁত timing-এ pin নাড়ায়, CPU-কে মুক্ত রেখে। কিন্তু মূল সমস্যা বদলায়নি: software-এর timing interrupt-এর কাছে অসহায়, তাই bit-banging-এর সময় interrupt বন্ধ রাখা বা timing-কে hardware-এ সরানো, এই দুইয়ের একটি বাছতেই হয়।

মূল উপলব্ধি: Opcode-এর সীমিত জায়গা আর chip কমানোর চাপ থেকে দুটি নির্দেশে অনেক কাজ জোড়া হয়েছে; তাতে সুবিধা আছে, কিন্তু প্রতিটি বিটের অর্থ মনে রেখে byte বানানোর দায়িত্বও প্রোগ্রামারের।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — cold room-এর alarm: তাপমাত্রা 8.00 °C ছাড়ালে একটি comparator RST 6.5 উঁচু করে, আর ঠান্ডা না হওয়া পর্যন্ত উঁচুই রাখে। Program লিখুন: main SP বসাবে, 2060H-এর counter শূন্য করবে, শুধু 6.5 খুলবে (পুরোনো 7.5 চাপ মুছে), EI দিয়ে HLT-এ অপেক্ষা করবে। ISR port 02H-এ 01H পাঠিয়ে alarm চালু করবে, counter বাড়াবে, আর line উঁচু থাকা অবস্থায় বারবার না চলার ব্যবস্থা করবে। দুটি অনুরোধ (T = 50 আর 300) দিয়ে পরীক্ষা করুন।
            ORG 0034H
            JMP ALARM
            ORG 2000H
    MAIN:   LXI SP,2800H
            XRA A
            STA 2060H       ; counter = 0
            MVI A,1DH       ; R7.5=1, MSE=1, শুধু 6.5 খোলা
            SIM
            EI
            HLT
            MVI C,20        ; একটু অপেক্ষা, তারপর অবস্থা দেখা
    DLY:    DCR C
            JNZ DLY
            RIM
            STA 2061H
            HLT
    ALARM:  PUSH PSW
            MVI A,01H
            OUT 02H         ; alarm চালু
            LDA 2060H
            INR A
            STA 2060H
            MVI A,0FH       ; MSE=1, তিনটি mask বন্ধ
            SIM
            POP PSW
            EI
            RET

    মূল সিদ্ধান্ত ISR-এর MVI A,0FH আর SIM: 6.5 নিজেকেই বন্ধ করে, তাই উঁচু line আর ISR চালায় না; ঠান্ডা হলে main অবস্থা দেখে আবার 1DH দিয়ে খুলবে। SIM A বদলায় বলে PUSH PSW আগে। সত্যিকারের run: 2060H: 01 2F, OUT port 02H <- 01H (at T=101) মাত্র একবার, ৬৩টি নির্দেশ, ৪৭২ T. দ্বিতীয় অনুরোধ (T = 300) হারায়নি: RIM = 2FH = 0010 1111, অর্থাৎ 6.5 অপেক্ষায়, IE = 1, তিনটি mask বন্ধ। Simulator level line-কে “নেওয়া পর্যন্ত ধরে রাখা অনুরোধ” হিসেবে মডেল করে (Spec decision 7), তাই এখানে দ্বিতীয় অনুরোধ একটি আলাদা ঘটনা হিসেবে দেওয়া।

  2. ভুল খুঁজুন — দ্বিতীয় চাপে কিছু হয় না: Reference lab-এর interrupt.asm-এর ISR থেকে কেউ EI লাইনটি মুছে দিলেন: ISR75: PUSH PSW / LDA 2050H / INR A / STA 2050H / POP PSW / RET. Main একই: SIM (0BH), EI, তারপর WAIT: HLT, counter 2 না হওয়া পর্যন্ত JNZ WAIT. দুটি RST 7.5 আসে T = 100 আর 300-এ। কী ঘটবে? Simulator কী দেখায়, আর আসল chip-এ কী হতো?

    প্রথম চাপে ISR চলে, counter = 1. কিন্তু acknowledge IE = 0 করেছিল, আর ISR তা আর খোলেনি। Main আবার HLT-এ যায়। দ্বিতীয় চাপ 7.5-এর latch-এ ঠিকই জমে, কিন্তু IE = 0 বলে নেওয়া হয় না, CPU আর জাগে না। সত্যিকারের run:

    ~/lab$ python -B sim8085.py run noei.asm
    A=01 B=00 C=00 D=00 E=00 H=00 L=00 SP=2800 PC=200C
    Flags: S=1 Z=0 AC=0 P=1 CY=1   (F=85H)
    Memory 2050H..2051H:
      2050H: 01 00
    Instructions: 19   T-states: 300

    Counter 01, PC = 200CH (WAIT-এর HLT-এর পরের ঠিকানা), আর 2051H = 00, কারণ শেষের RIM পর্যন্ত program কখনো পৌঁছায়নি। Simulator থামে কারণ আর কোনো ঘটনা নেই যা CPU-কে জাগাতে পারে (Spec decision 11); আসল chip চিরকাল HLT-এ ঘুমিয়ে থাকত, শুধু TRAP বা reset জাগাতে পারত। সমাধান: POP PSW-এর পরে, RET-এর ঠিক আগে EI. তখন ফল 2050H: 02 0B, ৪৩৭ T.

  3. আগে বলুন, তারপর চালান: LXI SP,2800H / MVI A,0EH / SIM / EI / NOP / HLT / HLT. RST 7.5 আর RST 5.5 দুটোই T = 30-এ আসে। 002CH-এ JMP ISR55, যেখানে RIM / STA 2070H / EI / RET; 003CH-এ JMP ISR75, যা 2071H-এ 75H লেখে। কোন ISR চলবে, কতবার? 2070H আর 2071H-এ কী থাকবে? ISR-এ ঢোকার সময় stack-এ কোন ঠিকানা?

    0EH = 0000 1110: MSE = 1, M7.5 = 1, M6.5 = 1, M5.5 = 0, তাই শুধু 5.5 খোলা। 7.5-এর ক্রম বেশি হলেও সে বন্ধ, প্রতিযোগিতাতেই নেই; তবে তার latch বসে থাকে। দুটি line আসে যখন CPU প্রথম HLT-এ (T = 34). CPU জেগে 5.5 নেয়: ফেরার ঠিকানা 2009H (প্রথম HLT-এর পরে, দ্বিতীয় HLT) stack-এ, মোট ৪৬ T. ISR-এর RIM = 46H = 0100 0110: I7.5 = 1 (অপেক্ষায়), I5.5 = 0 (এইমাত্র নেওয়া), IE = 0, M7.5 = 1, M6.5 = 1, M5.5 = 0. তারপর দ্বিতীয় HLT; 7.5 বন্ধ বলে CPU আর জাগে না। সত্যিকারের run: 2070H: 46 00, অর্থাৎ 2071H = 00, ISR75 একবারও চলেনি; ১২টি নির্দেশ, ৯২ T. দ্বিতীয় HLT-টি জরুরি: না থাকলে ISR-এর RET ফিরত ISR-এর নিজের শুরুতে (অংশ ৮-এর নিয়ম ৬).

  4. হিসাব — latency: IE খোলা, শুধু 7.5 খোলা; CPU একটি CALL (১৮ T) শুরু করেছে T = 39-এ, আর বোতামের edge আসে T = 40-এ। Vector-এ JMP ISR. ISR-এর প্রথম নির্দেশ কখন শুরু হবে? Latency কত T আর কত µs? সবচেয়ে খারাপ ক্ষেত্র কত? Interrupt-এর সময় stack-এ কোন ঠিকানা যায়?
    1. CALL শেষ হয় 39 + 18 = 57-এ; PC তখন subroutine-এর শুরু 200CH.
    2. Acknowledge: 57 + 12 = 69; stack-এ যায় 200CH, অর্থাৎ subroutine-এর প্রথম নির্দেশ, কারণ CPU তখন সেখানেই।
    3. Vector-এর JMP: 69 + 10 = 79. ISR-এর প্রথম নির্দেশ শুরু হয় T = 79-এ।
    4. Latency = 79 − 40 = 39 T = 39 × 0.333 µs = 13.0 µs.
    5. সবচেয়ে খারাপ: edge ঠিক CALL শুরুর মুহূর্তে, 18 + 12 + 10 = 40 T = 13.33 µs. CPU HLT-এ থাকলে 12 + 10 = 22 T = 7.33 µs.

    লেখকের lab-এ সত্যিকারের trace (latency.asm): CALL শেষে total = 57, acknowledge-এর পরে JMP শেষে 79, ISR-এর EI আর RET ফেরে 200CH-এ, তারপর subroutine-এর RET আর HLT: মোট ১০৮ T. সর্বোচ্চ stack-গভীরতা দুই ঠিকানা: CALL-এর ফেরার ঠিকানা আর interrupt-এর। এর মানে stack-এর আকার ঠিক করতে interrupt-এর জন্য বাড়তি জায়গা হিসাবে রাখতে হয়।

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

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

ক্রম8085-এ খোলা mask আর IE = 1 অবস্থায় RST 7.5 এলে কী কী ঘটে, সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. উঠন্ত edge RST 7.5-এর ভেতরের latch-এ জমা হয়
  2. CPU চলতি নির্দেশ শেষ করে
  3. Mask, IE আর অগ্রাধিকার দেখে RST 7.5 বাছাই হয়
  4. IE = 0 হয়, ফেরার ঠিকানা stack-এ যায়, PC = 003CH
  5. ISR register বাঁচিয়ে নিজের কাজ করে আর register ফেরায়
  6. EI, তারপর RET stack থেকে ঠিকানা তুলে আগের জায়গায় ফেরে

8085-এ RST 6.5-এর interrupt নেওয়া হলে CPU কোন ঠিকানায় লাফ দেয়?

  • 0030H
  • 003CH
  • 0034H
  • 002CH

8085-এর কোন interrupt mask বা DI দিয়ে বন্ধ করা যায় না, আর edge ও level দুটোতেই সাড়া দেয়?

  • TRAP
  • RST 7.5
  • INTR
  • RST 5.5

8085-এ শুধু RST 5.5 খোলা রাখতে (7.5 আর 6.5 বন্ধ), জমে থাকা RST 7.5 অনুরোধ মুছতে, আর SOD না ছুঁতে SIM-এর আগে A-তে কোন byte দিতে হবে?

  • 0EH
  • 1DH
  • 16H
  • 1EH

8085-এ RIM চালানোর পরে A = 2AH. এর অর্থ কী?

  • RST 7.5 অপেক্ষায়, IE = 1
  • RST 6.5 অপেক্ষায় কিন্তু তার mask বন্ধ, IE = 1
  • SID = 1, IE = 0
  • শুধু RST 5.5 বন্ধ, কেউ অপেক্ষায় নেই

8085-এর INTR-এর acknowledge-এর সময় একটি যন্ত্র data bus-এ EFH রাখল। CPU কোথায় লাফ দেবে?

  • 00EFH
  • 0038H
  • 0028H
  • 002CH

8085-এর একটি ISR শেষ হয় EI আর তারপর RET দিয়ে। আরেকটি interrupt আগে থেকেই অপেক্ষায় থাকলে সেটি কখন নেওয়া হয়?

  • EI শেষ হওয়ামাত্র, RET-এর আগে
  • RET শেষ হওয়ার পরে, main-এর পরের নির্দেশের আগে
  • Main-এর আরেকটি নির্দেশ চলার পরে
  • Main আবার EI দিলে তবেই

শব্দকোষ

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

মনে রাখুন

  1. পাঁচটি line: TRAP (0024H, non-maskable, edge + level) > RST 7.5 (003CH, edge, latch) > RST 6.5 (0034H, level) > RST 5.5 (002CH, level) > INTR (যন্ত্রের RST n, INTA).
  2. CPU-র কাজ: চলতি নির্দেশ শেষ, IE = 0, PC stack-এ, vector-এ লাফ, ১২ T; register বাঁচানো আর EI, RET ISR-এর কাজ।
  3. SIM: SOD, SDE, —, R7.5, MSE, M7.5, M6.5, M5.5; MSE = 1 না দিলে mask বদলায় না, R7.5 জমে থাকা চাপ মোছে।
  4. RIM: SID, I7.5, I6.5, I5.5, IE, M7.5, M6.5, M5.5; TRAP-এর পরে প্রথম RIM আগের IE দেখায়।
  5. সময়: EI এক নির্দেশ পরে কাজ করে; latency সর্বোচ্চ 18 + 12 + 10 = 40 T = 13.33 µs; bit-banging-এ ২৪০০ baud = ১২৫০ T প্রতি বিট।

পরের পর্বে: পর্ব ১৪ (8086-এর গঠন — BIU, EU, segment আর physical address). ৮ বিটের 8085 থেকে ১৬ বিটের 8086-এ: দুই ভাগে ভাগ করা CPU, আগে থেকে নির্দেশ এনে রাখার queue, আর segment দিয়ে ১ MB memory-র ঠিকানা।

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

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