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

8085 আর 8086-এর সমস্যা অনুশীলন — program, timing আর interfacing

Practice: 8085 and 8086 Problems — Flags, Machine Code, BCD, Loops, Stack, Delay Timing, SIM/RIM, Physical and Effective Addresses, String Instructions, Stack Frames, Interrupt Vectors, Address Decoding, 8255, 8254 and 8259

Taught in Bangla, this practice page gathers module 2–4 calculations into 31 problems, each with marks, difficulty and a step-by-step model answer. It covers 8085 flags, machine code, BCD, loops, stack, 3 MHz delays and SIM/RIM; 8086 physical and effective addresses, string instructions, stack frames and interrupt vectors; address decoding; and 8255, 8254 and 8259. 8085 answers are real sim8085.py runs with T-states, 8086 results are assembled with NASM and run in Unicorn, and ten Pyodide blocks recheck the rest.

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

  • 8085-এর যেকোনো ছোট program-এর পরে A, flag byte, memory আর মোট T-state হাতে বের করা, আর machine code হাতে লেখা
  • DAA, unsigned বনাম signed তুলনা, গুণ-ভাগের loop আর শূন্য গণকের ফাঁদ চেনা
  • Stack-এর প্রতিটি byte, CALL/RET-এর ঠিকানা আর 3 MHz-এ delay loop-এর N হিসাব করা; SIM আর RIM-এর byte লেখা ও পড়া
  • 8086-এ effective address, default segment, physical address, flag, DIV, REP, stack frame আর vector table-এর ঠিকানা বের করা
  • 74LS138 দিয়ে address range, partial decoding-এর আয়না-ঠিকানা, 8255-এর control word, 8254-এর count আর 8259-এর ICW লেখা

১ · পাতার নিয়ম, ভাগের মানচিত্র আর উত্তরের পাঁচ ধাপ

বাজারের দাঁড়িপাল্লায় ওজন মাপার আগে দোকানি দেখেন কাঁটা শূন্যে আছে কি না, কোন বাটখারা কোন পাল্লায়, আর শেষে হিসাব দুবার মেলান। 8085 আর 8086-এর সমস্যাও এভাবে করুন: শুরুর অবস্থা (register, SP, segment, port-এর ঠিকানা) খাতায় লিখুন, প্রতিটি নির্দেশ কোন flag ছোঁয় তা মনে করুন, আর শেষে simulator-এ মেলান। এই পাতার প্রতিটি প্রশ্ন নিজে-নিজে সম্পূর্ণ: যা data লাগে, প্রশ্নেই দেওয়া।

উত্তরের পাঁচ ধাপ
শুরুর অবস্থা → প্রতি নির্দেশে পরিবর্তন → flag-এর নিয়ম → সময় বা ঠিকানার সূত্র → চালিয়ে মেলানো
  1. শুরুর অবস্থা: register, SP, segment, memory-র byte আর port-এর ঠিকানা। এখানে hex লেখা হয় Intel-এর রীতিতে, শেষে H (2050H, 0FFH); অক্ষর দিয়ে শুরু হলে সামনে 0 লাগে (কোর্সের assembler FFH-কে নাম ভাবে)। NASM-এর 8086 কোডে ছোট h (2000h) চলে।
  2. প্রতি নির্দেশে পরিবর্তন: কোন register বা byte বদলাল, পাশে লিখুন। Stack আর string-এর প্রশ্নে pointer-এর মান প্রতি লাইনে।
  3. Flag-এর নিয়ম: কোন নির্দেশ কোন flag ছোঁয় না, সেখানেই সবচেয়ে বেশি নম্বর কাটে (INR/DCR CY ছোঁয় না, INX/DCX কিছুই ছোঁয় না; 8086-এর INC CF ছোঁয় না)।
  4. সূত্র: 8085-এর clock 3 MHz (6 MHz crystal), এক T-state = 0.333 µs; 8086-এ physical address = segment × 10H + offset.
  5. মেলানো: 8085 হলে sim8085.py run বা trace, 8086 হলে run8086.py --regs/--trace, আর পাতার Python block.

ছবি ৮১.১ — কোন অংশে কোন ধরনের প্রশ্ন, আর মূল পর্ব

নীল 8085, বেগুনি 8086, সবুজ interfacing, কমলা মিশ্র

Map of the practice groups: 8085, 8086, interfacing and mixed problems with their source lessons 8085: flag আরmachine code 8085: BCD, array,গুণ-ভাগ 8085: stack আরdelay (3 MHz) 8085: SIM আর RIM 8086: EA, physicaladdress, flag 8086: REP, frame,vector table Address decoding 8255, 8254আর 8259 মিশ্র: cold room-এর alarm অংশ ২পর্ব ০৭, ০৯, ১০ অংশ ৩পর্ব ০৫, ১১ অংশ ৪পর্ব ১২ অংশ ৫পর্ব ১৩ অংশ ৬পর্ব ১৪–১৬ অংশ ৭পর্ব ১৭–২০ অংশ ৮পর্ব ২২ অংশ ৯পর্ব ২৪–২৬ অংশ ১০পর্ব ২৩, ২৪ প্রতিটি উত্তর: simulator-এ চালিয়ে মেলান

কোন tool কী দেয়: sim8085.py কোর্সের reference lab-এর 8085 assembler আর emulator (Intel-এর manual-এর T-state, README-র Spec decision ১–১২)। পাতার Python block-এ এর হুবহু কপি sim85.py চলে। run8086.py NASM 3.02 (BSD-2-Clause) দিয়ে assemble করে Unicorn 2.1.4-এ (binding BSD, engine GPLv2) চালায়; এটি 386-শ্রেণির core, তাই চারটি ছোট পার্থক্য আছে (Spec decision ১৫), আর 8086-এর clock গোনা হয় না (Spec decision ১৬)। Reference lab-এ interfacing chip-এর simulator নেই: তাদের byte পাতার Python block হিসাব করে, আর 8085 থেকে যাওয়া OUT-এর ক্রম simulator-এর log দেখায়।

অংশপ্রশ্নের ধরনমূল পর্বপ্রশ্ন
২Flag byte, borrow, machine code, ১৬ বিটের loop-এর ভুল০৭, ০৯, ১০২.১–২.৪
৩DAA, signed বনাম unsigned গোনা, গুণ আর ভাগের T-state০৫, ১১৩.১–৩.৪
৪Stack trace, delay-এর N, শূন্য গণক, হারানো POP১২৪.১–৪.৪
৫SIM-এর byte, RIM পড়া, vector আর EI১৩৫.১–৫.৩
৬Physical address, EA আর default segment, flag, DIV১৪–১৬৬.১–৬.৪
৭REP MOVSB, REPNE SCASB, stack frame, vector table১৭–২০৭.১–৭.৪
৮Address line, 74LS138-এর range, partial decoding২২৮.১–৮.৩
৯8255-এর control word, 8254-এর count, 8259-এর ICW২৪–২৬৯.১–৯.৩
১০মিশ্র নকশা আর এক লাইনের সিদ্ধান্ত০৯, ২৩, ২৪১০.১–১০.২

Cortex-M, timer, baud rate, ADC আর RTOS-এর গাণিতিক সমস্যা আছে পর্ব ৮৪-এ, আর তুলনামূলক লিখিত প্রশ্ন পর্ব ৮৩-এ; এখানে সেগুলো আবার নেই।

২ · 8085 — flag, borrow আর machine code

ঝালিয়ে নিন: পর্ব ০৭ · 8085-এর গঠন (flag byte = S Z 0 AC 0 P 0 CY), পর্ব ০৯ · instruction set (কোন নির্দেশ কোন flag ছোঁয়), পর্ব ১০ · addressing mode (ঠিকানার ছোট byte আগে)।

২.১MVI A,8CH, MVI B,7DH, ADD B, HLT চালানোর পরে A, পাঁচটি flag, flag byte আর মোট T-state কত? — ৫ নম্বর (সহজ)

8CH + 7DH = 109H; A-তে থাকে নিচের ৮ বিট 09H, আর নবম বিট যায় CY-তে: CY = 1. নিচের nibble C + D = 25 > 15, তাই বিট ৩ থেকে carry: AC = 1. 09H = 0000 1001-এ দুটি 1, জোড় সংখ্যা: P = 1. S = 0, Z = 0. Flag byte S Z 0 AC 0 P 0 CY = 0001 0101 = 15H. সময়: 7 + 7 + 4 + 5 = 23 T. সত্যিকারের run:

A=09 B=7D C=00 D=00 E=00 H=00 L=00 SP=0000 PC=2006
Flags: S=0 Z=0 AC=1 P=1 CY=1   (F=15H)
Instructions: 4   T-states: 23

নম্বর-ভাগ: A (১), পাঁচটি flag (২), flag byte (১), T-state (১)। যেখানে নম্বর কাটে: P-কে পুরো 109H থেকে গোনা; parity শুধু A-র ৮ বিটের।

২.২A = 32H অবস্থায় SUI 47H: A আর flag কত? CY = 1-এর অর্থ কী, আর signed সংখ্যা হিসেবে ফলটি ঠিক কি না? — ৫ নম্বর (সহজ)

50 − 71 = −21; ৮ বিটে −21 = 256 − 21 = 235 = EBH. বিয়োগে CY = 1 মানে borrow: unsigned হিসেবে A ছোট ছিল। S = 1 (বিট ৭), Z = 0, EBH = 1110 1011-এ ছয়টি 1, তাই P = 1. AC: 8085 বিয়োগ করে A + (NOT 47H) + 1 হিসেবে (Spec decision ৪); নিচের nibble 2 + 8 + 1 = 11, বিট ৩ থেকে carry নেই, তাই AC = 0. Flag byte 85H, সময় 7 + 7 + 5 = 19 T (সত্যিকারের run: A=EB … S=1 Z=0 AC=0 P=1 CY=1 (F=85H)). Signed হিসেবে −21 ঠিক, overflow নেই; 8085-এ overflow flag-ই নেই।

যেখানে নম্বর কাটে: CY = 1-কে “carry হয়েছে” লেখা; বিয়োগে এটি ধার। আর AC-কে 8086-এর নিয়মে হিসাব করা।

২.৩নিচের program হাতে assemble করুন (2000H থেকে), প্রতিটি byte লিখুন, মোট মাপ আর T-state বলুন। [2050H] = A7H, [2051H] = 6CH হলে [2052H] আর CY কত? LXI H,2050H / MOV A,M / INX H / ADD M / STA 2052H / HLT — ১০ নম্বর (মাঝারি)

প্রথম byte opcode, তারপর data বা ঠিকানার ছোট byte আগে। সত্যিকারের sim8085.py asm:

2000  21 50 20     LXI H,2050H     10 T
2003  7E           MOV A,M          7 T
2004  23           INX H            6 T
2005  86           ADD M            7 T
2006  32 52 20     STA 2052H       13 T
2009  76           HLT              5 T
Bytes: 10          মোট             48 T

A7H + 6CH = 113H: [2052H] = 13H, CY = 1 (run: 2050H: A7 6C 13, T-states: 48). নম্বর-ভাগ: byte (৪), মাপ (১), T-state (৩), ফল (২)। যেখানে নম্বর কাটে: 32 20 52 লেখা (তখন চলে STA 5220H), আর INX-কে ৪ T ধরা: opcode fetch এখানে ৬ T.

