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

8085-এর instruction set — data transfer, arithmetic, logical আর branch

The 8085 Instruction Set — Data Transfer, Arithmetic, Logical and Branch

Taught in Bangla, this lesson organises the 8085's 246 documented opcodes into data transfer, arithmetic, logical, branch and machine control groups, using the opcode table of the course's 8085 simulator. It shows which instructions leave flags untouched, the INR, INX and DAD traps in 16-bit loops, why multi-byte addition needs ADC, and how CMP compares unsigned values. In-page Python runs a copy of the simulator to check flag traps, signed comparison and T-state totals.

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

  • 8085-এর যেকোনো নির্দেশ দেখে বলা: কোন দলের, কত byte, কত T-state, কোন flag বদলায়
  • Register, memory আর port-এর মধ্যে data সরানোর নির্দেশ বেছে নেওয়া
  • বহু-byte যোগ-বিয়োগে carry আর borrow ঠিকমতো বয়ে নেওয়া
  • AND, OR, XOR, rotate আর তুলনা দিয়ে বিট বাছা আর সিদ্ধান্ত নেওয়া
  • শর্তযুক্ত লাফ দিয়ে loop আর সিদ্ধান্ত লেখা, আর তার T-state হিসাব করা

১ · Instruction set কী — ২৪৬টি opcode আর পাঁচটি দল

বাজারঘরের দোকানে একজন কর্মচারী কয়েক ধরনের কাজই জানেন: মাল এক তাক থেকে অন্য তাকে সরানো, হিসাব যোগ-বিয়োগ করা, দুটি জিনিস মিলিয়ে দেখা, খাতার নির্দিষ্ট পাতায় চলে যাওয়া, আর দোকান বন্ধ করা বা বিরতি নেওয়া। মালিক যত জটিল কাজই চান, তা এই কয়েকটি কাজ জুড়ে জুড়েই বলতে হয়। একটি CPU-র ক্ষেত্রেও তাই। CPU যেসব নির্দেশ বোঝে, তার পুরো তালিকা আর নিয়মের নাম instruction set. Hardware আর software-এর এই চুক্তির তত্ত্ব Computer Architecture পর্ব ২৫-এ আছে; এখানে আমরা একটি নির্দিষ্ট, পরীক্ষায় খুব জনপ্রিয় CPU-র পুরো তালিকা হাতে-কলমে দেখব।

8085-এর প্রতিটি নির্দেশের প্রথম byte হলো opcode: এটিই বলে কী কাজ। একটি byte-এ ২৫৬টি মান সম্ভব। এর মধ্যে ২৪৬টি নথিভুক্ত নির্দেশ, আর ১০টি মান Intel নথিভুক্ত করেনি; কোর্সের simulator সেগুলো পেলে “undocumented opcode” বলে থেমে যায় (Spec decision 1). মানুষ opcode-এর সংখ্যা মনে রাখে না, মনে রাখে ছোট নাম, যেমন MOV, ADD, JNZ; এগুলোকে বলে mnemonic. নির্দেশ যে মান বা register নিয়ে কাজ করে, সেটি তার operand.

আগের পর্বগুলোর কয়েকটি কথা এক লাইনে মনে করিয়ে দিই। 8085-এর হিসাবের কেন্দ্র accumulator A; সাধারণ register B, C, D, E, H, L, যারা জোড়ায় BC, DE, HL হয়ে ১৬ বিটের register pair হতে পারে; আর flag register-এর পাঁচটি flag: S, Z, AC, P, CY, যেগুলোর অর্থ আর বিটের জায়গা পর্ব ০৫-এ দেখেছেন। CPU-র ভেতরের গঠন পর্ব ০৭-এ, আর প্রতিটি নির্দেশের machine cycle পর্ব ০৮-এ।

লেখার নিয়ম: এই পর্বের সব সংখ্যা Intel-এর ধরনে, শেষে H: 2050H, 0FFH (A থেকে F দিয়ে শুরু হলে সামনে একটি 0, যাতে assembler একে নাম না ভাবে; Spec decision 9). Program শুরু হয় 2000H-এ, data থাকে 2050H থেকে। টেবিলের সংক্ষেপগুলো:

লেখামানেউদাহরণ
r৮ বিটের একটি register: A B C D E H LMOV A,B
MHL যে memory-ঘরের ঠিকানা ধরে আছে, সেই ঘরMOV A,M
rpregister pair: B (BC), D (DE), H (HL), SPLXI H,2050H
dataনির্দেশের ভেতরে লেখা ৮ বিটের ধ্রুবকMVI A,32H
addr, data16১৬ বিটের ঠিকানা বা ধ্রুবক, memory-তে ছোট byte আগেLDA 2050H

নির্দেশের ভেতরে লেখা ধ্রুবককে বলে immediate মান; তাই MVI-এর “I” আর ADI-এর “I”. নির্দেশের দৈর্ঘ্য তিন রকম: ২০২টি opcode এক byte-এর, ১৮টি দুই byte-এর (৮ বিটের ধ্রুবক বা port নম্বর সঙ্গে), ২৬টি তিন byte-এর (১৬ বিটের ঠিকানা বা ধ্রুবক সঙ্গে)। এই গঠনের পুরো আলোচনা পরের পর্বে, পর্ব ১০-এ। নিচের ছবিতে ২৫৬টি opcode-এর মানচিত্র, প্রতিটি ঘর একটি byte-মান।

ছবি ৯.১ — 8085-এর opcode মানচিত্র

সারি = opcode-এর ওপরের nibble, কলাম = নিচের nibble; রং = দল

8085-এর opcode মানচিত্র নিচের nibble → 0123456789ABCDEF0123456789ABCDEF data transfer (৯৬)arithmetic (৬৫)logical (৪৩)branch (৩৬)machine control (৬)নথিভুক্ত নয় (১০)
ছবি ৯.১ — মোটা দাগের প্রথম ব্লক (40H–7FH) পুরোটাই MOV, শুধু 76H-এ HLT. দ্বিতীয় ব্লক (80H–BFH) আটটি হিসাবের নির্দেশ, প্রতিটি আটটি operand-এর সঙ্গে। এমন নিয়মিত সাজানোর জন্যই ২৪৬টি opcode মুখস্থ না করে নিয়ম দিয়ে বের করা যায় (নিচে “আরও গভীরে”)। মানচিত্রটি কোর্সের reference lab-এর sim8085.py-র opcode টেবিল থেকে script দিয়ে আঁকা।

দলগুলো এভাবে ভাগ করা প্রচলিত পাঠ্যবইয়ের ধারা মেনে। Intel-এর নিজের manual শেষ দলটিকে “stack, I/O আর machine control” নামে একসাথে রাখে, আর কোনো কোনো বই PUSH/POP আলাদা দলে দেখায়। নাম নিয়ে চিন্তা নয়; কাজটি চিনতে পারাই আসল। নিচের ব্লকটি একটি ছোট instruction explorer: কোর্সের simulator-এর opcode টেবিল থেকে দলের গণনা করে, তারপর যেকোনো নির্দেশ assemble করে তার byte, দৈর্ঘ্য আর T-state দেখায়। তালিকায় নিজের নির্দেশ যোগ করে চালিয়ে দেখুন।

# নির্দেশের খাতা: opcode, byte, T-state আর দল (reference-এর sim8085.py-র টেবিল থেকে)
from sim85 import OPS, CONDS, assemble
GROUPS = {"data transfer": "MOV MVI LXI LDA STA LHLD SHLD LDAX STAX XCHG SPHL XTHL PUSH POP IN OUT",
          "arithmetic": "ADD ADC ADI ACI SUB SBB SUI SBI INR DCR INX DCX DAD DAA",
          "logical": "ANA ANI ORA ORI XRA XRI CMP CPI RLC RRC RAL RAR CMA CMC STC",
          "branch": "JMP CALL RET PCHL RST " + " ".join(p + c for p in "JCR" for c in CONDS),
          "machine control": "EI DI NOP HLT RIM SIM"}

def group(mn):
    return next(g for g, names in GROUPS.items() if mn.split()[0] in names.split())

count = {}
for mn, kind, length, t, t_alt in OPS.values():
    count[group(mn)] = count.get(group(mn), 0) + 1
print(count, "| মোট", sum(count.values()))

# নিজের নির্দেশ যোগ করে দেখুন
for line in ["MOV A,B", "MOV A,M", "MVI A,32H", "LXI H,2050H", "LDA 2050H", "ADD B",
             "INX H", "DAD D", "CPI 81H", "JNZ 2007H", "CALL 2100H", "RNC", "HLT"]:
    mem = assemble(" ORG 2000H\n " + line).mem
    data = [mem[a] for a in sorted(mem)]
    mn, kind, length, t, t_alt = OPS[data[0]]
    tt = str(t) if t == t_alt else f"{t}/{t_alt}"
    hexb = " ".join(f"{b:02X}" for b in data)
    print(f"{line:<12} {hexb:<9} {length} byte  T={tt:<5} {group(mn)}")

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

{'data transfer': 96, 'arithmetic': 65, 'logical': 43, 'branch': 36, 'machine control': 6} | মোট 246
MOV A,B      78        1 byte  T=4     data transfer
MOV A,M      7E        1 byte  T=7     data transfer
MVI A,32H    3E 32     2 byte  T=7     data transfer
LXI H,2050H  21 50 20  3 byte  T=10    data transfer
LDA 2050H    3A 50 20  3 byte  T=13    data transfer
ADD B        80        1 byte  T=4     arithmetic
INX H        23        1 byte  T=6     arithmetic
DAD D        19        1 byte  T=10    arithmetic
CPI 81H      FE 81     2 byte  T=7     logical
JNZ 2007H    C2 07 20  3 byte  T=10/7  branch
CALL 2100H   CD 00 21  3 byte  T=18    branch
RNC          D0        1 byte  T=12/6  branch
HLT          76        1 byte  T=5     machine control

প্রথম লাইন মানচিত্রের রং গুনে দেয়: ৯৬ + ৬৫ + ৪৩ + ৩৬ + ৬ = ২৪৬. তারপর প্রতিটি নির্দেশের machine code. LXI H,2050H-এর byte 21 50 20: ঠিকানার ছোট byte 50 আগে, বড় byte 20 পরে। JNZ-এর T-state দুটি, 10/7: লাফ দিলে ১০, না দিলে ৭ (Spec decision 2). T-state হলো clock-এর একটি ধাপ; 8085-এর 3 MHz clock-এ একটি T-state = 0.333 µs. এই ব্লকের sim85.py কোর্সের reference lab-এর sim8085.py-র হুবহু কপি, শুধু command line অংশ বাদ; লেখকের lab-এ ১৯টি program-এর run আর trace আউটপুট, মোট ৩৮টি তুলনা, দুটিতে অক্ষরে অক্ষরে মিলেছে।

২ · Data transfer — কপি করে, flag ছোঁয় না

সবচেয়ে বেশি opcode এই দলে: ৯৬টি। কাজ একটাই, এক জায়গার byte আরেক জায়গায় কপি করা: register থেকে register, memory থেকে register, port থেকে A. নাম MOV (move) হলেও উৎস খালি হয় না; ফটোকপির দোকানের মতো, মূল কাগজ আপনার হাতেই থাকে। আর সবচেয়ে গুরুত্বপূর্ণ নিয়ম: এই দলের কোনো নির্দেশ flag বদলায় না (একমাত্র ব্যতিক্রম POP PSW, যা flag-এর byte-টিই stack থেকে ফিরিয়ে আনে)।

নির্দেশকাজbyteT
MOV r1,r2r1 ← r214
MOV r,M / MOV M,rr ← [HL] / [HL] ← r17
MVI r,data / MVI M,datar বা [HL]-এ ধ্রুবক27 / 10
LXI rp,data16register pair-এ ১৬ বিটের ধ্রুবক310
LDA addr / STA addrA ← [addr] / [addr] ← A313
LHLD addr / SHLD addrL ↔ [addr], H ↔ [addr+1]316
LDAX B/D / STAX B/DA ← [BC বা DE] / উল্টো17
XCHGDE আর HL অদলবদল14
IN port / OUT portA ← port / port ← A210
PUSH, POP, XTHL, SPHLstack-এর কাজ (পর্ব ১২)112, 10, 16, 6

কয়েকটি খুঁটিনাটি পরীক্ষায় আসে। MOV M,M নেই: সেই জায়গার opcode 76H আসলে HLT. LDAX আর STAX শুধু BC আর DE নেয়, HL নয় (HL-এর জন্য তো MOV A,M আছেই)। এর ব্যবহার বোঝা যায় যখন দুটি pointer একসাথে লাগে: একটি তালিকা থেকে byte পড়া (MOV A,M, HL দিয়ে) আর অন্য তালিকায় লেখা (STAX D, DE দিয়ে), যেমন block transfer program-এ (পর্ব ১১). IN/OUT-এর port নম্বর ৮ বিটের, তাই ২৫৬টি port. বাজারঘরের স্কেলটিকে 8085 যুগে ভাবুন: ওজনের byte আসে port 01H দিয়ে, আর একটি দাম memory-তে রাখা। নিচের program এগুলো সরায়। শুরুতে XRA A ইচ্ছা করে রাখা: এটি A শূন্য করে আর Z = 1 বসায়। তারপর দেখুন, A বদলালেও Z কী করে।

1XRA A        ; Z = 12IN 01H       ; ওজন3MOV B,A4STA 2054H5LHLD 2050H   ; দাম6XCHG7LXI H,2056H8MOV M,E9HLT
Register, memory আর flag
A · B
DE · HL
2054H · 2056H
S Z AC P CY
মোট T
  1. XRA A: flag বসানো. A-কে নিজের সঙ্গে XOR করলে সবসময় 00H, তাই Z = 1, P = 1 (শূন্যটি 1, জোড়), CY = 0. এই program-এ flag বদলানোর নির্দেশ শুধু এটিই। ৪ T-state.
  2. IN 01H. Port 01H থেকে ওজন 150 g = 96H এল A-তে (simulator-এ port-এর মান ;@in দিয়ে বসানো; Spec decision 10). A আর শূন্য নয়, অথচ Z এখনো 1. এখানে JZ লিখলে program ভুল দিকে যেত।
  3. MOV B,A. B = 96H, A-ও 96H: কপি, সরানো নয়। ৪ T-state, কারণ বাইরের bus-এ যেতে হয়নি, শুধু opcode পড়া।
  4. STA 2054H. A-র byte গেল 2054H-এ। ৩ byte-এর নির্দেশ, ১৩ T-state: opcode, ঠিকানার দুটি byte পড়া, তারপর memory-তে লেখা।
  5. LHLD 2050H. 2050H-এ রাখা দাম 983 পয়সা (9.83 টাকা) = 03D7H, memory-তে D7 03. ছোট byte গেল L-এ, বড়টি H-এ: HL = 03D7H. ১৬ T-state.
  6. XCHG. DE আর HL অদলবদল, ৪ T-state. এখন দাম DE-তে, আর HL খালি হলো ঠিকানার কাজের জন্য। 8085-এ শুধু HL দিয়ে memory-র যেকোনো ঘর M হিসেবে ধরা যায়, তাই HL প্রায়ই এভাবে ফাঁকা করতে হয়।
  7. LXI H,2056H. HL-এ একটি ঠিকানা বসল, কোনো memory পড়া হয়নি। ৩ byte, ১০ T-state.
  8. MOV M,E, তারপর HLT. E-র D7H গেল HL-এর ঠিকানায়, 2056H-এ। ৭ T-state. শেষে HLT (৫ T) ধরে মোট ৭৩ T-state. পুরো সময় flag একবারও বদলায়নি।

একই program কোর্সের simulator-এ, সত্যিকারের run (python -B sim8085.py run dt.asm; reference lab, Python 3.13.5, কোর্সের নিজের pure-Python simulator; lab-এর পরিচয় পর্ব ০৬-এ):

~/lab$ python -B sim8085.py run dt.asm
A=96 B=96 C=00 D=03 E=D7 H=20 L=56 SP=0000 PC=2010
Flags: S=0 Z=1 AC=0 P=1 CY=0   (F=44H)
Memory 2050H..2057H:
  2050H: D7 03 00 00 96 00 D7 00
Instructions: 9   T-states: 73
নিয়ম

শর্তযুক্ত লাফের ঠিক আগে যে নির্দেশ flag বসায়, সেটিই সিদ্ধান্ত নেয়; মাঝের data transfer নির্দেশ flag-এ কোনো ছাপ রাখে না। তাই memory থেকে একটি byte এনে সেটি শূন্য কি না দেখতে চাইলে MOV A,M-এর পরে ORA A লিখুন: A বদলায় না, কিন্তু S, Z, P ঠিক হয়।

৩ · Arithmetic — যোগ, বিয়োগ আর carry বয়ে নেওয়া

8085-এর ALU ৮ বিটে যোগ আর বিয়োগ করে, ফল যায় A-তে। গুণ আর ভাগের কোনো নির্দেশ নেই; সেগুলো বারবার যোগ-বিয়োগ বা shift দিয়ে করতে হয় (পর্ব ১১). নিচের টেবিলের শেষ কলামটি সবচেয়ে গুরুত্বপূর্ণ। এটি reference simulator-এ প্রতিটি opcode ৪০০টি এলোমেলো অবস্থা থেকে চালিয়ে script দিয়ে বের করা, কোন flag কখনো বদলায়; তারপর Intel-এর 8085 manual-এর সঙ্গে মেলানো।

নির্দেশকাজbyte · Tযে flag বদলায়
ADD r / ADD M / ADI dataA ← A + operand1·4 / 1·7 / 2·7সব পাঁচটি
ADC r / ACI dataA ← A + operand + CY1·4 / 2·7সব পাঁচটি
SUB r / SUI dataA ← A − operand1·4 / 2·7সব; CY = borrow
SBB r / SBI dataA ← A − operand − CY1·4 / 2·7সব; CY = borrow
INR r / DCR rr ← r ± 1 (M হলে 10 T)1·4S Z AC P — CY নয়
INX rp / DCX rpregister pair ± 11·6কোনোটিই নয়
DAD rpHL ← HL + rp (১৬ বিট)1·10শুধু CY
DAABCD সংশোধন (Spec decision 5)1·4সব পাঁচটি

বিয়োগে CY-এর অর্থ borrow: CY = 1 মানে বিয়োগ করতে গিয়ে ধার লেগেছে, অর্থাৎ A ছিল operand-এর চেয়ে ছোট (Spec decision 4; ARM-এ ঠিক উল্টো, পর্ব ০৫ দেখুন)। DAA আর BCD যোগের পুরো উদাহরণও পর্ব ০৫-এ; এখানে আবার নয়।

এবার ADC-এর আসল কাজ, যা carry flag বয়ে নেয়। 8085 একবারে ৮ বিট যোগ করে, কিন্তু বাজারঘরের দাম পয়সায় রাখলে প্রায়ই ২৫৫ ছাড়ায়। দুটি দাম: ১৫০ g আলু 983 পয়সা = 03D7H, আর ১২৫০ g আলু 8188 পয়সা = 1FFCH (README-র worked numbers). যোগ করতে হবে দুই ধাপে, স্কুলের খাতায় একক আর দশকের ঘরের মতো: আগে ছোট byte, তারপর বড় byte, মাঝখানে “হাতে থাকা” carry.