২.৪ভুল খুঁজুন: তিনবার ঘোরার জন্য লেখা LXI B,0003H / L: DCX B / JNZ L / HLT. কী হয়, কেন, আর ঠিক রূপের মোট T-state কত? — ৫ নম্বর (মাঝারি)

DCX কোনো flag ছোঁয় না। Reset-এর পরে Z = 0, তাই JNZ সবসময় লাফ দেয়: অসীম loop. BC শূন্য হলেও Z জানে না। Simulator ৫০০০টি নির্দেশ পরে থামে: runtime error: stopped after 5000 instructions (no HLT reached?). ঠিক রূপে DCX B-এর পরে MOV A,C আর ORA B: BC = 0 হলে তবেই Z = 1. সময় 10 + (6 + 4 + 4 + 10) × 3 − 3 + 5 = 84 T, অর্থাৎ 24N + 7 আর HLT-এর 5 (run: Instructions: 14 T-states: 84).

যেখানে নম্বর কাটে: “DCX শূন্যে Z বসায়” লেখা; শুধু ৮ বিটের DCR বসায়।

# ২.১–২.৪-এর চেকার: ছোট program চালিয়ে A, flag আর T-state (sim85 = sim8085.py-র কপি)
from sim85 import assemble, run, CpuError

def go(lines, steps=1_000_000):
    src = "  ORG 2000H\n" + "\n".join("  " + x for x in lines) + "\n  HLT"
    return run(assemble(src), max_steps=steps)

cases = [("ADD 8CH+7DH", ["MVI A,8CH", "MVI B,7DH", "ADD B"]),
         ("SUI 32H-47H", ["MVI A,32H", "SUI 47H"]),
         ("STC, INR FFH", ["MVI A,0FFH", "STC", "INR A"]),
         ("ANI 3CH&F0H", ["MVI A,3CH", "ANI 0F0H"])]
for name, prog in cases:
    c = go(prog)
    print(f"{name:13} A={c.A:02X}  {c.flags_str()}  F={c.F:02X}H  T={c.tstates}")

good = ["LXI B,0003H", "L: DCX B", "MOV A,C", "ORA B", "JNZ L"]
print("ঠিক loop:", go(good).tstates, "T  (24N + 7 + HLT 5, N = 3)")
try:
    go(["LXI B,0003H", "L: DCX B", "JNZ L"], steps=5000)
except CpuError as e:
    print("শুধু DCX B / JNZ:", e)

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

ADD 8CH+7DH   A=09  S=0 Z=0 AC=1 P=1 CY=1  F=15H  T=23
SUI 32H-47H   A=EB  S=1 Z=0 AC=0 P=1 CY=1  F=85H  T=19
STC, INR FFH  A=00  S=0 Z=1 AC=1 P=1 CY=1  F=55H  T=20
ANI 3CH&F0H   A=30  S=0 Z=0 AC=1 P=1 CY=0  F=14H  T=19
ঠিক loop: 84 T  (24N + 7 + HLT 5, N = 3)
শুধু DCX B / JNZ: stopped after 5000 instructions (no HLT reached?)

প্রথম দুই সারি ২.১ আর ২.২-এর সত্যিকারের run-এর সঙ্গে অক্ষরে অক্ষরে মেলে। তৃতীয় সারি INR-এর ফাঁদ দেখায়: FFH থেকে 00H হলো, Z = 1, কিন্তু আগে STC দিয়ে বসানো CY = 1 অক্ষত, কারণ INR CY ছোঁয় না। চতুর্থ সারিতে ANI-এর পরে AC = 1 আর CY = 0: এটি 8085-এর নিয়ম (8080-এ AC আলাদা)। শেষ দুই লাইন ২.৪-এর দুই রূপ।

৩ · 8085 — BCD, array আর গুণ-ভাগ