1LDA 2050H   ; D72MOV B,A3LDA 2052H   ; FC4ADD B5STA 2054H6LDA 2051H   ; 037MOV B,A8LDA 2053H   ; 1F9ADC B       ; ভুলে ADD?10STA 2055H11HLT12; DAD পথ: LHLD, XCHG, LHLD, DAD D
Register, CY আর ফল
A · B
CY
2054H 2055H
মোট T
  1. ছোট byte দুটি আনা. LDA আর MOV দিয়ে B = D7H (983-এর ছোট byte), A = FCH (8188-এর ছোট byte). এখন পর্যন্ত ৩০ T-state, কোনো flag বদলায়নি।
  2. ADD B. D7H + FCH = 1D3H. A-তে D3H, আর বাড়তি 1 গেল CY-তে: CY = 1. এই 1 আসলে ২৫৬ পয়সার সমান, বড় byte-এর ঘরের এক একক।
  3. হাতের carry বাঁচিয়ে রাখা. STA, LDA, MOV: কেউই flag ছোঁয় না, তাই CY = 1 অক্ষত। এখন A = 1FH, B = 03H. এই কারণেই মাঝখানে কোনো flag-বদলানো নির্দেশ বসানো চলে না।
  4. ADC B. 1FH + 03H + CY = 23H. CY আবার 0. ৮১ T-state.
  5. ফল. 2054H-এ D3, 2055H-এ 23: 23D3H = 9171 পয়সা = 91.71 টাকা = 9.83 + 81.88. ছোট byte আগে, তাই ফলও little-endian. মোট ১১টি নির্দেশ, ৯৯ T-state = 33.0 µs.
  6. ভুল পথ: ৯ নম্বর লাইনে ADD B. হাতের carry হারিয়ে যায়: 1FH + 03H = 22H, ফল 22D3H = 8915 পয়সা = 89.15 টাকা. ঠিক ২৫৬ পয়সা কম। Program কোনো error দেয় না; শুধু হিসাব ভুল (সত্যিকারের run, sum16_bad.asm).
  7. সংক্ষিপ্ত পথ: DAD D. LHLD 2050H, XCHG, LHLD 2052H, DAD D, SHLD 2054H: HL = 23D3H, একই উত্তর, মাত্র ৬টি নির্দেশ আর ৬৭ T-state (22.33 µs). তবে DAD শুধু CY বদলায়; ফল শূন্য হলেও Z বসে না।

ADC-এর নিয়মটি যেকোনো দৈর্ঘ্যে খাটে: ৩২ বিটের যোগ মানে একটি ADD আর তিনটি ADC. বিয়োগে একইভাবে প্রথম byte SUB, বাকিগুলো SBB, যেখানে CY বয়ে নেয় ধার। উল্টো হিসাবটি দিয়ে যাচাই করা যাক: 9171 − 8188 = 983 পয়সা. ছোট byte: D3H − FCH করতে ধার লাগে, A = D7H, CY = 1. বড় byte: 23H − 1FH − 1 = 03H, CY = 0. ফল 03D7H = 983, প্রথম দামটিই ফিরে এল (সত্যিকারের run, sub16.asm: 2054H: D7 03, ৯৯ T-state). SBB-এর জায়গায় SUB লিখলে বড় byte হতো 04H, আর ফল 1239 পয়সা: এবার ২৫৬ পয়সা বেশি। এখন সেই ফাঁদগুলো, যেগুলো টেবিলের মোটা অক্ষরে। নিচের ব্লক প্রতিটি ছোট টুকরো সব flag 0 অবস্থা থেকে চালায় আর ফল ছাপে।

# একই শুরুর অবস্থা (সব flag 0), আলাদা নির্দেশ: কোন flag বদলায়, কোনটি বদলায় না
from sim85 import assemble, run

CASES = [("ADI", "MVI A,0FFH\n ADI 01H"),        # FFH + 1
         ("INR", "MVI A,0FFH\n INR A"),          # FFH + 1, কিন্তু INR দিয়ে
         ("DCR", "MVI C,01H\n DCR C"),           # 8-বিট: 1 - 1
         ("DCX", "LXI B,0001H\n DCX B"),         # 16-বিট: 0001H - 1
         ("DAD", "LXI H,0FFFFH\n LXI D,0001H\n DAD D"),
         ("ANI", "MVI A,0F0H\n ANI 0FH"),
         ("ORI", "MVI A,0F0H\n ORI 0FH"),
         ("CPI", "MVI A,05H\n CPI 07H"),         # A বদলায় না
         ("CMA", "MVI A,96H\n CMA")]

print("নির্দেশ  A   BC    HL    flag")
for name, body in CASES:
    cpu = run(assemble(" ORG 2000H\n " + body + "\n HLT"))
    print(f"{name:<6} {cpu.A:02X}  {cpu.B:02X}{cpu.C:02X}  {cpu.H:02X}{cpu.L:02X}  {cpu.flags_str()}")

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

নির্দেশ  A   BC    HL    flag
ADI    00  0000  0000  S=0 Z=1 AC=1 P=1 CY=1
INR    00  0000  0000  S=0 Z=1 AC=1 P=1 CY=0
DCR    00  0000  0000  S=0 Z=1 AC=1 P=1 CY=0
DCX    00  0000  0000  S=0 Z=0 AC=0 P=0 CY=0
DAD    00  0000  0000  S=0 Z=0 AC=0 P=0 CY=1
ANI    00  0000  0000  S=0 Z=1 AC=1 P=1 CY=0
ORI    FF  0000  0000  S=1 Z=0 AC=0 P=1 CY=0
CPI    05  0000  0000  S=1 Z=0 AC=0 P=0 CY=1
CMA    69  0000  0000  S=0 Z=0 AC=0 P=0 CY=0

প্রথম দুই লাইন একই হিসাব, FFH + 1 = 00H, কিন্তু ADI-এ CY = 1 আর INR-এ CY = 0. INR carry বসায় না, তাই ২৫৫-এর পরের মান ধরতে INR-এর পরে JC লেখা অর্থহীন; দেখতে হয় Z. DCX-এ BC = 0000H হলেও Z = 0: ১৬ বিটের INX/DCX কোনো flag ছোঁয় না। DAD-এ HL = 0000H, CY = 1, কিন্তু Z = 0. ANI আর ORI-এর পার্থক্য পরের অংশে। CPI-এর পরে A এখনো 05H, আর CMA A উল্টালেও কোনো flag বদলায়নি।

কেন এই নকশা? INX/DCX মূলত ঠিকানা (pointer) এগোনোর জন্য। একটি loop-এ INX H দিয়ে পরের byte-এ গেলে আগের হিসাবের CY যেন নষ্ট না হয়, সেটিই উদ্দেশ্য; বহু-byte যোগের loop এর ওপর নির্ভর করে। INR CY রাখে একই কারণে। কিন্তু এর দাম: ১৬ বিটের counter শূন্য হলো কি না জানতে আলাদা নির্দেশ লাগে, MOV A,C আর ORA B (দুটি byte-এর OR শূন্য হলে তবেই দুটোই শূন্য)।

৪ · Logical — AND, OR, XOR, rotate আর তুলনা

Logical দলের নির্দেশ A-র প্রতিটি বিটের ওপর আলাদাভাবে কাজ করে। AND দিয়ে বিট ছাঁকা হয়, OR দিয়ে চালু, XOR দিয়ে উল্টানো; যে সংখ্যা ঠিক করে দেয় কোন বিট, তাকে বলে bitmask. বিটের এই কৌশলের C রূপ C কোর্সের পর্ব ০৯-এ। নিচের টেবিলের সব মান সত্যিকারের trace থেকে, A = 96H (1001 0110) দিয়ে শুরু করে।

নির্দেশA = 96H থেকেflag-এর নিয়ম
ANA r / ANI dataANI 0FH → 06HS Z P ফল থেকে; CY = 0, AC = 1
ORA r / ORI dataORI 0FH → 9FHS Z P ফল থেকে; CY = 0, AC = 0
XRA r / XRI dataXRI 0FFH → 69HS Z P ফল থেকে; CY = 0, AC = 0
CMP r / CPI dataA বদলায় নাA − operand-এর মতো সব flag
RLC / RRC2DH, CY = 1 / 4BH, CY = 0শুধু CY
RAL / RAR (CY ঘুরে)CY = 0 থেকে RAL → 2CH; CY = 1 থেকে RAR → CBHশুধু CY
CMA69H (সব বিট উল্টো)কোনোটিই নয়
STC / CMCA বদলায় নাCY = 1 / CY উল্টো

প্রতিটি নির্দেশ ১ byte আর ৪ T-state (M হলে ৭, immediate হলে ২ byte আর ৭). Rotate নির্দেশ চারটি: RLC বিট ৭-কে বিট ০-তে ঘোরায় আর সেটির কপি CY-তে রাখে; RAL পুরোনো CY-কে বিট ০-তে ঢোকায়, যেন CY একটি নবম বিট। তাই ৯ বিটের চাকার মতো RAL/RAR বহু-byte shift-এ কাজে লাগে। CMA দেয় one's complement; two's complement চাইলে CMA-এর পরে INR A. লক্ষ করুন ANA-এর AC = 1: এটি 8085-এর নিয়ম, পুরোনো 8080-এ আলাদা (Spec decision 4); simulator-এর independent cross-check এই কারণেই এটিকে তুলনা থেকে বাদ রাখে (Spec decision 12).

Bitmask-এর চারটি দৈনন্দিন কৌশল, আবার A = 96H দিয়ে (সত্যিকারের trace): একটি বিট পরীক্ষা, ANI 80H → 80H, Z = 0, তাই বিট ৭ চালু, পরে JNZ; একটি বিট চালু, ORI 40H → D6H; একটি বিট উল্টানো, XRI 01H → 97H; আর A শূন্য করা, XRA A. শেষটি MVI A,00H-এর চেয়ে ছোট (১ byte বনাম ২) আর দ্রুত (৪ T বনাম ৭), সঙ্গে CY-ও 0 করে দেয়; যোগফলের হিসাব শুরুর আগে তাই প্রায়ই এটিই লেখা হয়। উল্টো দিকে, শুধু CY 0 করতে চাইলে STC তারপর CMC, বা ORA A, যা A না বদলে CY মোছে।

এবার এই দলের সবচেয়ে বেশি ব্যবহৃত নির্দেশ: CMP. এটি বিয়োগ করে, কিন্তু ফল ফেলে দেয়; থাকে শুধু flag. ফল তিন রকম হতে পারে, আর প্রতিটি flag-এর একটি নির্দিষ্ট ছাপ রেখে যায়। বাজারঘরের cold room-এর তাপমাত্রা ১/১৬ °C এককে রাখলে (পর্ব ০৫-এর t16) HIGH সীমা ৮.০০ °C = 128 = 80H. তিনটি reading সেই সীমার সঙ্গে তুলনা করা যাক, তারপর একটি ঋণাত্মক reading LOW সীমা ০.০০ °C-এর সঙ্গে।

1MVI B,80H   ; 8.00 °C2MVI A,7AH   ; 7.6253CMP B4MVI A,80H   ; 8.005CMP B6MVI A,84H   ; 8.257CMP B8MVI B,00H   ; 0.00 °C9MVI A,0F8H  ; −0.5010CMP B
তুলনা আর flag
A · B
A − B
S Z AC P CY
সিদ্ধান্ত
  1. 7.625 °C বনাম 8.00 °C. 7AH − 80H করতে ধার লাগে: CY = 1, অর্থাৎ A ছোট। ফলের byte FAH হতো, কিন্তু A-তে রয়ে গেল 7AH. S = 1, কারণ FAH-এর বিট ৭ = 1.
  2. 8.00 বনাম 8.00. 80H − 80H = 0: Z = 1, CY = 0. সমান, কারণ zero flag = 1. “৮.০০-এর ওপরে” প্রশ্নে এটি “না”; README-র নিয়মও তাই, সীমার ঠিক ওপরে না গেলে alarm-এর গণনা হয় না।
  3. 8.25 বনাম 8.00. 84H − 80H = 04H: Z = 0, CY = 0, অর্থাৎ A বড়। তিনটি ক্ষেত্রেই A অক্ষত: CMP শুধু flag বসায়।
  4. ফাঁদ: −0.50 °C বনাম 0.00 °C. −0.50 °C = −8, এক byte-এ two's complement-এ F8H. CMP জানে না এটি ঋণাত্মক; unsigned অর্থে F8H = 248 > 0, তাই CY = 0. LOW alarm-এর পরীক্ষা “A < 0?” উত্তর দিল “না”, অথচ ঘর জমে যাচ্ছে।
  5. লাফের সিদ্ধান্তের ভাষা. CMP-এর পরে: A < operand হলে JC, A ≥ operand হলে JNC, সমান হলে JZ, অসমান হলে JNZ. সবই unsigned. শেষ ক্ষেত্রে S = 1 দেখে মনে হতে পারে “ঋণাত্মক”, কিন্তু S শুধু বিয়োগফলের বিট ৭; বড় দুটি সংখ্যার পার্থক্যে সেটিও ভুল বলে।

সমাধান কী? Signed byte তুলনায় একটি পুরোনো কৌশল আছে: দুটি সংখ্যারই বিট ৭ উল্টে নিন (XRI 80H), তারপর CMP. এতে −128…127 পরিসরটি সরে 0…255-এ চলে আসে, ক্রম না বদলে। মুখের কথায় বিশ্বাস না করে নিচের ব্লক সব ৬৫,৫৩৬টি জোড়া simulator-এর ALU-তে তুলনা করে দেখে।

# CMP তুলনা করে unsigned অর্থে। Signed byte (−128…127)-এ কী হয়, আর XRI 80H কৌশল
from sim85 import CPU8085

cpu = CPU8085()
def cmp_says_less(a, b, flip=False):   # CMP-এর পরে CY = 1 মানে "A ছোট"
    if flip:                           # দুটিরই বিট ৭ উল্টানো (XRI 80H)
        a, b = a ^ 0x80, b ^ 0x80
    cpu.A = a
    cpu.alu(7, b)                      # 7 = CMP; নিয়ম Spec decision 4
    return cpu.F & 0x01 == 1

def sv(x):                             # byte-এর signed অর্থ
    return x - 256 if x & 0x80 else x

pairs = [(a, b) for a in range(256) for b in range(256)]
for flip in (False, True):
    wrong = [p for p in pairs if cmp_says_less(*p, flip) != (sv(p[0]) < sv(p[1]))]
    print(f"XRI 80H={flip}: {len(pairs)} জোড়ায় signed অর্থে ভুল {len(wrong)}টি")

a, b = 0xF8, 0x00                      # −0.50 °C বনাম LOW সীমা 0.00 °C (1/16 °C এককে)
print(f"F8H < 00H? unsigned CMP: {cmp_says_less(a, b)}, signed: {sv(a)} < {sv(b)}?")
print(f"XRI 80H-এর পরে CMP: {cmp_says_less(a, b, True)}")

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

XRI 80H=False: 65536 জোড়ায় signed অর্থে ভুল 32768টি
XRI 80H=True: 65536 জোড়ায় signed অর্থে ভুল 0টি
F8H < 00H? unsigned CMP: False, signed: -8 < 0?
XRI 80H-এর পরে CMP: True

সোজা CMP ঠিক অর্ধেক জোড়ায় signed অর্থে ভুল: যেখানে দুটির চিহ্ন আলাদা, সেখানেই (১২৮ × ১২৮ × ২ = ৩২,৭৬৮). বিট ৭ উল্টানোর পরে একটিও ভুল নেই, আর −0.50 °C ঠিকভাবে ০-এর চেয়ে ছোট হলো। 8086 আর ARM-এ এই কৌশল লাগে না, কারণ সেখানে overflow flag আর signed শর্ত (JL, BLT) আছে; 8085-এ নেই। alu(7, b) হলো simulator-এর CMP-এর নিজের কোড, তাই এটি অনুমান নয়, ঠিক সেই নিয়ম।

৫ · Branch — শর্ত দেখে লাফ

সাধারণভাবে CPU একটির পর একটি নির্দেশ চালায়, কারণ program counter (PC) প্রতিটি fetch-এর পরে এগোয়। Branch দলের নির্দেশ PC-তে নতুন ঠিকানা বসিয়ে এই ধারা ভাঙে। শর্ত ছাড়া লাফ JMP; শর্ত দেখে লাফ দেয় conditional branch: শর্ত সত্য হলে লাফ, মিথ্যা হলে পরের নির্দেশ। 8085-এর আটটি শর্ত, চারটি flag-এর দুই অবস্থা থেকে:

উপমা — রেললাইনের জংশন: ট্রেন (PC) সাধারণত সোজা লাইনে এগোয়। জংশনে পয়েন্টসম্যান লাইন বদলান শুধু সিগন্যালের বাতি দেখে, আর সেই বাতি জ্বালিয়ে গেছে আগের স্টেশন। শর্তযুক্ত লাফও নিজে কিছু হিসাব করে না; আগের কোনো নির্দেশের রেখে যাওয়া flag দেখে লাইন বদলায় বা সোজা চলে। মাঝখানে কেউ বাতি বদলে দিলে ট্রেন ভুল লাইনে যায়, আর কেউ বাতি না জ্বালালে পুরোনো বাতিই সিদ্ধান্ত নেয়।

লাফশর্তopcodeসাধারণ ব্যবহার
JNZ / JZZ = 0 / Z = 1C2H / CAHcounter শেষ হয়নি / সমান
JNC / JCCY = 0 / CY = 1D2H / DAHA ≥ operand / A ছোট
JPO / JPEP = 0 / P = 1E2H / EAHবিজোড় / জোড় parity
JP / JMS = 0 / S = 1F2H / FAHবিট ৭ = 0 (plus) / 1 (minus)

সব লাফ ৩ byte: opcode আর ১৬ বিটের পূর্ণ ঠিকানা। T-state: JMP 10; শর্তযুক্ত লাফ 10 (লাফ দিলে) বা 7 (না দিলে). CALL 18, শর্তযুক্ত CC, CNZ … 18 বা 9; RET 10, শর্তযুক্ত RZ, RNC … 12 বা 6; RST n 12; PCHL (PC ← HL) 6. CALL আর RET stack ব্যবহার করে, তাই এদের বিস্তারিত পর্ব ১২ (8085-এর stack আর subroutine)-এ, আর RST পর্ব ১৩ (8085-এর interrupt)-এ। PCHL-এর একটি সুন্দর ব্যবহার jump table: একটি menu-র বোতাম নম্বর থেকে হিসাব করে HL-এ সংশ্লিষ্ট কাজের ঠিকানা বসিয়ে এক নির্দেশে সেখানে লাফ, অনেকগুলো CPI আর JZ ছাড়াই। লক্ষ করুন JP মানে “jump if plus”, “jump” নয়; এটি Z80-এর JP-এর সঙ্গে গুলিয়ে ফেলা খুব সাধারণ ভুল।

এখন সব জোড়া লাগাই। Cold room-এর নিয়ম (README): পরপর তিনটি reading ৮.০০ °C-এর ওপরে হলে HIGH alarm. ১/১৬ °C এককে “৮.০০-এর ওপরে” মানে t16 ≥ 129 = 81H, তাই CPI 81H-এর পরে CY = 1 মানে সীমার নিচে বা ঠিক সীমায়। Reading-গুলো reference-এর script-এর সেই সময়ের মান: ৫.৫০, ৮.২৫, ৯.০০, ৯.৫০ °C = 58H, 84H, 90H, 98H. এক byte-এ ০ থেকে ১৫.৯৩৭৫ °C ধরা যায়; এই উদাহরণের জন্য যথেষ্ট।

1      LXI H,2050H2      MVI C,04H3      MVI B,00H4NEXT: MOV A,M5      CPI 81H6      JC RESET7      INR B8      MOV A,B9      CPI 03H10      JZ ALARM11      JMP STEP12RESET:MVI B,00H13STEP: INX H14      DCR C15      JNZ NEXT16ALARM:MVI A,01H17      STA 2060H
প্রতিটি reading-এর শেষে
HL · reading
CPI 81H-এ CY
JC
B (পরপর)
মোট T
  1. প্রথম reading, ৫.৫০ °C. 58H − 81H-এ ধার, CY = 1, তাই JC লাফ দেয় RESET-এ (১০ T): B = 0. তারপর INX H, DCR C (C = 3, Z = 0), আর JNZ লাফ দেয় NEXT-এ। এই পর্যন্ত ৭৫ T-state.
  2. ৮.২৫ °C. 84H ≥ 81H, CY = 0: JC লাফ দেয় না (৭ T). INR B → 1. CPI 03H-এ Z = 0, তাই JZ-ও লাফ দেয় না (৭ T), আর JMP STEP সোজা loop-এর শেষে নিয়ে যায়। মোট ১৪৮.
  3. ৯.০০ °C. আবার সীমার ওপরে: B = 2. একই পথ, একই খরচ: প্রতিবার ৭৩ T-state. মোট ২২১.
  4. ৯.৫০ °C. B = 3, আর CPI 03H-এ এবার Z = 1: JZ লাফ দেয় ALARM-এ (১০ T). Loop-এর বাকি অংশ আর চলে না। মোট ২৬৭.
  5. Alarm. MVI A,01H, STA 2060H, HLT: 2060H-এ 01. সব মিলিয়ে ৪২টি নির্দেশ, ২৯২ T-state = 97.33 µs. Reference firmware-এর alarm-ও ঠিক এই চতুর্থ reading-এ, ৭ সেকেন্ডে বাজে (README-র cold-room আউটপুট).