ঝালিয়ে নিন: পর্ব ০৫ · এমবেডেড কাজের সংখ্যা (BCD, two's complement), পর্ব ১১ · 8085 assembly program (loop-এর ছাঁচ, গুণ = 69 + 24b T, ভাগ = 86 + 29q T, DAA-র নিয়ম)।

৩.১BCD যোগ: [2050H] + [2051H], তারপর DAA, ফল [2052H]-এ। (ক) 38H + 45H (খ) 99H + 01H. প্রতিটিতে ADD-এর পরের A, DAA কী যোগ করে, শেষ A আর CY? — ৫ নম্বর (সহজ)
  1. (ক) 38H + 45H = 7DH; নিচের nibble D > 9, তাই DAA 06H যোগ করে: 83H, CY = 0, অর্থাৎ ৩৮ + ৪৫ = ৮৩. সংশোধনে D + 6-এ বিট ৩ থেকে carry, তাই AC = 1; S = 1, P = 0 (run: 2050H: 38 45 83, F=90H).
  2. (খ) 99H + 01H = 9AH; নিচের nibble A > 9 → 06H, তাতে A0H, ওপরের nibble A > 9 → 60H, মোট 66H: A = 00H, CY = 1, অর্থাৎ ১০০ (run: 2050H: 99 01 00, Z=1 … CY=1).

দুটিতেই ৭টি নির্দেশ, 56 T. যেখানে নম্বর কাটে: (খ)-তে CY ভুলে শুধু 00 লেখা; শতকের অঙ্কটি CY-তেই থাকে। আর Intel 8085-এ DAA শুধু যোগের পরে ঠিক, বিয়োগের পরে নয়।

৩.২বাজারঘরের cold room-এর ছয়টি পূর্ণসংখ্যা তাপমাত্রা (°C, ৮ বিটের two's complement) [2051H]–[2056H]-এ: 10, −2, 8, 9, −1, 7; [2050H]-এ গণনা 06H. নিচের program ৮-এর বেশি কয়টি গোনার কথা। সে কত দেয়, ভুল কোথায়, ঠিক করুন। LXI H,2050H / MOV C,M / MVI B,00H / NEXT: INX H / MOV A,M / CPI 09H / JC OK / INR B / OK: DCR C / JNZ NEXT / MOV A,B / STA 2060H / HLT — ১০ নম্বর (মাঝারি)

CPI unsigned তুলনা করে: −2 = FEH আর −1 = FFH, দুটিই 09H-এর চেয়ে “বড়”। তাই program দেয় 4 (0AH, FEH, 09H, FFH), ঠিক উত্তর 2 (10 আর 9). সংশোধন: তুলনার আগে চিহ্ন দেখুন। MOV A,M-এর পরে ORA A আর JM OK: ঋণাত্মক মান কখনো “গরম” নয়। সত্যিকারের run দুই রূপের:

ভুল রূপ:  2060H: 04   Instructions: 46   T-states: 311
ঠিক রূপ:  2060H: 02   Instructions: 52   T-states: 347

৩৬ T বেশি কেন: ORA A আর JM ছয়টি পাকে যোগ করে ৭২ T (চারটি ধনাত্মকে 4 + 7, দুটি ঋণাত্মকে 4 + 10), আর দুটি ঋণাত্মক মান CPI, JC আর INR এড়িয়ে ৩৬ T বাঁচায়। নম্বর-ভাগ: ভুল ফল (৩), কারণ (৩), সংশোধন (৪)। দামি কারণ: unsigned ভুলে −1 °C-এর ঠান্ডা ঘরকে “গরম” বলা হয়।

৩.৩বারবার যোগের গুণ: LDA 2050H / MOV E,A / MVI D,00H / LDA 2051H / MOV C,A / LXI H,0000H / LOOP: DAD D / DCR C / JNZ LOOP / SHLD 2052H / HLT. [2050H] = 25, [2051H] = 12: ফল কোথায় কী, আর মোট T-state কত (সূত্রসহ)? গুণক 0 হলে কী হয়? — ১০ নম্বর (মাঝারি)

25 × 12 = 300 = 012CH; SHLD L আগে রাখে: [2052H] = 2CH, [2053H] = 01H. সময়: loop-এর বাইরে 13 + 4 + 7 + 13 + 4 + 10 = 51, প্রতি পাক 10 + 4 + 10 = 24, শেষ JNZ-এ −3, শেষে 16 + 5: 51 + 24b − 3 + 21 = 69 + 24b = 69 + 288 = 357 T (run: 2050H: 19 0C 2C 01, T-states: 357). ৩ MHz-এ 119 µs.

গুণক 0: DCR C 00H থেকে FFH-এ যায়, Z = 0, তাই loop ২৫৬ বার ঘোরে: ফল 25 × 256 = 6400, শূন্য নয়। নিচের ব্লক এটি চালিয়ে দেখায়। যেখানে নম্বর কাটে: DAD-এর পরে CY ধরে ১৭ বিটের ফল ভাবা (৮ × ৮ বিটে সর্বোচ্চ 65025, ১৬ বিটে আঁটে), আর গুণক 0 যাচাই না করা।

৩.৪বারবার বিয়োগের ভাগ (LDA 2051H / MOV B,A / LDA 2050H / MVI C,00H / LOOP: CMP B / JC DONE / SUB B / INR C / JMP LOOP / DONE: STA 2053H / MOV A,C / STA 2052H / HLT): 250 ÷ 9-এর ভাগফল, ভাগশেষ আর T-state কত? ভাজক 0 হলে? — ৫ নম্বর (মাঝারি)

250 = 9 × 27 + 7: [2052H] = 1BH, [2053H] = 07H. প্রতি সফল পাক CMP 4 + JC না নেওয়া 7 + SUB 4 + INR 4 + JMP 10 = 29 T; বাকিটা স্থির 86 T. মোট 86 + 29 × 27 = 869 T (run: 2050H: FA 09 1B 07, Instructions: 145 T-states: 869). ভাজক 0 হলে CMP B কখনো CY দেয় না: loop থামে না (simulator ২০০০০টি নির্দেশ পরে থামায়)। প্রতিকার: শুরুতে MOV A,B / ORA A / JZ ERROR.

যেখানে নম্বর কাটে: সময়কে ভাগফলের ওপর নির্ভরহীন ধরা; এখানে সময় q-এর রৈখিক অপেক্ষক।

# ৩.৩–৩.৪-এর চেকার: গুণ আর ভাগের program সব মানে, T-state-এর সূত্রসহ (sim85 = sim8085.py)
from sim85 import assemble, run

MUL = """LDA 2050H / MOV E,A / MVI D,00H / LDA 2051H / MOV C,A / LXI H,0000H
         / LOOP: DAD D / DCR C / JNZ LOOP / SHLD 2052H / HLT"""
DIV = """LDA 2051H / MOV B,A / LDA 2050H / MVI C,00H / LOOP: CMP B / JC DONE
         / SUB B / INR C / JMP LOOP / DONE: STA 2053H / MOV A,C / STA 2052H / HLT"""
prog = {k: assemble("\n".join(["  ORG 2000H"] + ["  " + x.strip() for x in s.split("/")]))
        for k, s in (("mul", MUL), ("div", DIV))}

def go(k, a, b):
    c = run(prog[k], sets=[(0x2050, [a, b])])
    return c.mem[0x2052], c.mem[0x2053], c.tstates

print("25 x 12 :", go("mul", 25, 12))
print("250 / 9 :", go("div", 250, 9))
bad_m = [(a, b) for a in (0, 1, 25, 200, 255) for b in range(1, 256)
         if go("mul", a, b) != ((a * b) & 255, (a * b) >> 8, 69 + 24 * b)]
bad_d = [(a, b) for a in range(0, 256, 5) for b in range(1, 256, 9)
         if go("div", a, b) != (a // b, a % b, 86 + 29 * (a // b))]
print("গুণ: 69 + 24b মেলেনি", len(bad_m), "জোড়ায়;  ভাগ: 86 + 29q মেলেনি", len(bad_d), "জোড়ায়")
c = run(prog["mul"], sets=[(0x2050, [25, 0])])
print("গুণক 0:", c.mem[0x2053] * 256 + c.mem[0x2052], "পেলাম, পাক =", (c.tstates - 69) // 24)

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

25 x 12 : (44, 1, 357)
250 / 9 : (27, 7, 869)
গুণ: 69 + 24b মেলেনি 0 জোড়ায়;  ভাগ: 86 + 29q মেলেনি 0 জোড়ায়
গুণক 0: 6400 পেলাম, পাক = 256

দুই সূত্র ১২৭৫টি গুণের জোড়ায় আর ১৫০৮টি ভাগের জোড়ায় simulator-এর সঙ্গে হুবহু মিলেছে। শেষ লাইনটি ৩.৩-এর ফাঁদ: গুণক 0 দিলে ফল 6400 আর পাক ২৫৬. পরীক্ষায় তাই গুণক বা ভাজক শূন্য হলে কী হবে, এক লাইনে লিখে দিন।

৪ · 8085 — stack, subroutine আর 3 MHz-এ delay

ঝালিয়ে নিন: পর্ব ১২ · 8085-এর stack আর subroutine: SP নিচের দিকে বাড়ে; PUSH ১২, POP ১০, CALL ১৮, RET ১০ T; delay loop ৮ বিটে 14N + 4, ১৬ বিটে 24N + 7 T; 1 ms = 3000 T.

৪.১Trace করুন: LXI SP,2800H / LXI B,1234H / MVI A,56H / PUSH B / PUSH PSW / CALL SUB1 / POP PSW / POP D / HLT, আর SUB1: XRA A / RET (CALL-টি 200AH-এ, SUB1 2010H-এ)। প্রতিটি ধাপে SP, 27FAH–27FFH-এর byte, আর শেষে A, DE, Z ও মোট T-state? — ১০ নম্বর (মাঝারি)

PUSH আগে SP − 1-এ উঁচু byte, তারপর SP − 2-এ নিচু byte রাখে। PUSH PSW-এ A উঁচু ঠিকানায়, flag byte নিচুতে; CALL ফেরার ঠিকানা 200DH রাখে। শেষে stack-এ 0D 20 00 56 34 12 (27FAH থেকে) পড়ে থাকে, কারণ POP পড়ে কিন্তু মোছে না। XRA A ভেতরে Z = 1 করেছিল, কিন্তু POP PSW পুরোনো flag byte 00H ফেরত আনে: শেষে A = 56H, Z = 0, DE = 1234H, SP = 2800H, মোট 108 T. নিচের stepper প্রতিটি ধাপ দেখায় (সত্যিকারের trace থেকে)।

যেখানে নম্বর কাটে: PSW-তে flag আগে লেখা; আর ফেরার ঠিকানা 200AH (CALL-এর নিজের ঠিকানা) লেখা। CALL তিন byte, তাই 200DH.

Byte-এর সারি 27FAH থেকে 27FFH · — মানে এখনো লেখা হয়নি
নির্দেশ
SP
27FA–27FF
Register
মোট T
  1. শুরু। SP = 2800H, stack ফাঁকা। BC = 1234H, A = 56H, flag byte 00H. এখন পর্যন্ত 10 + 10 + 7 = 27 T.
  2. PUSH B. 27FFH-এ B (12H), 27FEH-এ C (34H); SP = 27FEH. ১২ T.
  3. PUSH PSW. 27FDH-এ A (56H), 27FCH-এ flag byte (00H); SP = 27FCH.
  4. CALL SUB1. ফেরার ঠিকানা 200DH: 27FBH-এ 20H, 27FAH-এ 0DH; SP = 27FAH, PC = 2010H. ১৮ T.
  5. XRA A আর RET. A = 00H, Z = 1. RET 27FAH–27FBH থেকে 200DH তুলে PC-তে বসায়; SP = 27FCH. Byte-গুলো মোছে না।
  6. POP PSW. 27FCH থেকে flag byte 00H, 27FDH থেকে A = 56H: Z আবার 0. SP = 27FEH.
  7. POP D আর HLT. E = 34H, D = 12H; SP = 2800H, stack আবার “ফাঁকা”, যদিও ছয়টি byte memory-তে রয়ে গেছে। মোট ১০৮ T.
৪.২3 MHz-এর 8085-এ ১৬ বিটের delay subroutine (DELAY: LXI B,N / LOOP: DCX B / MOV A,C / ORA B / JNZ LOOP / RET), CALL-সহ ঠিক 10 ms-এর কাছাকাছি চাই। N কত (দশমিক আর hex), সত্যিকারের সময় কত, ভুল কত µs? — ১০ নম্বর (মাঝারি)
  1. লক্ষ্য: 10 ms × 3000 T/ms = 30000 T.
  2. খরচ: CALL 18 + LXI 10 + loop (24N − 3) + RET 10 = 24N + 35.
  3. N = (30000 − 35) ÷ 24 = 1248.54 → N = 1249 = 04E1H.
  4. সময়: 24 × 1249 + 35 = 30011 T = 30011 ÷ 3 µs = 10.0037 ms; ভুল +11 T = 3.67 µs.

সত্যিকারের run (caller-এর LXI SP 10 আর HLT 5 T-সহ): Instructions: 5001 T-states: 30026 = 30011 + 15. হুবহু 1 ms দরকার হলে ৮ বিটের রূপ 14N + 32-এ N = 212 নিখুঁত মেলে (পর্ব ১২)। যেখানে নম্বর কাটে: crystal-এর 6 MHz দিয়ে হিসাব (সময় অর্ধেক আসে), আর CALL/RET বাদ দেওয়া।

৪.৩(ক) MVI C,00H / L: DCR C / JNZ L কতবার ঘোরে, কত T? (খ) LXI B,0000H-এর ১৬ বিটের loop কত সময় নেয়? (গ) 1 s-এর delay একটি ১৬ বিটের loop-এ সম্ভব? — ৫ নম্বর (কঠিন)

(ক) 00H থেকে কমালে FFH, তাই ২৫৬ পাক: 14 × 256 + 4 = 3588 T (run: HLT-সহ 3593). (খ) 0000H থেকে FFFFH, তাই ৬৫৫৩৬ পাক: 24 × 65536 + 7 = 1572871 T ≈ 524.29 ms (run: HLT-সহ 1572876). (গ) না: 1 s = 3000000 T, সবচেয়ে বড় এক loop ≈ 0.524 s. বাইরে আরেকটি গণক লাগে (nested loop), যেমন 50 ms-এর subroutine ২০ বার ডাকা। যেখানে নম্বর কাটে: N = 0-কে “শূন্যবার” ধরা।

৪.৪ভুল খুঁজুন: LXI SP,2800H / CALL WORK / HLT, আর WORK: PUSH B / MVI C,05H / RET. Reset-এর পরে BC = 0000H. RET কোথায় যায়, কেন, আর কীভাবে ঠিক করবেন? — ৫ নম্বর (মাঝারি)

RET stack-এর মাথা থেকে দুই byte তোলে। মাথায় আছে PUSH B-এর 0000H, ফেরার ঠিকানা তার নিচে চাপা। তাই PC = 0000H: program reset-এর ঠিকানায় ফিরে যায়, আর SP 2800H-এ না ফিরে 27FEH-এ থাকে। সত্যিকারের trace:

200A  C9  RET   … C=05 … SP=27FE PC=0000 …  T=10 total=57
0000  00  NOP   … SP=27FE PC=0001 …

সংশোধন: RET-এর আগে POP B; প্রতিটি PUSH-এর জোড়া POP, উল্টো ক্রমে। তখন C-ও আবার 00H হয়, যা subroutine-এর “register রক্ষা”-র উদ্দেশ্য।

# ৪.২–৪.৩-এর চেকার: চাওয়া সময় থেকে N, তারপর simulator-এ মেলানো (3 MHz, sim85 = sim8085.py)
from sim85 import assemble, run
T_US = 1 / 3                                   # 6 MHz crystal -> 3 MHz clock -> 0.333 µs

def delay16(n):                                # CALL + 16 বিটের loop + RET; caller-এর অংশ বাদ
    src = f"""  ORG 2000H
  LXI SP,2800H
  CALL DELAY
  HLT
DELAY: LXI B,{n}
LOOP:  DCX B
  MOV A,C
  ORA B
  JNZ LOOP
  RET"""
    return run(assemble(src)).tstates - (10 + 5)    # LXI SP আর HLT বাদ

for ms in (1, 10, 50):
    want = ms * 3000                           # 1 ms = 3000 T
    n = round((want - 35) / 24)                # 24N + 35 = want
    t = delay16(n)
    print(f"{ms:2} ms: N = {n:5} ({n:04X}H)  sim = {t} T = {t * T_US / 1000:.4f} ms")
t = delay16(0)
print(f"N = 0000H: {t} T = {t * T_US / 1000:.2f} ms  (65536 পাক)")

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

 1 ms: N =   124 (007CH)  sim = 3011 T = 1.0037 ms
10 ms: N =  1249 (04E1H)  sim = 30011 T = 10.0037 ms
50 ms: N =  6249 (1869H)  sim = 150011 T = 50.0037 ms
N = 0000H: 1572899 T = 524.30 ms  (65536 পাক)

প্রতিটি লক্ষ্যে ভুল একই, +11 T = 3.67 µs: 24 দিয়ে ভাগ না যাওয়ার ফল। 10 ms-এর সারি ৪.২-এর সঙ্গে মেলে, আর শেষ সারি ৪.৩(খ)-এর 524.29 ms-এর সঙ্গে CALL, LXI আর RET-এর ২৮ T যোগ করে (24N + 35). Block-টির ফাংশন সরাসরি sim85-এ program চালিয়ে সময় নেয়, সূত্র থেকে নয়।

৫ · 8085 — interrupt, SIM আর RIM

ঝালিয়ে নিন: পর্ব ১৩ · 8085-এর interrupt. SIM-এর byte: SOD SDE x R7.5 MSE M7.5 M6.5 M5.5; RIM-এর byte: SID I7.5 I6.5 I5.5 IE M7.5 M6.5 M5.5. Mask বিট 1 মানে বন্ধ।

৫.১RST 7.5 আর RST 5.5 খোলা, RST 6.5 বন্ধ, আর আগে জমে থাকা 7.5-এর অনুরোধ মুছতে হবে; serial output ছোঁয়া যাবে না। SIM-এর byte কত? এর পরে (IE = 1) RIM কী পড়বে? — ৫ নম্বর (সহজ)

বিট ধরে: SOD 0, SDE 0, x 0, R7.5 1, MSE 1, M7.5 0, M6.5 1, M5.5 0 → 0001 1010 = 1AH. কোড: MVI A,1AH / SIM. MSE = 1 না দিলে mask-এর তিন বিট উপেক্ষিত হয়। এর পরে কোনো অনুরোধ নেই, IE = 1, mask 010: RIM = 0000 1010 = 0AH (সত্যিকারের run-এ [2052H] = 0A). যেখানে নম্বর কাটে: mask-এ 1 মানে “খোলা” ধরা, আর MSE ভুলে যাওয়া।

৫.২একটি program MVI A,0FH / SIM / EI চালাল, তারপর RST 7.5 pin-এ একটি pulse এলো, পরে RIM দিল 4FH. প্রতিটি বিটের অর্থ বলুন। ISR কি চলেছে? এর পরে MVI A,18H / SIM দিলে কী হয়? — ৫ নম্বর (মাঝারি)

4FH = 0100 1111: SID 0, I7.5 = 1 (অনুরোধ জমে আছে), I6.5 0, I5.5 0, IE 1, M7.5 = M6.5 = M5.5 = 1. 7.5 edge-latched: mask থাকলেও flip-flop অনুরোধটি ধরে রাখে, কিন্তু ISR চলে না। 18H = R7.5 1, MSE 1, সব mask 0: জমা অনুরোধ মুছে তিনটিই খোলা, তাই পুরোনো pulse-এর জন্য ISR আর চলে না; পরের RIM = 08H. সত্যিকারের run-এ তিনটি RIM ছিল 4F 08 0A, আর 003CH-এর ISR একবারও চলেনি।

RIM-এর বিট: SID I7.5 I6.5 I5.5 IE M7.5 M6.5 M5.5
ঘটনা
Mask 7.5 6.5 5.5
7.5-এর latch
RIM
  1. সব বন্ধ। 0FH = MSE 1, তিনটি mask 1. EI দিয়ে IE = 1, কিন্তু তিন RST line-ই বন্ধ।
  2. Pulse এলো। RST 7.5 edge-latched: flip-flop 1 হলো। Mask থাকায় CPU লাফ দেয় না।
  3. RIM. 4FH: I7.5 = 1 (অপেক্ষায়), IE = 1, তিনটি mask 1. এখনো ISR চলেনি।
  4. 18H. R7.5 = 1 জমা অনুরোধ মুছে দেয়, MSE = 1 তিনটি mask খোলে। মোছার পরে খোলা, তাই পুরোনো pulse-এ লাফ হয় না। RIM = 08H.
  5. 1AH. শুধু 6.5 বন্ধ (৫.১-এর উত্তর)। RIM = 0AH. সারা run-এ 003CH-এর ISR একবারও চলেনি।
৫.৩TRAP, RST 7.5, 6.5 আর 5.5-এর vector ঠিকানা কোন নিয়মে আসে? দুই অনুরোধ একসঙ্গে এলে কে আগে? ISR-এর শেষে EI না দিলে কী হয়? — ৫ নম্বর (সহজ)

ঠিকানা = নম্বর × 8: TRAP (4.5) 0024H, 7.5 003CH, 6.5 0034H, 5.5 002CH. ক্রম TRAP > 7.5 > 6.5 > 5.5 > INTR. কোনো interrupt নিলেই CPU IE = 0 করে; ISR-এর শেষে EI না দিলে পরের কোনো maskable interrupt আর আসে না, শুধু TRAP আসে। লাফ দেওয়ার খরচ simulator-এ ১২ T (Spec decision ৭)।

# ৫.১–৫.২-এর চেকার: SIM-এর byte বানানো, RIM-এর byte পড়া, তারপর simulator-এ যাচাই
from sim85 import assemble, run

def sim_byte(mask75, mask65, mask55, reset75=False, sod=None):
    b = 0x08 | mask75 << 2 | mask65 << 1 | mask55          # MSE = 1
    b |= 0x10 if reset75 else 0
    return b | (0x40 | sod << 7 if sod is not None else 0)  # SDE, SOD

def rim_text(b):
    names = ["M5.5", "M6.5", "M7.5", "IE", "I5.5", "I6.5", "I7.5", "SID"]
    return " ".join(f"{n}={b >> i & 1}" for i, n in reversed(list(enumerate(names))))

w = sim_byte(0, 1, 0, reset75=True)
print(f"৫.১ SIM byte = {w:02X}H = {w:08b}b")
src = f"""  ORG 2000H
  MVI A,0FH
  SIM
  EI
  MVI C,10
W: DCR C
  JNZ W
  RIM
  MOV B,A
  MVI A,{w:02X}H
  SIM
  RIM
  HLT"""
c = run(assemble(src), irqs=[(60, "RST7.5", None)])   # T = 60-এ 7.5-এর pulse
for label, b in (("সব mask, 7.5 অপেক্ষায়", c.B), (f"SIM {w:02X}H-এর পরে", c.A)):
    print(f"RIM {b:02X}H ({label}): {rim_text(b)}")

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

৫.১ SIM byte = 1AH = 00011010b
RIM 4FH (সব mask, 7.5 অপেক্ষায়): SID=0 I7.5=1 I6.5=0 I5.5=0 IE=1 M7.5=1 M6.5=1 M5.5=1
RIM 0AH (SIM 1AH-এর পরে): SID=0 I7.5=0 I6.5=0 I5.5=0 IE=1 M7.5=0 M6.5=1 M5.5=0

sim_byte প্রশ্নের ভাষা থেকে byte বানায়, তারপর simulator-এ সেই byte দিয়ে SIM চালিয়ে RIM পড়া হয়। দুটি RIM ৫.১ আর ৫.২-এর উত্তরের সঙ্গে মেলে। খাতায় RIM-এর byte ভাঙার সময় এভাবেই বিটের নাম ওপরে লিখে নিচে মান বসান।

৬ · 8086 — physical address, EA, flag আর DIV

ঝালিয়ে নিন: পর্ব ১৪ · 8086-এর গঠন (physical address = segment × 10H + offset), পর্ব ১৫ · addressing mode (EA = base + index + displacement; BP থাকলে default segment SS), পর্ব ১৬ · instruction set (MUL/DIV-এর বাঁধা register). Overflow-এর তত্ত্ব Computer Architecture পর্ব ০৫-এ।

৬.১(ক) DS = 2345H, offset FFFEH: physical address? (খ) 4000H:0250H, 4025H:0000H আর 3FFFH:0260H কি একই byte? (গ) 40250H-কে মোট কয়টি segment:offset জোড়ায় লেখা যায়? — ৫ নম্বর (সহজ)

(ক) 23450H + FFFEH = 3344EH (segment-এর পাশে একটি শূন্য বসিয়ে যোগ)। (খ) হ্যাঁ, তিনটিই 40250H: 40000H + 0250H, 40250H + 0, 3FFF0H + 0260H. (গ) Segment s হলে offset = 40250H − 16s, যা 0000H–FFFFH-এর মধ্যে থাকতে হবে: s = 3026H থেকে 4025H, মোট ৪০৯৬টি। যেখানে নম্বর কাটে: segment আর offset সরাসরি যোগ করা (2345H + FFFEH).

৬.২DS = 2000H, SS = 3000H, ES = 4000H, BX = 0400H, BP = 0600H, SI = 0030H, DI = 0010H. প্রতিটির EA, segment আর physical address: (ক) [bx+si] (খ) [bp+di+05h] (গ) [si+20h] (ঘ) [bp] (ঙ) [es:bx+di]. প্রতিটির addressing mode-এর নাম? — ১০ নম্বর (মাঝারি)
OperandModeEASegPA
[bx+si]based-indexed0430HDS20430H
[bp+di+05h]based-indexed + disp0615HSS30615H
[si+20h]indexed0050HDS20050H
[bp]register indirect (based)0600HSS30600H
[es:bx+di]based-indexed, override0410HES40410H

যাচাইয়ের জন্য lab-এ পাঁচটি PA-তে আলাদা চিহ্ন-byte (A1, B2, C3, D4, E5) লিখে এই পাঁচ operand দিয়ে পড়া হয়েছে, শেষে lea si,[bp+di+05h]. সত্যিকারের run8086.py --regs:

AX=B2A1 BX=0400 CX=D4C3 DX=00E5 SI=0615 DI=0010 BP=0600
SP=FFFE CS=1000 DS=2000 ES=4000 SS=3000 IP=0163 --I------

পাঁচটি byte-ই ঠিক জায়গা থেকে এসেছে, আর SI = 0615H হলো (খ)-এর EA. [bp]-এর আসল encoding [bp+00h], কারণ mod 00-তে r/m 110 মানে direct address (পর্ব ১৫)। যেখানে নম্বর কাটে: (খ) আর (ঘ)-তে DS ধরা।

৬.৩প্রতিটির পরে ফল আর CF, PF, AF, ZF, SF, OF: (ক) AX = 8000H, add ax,8000h (খ) AX = 0005H, sub ax,7 (গ) AX = 7FFFH, CF = 0, inc ax. — ৫ নম্বর (মাঝারি)
  1. (ক) 0000H; CF = 1 (unsigned উপচে), OF = 1 (দুটি ঋণাত্মক যোগে ধনাত্মক), ZF = 1, PF = 1 (নিচের byte 00H-এ শূন্যটি 1), SF = 0, AF = 0. Run: O-I--Z-PC.
  2. (খ) FFFEH = −2; CF = 1 (ধার), SF = 1, AF = 1 (5 থেকে 7 নিতে nibble-এ ধার), OF = 0, PF = 0 (FEH-এ সাতটি 1). Run: --I-S-A-C.
  3. (গ) 8000H; OF = 1 (৩২৭৬৭ + ১ signed-এ আঁটে না), SF = 1, AF = 1, PF = 1, CF = 0: INC CF ছোঁয় না। Run: O-I-S-AP-.

Run-এর অক্ষর-ক্রম O D I T S Z A P C; I হলো শুরুর IF = 1. যেখানে নম্বর কাটে: PF পুরো ১৬ বিট থেকে গোনা; 8086-এও PF শুধু নিচের byte-এর।

৬.৪(ক) AX = 1000 (দশমিক), BL = 7, div bl: AL, AH আর AX? (খ) একই AX, BL = 3 হলে? (গ) (খ)-কে কীভাবে ঠিক করবেন? — ৫ নম্বর (মাঝারি)

(ক) 1000 = 7 × 142 + 6: AL = 8EH (১৪২), AH = 06H, AX = 068EH (run: AX=068E). (খ) ভাগফল ৩৩৩ AL-এ আঁটে না (সর্বোচ্চ ২৫৫): divide error, type 0. Handler নেই বলে run থামে: error: divide error (INT 0) at 1000:0105 and no INT 0 handler installed. 1000:0105H হলো div-এর নিজের ঠিকানা; আসল 8086 পরের নির্দেশের ঠিকানা stack-এ রাখত (Spec decision ১৫)। (গ) ১৬ বিটের ভাজক: xor dx,dx / mov bx,3 / div bx: AX = 014DH (৩৩৩), DX = 0001H (run মেলে)।

# ৬.১–৬.৩-এর চেকার: EA, default segment, physical address আর ১৬ বিটের flag (stdlib)
R = dict(BX=0x0400, BP=0x0600, SI=0x0030, DI=0x0010)
SEG = dict(DS=0x2000, SS=0x3000, ES=0x4000)
def pa(mode, disp=0, override=None):
    parts = [p for p in mode.split("+") if p]
    ea = (sum(R[p] for p in parts) + disp) & 0xFFFF
    seg = override or ("SS" if "BP" in parts else "DS")     # BP থাকলে SS
    return ea, seg, (SEG[seg] * 0x10 + ea) & 0xFFFFF
for mode, d, ov in [("BX+SI", 0, None), ("BP+DI", 5, None), ("SI", 0x20, None),
                    ("BP", 0, None), ("BX+DI", 0, "ES")]:
    ea, seg, p = pa(mode, d, ov)
    print(f"[{mode}+{d:02X}h]".ljust(14), f"EA={ea:04X}h  {seg}  PA={p:05X}h")
p20 = lambda s, o: f"{(s * 0x10 + o) & 0xFFFFF:05X}h"
print("2345h:FFFEh ->", p20(0x2345, 0xFFFE))
print("4000h:0250h, 4025h:0000h, 3FFFh:0260h ->", {p20(0x4000, 0x250), p20(0x4025, 0), p20(0x3FFF, 0x260)})
print("40250h-এর segment:offset জোড়া:", sum(0 <= 0x40250 - s * 16 <= 0xFFFF for s in range(0x10000)))
def flags16(a, b, sub=False):
    r = (a - b if sub else a + b) & 0xFFFF
    cf = (a < b) if sub else (a + b > 0xFFFF)
    sa, sb, sr = a >> 15, b >> 15, r >> 15
    of = (sa != sb and sr != sa) if sub else (sa == sb and sr != sa)
    af = ((a & 15) < (b & 15)) if sub else ((a & 15) + (b & 15) > 15)
    pf = bin(r & 0xFF).count("1") % 2 == 0                     # শুধু নিচের byte
    f = dict(O=of, S=sr, Z=r == 0, A=af, P=pf, C=cf)
    return f"{r:04X}h " + "".join(k if v else "-" for k, v in f.items())
print("8000h + 8000h =", flags16(0x8000, 0x8000))
print("0005h - 0007h =", flags16(0x0005, 0x0007, sub=True))
print("7530h + 1388h =", flags16(0x7530, 0x1388))

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

[BX+SI+00h]    EA=0430h  DS  PA=20430h
[BP+DI+05h]    EA=0615h  SS  PA=30615h
[SI+20h]       EA=0050h  DS  PA=20050h
[BP+00h]       EA=0600h  SS  PA=30600h
[BX+DI+00h]    EA=0410h  ES  PA=40410h
2345h:FFFEh -> 3344Eh
4000h:0250h, 4025h:0000h, 3FFFh:0260h -> {'40250h'}
40250h-এর segment:offset জোড়া: 4096
8000h + 8000h = 0000h O-Z-PC
0005h - 0007h = FFFEh -S-A-C
7530h + 1388h = 88B8h OS--P-

পাঁচটি PA ৬.২-এর run-এর চিহ্ন-byte-এর ঠিকানার সঙ্গে মেলে, আর তিনটি flag-এর সারি run8086.py-এর অক্ষরের সঙ্গে (শেষ সারিটি 7530H + 1388H, lab-এ চালিয়ে O-I-S--P-)। চেকারটি শুধু ছয়টি status flag হিসাব করে; IF, DF, TF control flag, যোগ-বিয়োগে বদলায় না।

৭ · 8086 — string, procedure আর interrupt vector

ঝালিয়ে নিন: পর্ব ১৭ · 8086 assembly program, পর্ব ১৮ · procedure আর stack frame, পর্ব ১৯ · string instruction (উৎস DS:SI, গন্তব্য ES:DI, DF), পর্ব ২০ · 8086-এর interrupt (type n-এর vector n × 4-এ, আগে IP তারপর CS). নিচের run-গুলোতে CS = DS = ES = SS = 1000H আর শুরুতে SP = FFFEH (Spec decision ১৩)।

৭.১DS:0200H থেকে "BAZAR-65.50" লেখা। cld / mov si,0200h / mov di,0300h / mov cx,5 / rep movsb-এর পরে SI, DI, CX আর ES:0300H–0304H কী? std দিলে কোন ঠিকানা থেকে শুরু করতে হতো? — ৫ নম্বর (সহজ)

REP প্রতি পাকে একটি byte কপি করে SI আর DI এক বাড়ায়, CX এক কমায়: SI = 0205H, DI = 0305H, CX = 0, আর গন্তব্যে "BAZAR" (42 41 5A 41 52). সত্যিকারের run: CX=0000 … SI=0205 DI=0305, 1000:0300 42 41 5A 41 52. std-এ ঠিকানা কমে, তাই শেষ byte থেকে শুরু: SI = 0204H, DI = 0304H. যেখানে নম্বর কাটে: শেষে SI-কে শেষ কপি হওয়া byte-এর ঠিকানা (0204H) লেখা।

৭.২একই ১১ byte-এ cld / mov di,0200h / mov cx,11 / mov al,'-' / repne scasb: শেষে DI, CX, ZF? '-' কত নম্বর ঘরে? AL = '#' হলে (যা লেখায় নেই)? — ৫ নম্বর (মাঝারি)

REPNE মিল না পাওয়া পর্যন্ত চলে। '-' ষষ্ঠ byte (offset 0205H). মিলের পরেও DI এক বাড়ে: DI = 0206H, অবস্থান = DI − 1 = 0205H; ছয়টি তুলনা হয়েছে, CX = 11 − 6 = 5, ZF = 1. Run: AX=002D … CX=0005 … DI=0206 … --I--Z-P-. '#' হলে ১১টি তুলনার পরে CX = 0, DI = 020BH, আর ZF = 0 (run: CX=0000 … DI=020B … --I-S--PC). থামার পরে CX নয়, ZF দেখুন: শেষ ঘরে মিল পেলেও CX = 0 হতো।

৭.৩বাজারঘরের দামের procedure: price(grams, rate) = (grams × rate + 500) ÷ 1000 পয়সা। Caller push 6550, তারপর push 1250, তারপর call price (ফেরার ঠিকানা 010BH). Procedure: push bp / mov bp,sp / mov ax,[bp+4] / mul word [bp+6] / add ax,500 / adc dx,0 / mov cx,1000 / div cx / pop bp / ret 4. শুরুতে SP = FFFEH. প্রতিটি ধাপে SP, [bp+4] আর [bp+6] কী, শেষে AX আর SP? — ১০ নম্বর (কঠিন)

Push: FFFCH-এ 1996H (৬৫৫০), FFFAH-এ 04E2H (১২৫০), CALL-এ FFF8H-এ 010BH, push bp-এ FFF6H-এ পুরোনো BP. তখন BP = FFF6H: [bp+2] ফেরার ঠিকানা, [bp+4] = FFFAH = grams, [bp+6] = FFFCH = rate. 1250 × 6550 = 8187500 = 007C EE6CH (DX:AX); +500 = 007C F060H; ÷ 1000 = 8188 = 1FFCH, ভাগশেষ 0: ৮১.৮৮ টাকা, README-র smart scale-এর সংখ্যার সঙ্গে হুবহু। ret 4 ফেরার ঠিকানা তুলে আরও ৪ byte সরায়: SP = FFFEH, ভারসাম্য ঠিক।

সত্যিকারের run-এর stack (--mem 1000:FFF6,8): 00 00 0B 01 E2 04 96 19. adc dx,0 জরুরি: নিচের word-এ +500 carry দিলে তা উঁচু word-এ যেতে হবে (এখানে দেয়নি, কিন্তু অন্য ওজনে দিতে পারে)। নম্বর-ভাগ: frame (৪), গুণ-ভাগ (৪), SP (২)। যেখানে নম্বর কাটে: প্রথম argument [bp+2]-এ ধরা, আর ret লিখে caller-এর stack-এ চার byte রেখে দেওয়া।

Word-এর ঠিকানা FFF6H, FFF8H, FFFAH, FFFCH · শুরুতে SP = FFFEH
নির্দেশ
SP
FFF6 → FFFC
AX, DX
  1. Rate push. 6550 = 1996H, FFFCH-এ। আগে push করা argument বড় ঠিকানায় থাকে।
  2. Grams push. 1250 = 04E2H, FFFAH-এ। SP = FFFAH.
  3. Near call. শুধু IP (010BH) stack-এ, FFF8H-এ; procedure 010CH থেকে শুরু।
  4. Frame. পুরোনো BP (0000H) FFF6H-এ, BP = SP = FFF6H. এখন [bp+4] = grams, [bp+6] = rate: argument-এর ঠিকানা BP থেকে স্থির।
  5. হিসাব। MUL: DX:AX = 007CH:EE6CH; +500 আর carry; DIV CX: AX = 1FFCH = 8188 পয়সা, DX = 0 ভাগশেষ।
  6. pop bp. BP = 0000H ফেরত, SP = FFF8H, মাথায় ফেরার ঠিকানা।
  7. ret 4. IP = 010BH, তারপর SP-তে 2 + 4: FFFEH. দুটি argument procedure নিজেই সরাল; caller-কে add sp,4 লিখতে হয় না।
৭.৪বাজারঘরের দাম-সেবা INT 60h. (ক) IVT-র কোন চার byte-এ এর vector? (খ) সেখানে 15 01 00 10 থাকলে handler-এর CS:IP আর physical address? (গ) INT 60h-এর ঠিক আগে SP = FFFEH, পরের নির্দেশ 0114H-এ, FLAGS = 0246H, CS = 1000H হলে ISR-এ ঢোকার মুহূর্তে SP আর stack-এর তিনটি word? — ১০ নম্বর (মাঝারি)

(ক) 60H × 4 = 00180H–00183H. (খ) আগে IP তারপর CS, ছোট byte আগে: IP = 0115H, CS = 1000H, PA = 10115H. (গ) CPU FLAGS, CS, IP এই ক্রমে push করে, তারপর IF = TF = 0: SP = FFF8H; [FFFCH] = 0246H, [FFFAH] = 1000H, [FFF8H] = 0114H. সত্যিকারের run-এ ISR stack পড়ে AX = 0114, BX = 1000, CX = 0246 আর SP = FFF8 পেয়েছে, আর --mem 0000:0180,4 দিয়েছে 15 01 00 10. আসল 8086 FLAGS-এর বিট ১২–১৫ 1 রাখে, তাই সেখানে F246H দেখা যেত; Unicorn সেগুলো 0 দেখায় (Spec decision ১৫)। যেখানে নম্বর কাটে: CS আগে IP পরে পড়া, আর ISR-এর শেষে ret লেখা (iret চাই)।

# ৭.৪-এর চেকার: type থেকে IVT-র ঠিকানা, ৪ byte থেকে handler, আর ঢোকার সময়ের stack
def vec(t):
    return t * 4, t * 4 + 3

for t, name in ((0, "divide error"), (2, "NMI"), (0x21, "DOS"), (0x4B, "8259 IR3"), (0x60, "বাজারঘর")):
    a, b = vec(t)
    print(f"type {t:02X}h ({name}): {a:05X}h-{b:05X}h")

ivt = bytes([0x15, 0x01, 0x00, 0x10])            # 00180h থেকে পড়া চারটি byte
ip, cs = ivt[0] | ivt[1] << 8, ivt[2] | ivt[3] << 8
print(f"IP={ip:04X}h CS={cs:04X}h -> handler PA {cs * 16 + ip:05X}h")

sp, stack = 0xFFFE, {}
for name, val in (("FLAGS", 0x0246), ("CS", 0x1000), ("IP", 0x0114)):
    sp -= 2
    stack[sp] = (name, val)
print(f"INT 60h-এর পরে SP = {sp:04X}h")
for a, (n, v) in sorted(stack.items()):
    print(f"  [{a:04X}h] = {v:04X}h  ({n})")

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

type 00h (divide error): 00000h-00003h
type 02h (NMI): 00008h-0000Bh
type 21h (DOS): 00084h-00087h
type 4Bh (8259 IR3): 0012Ch-0012Fh
type 60h (বাজারঘর): 00180h-00183h
IP=0115h CS=1000h -> handler PA 10115h
INT 60h-এর পরে SP = FFF8h
  [FFF8h] = 0114h  (IP)
  [FFFAh] = 1000h  (CS)
  [FFFCh] = 0246h  (FLAGS)

8259-এর IR3 এখানে type 4BH ধরা, যা ৯.৩-এর ICW2 = 48H থেকে আসে। Stack-এর তিনটি word সত্যিকারের run-এর AX, BX, CX-এর সঙ্গে মেলে। পরীক্ষায় vector-এর প্রশ্নে সবসময় চার byte-এর ক্রম (IP নিচু, IP উঁচু, CS নিচু, CS উঁচু) লিখে দিন।

৮ · Memory interfacing — address line, decoder আর আয়না-ঠিকানা

ঝালিয়ে নিন: পর্ব ২২ · Memory interfacing আর address decoding: 2n ঘরে n টি line chip-এর ভেতরে; 74LS138-এর C B A-তে A15 A14 A13 দিলে প্রতিটি output 8 KB-এর একটি ভাগ বাছে (output active-low). Decoder-এর logic Computer Architecture পর্ব ১২-এ।

৮.১8085-এর একটি board-এ 74LS138-এর C B A = A15 A14 A13, enable সবসময় সক্রিয়। (ক) Y5 কোন range বাছে? (খ) 8K × 8 chip-এর ভেতরে কয়টি address line? (গ) 64 KB পুরো ভরতে কয়টি chip? — ৫ নম্বর (সহজ)

(ক) C B A = 101: A15 = 1, A14 = 0, A13 = 1, বাকি ১৩টি line যেকোনো: A000H–BFFFH (শুরু = 5 × 2000H, শেষ = শুরু + মাপ − 1). (খ) 213 = 8192, তাই ১৩টি, A0–A12. (গ) 64 ÷ 8 = ৮টি, প্রতিটি output-এ একটি। যেখানে নম্বর কাটে: শেষ ঠিকানা C000H লেখা (শুরু + মাপ, −1 ভুলে)।

৮.২নকশা: 8085-এ একটি 4 KB EPROM 0000H থেকে, আর দুটি 2 KB RAM পরপর 4000H থেকে, full decoding-এ। 74LS138 (A15 A14 A13) ছাড়া আর কোন line লাগবে? প্রতিটি chip-এর range আর ভেতরের line? — ১০ নম্বর (কঠিন)
  1. EPROM: ভেতরে A0–A11 (212 = 4096). Y0 (0000H–1FFFH) বাছে 8 KB, তাই A12 = 0 শর্ত লাগে: CS̅ = Y0̅ OR A12 (দুটিই 0 হলে তবে 0). Range 0000H–0FFFH.
  2. RAM1 আর RAM2: ভেতরে A0–A10. 4000H পড়ে Y2-তে (4000H–5FFFH). A12 = 0, আর A11 দুটিকে আলাদা করে: RAM1 A11 = 0 → 4000H–47FFH, RAM2 A11 = 1 → 4800H–4FFFH.

Full decoding মানে প্রতিটি chip ঠিক একবার: তাই A12 (আর RAM-এ A11) gate-এ জুড়তেই হবে। না জুড়লে EPROM 1000H–1FFFH-এও দেখা দিত। নিচের ব্লক 64 KB-এর প্রতিটি ঠিকানা decode করে এই range মেলায়। নম্বর-ভাগ: line গোনা (৩), decoder output (২), বাড়তি gate (৩), range (২)।

৮.৩সস্তা নকশায় শুধু A13 দেখা হয়: A13 = 0 হলে ROM, 1 হলে 8 KB RAM. RAM কোন কোন range-এ দেখা দেয়? 6050H-এ একটি byte লিখলে আসলে কোন ঘর বদলায়, আর 2050H-এর মোট কয়টি নাম? — ৫ নম্বর (মাঝারি)

A15 আর A14 উপেক্ষিত, তাই RAM 22 = ৪ বার: 2000H–3FFFH, 6000H–7FFFH, A000H–BFFFH, E000H–FFFFH. 6050H-এ লিখলে বদলায় RAM-এর সেই ঘর, যাকে 2050H বলেও ডাকা যায়। 2050H-এর চারটি নাম: 2050H, 6050H, A050H, E050H (address aliasing). কোর্সের simulator-এ 64 KB-এর প্রতিটি ঘর আলাদা, তাই সেখানে এই আয়না দেখা যায় না; আসল board-এ যায় (পর্ব ২২)।

# ৮.১–৮.৩-এর চেকার: 64 KB-এর প্রতিটি ঠিকানা decode করে কোন chip সাড়া দেয়
def rng(chip, decode):
    hits = [a for a in range(0x10000) if decode(a) == chip]
    blocks, start = [], hits[0]                   # পরপর ঠিকানাকে এক ভাগে জোড়া
    for x, y in zip(hits, hits[1:] + [None]):
        if y != x + 1:
            blocks.append(f"{start:04X}H-{x:04X}H"); start = y
    return len(hits), blocks

y = lambda a: a >> 13                              # 74LS138: C B A = A15 A14 A13
print("Y5:", rng(5, y))

def full(a):                                       # ৮.২: Y0-তে EPROM, Y2-তে দুটি RAM
    if y(a) == 0 and a >> 12 & 1 == 0: return "EPROM"
    if y(a) == 2 and a >> 12 & 1 == 0:
        return "RAM2" if a >> 11 & 1 else "RAM1"
for chip in ("EPROM", "RAM1", "RAM2"):
    print(chip, rng(chip, full))

part = lambda a: "RAM" if a >> 13 & 1 else "ROM"   # ৮.৩: শুধু A13 দেখা
n, b = rng("RAM", part)
print("শুধু A13:", n, "ঠিকানা,", b)
print("2050H-এর আয়না:", [f"{a:04X}H" for a in range(0x10000)
      if part(a) == "RAM" and a & 0x1FFF == 0x0050])

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

Y5: (8192, ['A000H-BFFFH'])
EPROM (4096, ['0000H-0FFFH'])
RAM1 (2048, ['4000H-47FFH'])
RAM2 (2048, ['4800H-4FFFH'])
শুধু A13: 32768 ঠিকানা, ['2000H-3FFFH', '6000H-7FFFH', 'A000H-BFFFH', 'E000H-FFFFH']
2050H-এর আয়না: ['2050H', '6050H', 'A050H', 'E050H']

প্রতিটি ফাংশন একটি decoder-এর truth table: ঠিকানা দিলে কোন chip সাড়া দেয়। পুরো 64 KB ঘুরে range জোড়া হয়, তাই হাতের হিসাবে −1 ভুলে গেলে বা A12 বাদ দিলে সঙ্গে সঙ্গে ধরা পড়ে (চেষ্টা করুন: full-এ A12-এর শর্ত মুছে চালান)।

৯ · 8255, 8254 আর 8259 — control word, count আর ICW

ঝালিয়ে নিন: পর্ব ২৪ · 8255 PPI (mode set word D7 = 1; BSR D7 = 0), পর্ব ২৫ · 8253/8254 timer (control word = SC RW M BCD, N = fin ÷ fout), পর্ব ২৬ · 8259 PIC (ICW1–ICW4, OCW1 = mask). Port-এর ঠিকানা এই কোর্সের রীতিতে: 8255 80H–83H, 8254 40H–43H.

৯.১8255 (base 80H), সব mode 0: port A output, port B input, port C-র ওপরের অর্ধেক input, নিচের অর্ধেক output. (ক) Control word আর কোন port-এ? (খ) PC6 set আর PC2 reset-এর BSR word? (গ) 91H পড়ে নকশা বলুন। — ৫ নম্বর (সহজ)

(ক) D7 1, D6–D5 00, D4 A = 0 (out), D3 CU = 1 (in), D2 0, D1 B = 1 (in), D0 CL = 0 (out): 1000 1010 = 8AH, control register-এ, A1 A0 = 11: 83H. (খ) BSR: 0, তিনটি অব্যবহৃত বিট, বিট নম্বর, মান: PC6 = 1 → 0000 1101 = 0DH; PC2 = 0 → 0000 0100 = 04H, দুটিই 83H-এ (port C-তে নয়)। (গ) 91H = 1001 0001: A in, CU out, B out, CL in, সব mode 0. মনে রাখুন, নতুন mode word লিখলে সব output 0 হয়ে যায়, তাই শুরুতে একবারই।

৯.২8254-এর CLK 2 MHz, port 40H–43H. Counter 0-এ 50 Hz-এর square wave চাই (বাজারঘরের display-এর refresh). Count আর control word? কোন ক্রমে কোন port-এ লিখবেন? 20 Hz কি এক counter-এ হয়? BCD mode-এ 50 Hz? — ১০ নম্বর (মাঝারি)
  1. N = 2000000 ÷ 50 = 40000 = 9C40H (≤ 65536, এক counter-এ আঁটে)।
  2. Control word: SC 00 (counter 0), RW 11 (LSB তারপর MSB), M 011 (mode 3), BCD 0: 0011 0110 = 36H, 43H-এ।
  3. তারপর 40H-এ আগে 40H (LSB), পরে 9CH (MSB).
  4. 20 Hz: N = 100000 > 65536: আঁটে না। এক counter-এর সর্বোচ্চ সময় 65536 × 0.5 µs = 32.768 ms; দুটি counter জোড়া দিন: 20 Hz-এর জন্য যেমন 1000 × 100 = 100000; একইভাবে 20000 × 100 দিলে 1 s.
  5. BCD-তে চার দশমিক অঙ্ক, সর্বোচ্চ count ১০০০০; 40000 লেখা যায় না, তাই binary.

8085 থেকে 8255 আর 8254 একসঙ্গে শুরু করার সত্যিকারের run (OUT-এর log):

OUT port 83H <- 8AH  (at T=17)
OUT port 43H <- 36H  (at T=34)
OUT port 40H <- 40H  (at T=51)
OUT port 40H <- 9CH  (at T=68)
OUT port 83H <- 0DH  (at T=85)
Instructions: 11   T-states: 90

যেখানে নম্বর কাটে: MSB আগে লেখা, আর control word counter 0-এর port 40H-এ পাঠানো।

৯.৩8086-এর সঙ্গে একটি 8259 (single, edge-triggered, ICW4 লাগবে), IR0–IR7 যাবে type 48H–4FH-এ। ICW1, ICW2, ICW4? শুধু IR0 আর IR3 খোলা রাখার OCW1? IR3-এর vector কোথায়? ICW2-তে ভুলে 4BH লিখলে IR5-এর type কত? — ১০ নম্বর (কঠিন)

ICW1: D4 = 1, LTIM 0 (edge), ADI 0, SNGL 1, IC4 1 → 0001 0011 = 13H. ICW2 = 48H (8086 mode-এ শুধু T7–T3 কাজে লাগে)। ICW3 লাগে না (single). ICW4 = 01H (µPM = 1, normal EOI). OCW1: 1 মানে বন্ধ, IR0 আর IR3 শূন্য: 1111 0110 = F6H. IR3 → type 4BH → vector 4BH × 4 = 0012CH–0012FH. প্রতিটি ISR-এর শেষে non-specific EOI 20H. 4BH লিখলে নিচের তিন বিট উপেক্ষিত, base তবুও 48H: IR5 → 4DH, 50H নয়।

নম্বর-ভাগ: তিনটি ICW (৬), OCW1 (২), vector (২)। যেখানে নম্বর কাটে: OCW1-এ খোলা line-এ 1 বসানো।

# ৯.১-এর চেকার: 8255-এর mode set word আর BSR word বানানো, আর উল্টো দিকে পড়া
IN, OUT = 1, 0

def mode_word(a, b, cu, cl, mode_a=0, mode_b=0):
    return 0x80 | mode_a << 5 | a << 4 | cu << 3 | mode_b << 2 | b << 1 | cl

def bsr(bit, value):
    return bit << 1 | value                      # D7 = 0

def read(w):
    if not w & 0x80:
        return f"BSR: PC{w >> 1 & 7} = {w & 1}"
    io = lambda x: "in" if x else "out"
    return (f"A {io(w >> 4 & 1)} (mode {w >> 5 & 3}), CU {io(w >> 3 & 1)}, "
            f"B {io(w >> 1 & 1)} (mode {w >> 2 & 1}), CL {io(w & 1)}")

w = mode_word(a=OUT, b=IN, cu=IN, cl=OUT)
print(f"৯.১(ক) {w:02X}H = {w:08b}b")
for x in (bsr(6, 1), bsr(6, 0), bsr(2, 0), 0x91, 0x83, 0x0E):
    print(f"{x:02X}H -> {read(x)}")
print("base 80H: A, B, C, control =", [f"{0x80 + i:02X}H" for i in range(4)])

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

৯.১(ক) 8AH = 10001010b
0DH -> BSR: PC6 = 1
0CH -> BSR: PC6 = 0
04H -> BSR: PC2 = 0
91H -> A in (mode 0), CU out, B out (mode 0), CL in
83H -> A out (mode 0), CU out, B in (mode 0), CL in
0EH -> BSR: PC7 = 0
base 80H: A, B, C, control = ['80H', '81H', '82H', '83H']

read উল্টো দিকে কাজ করে: যেকোনো byte দিলে বলে এটি mode word না BSR, আর কী মানে। পরীক্ষায় “এই control word-এর অর্থ লিখুন” প্রশ্নে এভাবেই D7 দিয়ে শুরু করুন। 83H হলো বাজারঘরের scale-এর নকশা (পর্ব ২৪), আর 0EH হলো PC7 reset.

# ৯.২–৯.৩-এর চেকার: 8254-এর count আর control word, 8259-এর ICW আর OCW1
def cw8254(counter, rw, mode, bcd=0):            # rw: 1 = LSB, 2 = MSB, 3 = LSB তারপর MSB
    return counter << 6 | rw << 4 | mode << 1 | bcd

clk = 2_000_000
for f in (50, 1000, 20):
    n = clk // f
    print(f"{f:4} Hz: N = {n}" + (f" = {n:04X}H, LSB {n & 255:02X}H MSB {n >> 8:02X}H"
          if n <= 65536 else " > 65536: একটি counter-এ আঁটে না"))
print(f"control word = {cw8254(0, 3, 3):02X}H   সর্বোচ্চ = {65536 / clk * 1000} ms")
print("cascade 20000 x 100 =", 20000 * 100 / clk, "s")

icw1 = 0x10 | 0 << 3 | 1 << 1 | 1                # edge (LTIM 0), single (SNGL 1), IC4 1
icw2, icw4 = 0x48, 0x01                          # type 48H-4FH; 8086 mode, normal EOI
mask = 0xFF & ~(1 << 0 | 1 << 3)                 # শুধু IR0 আর IR3 খোলা
print(f"ICW1={icw1:02X}H ICW2={icw2:02X}H ICW4={icw4:02X}H OCW1={mask:02X}H EOI=20H")
for ir in (0, 3, 7):
    t = (icw2 & 0xF8) | ir
    print(f"IR{ir}: type {t:02X}H, vector {t * 4:05X}H")
print(f"ICW2 = 4BH লিখলে IR5-এর type = {(0x4B & 0xF8) | 5:02X}H (50H নয়)")

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

  50 Hz: N = 40000 = 9C40H, LSB 40H MSB 9CH
1000 Hz: N = 2000 = 07D0H, LSB D0H MSB 07H
  20 Hz: N = 100000 > 65536: একটি counter-এ আঁটে না
control word = 36H   সর্বোচ্চ = 32.768 ms
cascade 20000 x 100 = 1.0 s
ICW1=13H ICW2=48H ICW4=01H OCW1=F6H EOI=20H
IR0: type 48H, vector 00120H
IR3: type 4BH, vector 0012CH
IR7: type 4FH, vector 0013CH
ICW2 = 4BH লিখলে IR5-এর type = 4DH (50H নয়)

১০০০ Hz-এর সারি পর্ব ২৫-এর 2 MHz থেকে 1 kHz-এর উদাহরণ (2000 = 07D0H). ICW-এর সারি ৯.৩-এর উত্তর, আর শেষ লাইন ICW2-এর নিচের তিন বিট উপেক্ষার ফাঁদ।

১০ · মিশ্র সমস্যা — নকশা করুন, যাচাই করুন

বড় প্রশ্নে কয়েকটি অংশ একসঙ্গে আসে: port থেকে পড়া, তুলনা, আর একটি peripheral-এ লেখা। কৌশল একটাই: আগে data-র রূপ (signed না unsigned, কয় বিট), তারপর শাখার ক্রম, শেষে প্রতিটি শাখার সময়।

১০.১বাজারঘরের cold room-এর একটি সরল 8085 controller: port 01H থেকে পূর্ণসংখ্যা তাপমাত্রা (°C, ৮ বিটের two's complement) পড়ে, 8255-এর port C (82H, নিচের অর্ধেক output, 8AH দিয়ে শুরু করা) দিয়ে অবস্থা দেখায়: 00H ঠিক আছে, 01H HIGH (৮-এর বেশি), 02H LOW (০-এর কম)। Program লিখুন, প্রতিটি শাখার T-state দিন, আর বলুন তুলনার ক্রম উল্টালে কী ভুল হয়। (README-র আসল monitor-এর hysteresis আর তিনবার মেলানো এখানে বাদ।) — ১৫ নম্বর (কঠিন)
        ORG 2000H
        IN 01H          ; A <- তাপমাত্রা
        ORA A           ; S বসাতে
        JM LOW          ; ঋণাত্মক: ০-এর কম
        CPI 09H         ; এখন unsigned তুলনা নিরাপদ
        JNC HIGH        ; A ≥ 9 মানে ৮-এর বেশি
        MVI A,00H
        JMP SHOW
HIGH:   MVI A,01H
        JMP SHOW
LOW:    MVI A,02H
SHOW:   OUT 82H
        HLT

২৬ byte. −1 °C (FFH)-এর সত্যিকারের run: OUT port 82H <- 02H (at T=41), Instructions: 6 T-states: 46. শাখার সময় (HLT-সহ): ঠিক আছে ৬৭ T, HIGH ৭০ T, LOW ৪৬ T. আগে CPI আর পরে চিহ্ন দেখলে FFH আর ECH (−20 °C) JNC HIGH-এ চলে যায়: জমে যাওয়া ঘরে “গরম” alarm, আসল বিপদের উল্টো। ৮ °C নিজে ঠিক আছে, ৯ °C HIGH: README-র নিয়ম “৮.০০ °C-এর বেশি”।

নম্বর-ভাগ: program (৬), signed-এর চিন্তা (৩), সময় (৪), উল্টো ক্রমের বিশ্লেষণ (২)।

১০.২এক লাইনের সিদ্ধান্ত, প্রতিটিতে কারণ: (ক) 8085-এ LDA FFFFH লেখা চলে? (খ) PUSH PSW-এর পরে flag byte কোন ঠিকানায়? (গ) 8086-এ mov ax,[bx+bp]? (ঘ) 8086-এ shl ax,4? (ঙ) 8254-এ count 0 লিখলে? (চ) 8259-এর ISR শেষে EOI না দিলে? — ৬ নম্বর (মাঝারি)
(ক) না: অক্ষরে শুরু hex নাম মনে হয়; 0FFFFH লিখুন
(খ) SP - 2-এ (নিচু), A থাকে SP - 1-এ
(গ) না: দুটি base একসঙ্গে চলে না; base + index চাই
(ঘ) না: 8086-এ count 1 বা CL; mov cl,4 / shl ax,cl
(ঙ) binary-তে 65536 ধরা হয়, সবচেয়ে বড় count
(চ) সেই আর নিচের সব IR আটকে থাকে (fully nested)
# ১০.১-এর চেকার: cold room-এর alarm, দুটি ক্রম, ছয়টি তাপমাত্রায় (sim85 = sim8085.py)
from sim85 import assemble, run

GOOD = """  ORG 2000H
  IN 01H
  ORA A
  JM LOW
  CPI 09H
  JNC HIGH
  MVI A,00H
  JMP SHOW
HIGH: MVI A,01H
  JMP SHOW
LOW: MVI A,02H
SHOW: OUT 82H
  HLT"""
BAD = GOOD.replace("  ORA A\n  JM LOW\n  CPI 09H\n  JNC HIGH\n",
                   "  CPI 09H\n  JNC HIGH\n  ORA A\n  JM LOW\n")    # আগে unsigned তুলনা
name = {0: "ঠিক আছে", 1: "HIGH", 2: "LOW"}

print("  °C  byte | চিহ্ন আগে      | CPI আগে")
for t in (5, 8, 9, 0, -1, -20):
    row = []
    for src in (GOOD, BAD):
        c = run(assemble(src), ins=[(0x01, t & 0xFF)])
        row.append(f"{name[c.out_log[-1][2]]:7} {c.tstates} T")
    print(f"{t:4}  {t & 0xFF:02X}H  | " + " | ".join(row))

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

  °C  byte | চিহ্ন আগে      | CPI আগে
   5  05H  | ঠিক আছে 67 T | ঠিক আছে 67 T
   8  08H  | ঠিক আছে 67 T | ঠিক আছে 67 T
   9  09H  | HIGH    70 T | HIGH    59 T
   0  00H  | ঠিক আছে 67 T | ঠিক আছে 67 T
  -1  FFH  | LOW     46 T | HIGH    59 T
 -20  ECH  | LOW     46 T | HIGH    59 T

দুই program ছয়টি তাপমাত্রার চারটিতে একমত; অমিল শুধু ঋণাত্মক দুটিতে, যেখানে উল্টো ক্রম LOW-এর বদলে HIGH দেয়। একই আচরণ ৩.২-এর গোনায় দেখা গিয়েছিল। সময়ের কলাম দেখায়, কোন শাখা দীর্ঘতম (HIGH, ৭০ T ≈ 23.33 µs): worst-case-এর প্রশ্নে এটিই উত্তর।

শেষ মুহূর্তের নিয়ম-তালিকা আর সাধারণ ভুল

বিষয়নিয়মসাধারণ ভুলপর্ব
Flag byteS Z 0 AC 0 P 0 CY; P শুধু A-র ৮ বিটবিয়োগের CY-কে carry ভাবা০৭
Flag ছোঁয় নাMOV, INX/DCX; INR/DCR CY ছোঁয় নাDCX B / JNZ০৯
Machine codeOpcode, তারপর ছোট byte32 20 52১০
DAAশুধু যোগের পরে; শতক CY-তে99 + 01-এ CY বাদ১১
Loop-এর সময়বাইরে + পাক × প্রতি পাক − ৩শেষ JNZ-কে ১০ T ধরা১১, ১২
Delay14N + 4, 24N + 7; CALL + RET = 28; 1 ms = 3000 T6 MHz দিয়ে হিসাব; N = 0১২
SIMMSE = 1, mask 1 = বন্ধ, R7.5 latch মোছেMSE ভুলে যাওয়া১৩
8086 ঠিকানাseg × 10H + EA; BP থাকলে SS[bp]-এ DS ধরা১৪, ১৫
DIV r8AX ÷ r8: AL ভাগফল, AH ভাগশেষভাগফল ২৫৫ ছাড়ালে type 0 ভুলে যাওয়া১৬
StringDS:SI → ES:DI; থামার পরে ZF দেখুনCX = 0 মানে “পাওয়া যায়নি”১৯
Framenear: [bp+4] প্রথম argument; ret n[bp+2]-কে argument ধরা১৮
IVTtype × 4; IP তারপর CSCS আগে পড়া২০
Decodingশেষ = শুরু + মাপ − ১; k উপেক্ষিত line → 2k আয়নাবাড়তি line-এর gate ভুলে যাওয়া২২
8255 / 8254 / 825983H-এ control; LSB আগে; OCW1-এ 1 = বন্ধBSR port C-তে পাঠানো২৪–২৬

১৫ মিনিটের মিনি-সেট — ঘড়ি ধরে করুন

আটটি ছোট প্রশ্ন, প্রতিটিতে দুই মিনিটের মতো। কাগজ-কলম চলবে, চেকার নয়। ৭–৮ ঠিক হলে প্রস্তুত; ৫–৬ হলে সংশ্লিষ্ট অংশ আবার করুন।

  1. A = 0F0H, B = 20H, ADD B: A, CY আর Z?
  2. STA 2050H-এর machine code আর T-state?
  3. 3 MHz-এ ৮ বিটের delay loop (CALL নেই), N = 100: কত µs?
  4. SP = 3000H, PUSH D (DE = ABCDH): SP আর [2FFFH]?
  5. CS = 1A00H, IP = 0F20H: physical address?
  6. MOV AX,[BP+SI]-এর default segment?
  7. Type 08H-এর vector কোন চার byte-এ?
  8. 8254-এ counter 2, LSB তারপর MSB, mode 2, binary: control word?
উত্তরমিনি-সেটের উত্তর আর এক লাইনের কারণ (নিজে করার পরে খুলুন)
1. A = 10H, CY = 1, Z = 0   F0H + 20H = 110H
2. 32 50 20, 13 T   ছোট byte আগে; OF + MR + MR + MW
3. 468 µs   14 × 100 + 4 = 1404 T, ÷ 3
4. SP = 2FFEH, [2FFFH] = ABH   উঁচু byte (D) বড় ঠিকানায়
5. 1AF20H   1A000H + 0F20H
6. SS   EA-তে BP আছে
7. 00020H–00023H   08H × 4 = 20H
8. B4H   10 11 010 0

সবচেয়ে বেশি ভুল হয় ৩ আর ৪-এ। ৩-এ crystal-এর frequency নয়, 3 MHz clock ধরুন। ৪-এ উঁচু byte (D) বড় ঠিকানায় যায়।

আরও গভীরে: এই পাতার T-state Intel-এর 8085 user's manual-এর টেবিল থেকে, wait state ছাড়া; আসল board-এ ধীর memory READY নামালে প্রতিটি machine cycle-এ বাড়তি T যোগ হয় (পর্ব ০৮)। 8086-এর clock গোনা ইচ্ছা করেই এখানে নেই: queue আর bus-এর জোড়-বিজোড় ঠিকানার কারণে আসল সময় টেবিলের সংখ্যা থেকে সরে যায় (পর্ব ২১), আর কোর্সের runner Unicorn-এর 386-শ্রেণির core, যা সময় মাপে না। 8255, 8254 আর 8259 আজ আলাদা chip হিসেবে কম দেখা যায়, কিন্তু PC-র chipset আর microcontroller-এর timer ও interrupt controller-এ তাদের ধারণা টিকে আছে।

পরীক্ষা ও ইন্টারভিউতে: একই ধরনের প্রশ্ন বারবার আসে। “এই program-এর পরে register আর flag লিখুন” — প্রতি নির্দেশে কোন flag ছোঁয়, পাশে লিখে এগোন। “N = …-এ delay কত” — সূত্র, 3 MHz, তারপর CALL/RET. “Physical address বের করুন” — segment-এর পাশে শূন্য, তারপর যোগ; BP থাকলে SS. “8255/8254/8259-এর control word লিখুন” — বিটের নাম ওপরে, মান নিচে, শেষে hex. “Memory map আঁকুন” — line গোনা, decoder output, শেষ ঠিকানা = শুরু + মাপ − ১.

AI-এর যুগে — AI-এর লেখা assembly-উত্তর যাচাই

AI সহকারী এই ধরনের উত্তর দ্রুত লেখে, আর প্রায়ই এই পাতার ফাঁদেই পড়ে: 8085, 8086 আর Z80-এর নির্দেশ মিশিয়ে ফেলে (8085-এ DJNZ বা MUL লেখে), DCX-এর পরে Z ধরে নেয়, T-state ভুল দেয় (বিশেষ করে INX, PUSH, শর্তযুক্ত লাফের না-নেওয়া রূপ), crystal-এর 6 MHz দিয়ে সময় হিসাব করে, SIM-এর mask বিট উল্টো পড়ে, [bp]-এ DS ধরে, আর 8259-এর OCW1-এ 1-কে “খোলা” বলে। প্রতিকার: প্রতিটি উত্তর একটি 8085 simulator বা NASM-সহ 8086 emulator-এ চালিয়ে দেখুন, T-state Intel-এর টেবিল থেকে হাতে গুনে মেলান, আর control word-এর বিট datasheet-এর ছকে বসিয়ে দেখুন।

নিজের উত্তর AI-কে দিয়ে পরীক্ষা করানোর একটি কাঠামো:

তুমি microprocessor আর interfacing-এর একজন কড়া পরীক্ষক। নিচে একটি প্রশ্ন, প্রশ্নে দেওয়া রীতি (CPU 8085 না 8086, clock, port-এর ঠিকানা) আর আমার উত্তর দিলাম। [প্রশ্ন] [রীতি] [আমার উত্তর — প্রতিটি লাইন নম্বর দিয়ে] ১. শুধু প্রশ্নের CPU-র নির্দেশ ব্যবহার করো; Z80 বা অন্য CPU-র নির্দেশ বা flag চাপিয়ো না। ২. প্রতিটি নির্দেশের পরে কোন register আর flag বদলায়, কোনটি বদলায় না, লাইন নম্বর ধরে দেখাও। ৩. T-state বা ঠিকানার প্রতিটি সংখ্যা কোন টেবিল বা সূত্র থেকে এলো বলো; নিশ্চিত না হলে "নিশ্চিত নই" লেখো। ৪. শূন্য গণক, শূন্য ভাজক আর ঋণাত্মক data-র case আলাদা করে ভাবো। ৫. নম্বর-ভাগ বানিয়ে নম্বর দাও, পুরো উত্তর নিজে লিখে দিও না।

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

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

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

ক্রমএকটি 8085 board-এ 8255, 8254 আর RST 7.5 interrupt চালু করার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. LXI SP দিয়ে stack-এর জায়গা ঠিক করা
  2. 8255-এর mode set word control register-এ লেখা
  3. 8254-এর control word, তারপর count-এর LSB আর MSB
  4. SIM দিয়ে RST 7.5 খোলা আর পুরোনো latch মোছা
  5. EI দিয়ে interrupt চালু করা

(সহজ) 8085-এ A = FFH, CY = 1 অবস্থায় INR A চালালে A, Z আর CY কত?

  • A = 00H, Z = 1, CY = 0
  • A = 00H, Z = 1, CY = 1
  • A = 100H, Z = 0, CY = 1
  • A = 00H, Z = 0, CY = 1

(সহজ) 3 MHz clock-এর 8085-এ MVI C,N / L: DCR C / JNZ L (14N + 4 T). N = FFH হলে সময় কত?

  • 595.67 µs
  • 1190 µs
  • 1191.33 µs
  • 1196 µs

(মাঝারি) 8086-এ DS = 1000H, SS = 2000H, BP = 0100H, SI = 0020H. mov al,[bp+si+4] কোন physical address থেকে পড়ে?

  • 20124H
  • 10124H
  • 20120H
  • 02124H

(মাঝারি) 8086-এ ES:0200H থেকে "TAKA" লেখা; cld / mov di,0200h / mov cx,4 / mov al,'A' / repne scasb-এর পরে DI আর CX?

  • DI = 0201H, CX = 3
  • DI = 0204H, CX = 0
  • DI = 0202H, CX = 3
  • DI = 0202H, CX = 2

(মাঝারি) 74LS138-এর C B A-তে A15 A14 A13 দেওয়া 8085 board-এ Y3 কোন range বাছে?

  • 4000H–5FFFH
  • 6000H–7FFFH
  • 6000H–8000H
  • 3000H–3FFFH

(কঠিন) 8255-এর সব port mode 0: port A input, port B output, port C-র দুই অর্ধেকই output. Control word কত?

  • 90H
  • 82H
  • 10H
  • 99H

শব্দকোষ

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

মনে রাখুন

  1. Flag আগে: প্রতিটি নির্দেশ কোন flag ছোঁয় আর কোনটি ছোঁয় না; P শুধু নিচের ৮ বিটের, বিয়োগের CY মানে ধার।
  2. সময়: বাইরের খরচ + পাক × প্রতি পাক − ৩; delay 14N + 4 আর 24N + 7, CALL + RET = ২৮; 3 MHz-এ 1 ms = 3000 T; N = 0 মানে সবচেয়ে বেশি পাক।
  3. Stack আর interrupt: PUSH উঁচু byte বড় ঠিকানায়; প্রতিটি PUSH-এর জোড়া POP; SIM-এ MSE = 1 আর mask 1 = বন্ধ।
  4. 8086: PA = seg × 10H + EA, BP থাকলে SS; string-এর পরে ZF দেখুন; near frame-এ [bp+4] প্রথম argument; vector = type × 4, IP তারপর CS.
  5. Interfacing: শেষ ঠিকানা = শুরু + মাপ − ১; 8255-এর D7 বলে mode না BSR; 8254-এ LSB আগে; 8259-এর OCW1-এ 1 = বন্ধ।

পরের পর্বে: পর্ব ৮২ (MCQ প্রশ্নব্যাংক — মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT). পুরো কোর্সের তেরোটি মডিউল থেকে ব্যাখ্যাসহ বহুনির্বাচনী প্রশ্ন, আর ঘড়ি ধরে নিজেকে যাচাইয়ের সুযোগ।

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

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