একই program reference simulator-এ, সত্যিকারের run:

~/lab$ python -B sim8085.py run alarm.asm
A=01 B=03 C=01 D=00 E=00 H=20 L=53 SP=0000 PC=2025
Flags: S=0 Z=1 AC=1 P=1 CY=0   (F=54H)
Memory 2060H..2060H:
  2060H: 01
Instructions: 42   T-states: 292

T-state হাতেও মেলানো যায়। Loop-এর বাইরে শুরুতে ২৪ (10 + 7 + 7). প্রথম পাক: MOV A,M 7 + CPI 7 + JC লাফ 10 + MVI B 7 + INX H 6 + DCR C 4 + JNZ 10 = 51, মোট ৭৫. মাঝের দুই পাক প্রতিটি 7 + 7 + 7 + 4 + 4 + 7 + 7 + 10 + 6 + 4 + 10 = 73. শেষ পাক 7 + 7 + 7 + 4 + 4 + 7 + 10 = 46, তারপর alarm-এর 7 + 13 + 5 = 25. মোট 24 + 51 + 73 + 73 + 46 + 25 = 292. মিলেছে। নিচের ব্লকে এই program নিজে বদলে দেখুন: reading বদলান (;@set লাইন), বা cli(SRC, "trace") লিখে প্রতিটি নির্দেশের পরের অবস্থা দেখুন।

# নিজের 8085 program চালান: reference simulator-এর হুবহু কপি (sim85.py), একই আউটপুট
from sim85 import cli

SRC = """
;@set 2050H 58H,84H,90H,98H
;@show 2060H 1
        ORG 2000H
        LXI H,2050H     ; HL -> প্রথম reading (1/16 °C এককে)
        MVI C,04H       ; মোট 4টি reading
        MVI B,00H       ; পরপর কয়টি সীমার ওপরে
NEXT:   MOV A,M
        CPI 81H         ; CY = 1 হলে A < 81H, মানে 8.00 °C-এর ওপরে নয়
        JC RESET
        INR B
        MOV A,B
        CPI 03H
        JZ ALARM        ; পরপর তৃতীয়টি
        JMP STEP
RESET:  MVI B,00H
STEP:   INX H
        DCR C
        JNZ NEXT
        HLT             ; alarm নেই
ALARM:  MVI A,01H
        STA 2060H       ; alarm-এর চিহ্ন
        HLT
"""
cli(SRC)            # "trace" লিখলে প্রতিটি নির্দেশের পরের অবস্থা দেখাবে

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

A=01 B=03 C=01 D=00 E=00 H=20 L=53 SP=0000 PC=2025
Flags: S=0 Z=1 AC=1 P=1 CY=0   (F=54H)
Memory 2060H..2060H:
  2060H: 01
Instructions: 42   T-states: 292

আউটপুট ওপরের সত্যিকারের run-এর সঙ্গে অক্ষরে অক্ষরে এক, কারণ cli() reference-এর command line-এর ছাপার কোডই ব্যবহার করে। দ্বিতীয় reading 84H বদলে 80H করে দেখুন: ৮.০০ “ওপরে” নয়, তাই গণনা আবার শূন্য থেকে শুরু হয়, চারটি reading শেষ হয় alarm ছাড়া, আর 2060H-এ থাকে 00. 8085-এর লাফ সবসময় পূর্ণ ১৬ বিটের ঠিকানায়; 8086-এর মতো ছোট “আপেক্ষিক” লাফ নেই। এর মানে নিয়ে ভাবনার প্রশ্ন ৪-এ আলোচনা আছে।

৬ · Machine control — থামা, অপেক্ষা আর interrupt-এর দরজা

সবচেয়ে ছোট দল, মাত্র ছয়টি opcode. HLT (৫ T) CPU থামায়; reset বা interrupt ছাড়া আর চলে না (Spec decision 11). NOP (৪ T) কিছুই করে না, শুধু সময় নেয় আর একটি byte জায়গা রাখে; delay ঠিক করতে বা পরে নির্দেশ বসানোর ফাঁকা জায়গা হিসেবে লাগে। EI আর DI maskable interrupt চালু আর বন্ধ করে; EI-এর প্রভাব পরের নির্দেশের পরে আসে (Spec decision 7). RIM আর SIM interrupt-এর mask আর serial লাইন SID/SOD পড়ে-লেখে। এই দুটি 8085-এর নিজস্ব: 8080-এ ছিল না, আর 8080-এর সঙ্গে instruction set-এর প্রায় একমাত্র নতুন সংযোজন এরাই। বিস্তারিত পর্ব ১৩-এ।

HLT আর একটি অন্তহীন loop (L: JMP L) দুটোই “কিছু না করে থাকা”, কিন্তু পার্থক্য আছে। HLT-এ CPU bus ছেড়ে থেমে থাকে, আর একটি interrupt এলে জেগে ISR চালায়, তারপর HLT-এর পরের নির্দেশে ফেরে (Spec decision 7). তাই “EI, তারপর HLT” হলো ঘটনার জন্য অপেক্ষার সবচেয়ে সরল ধরন, আজকের microcontroller-এর sleep mode-এর পূর্বপুরুষ। অন্যদিকে NOP সময় মাপার একক: প্রতিটি ৪ T = 3 MHz-এ 1.33 µs, তাই delay-কে কয়েক T-state সূক্ষ্মভাবে মেলাতে loop-এর বাইরে দু-একটি NOP বসানো হয়।

এর বাইরে stack-এর চারটি নির্দেশ (PUSH, POP, XTHL, SPHL) কোনো বইয়ে data transfer, কোনোটিতে এই দলে। এরা stack pointer (SP) দিয়ে memory-র একটি অংশকে থালার স্তূপের মতো ব্যবহার করে: শেষে রাখা জিনিস আগে বেরোয়। Subroutine ডাকা, register বাঁচিয়ে রাখা আর delay-এর হিসাব একসাথে পর্ব ১২-এ।

8085 এসেছে ১৯৭৬ সালে, 8080-এর (১৯৭৪) উত্তরসূরি হিসেবে। নামের “5” প্রচলিত ব্যাখ্যায় একটিমাত্র +5 V সরবরাহের দিকে ইঙ্গিত করে, যেখানে 8080-কে তিনটি আলাদা voltage দিতে হতো। Instruction set প্রায় হুবহু 8080-এর রাখা হয়েছিল, যাতে পুরোনো program চলে; নতুন এলো শুধু RIM আর SIM. তবে timing বদলেছে: 8080-এ MOV r,r ৫ T-state, 8085-এ ৪. একই ১৯৭৬ সালে Zilog-এর Z80 বাজারে আসে, যা 8080-এর প্রায় সব machine code চালাতে পারে, কিন্তু assembly লেখে সম্পূর্ণ আলাদা নামে: MOV A,B-এর জায়গায় LD A,B, JMP-এর জায়গায় JP.

৭ · ফাঁদের তালিকা আর পরীক্ষার T-state হিসাব

এই পর্বের সব সতর্কতা এক জায়গায়। প্রতিটি সারি simulator-এ চালিয়ে দেখা:

ভুল ধারণাসত্যি
MOV, LDA, IN-এর পরে Z ফল দেখায়Data transfer flag ছোঁয় না; ORA A লাগে
INR A-এর পরে FFH → 00H হলে CY = 1INR/DCR CY ছোঁয় না; Z = 1 দেখুন
DCX B শূন্যে পৌঁছালে JNZ থামেINX/DCX কোনো flag ছোঁয় না; MOV A,C, ORA B
DAD সব flag বসায়শুধু CY
CMP A থেকে বিয়োগ করে ফল রাখেশুধু flag; A অক্ষত; তুলনা unsigned
ANA-এর পরে AC = 08085-এ AC = 1 (8080-এ ভিন্ন)
JP মানে সাধারণ লাফ“Jump if plus”, S = 0; সাধারণ লাফ JMP
8085-এ MUL, DIV, LOOP, JE আছেএগুলো 8086-এর; 8085-এ নেই

পরীক্ষায় প্রায়ই একটি ছোট program দিয়ে মোট byte, T-state আর সময় চাওয়া হয়। ধাপে ধাপে, ADD/ADC-এর stepper-এর DAD পথ (১৬ বিটের যোগ) দিয়ে:

  1. প্রতিটি নির্দেশের byte আর T টেবিল থেকে: LHLD 3·16, XCHG 1·4, LHLD 3·16, DAD D 1·10, SHLD 3·16, HLT 1·5.
  2. Byte যোগ: 3 + 1 + 3 + 1 + 3 + 1 = 12 byte (simulator-এ শেষে PC = 200CH, শুরু 2000H থেকে ঠিক 12 এগিয়ে).
  3. T-state যোগ: 16 + 4 + 16 + 10 + 16 + 5 = 67 T.
  4. সময়: 3 MHz-এ 1 T = 1 ÷ 3 MHz = 0.333 µs, তাই 67 × 0.333 µs = 22.33 µs. একই কাজ ADD/ADC দিয়ে 23 byte আর 99 T = 33.00 µs.

Loop থাকলে প্রতিটি শর্তযুক্ত লাফ কতবার লাফ দেয় আর কতবার দেয় না, আলাদা গুনুন; ওপরের alarm-এর হিসাবের মতো। Delay loop-এর সূত্র (14N + 4, 24N + 7) পর্ব ১২-এ।

আরও গভীরে: 8085-এর opcode-এর বিটগুলো নিয়ম মেনে সাজানো, যা ছবি ৯.১-এর opcode map-এ চোখে পড়ে। MOV = 01 DDD SSS, যেখানে register-এর সংকেত B = 000, C = 001, D = 010, E = 011, H = 100, L = 101, M = 110, A = 111: তাই MOV A,B = 01 111 000 = 78H. হিসাবের নির্দেশ = 10 AAA SSS (ADD 000 … CMP 111), তাই ADD B = 80H. এই নিয়মিততার কারণে decoder-এর circuit ছোট হয়। আর বাকি ১০টি undocumented opcode: ১৯৭০-এর দশকের শেষে স্বাধীন গবেষকেরা (প্রায়ই Dehnhardt আর Sorensen-এর নাম আসে) দেখান যে এগুলো আসলে কাজ করে, যেমন ১৬ বিটের বিয়োগ (প্রচলিত নাম DSUB) আর HL-এর ডান shift (ARHL). Intel এগুলো কখনো নথিভুক্ত করেনি, তাই নির্ভরযোগ্য কোডে এগুলোর জায়গা নেই।

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

  • 8085-এ কতটি opcode? ২৪৬টি নথিভুক্ত; ২৫৬-এর বাকি ১০টি নথিভুক্ত নয়।
  • কোন নির্দেশ শুধু CY বদলায়? DAD, চারটি rotate, STC, CMC.
  • CMP B-এর পরে A = B হলে? Z = 1, CY = 0; A অক্ষত।
  • LDA 2050H-এর দৈর্ঘ্য আর T-state? ৩ byte (3A 50 20), ১৩ T.
  • JNZ লাফ না দিলে কত T? ৭; লাফ দিলে ১০.

৮ · AI-এর যুগে 8085-এর নির্দেশ যাচাই

8085-এর প্রশ্নে AI assistant দ্রুত উত্তর দেয়, কিন্তু এই বিষয়ে তার ভুলের ধরন খুব নির্দিষ্ট: অনেক কাছাকাছি CPU (8080, Z80, 8086) একসাথে শিখেছে বলে সে নিয়ম মিশিয়ে ফেলে।

AI প্রায়ই যা করেকীভাবে ধরবেন
Z80 বা 8086-এর নির্দেশ লেখে: LD, JR, DJNZ, JE, LOOP, MULকোর্সের simulator-এ assemble করুন; “unknown mnemonic” এলে নির্দেশটি 8085-এর নয়
T-state ভুল বলে, যেমন MOV r,r = 5 (এটি 8080-এর)Intel-এর 8085 manual-এর টেবিল; simulator-এর trace-এর T=
INR CY বসায় বা DCX Z বসায় বলে ধরে loop লেখেসীমার মানে (FFH, 0001H) চালিয়ে flag দেখুন
Signed তুলনায় সরাসরি CMP আর JC ব্যবহার করেঋণাত্মক মান দিয়ে পরীক্ষা; সব জোড়ায় exhaustive তুলনা
নির্দেশ বানিয়ে ফেলে, যেমন CMPI বা SUBIনির্দেশের তালিকা; ঠিক নাম CPI, SUI
শর্তযুক্ত লাফের T-state একটি সংখ্যায় দেয়লাফ দিলে আর না দিলে আলাদা: 10/7, 18/9, 12/6

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

আমি Intel 8085 assembly লিখছি (8080 বা Z80 নয়; Intel-এর mnemonic, সংখ্যা 2050H ধরনে)। ১. 2050H আর 2052H-এ রাখা দুটি ১৬ বিটের সংখ্যা (ছোট byte আগে) যোগ করে 2054H-এ রাখার program লেখো, ADD আর ADC দিয়ে। ২. প্রতিটি লাইনের পাশে byte সংখ্যা, T-state আর কোন flag বদলায় লেখো। শর্তযুক্ত লাফ থাকলে লাফ দিলে আর না দিলে দুটো T-state-ই দাও। ৩. যে নির্দেশ 8085-এ নেই (8086 বা Z80-এর), তা ব্যবহার করবে না। কোনো তথ্যে নিশ্চিত না হলে অনুমান কোরো না, বলো। ৪. শেষে মোট T-state আর 3 MHz clock-এ সময় হিসাব করো, ধাপে ধাপে।

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

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

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

প্র ০১২৪৬টি opcode-এর মধ্যে ৬৩টিই শুধু MOV. এত জায়গা একটি নির্দেশে কেন, আর এই নকশার দাম কী?

8085-এর opcode-বিন্যাস এসেছে 8080 থেকে, আর 8080-এর পেছনে 8008 (১৯৭২). এই পরিবারের মূল নকশা-ভাবনা ছিল register থেকে register-এ সরানোকে সবচেয়ে সস্তা করা। কারণ accumulator-কেন্দ্রিক CPU-তে প্রায় প্রতিটি হিসাবের আগে আর পরে A-তে কিছু আনতে বা A থেকে সরাতে হয়। তাই MOV-কে একটি পুরো ব্লক দেওয়া হলো: 01 DDD SSS, যেখানে গন্তব্যের তিন বিট আর উৎসের তিন বিট সরাসরি opcode-এর ভেতরে। আটটি গন্তব্য × আটটি উৎস = ৬৪, তার একটি (MOV M,M) অর্থহীন বলে সেখানে HLT, বাকি ৬৩.

এর সুবিধা দুটি। প্রথমত, decoder সরল: opcode-এর বিট ৫–৩ সরাসরি গন্তব্য register বাছে, বিট ২–০ উৎস; একই বিট-ক্ষেত্র হিসাবের নির্দেশেও উৎস বাছে (10 AAA SSS). সেই যুগের chip-এ কয়েক হাজার transistor-এর মধ্যে decoder-এর জায়গা বাঁচানো বড় ব্যাপার ছিল। দ্বিতীয়ত, প্রতিটি MOV এক byte আর মাত্র ৪ T-state, তাই সবচেয়ে বেশি চলা কাজটি সবচেয়ে দ্রুত।

দাম হলো opcode-এর জায়গা ফুরিয়ে যাওয়া। ২৫৬টি ঘরের প্রায় এক-চতুর্থাংশ MOV নিয়ে নেওয়ায় নতুন নির্দেশের জায়গা কম: 8085-এ নতুন যোগ হলো শুধু RIM আর SIM, আর সেগুলো বসেছে 8080-এর ফাঁকা ঘরে (20H, 30H). Z80 যখন অনেক নতুন নির্দেশ আনতে চাইল, তাকে “prefix byte” ব্যবহার করতে হলো: CBH, DDH, EDH, FDH-এর মতো byte আগে বসিয়ে পরের byte-এর নতুন অর্থ। মজার ব্যাপার, এগুলো ঠিক সেই ঘর যেগুলো 8085-এ নথিভুক্ত নয়। 8086 সমাধান করেছে ভিন্নভাবে: opcode-এর পরে একটি “ModR/M” byte, যা register আর memory-র অনেক রকম মিশ্রণ বোঝায়। আধুনিক RISC-V ৩২ বিটের নির্দিষ্ট দৈর্ঘ্যের নির্দেশে register-এর জন্য ৫ বিটের ক্ষেত্র রাখে, কারণ সেখানে register ৩২টি।

মূল উপলব্ধি: Opcode-এর জায়গা একটি সীমিত সম্পদ; যে কাজ সবচেয়ে বেশি চলে, তাকে সস্তা করলে ভবিষ্যতের সম্প্রসারণের জায়গা কমে, আর সেই সিদ্ধান্তের ছাপ উত্তরসূরি CPU-গুলোতেও থেকে যায়।

প্র ০২INR কেন CY ছোঁয় না, আর INX কেন কোনো flag-ই ছোঁয় না? এটি কি ভুল নকশা, নাকি ইচ্ছাকৃত?

ইচ্ছাকৃত, আর কারণটি বোঝা যায় একটি সাধারণ কাজ দিয়ে: দুটি লম্বা সংখ্যার যোগ, প্রতিটি অনেক byte. Loop-এর প্রতিটি পাকে ADC দিয়ে একটি byte যোগ হয়, আর CY পরের পাকের জন্য “হাতে” থাকে। কিন্তু loop চালাতে আরও দুটি কাজ লাগে: ঠিকানা এগোনো (INX H) আর counter কমানো (DCR C). এই দুটি যদি CY বদলাত, তাহলে হাতের carry প্রতিটি পাকে নষ্ট হতো, আর বহু-byte যোগ করতে carry-কে বারবার কোথাও সরিয়ে রেখে ফেরত আনতে হতো। তাই নকশাকারেরা ঠিক করলেন: counter-এর নির্দেশ CY ছাড়া বাকি flag বসাবে (Z দিয়ে loop শেষ বোঝা যায়), আর ঠিকানার নির্দেশ কিছুই ছোঁবে না।

INX/DCX-এর আরেকটি দিক hardware-এর। 8085-এ ১৬ বিটের increment/decrement হয় ঠিকানার পথের একটি আলাদা circuit-এ, ৮ বিটের ALU-তে নয়। ALU-ই flag বানায়; যে হিসাব ALU-তে হয় না, তার flag তৈরির কোনো সহজ পথ নেই। এই কারণেই INX-এর জন্য ৬ T-state: এটি opcode fetch-এর বাইরে দুটি বাড়তি clock নেয় ঠিকানার পথের কাজের জন্য।

দাম হলো সেই পরিচিত ফাঁদ: ১৬ বিটের counter শূন্য হলো কি না, DCX নিজে জানায় না। প্রতিটি পাকে MOV A,C আর ORA B লাগে, যা ৮ T-state আর A-র মান নষ্ট করে। কোর্সের reference-এর ১৬ বিটের delay loop-এর সূত্র 24N + 7 এই কারণেই 14N + 4-এর চেয়ে এত বড়। পরের CPU-গুলো ভিন্ন পথ নিয়েছে। 8086-এ INC/DEC ১৬ বিটেও Z বসায় কিন্তু CF ছোঁয় না, ঠিক 8085-এর INR-এর দর্শন বড় আকারে, আর ঠিকানার হিসাব আলাদা register দিয়ে। Z80 যোগ করল DJNZ, যা counter কমিয়ে শূন্য না হলে লাফ দেয় এক নির্দেশেই। ARM-এ প্রতিটি নির্দেশ নিজে বেছে নেয় flag বসাবে কি না (ADD বনাম ADDS), ফলে সমস্যাটি নকশাতেই মিটে যায়।

মূল উপলব্ধি: কোন নির্দেশ কোন flag ছোঁবে, তা বহু-byte হিসাব আর loop-এর প্রয়োজন থেকে ঠিক করা; প্রতিটি সিদ্ধান্ত একটি কাজ সহজ করে আর অন্য একটিতে বাড়তি নির্দেশ চায়।

প্র ০৩8080, 8085 আর Z80 একই machine code চালাতে পারে, অথচ Z80-এর assembly দেখতে সম্পূর্ণ আলাদা। “একই instruction set” বলতে আসলে কী বোঝায়?

দুটি আলাদা স্তর আছে। নিচের স্তর binary: কোন byte কোন কাজ করে। 8080-এর জন্য লেখা একটি program-এর byte (78, 3A 50 20 …) 8085 আর Z80 দুটোতেই প্রায় একই কাজ করে, কারণ দুই নকশাকারই পুরোনো সফটওয়্যারের বাজার ধরে রাখতে চেয়েছিলেন। একে বলে binary compatibility. ওপরের স্তর মানুষের ভাষা: mnemonic আর লেখার নিয়ম। সেখানে Zilog সম্পূর্ণ নতুন নাম আনে: MOV A,B হয় LD A,B, MVI A,32H-ও LD A,32H, LDA 2050H হয় LD A,(2050H). প্রচলিত ব্যাখ্যা হলো Intel-এর mnemonic নিয়ে আইনি ঝুঁকি এড়ানো; তবে Z80-এর নামগুলো আরও নিয়মিতও, একটি LD দিয়েই সব রকম সরানো লেখা যায়।

তবু “হুবহু এক” বলা যায় না। Timing আলাদা: একই MOV r,r 8080-এ ৫ T-state, 8085-এ ৪, Z80-এ ৪. Flag-এর কিছু খুঁটিনাটি আলাদা: ANA-এর পরে AC 8080 আর 8085-এ ভিন্ন (Spec decision 4), আর Z80-এ parity flag-টি কিছু হিসাবের পরে overflow-এর অর্থ নেয়। 8085-এর RIM/SIM-এর opcode (20H, 30H) Z80-এ সম্পূর্ণ অন্য নির্দেশ, আপেক্ষিক লাফ JR. তাই যে program timing-নির্ভর (delay loop), flag-এর এই কোণগুলোর ওপর নির্ভরশীল, বা interrupt mask ব্যবহার করে, তা এক chip থেকে আরেকটিতে নিলে নীরবে ভুল করতে পারে।

পরীক্ষা আর AI-এর জন্য এর সরাসরি অর্থ আছে। ইন্টারনেটে 8080, 8085 আর Z80-এর কোড মিশে আছে, আর AI assistant এই মিশ্রণ থেকেই শেখে। ফলে সে প্রায়ই 8085-এর প্রশ্নে LD, JR বা DJNZ লিখে ফেলে, বা 8080-এর timing দেয়। এই কোর্সের simulator ঠিক 8085-এর নির্দেশ আর Intel-এর 8085 timing মেনে চলে (Spec decision 2), আর একটি স্বাধীন i8080 core-এর সঙ্গে ২৪,০০০টি একক-নির্দেশের ক্ষেত্রে মিলিয়ে দেখা, যেখানে ইচ্ছা করে বাদ রাখা হয়েছে শুধু সেই কয়েকটি জায়গা যেখানে দুই chip আলাদা।

মূল উপলব্ধি: “Compatible” মানে সাধারণত একই byte একই ফল দেয়; কিন্তু নাম, timing আর flag-এর কোণ আলাদা হতে পারে, তাই কোন chip-এর জন্য লিখছেন, তা সবসময় স্পষ্ট রাখুন।

প্র ০৪8085-এর প্রতিটি লাফে পূর্ণ ১৬ বিটের ঠিকানা লাগে, আপেক্ষিক লাফ নেই। এতে firmware-এর কী অসুবিধা হয়, আর পরের CPU-গুলো কী করেছে?

8085-এর JMP 2034H-এর অর্থ: পরের নির্দেশ আসবে ঠিক 2034H ঠিকানা থেকে, বর্তমান জায়গা যেখানেই হোক। একে বলে absolute ঠিকানা। এর একটি সরাসরি ফল: program-টি memory-র অন্য জায়গায় সরালে প্রতিটি লাফ আর CALL-এর ঠিকানা বদলাতে হয়। 2000H-এ লেখা আমাদের alarm program 3000H-এ নিলে JC 2017H তখনো 2017H-এই যেত, যেখানে হয়তো অন্য কিছু আছে। এই কারণে 8085 যুগে program সাধারণত নির্দিষ্ট ঠিকানার জন্য assemble করা হতো, আর অন্য জায়গায় বসাতে হলে relocating loader সব ঠিকানা ঠিক করে দিত। এছাড়া প্রতিটি লাফ ৩ byte, ছোট loop-এও।

আপেক্ষিক লাফের অর্থ: বর্তমান জায়গা থেকে এত byte সামনে বা পেছনে। দূরত্বটি নির্দেশের ভেতরে একটি signed সংখ্যা। এতে দুটি সুবিধা: program যেখানেই বসুক, ভেতরের লাফ ঠিক থাকে (position-independent code), আর কাছের লাফের নির্দেশ ছোট হয়। Z80 যোগ করে JR, ৮ বিটের দূরত্বসহ ২ byte-এর লাফ। 8086-এর শর্তযুক্ত লাফ (JZ, JC) মূলত ৮ বিটের আপেক্ষিক, আর সাধারণ JMP-এর ১৬ বিটের আপেক্ষিক রূপ আছে। ARM Cortex-M-এর Thumb B আর BL PC থেকে আপেক্ষিক, RISC-V-এর beq, jal-ও তাই। আজকের microcontroller firmware-এ linker প্রায় সব কোডকে নির্দিষ্ট flash ঠিকানায় বসায়, তবু আপেক্ষিক লাফ কোড ছোট রাখে আর bootloader বা firmware update-এর মতো জায়গায় কোড সরানো সহজ করে।

8085-এ position-independent কোড কি একেবারেই অসম্ভব? পুরোপুরি নয়, কিন্তু কঠিন। PCHL দিয়ে HL-এর ঠিকানায় লাফ দেওয়া যায়, তাই নিজের অবস্থান কোনোভাবে জানলে তার সঙ্গে দূরত্ব যোগ করে লাফ দেওয়া সম্ভব। নিজের অবস্থান জানার একটি পুরোনো কৌশল: একটি CALL করে stack থেকে ফেরার ঠিকানা পড়া। কয়েকটি নির্দেশ আর T-state বেশি লাগে, তাই বাস্তবে খুব কমই করা হতো।

মূল উপলব্ধি: লাফের ঠিকানা absolute না আপেক্ষিক, এই ছোট সিদ্ধান্ত ঠিক করে কোড সরানো যায় কি না আর ছোট loop কত byte নেয়; আধুনিক ISA প্রায় সবসময় আপেক্ষিক লাফ বেছে নেয়।

প্র ০৫8085 তুলনা করে flag বসিয়ে, তারপর আলাদা নির্দেশে লাফ দেয়। RISC-V এক নির্দেশেই তুলনা করে লাফ দেয়। কোন পথ ভালো, আর signed তুলনা কোথায় সহজ?

8085-এর পথ দুই ধাপের: CMP বা CPI flag বসায়, পরের JC/JZ flag পড়ে লাফ দেয়। এর সুবিধা হলো একটি তুলনার ফল অনেকবার ব্যবহার করা যায়: CPI 81H-এর পরে JZ দিয়ে সমান পরীক্ষা, তারপর JC দিয়ে ছোট পরীক্ষা, দ্বিতীয়বার তুলনা ছাড়াই। আর যোগ-বিয়োগের নির্দেশ নিজেই flag বসায় বলে অনেক সময় আলাদা তুলনাই লাগে না: DCR C নিজেই Z দেয়। অসুবিধা হলো flag একটি “লুকানো অবস্থা”: মাঝখানে কোনো নির্দেশ flag বদলালে সিদ্ধান্ত বদলে যায়, আর পাঠককে খুঁজতে হয় শেষ কোন নির্দেশ flag ছুঁয়েছে। এই পর্বের অনেক ফাঁদ ঠিক এখান থেকে।

RISC-V-এর নকশাকারেরা flag register-ই রাখেননি। blt x5, x6, label এক নির্দেশেই তুলনা আর লাফ করে, আর bltu একই কাজ unsigned অর্থে। কারণটি মূলত দ্রুত CPU-র ভেতরের: pipeline আর একসাথে অনেক নির্দেশ চালানো CPU-তে flag-এর মতো একটি সাধারণ অবস্থা প্রায় প্রতিটি নির্দেশের মধ্যে নির্ভরতা তৈরি করে, যা সামলাতে বাড়তি hardware লাগে। এর দাম: বহু-word যোগে carry ধরতে আলাদা তুলনা-নির্দেশ (sltu) লাগে, যেখানে 8085-এ ADC-ই যথেষ্ট।

Signed তুলনার প্রশ্নে 8085 সবচেয়ে দুর্বল। এর flag-এ overflow নেই, তাই CMP-এর পরে শুধু unsigned সিদ্ধান্ত নির্ভরযোগ্য; signed-এর জন্য এই পর্বের XRI 80H কৌশল বা চিহ্ন আলাদা পরীক্ষা লাগে। 8086-এ OF আছে, তাই CMP-এর পরে JL/JG সরাসরি signed সিদ্ধান্ত দেয়। ARM Cortex-M-এ CMP-এর পরে BLT লাফ দেয় যখন N ≠ V, অর্থাৎ overflow হিসাবে ধরে নিয়েই চিহ্ন বিচার করে; unsigned-এর জন্য BLO. RISC-V-এ blt আর bltu. প্রতিটি আধুনিক ISA তাই signed আর unsigned তুলনার আলাদা পথ রাখে; ভুলটি বাছাইয়ে, hardware-এ নয়।

মূল উপলব্ধি: Flag-ভিত্তিক তুলনা এক ফলকে বহুবার ব্যবহার করতে দেয় কিন্তু লুকানো নির্ভরতা আনে; তুলনা-লাফ একসাথে সেটি এড়ায়। আর signed না unsigned, সেই সিদ্ধান্ত সবসময় প্রোগ্রামারের, CPU-র নয়।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — ঋণাত্মক reading গোনা: Cold room-এর পাঁচটি reading ১/১৬ °C এককে signed byte হিসেবে 2050H থেকে রাখা: 40H, 0F8H, 00H, 88H, 7FH. কতগুলো ০.০০ °C-এর নিচে, গুনে 2060H-এ রাখার program লিখুন। কোন নির্দেশ দিয়ে চিহ্ন পরীক্ষা করবেন, আর কেন CPI 00H কাজ করবে না?
            LXI H,2050H
            MVI C,05H       ; পাঁচটি reading
            MVI B,00H       ; গণনা
    NEXT:   MOV A,M
            ORA A           ; A অক্ষত, S = বিট 7
            JP SKIP         ; S = 0: ঋণাত্মক নয়
            INR B
    SKIP:   INX H
            DCR C
            JNZ NEXT
            MOV A,B
            STA 2060H
            HLT

    Two's complement-এ ঋণাত্মক মানে বিট ৭ = 1. MOV A,M flag ছোঁয় না, তাই ORA A দিয়ে S বসাতে হয়; তারপর JP (S = 0) বা JM (S = 1). CPI 00H-এর পরে CY সবসময় 0, কারণ unsigned অর্থে কোনো byte ০-এর চেয়ে ছোট নয়। ফল: F8H (−0.50 °C) আর 88H (−120 × 0.0625 = −7.50 °C) ঋণাত্মক, তাই 2060H-এ 02. Simulator-এর সত্যিকারের run: 2060H: 02, ৩৮টি নির্দেশ, ২৫০ T-state.

  2. ভুল খুঁজুন — ১৬ বিটের delay: একজন ১০০০ বার ঘোরা delay loop লিখলেন: LXI B,03E8H / L: DCX B / JNZ L / HLT. Program কখনো HLT-এ পৌঁছায় না। কেন? ঠিক করুন, আর ঠিক program-এর মোট T-state আর 3 MHz-এ সময় বলুন।

    DCX কোনো flag ছোঁয় না, তাই JNZ সবসময় সেই Z দেখে যা loop-এর আগে ছিল। Simulator-এর reset অবস্থায় F = 00H (Spec decision 6; আসল chip-এ reset-এর পরে flag নির্দিষ্ট নয়), তাই Z = 0 আর JNZ প্রতিবার লাফ দেয়; BC শূন্য পেরিয়ে FFFFH-এ ঘুরে যায়, loop চলতেই থাকে। সত্যিকারের run (--max-steps 100000 দিয়ে; সাধারণ সীমা ১০ লাখ, Spec decision 11): runtime error: stopped after 100000 instructions (no HLT reached?). ঠিক রূপ (reference-এর delay16.asm-এর ধরন):

            LXI B,03E8H     ; N = 1000
    L:      DCX B
            MOV A,C
            ORA B           ; B আর C দুটোই 0 হলে তবেই Z = 1
            JNZ L
            HLT

    প্রতি পাক 6 + 4 + 4 + 10 = 24 T, শেষ পাকে JNZ লাফ দেয় না বলে 3 কম; সঙ্গে LXI-এর 10: 24N + 7 = 24 × 1000 + 7 = 24007 T (README-র সূত্র). HLT-সহ simulator দেখায় 24012. সময়: 24007 × 0.333 µs = 8002.33 µs, প্রায় 8.00 ms.

  3. আগে বলুন, তারপর চালান: MVI A,0FFH / INR A / JC L1 / MVI B,11H / L1: ADI 0FFH / RAL / HLT. শেষে A, B আর পাঁচটি flag কী? JC লাফ দেবে কি? মোট T-state কত?

    INR A: FFH + 1 = 00H, Z = 1, AC = 1, P = 1, কিন্তু CY অক্ষত = 0. তাই JC লাফ দেয় না (৭ T), আর MVI B,11H চলে: B = 11H. ADI 0FFH: 00H + FFH = FFH, carry নেই, CY = 0, S = 1, P = 1 (আটটি 1). RAL: FFH বাঁয়ে সরে, পুরোনো CY = 0 ঢোকে বিট ০-তে, বিট ৭-এর 1 যায় CY-তে: A = FEH, CY = 1; বাকি flag অক্ষত। শেষে A = FEH, B = 11H, S = 1, Z = 0, AC = 0, P = 1, CY = 1 (F = 85H). T-state: 7 + 4 + 7 + 7 + 7 + 4 + 5 = 41. Simulator-এর trace হুবহু একই।

  4. হিসাব — byte আর সময়: একটি program: LXI H,2050H, MOV A,M, INX H, ADD M, INX H, MOV M,A, HLT. মোট byte, T-state আর 3 MHz-এ সময় বের করুন। ADD M কেন ADD B-এর চেয়ে ৩ T বেশি নেয়?

    Byte: 3 + 1 + 1 + 1 + 1 + 1 + 1 = 9. T-state: LXI 10 + MOV A,M 7 + INX 6 + ADD M 7 + INX 6 + MOV M,A 7 + HLT 5 = 48 T. সময়: 48 × 0.333 µs = 16.0 µs (ঠিক 48 ÷ 3 = 16 µs). ADD B-এর operand CPU-র ভেতরেই, তাই শুধু opcode fetch (৪ T). ADD M-এর operand memory-তে, তাই opcode fetch-এর পরে একটি memory read machine cycle (৩ T) লাগে: 4 + 3 = 7. Machine cycle-এর বিস্তারিত পর্ব ০৮-এ। লেখকের lab-এ 2050H-এ 12H, 34H দিয়ে চালানো: 2052H-এ 46, ৭টি নির্দেশ, ৪৮ T-state.

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

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

ক্রম8085-এ memory-তে রাখা দুটি ১৬ বিটের সংখ্যা (ছোট byte আগে) যোগ করার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. দুটি সংখ্যার ছোট byte আনা (LDA, MOV B,A, LDA)
  2. ADD B: ছোট byte-এর যোগ, carry যায় CY-তে
  3. ফলের ছোট byte রাখা (STA), CY অক্ষত থাকে
  4. দুটি বড় byte আনা, flag না ছুঁয়ে
  5. ADC B: বড় byte আর CY একসাথে যোগ
  6. ফলের বড় byte রাখা আর HLT

8085-এ A = FFH আর CY = 0. কোন নির্দেশের পরে A = 00H হয় কিন্তু CY = 0-ই থাকে?

  • ADI 01H
  • INR A
  • INX B
  • ACI 01H

8085-এ A = 40H, B = 40H. CMP B চলার পরে কী হয়?

  • A = 00H, Z = 1
  • A = 40H, Z = 1, CY = 1
  • A = 40H, Z = 1, CY = 0
  • A = 40H, কোনো flag বদলায় না

8085-এর LDA 2050H নির্দেশের দৈর্ঘ্য আর T-state কত?

  • ২ byte, ৭ T
  • ৩ byte, ১০ T
  • ৩ byte, ১৬ T
  • ৩ byte, ১৩ T

8085-এ JNZ 2007H চলার সময় Z = 1. নির্দেশটি কত T-state নেয়?

  • ৭ T, লাফ হয় না
  • ১০ T, লাফ হয়
  • ১০ T, লাফ হয় না
  • ৪ T, লাফ হয় না

8085-এ ANI 0FH চলার পরে CY আর AC কী হয়?

  • CY = 0, AC = 0
  • CY = 0, AC = 1
  • CY = 1, AC = 1
  • CY আর AC আগের মতো থাকে

8085-এ BC = 0001H আর Z = 0. DCX B চলার পরে কী হয়?

  • BC = 0000H, Z = 1
  • C = 00H, B অক্ষত, Z = 1
  • BC = 0000H, Z = 0-ই থাকে
  • BC = FFFFH, CY = 1

শব্দকোষ

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

মনে রাখুন

  1. ২৪৬টি opcode, পাঁচ দল: data transfer ৯৬, arithmetic ৬৫, logical ৪৩, branch ৩৬, machine control ৬; দৈর্ঘ্য ১, ২ বা ৩ byte, ঠিকানার ছোট byte আগে।
  2. Data transfer flag ছোঁয় না: শর্তের আগে flag বসানো নির্দেশ লাগে, যেমন ORA A বা CPI.
  3. Flag-এর ফাঁদ: INR/DCR CY ছোঁয় না, INX/DCX কিছুই না, DAD শুধু CY, ANA-এ AC = 1, CMA কিছুই না।
  4. বহু-byte হিসাব: প্রথম byte ADD/SUB, বাকি ADC/SBB; মাঝে flag-বদলানো নির্দেশ নয়।
  5. তুলনা আর লাফ: CMP = ফল না রাখা বিয়োগ, unsigned; CY = 1 মানে ছোট, Z = 1 মানে সমান; লাফ ১০ T, না-লাফ ৭ T; signed-এ XRI 80H কৌশল।

পরের পর্বে: পর্ব ১০ (8085-এর addressing mode আর instruction format). এই পর্বের নির্দেশগুলো operand কোথা থেকে পায়: নির্দেশের ভেতর থেকে, register থেকে, সরাসরি ঠিকানা থেকে, না HL-এর দেখানো ঘর থেকে; আর JMP 2034H ঠিক কোন তিনটি byte হয়ে memory-তে বসে।

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

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