এই পর্বে যা শিখবেন
- যেকোনো 8085 instruction দেখে তার addressing mode, মাপ (byte), machine cycle আর T-state বলা
- Opcode-এর বিট-ছাঁচ (যেমন MOV-এর
01 DDD SSS) থেকে হাতে encode আর decode করা - ১৬ বিটের data আর ঠিকানা কেন ছোট byte আগে বসে, আর হাতে assemble করার সময় এই ক্রমের ভুল ধরা
- Direct আর register indirect-এর মধ্যে byte আর সময়ের হিসাব করে বেছে নেওয়া
- পরীক্ষার শ্রেণিবিভাগের ফাঁদ (
MVI M,JMP,IN,XCHG) আর AI-এর সাধারণ ভুল চেনা
১ · Operand কোথায় থাকে — addressing mode-এর মূল প্রশ্ন
প্রতিটি instruction দুটি কথা বলে: কী করতে হবে, আর কী নিয়ে করতে হবে। “কী করতে হবে” অংশটি opcode. “কী নিয়ে” অংশটি operand: যে মান বা ঠিকানা নিয়ে কাজ হবে। কিন্তু operand-টি কোথায় পাওয়া যাবে? Instruction-এর ভেতরেই লেখা থাকতে পারে, CPU-র কোনো register-এ থাকতে পারে, বা memory-র কোনো ঘরে। CPU-কে operand খুঁজে পাওয়ার যে নিয়ম instruction-টি জানায়, তার নাম addressing mode.
উপমা — বাজারের ফর্দ: বাজারঘরের মালিক কর্মচারীকে পাঁচ রকম নির্দেশ দিতে পারেন। “৫ কেজি চাল ওজন করুন”: পরিমাণ নির্দেশের ভেতরেই লেখা (immediate). “আপনার হাতের ব্যাগের জিনিসটা পাল্লায় রাখুন”: জিনিস হাতের কাছেই (register). “২০৫০ নম্বর তাকের জিনিসটা আনুন”: তাকের নম্বর নির্দেশে লেখা (direct). “এই চিরকুটে যে তাকের নম্বর লেখা, সেখান থেকে আনুন”: নম্বর আলাদা একটি চিরকুটে, যা বদলানো যায় (register indirect). আর “দাঁড়িপাল্লা শূন্যে আনুন”: কোন জিনিস, বলার দরকারই নেই (implicit). কাজ একই রকম, কিন্তু কর্মচারীকে কতটা শুনতে হলো, আর কতবার হাঁটতে হলো, তা আলাদা। CPU-র ক্ষেত্রেও তাই: কত byte পড়তে হলো আর কত T-state লাগল।
Addressing mode-এর সাধারণ তত্ত্ব, অর্থাৎ immediate, register, base + offset আর PC-relative, Computer Architecture পর্ব ২৮-এ RISC-V দিয়ে শেখানো হয়েছে; instruction-এর বিট কীভাবে field-এ ভাগ হয়, তা পর্ব ২৭-এ। এক লাইনে মনে করিয়ে দিই: effective address হলো সেই memory-ঠিকানা, যেখান থেকে instruction আসলে operand পড়ে বা যেখানে লেখে। এই পর্বে প্রশ্ন একটাই: ১৯৭৬ সালের 8085 এই তত্ত্বের কোন অংশ রাখে, কীভাবে byte-এ লেখে, আর প্রতিটির দাম কত। কোন instruction কী কাজ করে আর কোন flag বদলায়, তা পর্ব ০৯-এর বিষয়; এখানে একই instruction-গুলোকে দেখা হবে অন্য চোখে: operand কোথায়, আর byte-এ কীভাবে লেখা। সব সত্যিকারের run কোর্সের 8085 simulator-এ; lab কীভাবে কাজ করে আর নিজে অনুশীলনের free tool কোনগুলো, তা পর্ব ০৬-এ।
এত রকম mode কেন? কারণ তিনটি চাওয়া একসঙ্গে পূরণ হয় না: ছোট program, দ্রুত চলা, আর নমনীয়তা। Operand instruction-এর ভেতরে রাখলে (immediate) দ্রুত, কিন্তু মান বদলাতে program বদলাতে হয়। ঠিকানা instruction-এ রাখলে (direct) যেকোনো ঘরে যাওয়া যায়, কিন্তু instruction বড় হয় আর ঘরটি স্থির থাকে। ঠিকানা register-এ রাখলে (register indirect) instruction ছোট আর ঠিকানা চলার সময় বদলানো যায়, কিন্তু আগে register-এ ঠিকানা বসাতে একটি বাড়তি instruction লাগে। ISA-র নকশাকারী কয়েকটি mode রেখে programmer-কে প্রতিটি কাজের জন্য সেরা মিশ্রণ বাছার সুযোগ দেন। এই পর্বের প্রতিটি অংশ এই তিন চাওয়ার কোনো একটি টানাপোড়েন দেখায়।
8085-এর register-এর নাম মনে রাখুন (পর্ব ০৭, 8085-এর গঠন, এগুলো বিস্তারিত দেখায়): আটটি ৮ বিটের register A B C D E H L, যার মধ্যে A হলো accumulator; তিনটি register pair BC, DE, HL, যারা একসঙ্গে ১৬ বিটের মান বা ঠিকানা রাখে; আর ১৬ বিটের SP ও program counter (PC). লেখার নিয়ম: এই পর্বে সব সংখ্যা Intel-এর ধরনে, শেষে H দিয়ে hex, যেমন 2050H; অক্ষর দিয়ে শুরু হলে আগে একটি 0, যেমন 0E2H (Spec decision 9). Program শুরু 2000H-এ, data 2050H-এ।
পুরো পর্বে একটিই data ব্যবহার হবে, বাজারঘরের স্মার্ট স্কেলের একটি হিসাব: net ওজন 1250 g = 04E2H আর দাম 8188 পয়সা = 1FFCH (81.88 টাকা, reference README-র “বাজারঘর devices”). Memory-তে 2050H থেকে চারটি byte: E2 04 FC 1F, ছোট byte আগে, যা পর্ব ০৫-এ endianness-এর অংশে দেখেছেন।
২ · Instruction format — ১, ২ আর ৩ byte
8085-এর প্রতিটি instruction-এর প্রথম byte opcode. Operand কোথায় আছে তার ওপর নির্ভর করে opcode-এর পরে আরও শূন্য, এক বা দুই byte আসে। এই ছাঁচকে বলে instruction format. 8085-এর তিনটি ছাঁচ:
ছবি ১০.১ — 8085-এর তিন মাপের instruction আর MOV-এর বিট-ছাঁচ
ওপরে memory-র ঠিকানা, ঘরে byte, নিচে ঘরের ভূমিকা
কোর্সের 8085 simulator-এর opcode টেবিল গুনে দেখা গেল (সত্যিকারের run, sim8085.py-এর OPS টেবিল থেকে, লেখকের lab-এ count.py): ২৪৬টি নথিভুক্ত opcode-এর মধ্যে ২০২টি ১ byte, ১৮টি ২ byte, ২৬টি ৩ byte. ২ byte-এর ১৮টি হলো আটটি MVI, আটটি ৮ বিটের immediate ALU নির্দেশ (ADI, ACI, SUI, SBI, ANI, XRI, ORI, CPI), আর IN, OUT. ৩ byte-এর ২৬টি হলো চারটি LXI, LDA, STA, LHLD, SHLD, আর সব JMP/CALL (শর্তসহ)। বাকি সব, যেমন MOV, ADD r, INX, PUSH, RET, এক byte. যে ISA-তে instruction-এর মাপ এভাবে বদলায়, তাকে বলে variable-length instruction-এর ISA.
Opcode কেন সবসময় প্রথমে? কারণ CPU আগে থেকে জানে না instruction কত লম্বা। সে প্রথম byte পড়ে decode করে, আর decode-এর ফলেই জানে আরও শূন্য, এক না দুই byte পড়তে হবে, আর পরের instruction কোথায় শুরু। প্রথম byte যদি data হতো, CPU বুঝতেই পারত না কোনটি opcode. এ কারণে memory-র মাঝখান থেকে ভুল জায়গায় পড়া শুরু করলে (ধরুন LXI H,2050H-এর 21 50 20-এর দ্বিতীয় byte থেকে) CPU data-কে opcode ভেবে পুরো ভিন্ন program চালায়: 50 হয়ে যায় MOV D,B, 20 হয়ে যায় RIM (কোর্সের assembler-এর listing-এ মেলানো)। Disassembler-কেও তাই ঠিক শুরুর ঠিকানা দিতে হয়।
Opcode-এর ভেতরেও নিয়ম আছে। Intel 8085 manual-এর টেবিলে register-এর তিন বিটের কোড B = 000, C = 001, D = 010, E = 011, H = 100, L = 101, M = 110, A = 111. Register pair-এর দুই বিটের কোড BC = 00, DE = 01, HL = 10, SP = 11. তাই MVI r = 00 DDD 110, LXI rp = 00 RP0 001, MOV = 01 DDD SSS. Mnemonic (যেমন MOV C,M) মানুষের জন্য; CPU দেখে শুধু বিট। নিচের ব্লকে এই নিয়মগুলো দিয়ে একটি ছোট encoder; এর ফল কোর্সের assembler-এর listing-এর সঙ্গে হুবহু মেলানো হয়েছে।
# 8085 instruction-এর byte: opcode-এর bit-field নিয়ম থেকে (Intel 8085 manual)
REG = {"B": 0, "C": 1, "D": 2, "E": 3, "H": 4, "L": 5, "M": 6, "A": 7}
RP = {"B": 0, "D": 1, "H": 2, "SP": 3} # register pair-এর কোড
FIXED = {"LDA": 0x3A, "STA": 0x32, "LHLD": 0x2A, "JMP": 0xC3,
"CMA": 0x2F, "HLT": 0x76, "IN": 0xDB}
def lo_hi(w): # 16 বিট: ছোট byte আগে
return [w & 0xFF, w >> 8]
def enc(mn, *ops):
if mn == "MOV": return [0x40 | REG[ops[0]] << 3 | REG[ops[1]]]
if mn == "MVI": return [0x06 | REG[ops[0]] << 3, ops[1]]
if mn == "LXI": return [0x01 | RP[ops[0]] << 4] + lo_hi(ops[1])
if mn == "LDAX": return [0x0A | RP[ops[0]] << 4] # শুধু B বা D
if mn == "IN": return [FIXED[mn], ops[0]] # 8-বিট port
return [FIXED[mn]] + (lo_hi(ops[0]) if ops else [])
def show(o):
return o if isinstance(o, str) else f"{o:04X}H" if o > 0xFF else f"{o:02X}H"
prog = [("MVI", "A", 0x32), ("LXI", "H", 0x2050), ("MOV", "B", "A"),
("LDA", 0x2051), ("MOV", "C", "M"), ("LDAX", "D"), ("CMA",),
("IN", 0x01), ("JMP", 0x2034)]
addr = 0x2000
for ins in prog:
b = enc(*ins)
text = (ins[0] + " " + ",".join(show(o) for o in ins[1:])).strip()
print(f"{addr:04X} {' '.join(f'{x:02X}' for x in b):9}{len(b)} byte {text}")
addr += len(b)
for d, s in [("B", "A"), ("C", "M"), ("A", "M")]:
op = enc("MOV", d, s)[0]
f = format(op, "08b")
print(f"MOV {d},{s} = {f[:2]} {f[2:5]} {f[5:]} = {op:02X}H")আসল আউটপুট (ব্রাউজারের Python):
2000 3E 32 2 byte MVI A,32H
2002 21 50 20 3 byte LXI H,2050H
2005 47 1 byte MOV B,A
2006 3A 51 20 3 byte LDA 2051H
2009 4E 1 byte MOV C,M
200A 1A 1 byte LDAX D
200B 2F 1 byte CMA
200C DB 01 2 byte IN 01H
200E C3 34 20 3 byte JMP 2034H
MOV B,A = 01 000 111 = 47H
MOV C,M = 01 001 110 = 4EH
MOV A,M = 01 111 110 = 7EH
একই নয়টি লাইন কোর্সের simulator-এর python -B sim8085.py asm চালিয়ে হুবহু একই byte দেয় (লেখকের lab-এ enc_check.asm). তিনটি জিনিস দেখুন। প্রথমত, LXI H,2050H-এর byte 21 50 20: ১৬ বিটের মান ছোট byte আগে, ঠিক যেমন JMP 2034H-এর C3 34 20. দ্বিতীয়ত, LDAX-এর জন্য কোডে লেখা “শুধু B বা D”: LDAX H বলে কোনো instruction নেই, কারণ HL দিয়ে memory পড়ার কাজ MOV r,M করে। কোর্সের assembler এমন লাইন পেলে থামে: assembly error: line 2: bad operand H for LDAX. তৃতীয়ত, ঠিকানা লাফিয়ে চলে: পরের instruction-এর ঠিকানা = এই ঠিকানা + এর byte সংখ্যা, তাই 2000H, 2002H, 2005H, 2006H …
এখন একটি instruction-কে শুরু থেকে শেষ পর্যন্ত দেখি: assembler কীভাবে JMP 2034H-কে byte বানায়, আর CPU সেই byte কীভাবে পড়ে। Machine cycle-এর নাম (opcode fetch, memory read) আর প্রতিটির T-state এখানে সংক্ষেপে; সময়ের পুরো ছবি পর্ব ০৮ (8085-এর pin, machine cycle আর timing diagram)-এ। মোট T-state কোর্সের simulator থেকে (jmp.asm, Spec decision 2).
12000H: JMP 2034H22034H: MVI A,01H32036H: HLT
| 2000H…2002H | |
| PC | |
| W Z | |
| A | |
| মোট T |
- Mnemonic থেকে opcode. Assembler টেবিলে দেখে: শর্তহীন
JMP=C3H=1100 0011. এটি ২৬টি ৩ byte-এর opcode-এর একটি, তাই পরে আরও দুটি byte বসবে। - ঠিকানা দুই ভাগে। ১৬ বিটের 2034H-এর উঁচু byte
20H, নিচু byte34H. ৮ বিটের data bus একবারে একটি byte-ই আনতে পারে, তাই ঠিকানাটি দুই byte-এ ভাঙতেই হবে। - Little-endian ক্রমে বসানো। নিচু byte আগে: 2000H-এ
C3, 2001H-এ34, 2002H-এ20. Simulator-এর listing হুবহু তাই দেখায়:2000 C3 34 20. মানুষের চোখে “উল্টো”, CPU-র চোখে নিয়ম। - Opcode fetch, ৪ T-state. CPU PC-র ঠিকানা 2000H থেকে
C3পড়ে instruction register-এ রাখে আর decode করে: “৩ byte, আরও দুটি পড়তে হবে।” PC = 2001H. - দুটি memory read, ৩ + ৩ T-state. 2001H থেকে
34যায় ভেতরের অস্থায়ী register Z-এ, 2002H থেকে20যায় W-তে। PC বেড়ে 2003H. এই পর্যন্ত মোট ১০ T-state, যাJMP-এর পুরো খরচ। - PC ← WZ. W আর Z জোড়া লেগে 2034H, আর সেটিই নতুন PC. পরের opcode fetch হবে 2034H থেকে, 2003H থেকে নয়। এখানে নতুন কোনো T-state খরচ হয়নি; মোট এখনো ১০.
- লক্ষ্যে পৌঁছে। 2034H-এ
MVI A,01H(৭ T) চলে A = 01, তারপরHLT(৫ T). Simulator-এর trace: মোট ২২ T-state, PC = 2037H. 10 + 7 + 5 = 22 মেলে।
উল্টো কাজটিও শেখা দরকার: শুধু byte দেখে instruction চেনা। Debugger-এর memory dump, trainer kit-এর hex বা পরীক্ষার প্রশ্নে প্রায়ই শুধু byte থাকে। নিয়ম একটাই: প্রথম byte সবসময় opcode, তার বিট-ছাঁচ থেকে বোঝা যায় instruction-টি কত byte-এর, তাই পরের instruction কোথায় শুরু। নিচের ধারা 11 60 20 7E 12 76 2000H থেকে রাখা; প্রতিটি ফল কোর্সের assembler-এর listing (dec5.asm) দিয়ে মেলানো।
12000H: 1122001H: 6032002H: 2042003H: 7E52004H: 1262005H: 76
| বিট | |
| ছাঁচ | |
| Instruction | |
| Mode | |
| পরের opcode |
- প্রথম byte
11. বিটে0001 0001. প্রথম দুই বিট 00, শেষ চার বিট 0001: এটিLXI-এর ছাঁচ00 RP 0001. LXI সবসময় ৩ byte, তাই 2001H আর 2002H এই instruction-এরই অংশ। - Register pair আর মান। বিট ৫–৪ = 01, অর্থাৎ DE. পরের দুটি byte
60আর20; নিচু byte আগে, তাই মান 2060H. পুরো instruction:LXI D,2060H, immediate. পরের opcode 2003H-এ। 7E=0111 1110. প্রথম দুই বিট 01, তাই MOV. গন্তব্য 111 = A, উৎস 110 = M:MOV A,M, ১ byte, register indirect, HL-এর ঘর থেকে A-তে।12=0001 0010. ছাঁচ00 RP 0010হলোSTAX, RP = 01 মানে DE:STAX D, ১ byte. A-র মান যায় DE যে ঘর দেখায় সেখানে, অর্থাৎ 2060H-এ। চার instruction মিলে HL-এর ঘর থেকে 2060H-এ এক byte কপি।76=0111 0110. MOV-এর ছাঁচে এটি হতোMOV M,M, যা অর্থহীন; Intel এই ঘরেHLTরেখেছে। পুরো ধারা:LXI D,2060H/MOV A,M/STAX D/HLT, assembler-এর listing-এর সঙ্গে হুবহু এক।
৩ · Immediate আর register addressing — মান হাতের কাছে
Immediate addressing: operand নিজেই instruction-এর ভেতরে, opcode-এর ঠিক পরের byte বা byte দুটিতে। এমন মানকে বলে immediate. 8085-এ এর দুই রূপ। ৮ বিটের: MVI A,32H (২ byte, ৭ T), ADI 10H, CPI 0AH. ১৬ বিটের: LXI H,2050H (৩ byte, ১০ T), যা একটি register pair-এ পুরো ১৬ বিটের মান বসায়। চেনার উপায়: mnemonic-এর শেষে বা শুরুতে I (Immediate): MVI, LXI, ADI, ANI.
একটি সূক্ষ্ম বিষয় পরীক্ষায় প্রায়ই আসে। LXI H,2050H-এর 2050H একটি ঠিকানার মতো দেখায়, কিন্তু instruction-টি memory-র 2050H ঘরে যায়ই না: সে শুধু সংখ্যা 2050H-কে HL-এ বসায়। তাই এটি immediate, direct নয়। পরে HL-কে ঠিকানা হিসেবে ব্যবহার করবে অন্য instruction. MVI A,50H আর LDA 2050H-এর পার্থক্যও একই: প্রথমটি A-তে সংখ্যা 50H বসায়, দ্বিতীয়টি 2050H ঘরের ভেতরে যা আছে, তা আনে।
Register addressing: operand CPU-র একটি register-এ, আর instruction শুধু তার তিন বিটের কোড বলে দেয়। MOV B,A, ADD B, SUB C, INR D, CMP E: সব ১ byte, আর বেশিরভাগ ৪ T-state, কারণ opcode fetch-এর পরে memory-তে আর যেতে হয় না। ১৬ বিটের register pair-এর ওপর কাজ যেমন INX H, DCX B, DAD D-কেও অনেক বই register addressing বলে; INX ৬ T-state নেয়, কারণ এর opcode fetch ৪-এর বদলে ৬ T-state লম্বা (Intel 8085 manual; Spec decision 2-এর টেবিল)।
Immediate আর direct-এর মধ্যে বাছাই শুধু গতির প্রশ্ন নয়, নকশারও। স্মার্ট স্কেলের দর আলু 65.50 টাকা/kg = 6550 পয়সা = 1996H. Firmware-এ এই দর দুইভাবে আনা যায়। Immediate: LXI H,1996H, byte 21 96 19, ১০ T. Direct: দরটি একটি data ঘরে, ধরা যাক 2058H-এ 96 19, আর program পড়ে LHLD 2058H দিয়ে, byte 2A 58 20, ১৬ T. কোর্সের simulator-এ দুটিই HL = 1996H দেয় (rate.asm, প্রথমটির পরে HL = 1996H, ১০ T; দ্বিতীয়টির পরে আবার HL = 1996H, মোট ৩০ T). Immediate দ্রুত আর ছোট, কিন্তু দর লেখা থাকে program-এর byte-এ; 8085 সিস্টেমে program সাধারণত ROM বা EPROM-এ, তাই দর বদলাতে নতুন করে chip প্রোগ্রাম করতে হতো। Direct-এ দর থাকে আলাদা data ঘরে, যা RAM বা লেখা যায় এমন memory-তে রাখলে দোকানি নিজেই বদলাতে পারেন। নিয়ম: যে মান কখনো বদলায় না (port নম্বর, mask, loop-এর মাপ) তা immediate; যে মান ব্যবহারকারী বা configuration বদলাতে পারে, তা memory-তে, direct বা indirect দিয়ে পড়া।
Instruction যত কম জায়গায় operand খোঁজে, তত দ্রুত চলে। Register addressing-এ একটিই bus-এর কাজ (opcode fetch), immediate-এ opcode-এর পরে আরও এক বা দুইবার memory read, আর memory-র data নিয়ে কাজ করলে তার ওপর আরও একবার। তাই MOV B,A ৪ T, MVI A,32H ৭ T, LDA 2050H ১৩ T.
৪ · Direct addressing — ঠিকানা instruction-এই লেখা
Direct addressing-এ instruction-এর ভেতরে থাকে operand-এর পুরো memory-ঠিকানা, আর CPU সেই ঘরে গিয়ে data আনে বা রাখে। 8085-এ এর চারটি memory instruction: LDA addr (A ← [addr]), STA addr ([addr] ← A), LHLD addr (L ← [addr], H ← [addr+1]) আর SHLD addr (উল্টো দিকে)। চারটিই ৩ byte. আর দুটি I/O instruction: IN port আর OUT port, যেখানে ঠিকানা ৮ বিটের port নম্বর, তাই ২ byte. অনেক পাঠ্যবই এগুলোকেও direct addressing-এর উদাহরণ ধরে; port কী আর memory-mapped I/O থেকে এর পার্থক্য কী, তা পর্ব ২৩ (I/O interfacing)-এ।
Direct addressing-এর খরচ বেশি, কারণ CPU-কে প্রথমে instruction থেকে ঠিকানার দুটি byte পড়তে হয়, তারপর সেই ঠিকানায় যেতে হয়। LDA 2052H-এর চারটি machine cycle (Intel 8085 manual): opcode fetch (৪ T), ঠিকানার নিচু byte পড়া (৩ T), উঁচু byte পড়া (৩ T), আর 2052H থেকে data পড়া (৩ T): মোট ১৩. LHLD দুটি data byte পড়ে, তাই পাঁচটি machine cycle আর ১৬ T-state.
বাজারঘরের হিসাবে direct addressing-এর একটি সুন্দর ব্যবহার: দুটি ১৬ বিটের মান জায়গা বদল। 2050H-এ net ওজন (04E2H), 2052H-এ দাম (1FFCH). LHLD আর SHLD এক instruction-এ পুরো ১৬ বিট আনে বা রাখে, আর XCHG HL আর DE-কে অদলবদল করে (সত্যিকারের run, কোর্সের 8085 simulator, python -B sim8085.py trace swap.asm, Python 3.13.5):
2000 2A 50 20 LHLD 2050H ... D=00 E=00 H=04 L=E2 ... T=16 total=16
2003 EB XCHG ... D=04 E=E2 H=00 L=00 ... T=4 total=20
2004 2A 52 20 LHLD 2052H ... D=04 E=E2 H=1F L=FC ... T=16 total=36
2007 22 50 20 SHLD 2050H ... D=04 E=E2 H=1F L=FC ... T=16 total=52
200A EB XCHG ... D=1F E=FC H=04 L=E2 ... T=4 total=56
200B 22 52 20 SHLD 2052H ... D=1F E=FC H=04 L=E2 ... T=16 total=72
200E 76 HLT ... D=1F E=FC H=04 L=E2 ... T=5 total=77
Memory 2050H..2053H:
2050H: FC 1F E2 04
(লাইনগুলো ছোট করতে A, B, C, SP, PC আর flag-এর ঘর “...” দিয়ে বাদ দেওয়া হয়েছে; সেগুলো বদলায়নি।) প্রথম LHLD 2050H-এর পরে H = 04, L = E2: 2050H-এর byte গেছে L-এ, 2051H-এর byte H-এ। অর্থাৎ LHLD memory-র little-endian ক্রম মেনে পড়ে, আর SHLD সেই ক্রমেই লেখে। শেষে 2050H-এ দাম, 2052H-এ ওজন; ১৫ byte-এর program, ৭৭ T-state.
এবার I/O-র direct addressing. ধরা যাক বাজারঘরের একটি পুরোনো 8085-ভিত্তিক কাউন্টারে port 01H-এ একটি keypad, যেখান থেকে পণ্যের কোড আসে, আর port 02H-এ display-এর একটি latch. IN 01H port নম্বরটি instruction-এর দ্বিতীয় byte-এ বহন করে, ঠিক যেমন LDA ঠিকানা বহন করে, শুধু ৮ বিটের। কোর্সের simulator-এ keypad-এর মান ;@in 01H 05H pragma দিয়ে দেওয়া হলো (Spec decision 10; আসল keypad নেই, এটি simulator-এর ইনপুট)। সত্যিকারের run (io.asm):
2000 DB 01 4 START: IN 01H
2002 32 56 20 5 STA 2056H
2005 3A 52 20 6 LDA 2052H
2008 D3 02 7 OUT 02H
200A 76 8 HLT
...
OUT port 02H <- FCH (at T=46)
Instructions: 5 T-states: 51
(listing আর run-এর শেষ অংশ একসঙ্গে।) IN 01H আর OUT 02H দুটিই ২ byte আর ১০ T-state: opcode fetch ৪, port নম্বর পড়া ৩, তারপর I/O read বা write ৩. Simulator জানাল, ৪৬তম T-state-এ port 02H-এ গেছে FCH, দামের নিচু byte: আগের তিনটি instruction-এ 10 + 13 + 13 = 36 T, আর simulator সময়টি লেখে OUT শেষ হওয়ার মুহূর্তে: 36 + 10 = 46. ৮ বিটের port নম্বর মানে 8085-এ মোট ২৫৬টি input আর ২৫৬টি output port.
হাতে assemble করার পুরোনো ফাঁদ: অনেক trainer kit-এ program ঢোকাতে হয় hex byte টিপে টিপে। LDA 2052H-কে কেউ 3A 20 52 লিখলে কী হবে? CPU নিয়ম মেনে প্রথম data byte-কে নিচু byte ধরে, তাই ঠিকানা হয় 5220H. কোর্সের simulator-এ এই তিনটি byte DB দিয়ে বসিয়ে চালালে trace সোজা বলে দেয়: 2000 3A 20 52 LDA 5220H. কোনো error নেই; CPU শুধু ভুল ঘর পড়ে। এই ধরনের ভুল ধরতে disassembler (sim8085.py dis) দিয়ে নিজের byte আবার পড়ে দেখা সবচেয়ে সহজ পথ।
৫ · Register indirect addressing — ঠিকানা একটি register pair-এ
Register indirect addressing-এ instruction-এ ঠিকানা লেখা থাকে না; ঠিকানা থাকে একটি register pair-এ, আর instruction শুধু বলে “এই pair যেখানে দেখাচ্ছে, সেখানে যান”। C ভাষার pointer (C কোর্সের পর্ব ১৭) ঠিক এটাই: *p. 8085-এ তিন রকম:
| Pointer | Instruction | কাজ | Byte, T |
|---|---|---|---|
| HL (M) | MOV r,M, MOV M,r, ADD M, CMP M, INR M, MVI M,d8 | যেকোনো register বা ALU-র সঙ্গে memory | ১ byte, ৭ T (INR M ১০, MVI M ২ byte ১০) |
| BC বা DE | LDAX B, LDAX D, STAX B, STAX D | শুধু A-তে আনা বা A থেকে রাখা | ১ byte, ৭ T |
| SP | PUSH, POP, CALL, RET, XTHL | Stack; pointer-এর কথা opcode-এই বোঝা যায় | পর্ব ১২-এ |
HL এখানে বিশেষ: “M” নামে এটিই একমাত্র pointer, যা দিয়ে A ছাড়া অন্য register-ও memory পড়তে-লিখতে পারে, আর ALU সরাসরি memory-র মান নিয়ে যোগ বা তুলনা করতে পারে। BC আর DE দিয়ে শুধু A-র সঙ্গে আদানপ্রদান। নিচের stepper-এ ক্লাসিক জোড়া: LXI H,2050H দিয়ে pointer বসানো, তারপর MOV A,M দিয়ে পড়া। মানগুলো সত্যিকারের trace থেকে (python -B sim8085.py trace hlm.asm).
1LXI H,2050H ; 21 50 202MOV A,M ; 7E3INX H ; 234MOV B,M ; 465HLT ; 76
| PC | |
| HL | |
| A B | |
| data-র ঠিকানা | |
| মোট T |
- শুরু. সব register 00, PC = 2000H. Memory-র 2050H আর 2051H-এ net ওজনের দুটি byte:
E2 04, ছোট byte আগে। LXI H,2050H: immediate, ১০ T. তিনটি byte পড়া হয়: opcode21, তারপর50যায় L-এ,20যায় H-এ। HL = 2050H. এখনো 2050H ঘরে কেউ যায়নি; শুধু pointer তৈরি হলো।MOV A,M: register indirect, ৭ T. ১ byte-এর opcode7Efetch (৪ T), তারপর address bus-এ HL-এর মান 2050H বসিয়ে একটি memory read (৩ T): A =E2. মোট ১৭.INX H: pointer এগোল, ৬ T. HL = 2051H. কোনো data পড়া হয়নি, কোনো flag বদলায়নি। এই এক byte-এর instruction-ই register indirect-এর আসল শক্তি: ঠিকানা বদলাতে program বদলাতে হয় না।MOV B,M: আবার register indirect, ৭ T. একই ধরনের instruction, এবার ঠিকানা 2051H: B =04. মোট ৩০.HLT, ৫ T, মোট ৩৫. B আর A মিলে04E2H= 1250, অর্থাৎ ১২৫০ g. Simulator-এর শেষ লাইন:Instructions: 5 T-states: 35.
এবার একই data দুই পথে পড়ি: direct দিয়ে LDA 2052H, আর register indirect দিয়ে LDAX D. দুটিই A-তে 2052H-এর byte আনে, কিন্তু মাপ, সময় আর নমনীয়তা আলাদা (python -B sim8085.py trace ldax.asm).
1LDA 2052H ; 3A 52 202MOV B,A ; 473LXI D,2052H ; 11 52 204LDAX D ; 1A5INX D ; 136LDAX D ; 1A7HLT ; 76
| A B | |
| DE | |
| এই instruction | |
| মোট T |
LDA 2052H: direct. চারটি machine cycle: opcode fetch, ঠিকানার দুই byte পড়া, তারপর 2052H থেকে data. A =FC, দামের নিচু byte. ১৩ T-state, ৩ byte.MOV B,A. তুলনার জন্য প্রথম ফল B-তে রাখা হলো: B =FC. Register addressing, ৪ T. মোট ১৭.LXI D,2052H. Indirect পথের প্রস্তুতি: DE = 2052H. এটি immediate, ১০ T. মোট ২৭. এই খরচ একবারই।LDAX D: register indirect. Opcode fetch আর একটি memory read, ঠিকানা আসে DE থেকে। A =FC, B-র সঙ্গে হুবহু এক। মাত্র ১ byte আর ৭ T,LDA-র প্রায় অর্ধেক।INX D. Pointer এক ঘর এগোল: DE = 2053H. ৬ T, মোট ৪০.- আবার
LDAX D. একই opcode1A, কিন্তু এবার A =1F, দামের উঁচু byte.LDA-র ঠিকানা program-এর byte-এ বাঁধা;LDAX-এর ঠিকানা চলার সময় বদলায়। Loop-এ array পড়ার একমাত্র উপায় এটাই। HLT, মোট ৫২ T. B-তেFC, A-তে1F: দাম1FFCH= 8188 পয়সা = 81.88 টাকা. সিদ্ধান্তের নিয়ম: একটি ঘর একবার পড়তেLDAসহজ; অনেক ঘর, বা একই ঘর বারবার, পড়তে pointer লাভজনক।
Pointer বসাতে ভুলে গেলে: Register indirect instruction কখনো জিজ্ঞেস করে না HL-এ ঠিক ঠিকানা আছে কি না। Reset-এর পরে HL = 0000H (Spec decision 6), তাই LXI H ছাড়াই MVI M,05H লিখলে 05 গিয়ে বসে 0000H-এ। কোর্সের simulator-এ দুই লাইনের program (MVI M,05H, HLT) চালালে শেষ অংশ: 0000H: 05 00, Instructions: 2 T-states: 15. বাস্তব 8085 সিস্টেমে 0000H সাধারণত ROM-এর শুরু, যেখানে reset-এর পরের প্রথম instruction থাকে; RAM হলে আপনি নিজের program-এর ওপরই লিখতেন। C-তে ঠিক এই ভুলের নাম uninitialized বা NULL pointer, আর এর ফল প্রায়ই কোনো error ছাড়াই ভুল আচরণ।
আরও গভীরে: 8085-এ memory indirect mode নেই: কোনো instruction memory থেকে একটি ঠিকানা পড়ে সেই ঠিকানায় আবার যেতে পারে না, যাকে তত্ত্বে indirect addressing বলে। দরকার হলে দুই ধাপে করতে হয়: LHLD ptr (ঠিকানাটি HL-এ আনা), তারপর MOV A,M. Indexed addressing-ও নেই; base আর index যোগ করতে DAD দিয়ে HL-এ যোগফল বানিয়ে তারপর M ব্যবহার করতে হয়। Z80 (১৯৭৬, Zilog) এই অভাব পূরণ করেছিল IX আর IY register আর (IX+d) mode দিয়ে, আর সেগুলোর opcode বসিয়েছিল ঠিক সেই prefix byte-এ (DD, FD, ED, CB), যেগুলো 8080/8085-এ নথিভুক্ত নয় (Spec decision 1-এর অনথিভুক্ত তালিকায় এই চারটি আছে)। 8086-এ base আর index মিলিয়ে পুরো পরিবারই আছে, পর্ব ১৫-এ।
৬ · Implicit addressing আর পুরো শ্রেণিবিভাগ
Implicit বা implied addressing-এ operand-এর কথা instruction-এ আলাদা করে লেখা থাকে না; opcode নিজেই জানে কী নিয়ে কাজ। CMA (A-র সব বিট উল্টানো), RLC, RAL (A ঘোরানো), DAA, STC আর CMC (carry flag), EI, DI, RIM, SIM: সব ১ byte, ৪ T. অনেক বই XCHG (HL ↔ DE), SPHL, PCHL-কেও এখানে রাখে, কারণ register-এর নাম opcode-এ বাঁধা; অন্যরা এগুলোকে register addressing বলে। RST n-ও implicit: লাফের ঠিকানা (n × 8) opcode থেকেই আসে।
নিচের টেবিল পুরো ছবি একসঙ্গে। Byte আর মোট T-state কোর্সের simulator-এ প্রতিটি instruction চালিয়ে মেলানো (tab.asm); machine cycle-এর ভাগ Intel 8085 manual থেকে। সংকেত: OF = opcode fetch, MR = memory read, MW = memory write, IOR/IOW = I/O read/write.
| Instruction | Mode | Byte | Machine cycle | T |
|---|---|---|---|---|
MVI A,32H | immediate | 2 | OF MR | 7 |
LXI H,2050H | immediate | 3 | OF MR MR | 10 |
MOV B,A, ADD B | register | 1 | OF | 4 |
INX H | register (pair) | 1 | OF (৬ T) | 6 |
LDA, STA 2051H | direct | 3 | OF MR MR MR/MW | 13 |
LHLD, SHLD | direct | 3 | OF MR MR, তারপর দুটি MR/MW | 16 |
IN 01H, OUT 02H | direct (port) | 2 | OF MR IOR/IOW | 10 |
MOV A,M, ADD M | register indirect | 1 | OF MR | 7 |
LDAX B, STAX D | register indirect | 1 | OF MR/MW | 7 |
MVI M,05H | immediate → indirect | 2 | OF MR MW | 10 |
CMA, STC, RLC | implicit | 1 | OF | 4 |
JMP 2034H | immediate/direct (বই ভেদে) | 3 | OF MR MR | 10 |
শেষ দুটি সারি পরীক্ষায় সবচেয়ে বেশি ধোঁকা দেয়। MVI M,05H-এ উৎস immediate (05H instruction-এ), কিন্তু গন্তব্য register indirect (HL যেখানে দেখায়); উত্তরে দুটোই লিখুন। JMP 2034H-কে কিছু বই immediate বলে (লক্ষ্যের ঠিকানা instruction-এর ভেতরের একটি সংখ্যা, যা সরাসরি PC-তে যায়), কিছু বই direct (ঠিকানা instruction-এ লেখা)। Memory-র 2034H ঘর থেকে কোনো data পড়া হয় না, পরের instruction সেখান থেকে fetch হয় মাত্র। পরীক্ষায় যে নামই লিখুন, এই যুক্তিটি এক লাইনে যোগ করুন।
একই ধারণা পরের CPU-গুলোতে কেমন দেখায়, তার একটি আগাম ঝলক। 8086-এর লাইনগুলো NASM 3.02 (cpu 8086) দিয়ে, আর Cortex-M-এর লাইনগুলো Clang 22.1.8-এর assembler (ziglang 0.17.1, cortex_m3) দিয়ে লেখকের lab-এ assemble করে যাচাই করা; বিস্তারিত পর্ব ১৫ (8086-এর addressing mode আর effective address) আর পর্ব ২৯ (ARM Cortex-M-এর গঠন)-এ।
| Mode | 8085 | 8086 (NASM) | Cortex-M (Thumb) |
|---|---|---|---|
| immediate | MVI A,32H | mov al,32h | movs r0,#0x32 |
| register | MOV B,A | mov bl,al | mov r1,r0 |
| direct | LDA 2050H | mov al,[2050h] | নেই; আগে ঠিকানা register-এ (ldr r1,=…) |
| register indirect | MOV A,M | mov al,[bx] | ldrb r0,[r1] |
| base/index + offset | নেই | mov al,[bx+si+5] | ldrb r0,[r1,#5] |
| PC-relative | নেই | jmp short (দূরত্ব) | b, literal-এর ldr |
দুটি জিনিস চোখে পড়ার মতো। 8086-এর mov al,[2050h]-এর NASM listing A05020: সেখানেও ঠিকানা ছোট byte আগে, 8085-এর LDA 2050H = 3A 50 20-এর মতোই। আর Cortex-M-এ direct mode-ই নেই: ৩২ বিটের ঠিকানা ১৬ বা ৩২ বিটের instruction-এ আঁটে না, তাই ঠিকানা আগে একটি register-এ আনতে হয়, তারপর register indirect দিয়ে পড়া। এমবেডেড C-তে বাজারঘর board-এর GPIOA-র IDR (0x40010808, README-র memory map) পড়ার মতো কাজ compiler ঠিক এভাবেই বানায়, পর্ব ৩৬-এ দেখবেন। 8085-এর register indirect-ই তাই আধুনিক microcontroller-এর প্রধান পথ।
এখন সব mode এক program-এ, আর একটি ছোট emulator, যা প্রতিটি instruction-এর byte decode করে বলে operand কোথা থেকে এলো। এটি কোর্সের reference sim8085.py-এর decode-execute পথের খুব ছোট একটি অংশ, শুধু এই program-এর ১০টি opcode; প্রতিটি লাইনের register আর মোট T-state python -B sim8085.py trace modes.asm-এর সঙ্গে মিলিয়ে দেখা হয়েছে (১১টি instruction, সব মান এক)।
# ছোট 8085 subset: byte fetch, decode, operand কোথায় (mode), তারপর execute
mem = bytearray(65536)
code = "3E32 215020 47 3A5120 4E 115220 1A 2F 325420 2A5220 76"
mem[0x2000:0x2016] = bytes.fromhex(code.replace(" ", ""))
mem[0x2050:0x2054] = bytes([0xE2, 0x04, 0xFC, 0x1F]) # net 1250 g, দাম 8188
r = dict.fromkeys("ABCDEHL", 0); pc = 0x2000; total = 0
pair = lambda h, l: r[h] << 8 | r[l]
while mem[pc] != 0x76:
op, d8 = mem[pc], mem[pc + 1]
a16 = d8 | mem[pc + 2] << 8 # ছোট byte আগে
if op == 0x3E: n, t, m, s = 2, 7, "immediate", "MVI A"; r["A"] = d8
elif op in (0x11, 0x21):
n, t, m = 3, 10, "immediate"; h, l = ("D", "E") if op == 0x11 else ("H", "L")
r[h], r[l] = a16 >> 8, a16 & 0xFF; s = "LXI " + h
elif op == 0x47: n, t, m, s = 1, 4, "register", "MOV B,A"; r["B"] = r["A"]
elif op == 0x3A: n, t, m, s = 3, 13, f"direct [{a16:04X}]", "LDA"; r["A"] = mem[a16]
elif op == 0x4E:
n, t, m, s = 1, 7, f"reg-ind [HL={pair('H', 'L'):04X}]", "MOV C,M"
r["C"] = mem[pair("H", "L")]
elif op == 0x1A:
n, t, m, s = 1, 7, f"reg-ind [DE={pair('D', 'E'):04X}]", "LDAX D"
r["A"] = mem[pair("D", "E")]
elif op == 0x2F: n, t, m, s = 1, 4, "implicit (A)", "CMA"; r["A"] ^= 0xFF
elif op == 0x32: n, t, m, s = 3, 13, f"direct [{a16:04X}]", "STA"; mem[a16] = r["A"]
elif op == 0x2A:
n, t, m, s = 3, 16, f"direct [{a16:04X}]", "LHLD"
r["L"], r["H"] = mem[a16], mem[a16 + 1]
total += t
print(f"{pc:04X} {s:8}{n}B {m:21} A={r['A']:02X} B={r['B']:02X} "
f"C={r['C']:02X} HL={pair('H', 'L'):04X} T={total}")
pc += n
print(f"HLT: total T = {total + 5}, 2050H: {mem[0x2050:0x2056].hex(' ').upper()}")আসল আউটপুট (ব্রাউজারের Python):
2000 MVI A 2B immediate A=32 B=00 C=00 HL=0000 T=7
2002 LXI H 3B immediate A=32 B=00 C=00 HL=2050 T=17
2005 MOV B,A 1B register A=32 B=32 C=00 HL=2050 T=21
2006 LDA 3B direct [2051] A=04 B=32 C=00 HL=2050 T=34
2009 MOV C,M 1B reg-ind [HL=2050] A=04 B=32 C=E2 HL=2050 T=41
200A LXI D 3B immediate A=04 B=32 C=E2 HL=2050 T=51
200D LDAX D 1B reg-ind [DE=2052] A=FC B=32 C=E2 HL=2050 T=58
200E CMA 1B implicit (A) A=03 B=32 C=E2 HL=2050 T=62
200F STA 3B direct [2054] A=03 B=32 C=E2 HL=2050 T=75
2012 LHLD 3B direct [2052] A=03 B=32 C=E2 HL=1FFC T=91
HLT: total T = 96, 2050H: E2 04 FC 1F 03 00
বন্ধনীর ঠিকানাই প্রতিটি memory-instruction-এর effective address. Direct-এর ঠিকানা আসে instruction-এর byte থেকে (a16), register indirect-এর ঠিকানা আসে register pair থেকে (pair(...)); কোডে দুই লাইনের এই পার্থক্যই দুই mode-এর পার্থক্য। CMA কোনো operand পড়ে না: FC-এর সব বিট উল্টে 03. শেষ লাইনে কোর্সের simulator-এর মতোই মোট ৯৬ T-state, আর 2054H-এ STA-র রাখা 03. Simulator-এর নিজের শেষ অংশ:
A=03 B=32 C=E2 D=20 E=52 H=1F L=FC SP=0000 PC=2016
Flags: S=0 Z=0 AC=0 P=0 CY=0 (F=00H)
Memory 2050H..2055H:
2050H: E2 04 FC 1F 03 00
Instructions: 11 T-states: 96
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:
- 8085-এর addressing mode কয়টি? পাঁচটি: immediate, register, direct, register indirect, implicit; প্রতিটির একটি উদাহরণ (
MVI,MOV B,A,LDA,MOV A,M,CMA) দিন। LDA 2050HআরLDAX D-এর পার্থক্য? প্রথমটি direct, ৩ byte, ১৩ T; দ্বিতীয়টি register indirect, ১ byte, ৭ T, ঠিকানা DE-তে।LXI H,2050H-এর mode? Immediate; 2050H একটি ১৬ বিটের সংখ্যা যা HL-এ যায়, memory পড়া হয় না।STA 2050H-এর machine code?32 50 20: opcode, তারপর নিচু byte, তারপর উঁচু byte.LDAX Hকেন নেই? HL দিয়ে memory-র কাজMOV r,Mকরে, আর opcode-এর জায়গা সীমিত;LDAXশুধু BC আর DE.
৭ · কোন mode কখন — byte আর সময়ের হিসাব
বাজারঘরের স্মার্ট স্কেলের চারটি byte (ওজন আর দাম, 2050H–2053H) display-এর buffer-এ, 2060H–2063H-এ, কপি করতে হবে। দুইভাবে লেখা যায়। Direct: প্রতিটি byte-এর জন্য একটি LDA আর একটি STA, loop ছাড়া। Register indirect: HL উৎস, DE গন্তব্য, C গণক, আর একটি loop. দুটোই কোর্সের simulator-এ চালানো হলো (সত্যিকারের run, copy_d.asm আর copy_i.asm):
copy_d (direct) Bytes: 25 2060H: E2 04 FC 1F Instructions: 9 T-states: 109
copy_i (indirect) Bytes: 17 2060H: E2 04 FC 1F Instructions: 28 T-states: 189
(দুটি run-এর asm আর run আউটপুটের মূল লাইনগুলো এক সারিতে সাজানো।) চার byte-এর জন্য direct প্রায় ১.৭ গুণ দ্রুত, কিন্তু program বড়। কেন? প্রতি byte-এ direct খরচ করে ২৬ T (১৩ + ১৩) আর ৬ byte; loop-এর প্রতি পাকে MOV A,M ৭, STAX D ৭, দুটি INX ৬ + ৬, DCR C ৪, JNZ ১০: মোট ৪০ T, কিন্তু program-এর মাপ স্থির। নিচের ব্লক N byte-এর জন্য দুই সূত্র বের করে; সূত্র দুটি N = 1, 2, 4, 8, 16, 64 আর 200-এ simulator চালিয়ে হুবহু মিলেছে (লেখকের lab-এ gen_copy.py).
# N byte copy: direct (LDA/STA জোড়া) বনাম register indirect loop
# সূত্র দুটি কোর্সের simulator-এ N = 1, 2, 4, 8, 16, 64-এ চালিয়ে মেলানো
def direct(n): # প্রতি byte: LDA a (3 byte, 13 T) + STA b (3 byte, 13 T); শেষে HLT
return 6 * n + 1, 26 * n + 5
def indirect(n): # LXI H / LXI D / MVI C, loop: MOV A,M STAX D INX H INX D DCR C JNZ
loop = 7 + 7 + 6 + 6 + 4 + 10 # প্রতি পাক 40 T
return 3 + 3 + 2 + 1 + 1 + 1 + 1 + 1 + 3 + 1, 27 + loop * n - 3 + 5
print(" N | direct: byte T µs | indirect: byte T µs")
for n in (1, 4, 16, 64, 200):
(bd, td), (bi, ti) = direct(n), indirect(n)
print(f"{n:4} | {bd:12} {td:5} {td / 3:7.1f} | {bi:14} {ti:5} {ti / 3:7.1f}")
print("শেষ পাকে JNZ লাফ দেয় না: 10 T-এর জায়গায় 7 T, তাই সূত্রে - 3")
print("3 MHz clock: 1 T = 1/3 µs")আসল আউটপুট (ব্রাউজারের Python):
N | direct: byte T µs | indirect: byte T µs
1 | 7 31 10.3 | 17 69 23.0
4 | 25 109 36.3 | 17 189 63.0
16 | 97 421 140.3 | 17 669 223.0
64 | 385 1669 556.3 | 17 2589 863.0
200 | 1201 5205 1735.0 | 17 8029 2676.3
শেষ পাকে JNZ লাফ দেয় না: 10 T-এর জায়গায় 7 T, তাই সূত্রে - 3
3 MHz clock: 1 T = 1/3 µs
সূত্র: direct-এ byte = 6N + 1 আর T = 26N + 5; indirect-এ byte = 17 আর T = 40N + 29. সময়ে direct সবসময় জেতে, কারণ প্রতি byte-এ ১৪ T কম; কিন্তু তার program N-এর সঙ্গে বাড়ে। N = 2-এ দুটির মাপ কাছাকাছি (১৩ বনাম ১৭ byte), N = 3 থেকে direct বড় (১৯ byte), আর ২০০ byte কপি করতে direct-এর লাগে ১২০১ byte-এর program, যা অনেক ছোট ROM-এর বড় অংশ। ৩ MHz-এ (৬ MHz crystal, README) ১ T = ১/৩ µs, তাই ২০০ byte-এ direct ≈ 1.7 ms, indirect ≈ 2.7 ms. আরেকটি কথা টেবিলে নেই: direct-এর ঠিকানাগুলো program-এর ভেতরে বাঁধা, তাই অন্য buffer কপি করতে নতুন program লাগে; indirect-এ শুধু HL আর DE বদলালেই হয়।
একটি তৃতীয় পথও আছে, যা দেখায় যে ধীরগতির আসল কারণ addressing mode নয়, loop-এর পাহারা। Loop বাদ দিয়ে register indirect-এর চার লাইন (MOV A,M, STAX D, INX H, INX D) প্রতি byte-এর জন্য পরপর লিখলে প্রতি byte-এ খরচ 7 + 7 + 6 + 6 = ২৬ T, ঠিক direct-এর সমান, আর মাপ ৬-এর বদলে ৪ byte. চার byte-এর জন্য simulator-এর ফল (copy_u.asm, শেষ byte-এর পরে INX বাদ): Bytes: 21, Instructions: 17 T-states: 117, আর 2060H-এ একই E2 04 FC 1F. Direct-এর চেয়ে ৪ byte ছোট, মাত্র ৮ T বেশি (শুরুর দুটি LXI যোগ করে ২০ T, শেষের দুটি INX বাদ দিয়ে বাঁচে ১২ T), আর ঠিকানা বদলাতে শুধু দুটি LXI বদলালেই হয়। Loop-এর প্রতি পাকের বাড়তি ১৪ T আসে DCR C আর JNZ থেকে। এই কৌশলের নাম loop unrolling; compiler-ও গতির জন্য এটি করে।
এই পরীক্ষায় একটি বাস্তব ভুলও ধরা পড়ল। প্রথমবার N = 64-এর direct program 2000H থেকে আর data 2100H থেকে রাখা হয়েছিল। Program ৩৮৫ byte, অর্থাৎ 2000H থেকে 2180H পর্যন্ত, তাই data-র byte program-এর শেষ অংশের ওপর বসে গেল। Simulator কোনো সতর্কতা ছাড়াই চলল আর থামল এই বার্তায়: runtime error: stopped after 1000000 instructions (no HLT reached?) (Spec decision 11). Data সরিয়ে 2400H-এ রাখতেই সব ঠিক। 8085-এ code আর data একই memory-তে (von Neumann), আর direct ঠিকানা লেখা program বড় হলে কোন ঘর কার, সেই হিসাব আপনার। Memory map আর address decoding-এর পুরো কাজ পর্ব ২২-এ।
8085-এর encoding নতুন নয়। ১৯৭২ সালের 8008-এর নির্দেশ-ছাঁচ থেকে ১৯৭৪ সালের 8080, আর তার প্রায় পুরো opcode টেবিল ১৯৭৬ সালের 8085-এ এসেছে; 8085 নতুন যোগ করেছে মূলত RIM আর SIM, 8080-এর ফাঁকা দুটি opcode (20H, 30H)-এ। এজন্যই কোর্সের simulator-এর ফল একটি স্বাধীন 8080 emulator-এর সঙ্গে মিলিয়ে দেখা যায় (README, cross-check: ২৪,০০০টি একক instruction-এর পরীক্ষা, ০টি অমিল)। MOV-এর 01 DDD SSS ছাঁচে MOV M,M হওয়ার কথা ছিল 76H, যা অর্থহীন; সেই ঘরেই বসেছে HLT.
৮ · AI-এর যুগে addressing mode যাচাই
AI assistant 8085-এর program আর শ্রেণিবিভাগ দ্রুত লিখে দেয়, কিন্তু এই বিষয়ে তার ভুলগুলো খুব নির্দিষ্ট, আর প্রায় সবই কোর্সের simulator এক মুহূর্তে ধরে ফেলে:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
Z80 বা 8086-এর mode 8085-এ লেখা: JR, LD A,(IX+5), MOV AX,[BX] | Simulator-এ assemble; Intel 8085 manual-এর instruction তালিকা |
LDAX H বা STAX H লেখা, বা MOV A,2050H | Assembler-এর error: bad operand H for LDAX, bad MOV operands A,2050H |
| হাতে machine code দিতে গিয়ে ঠিকানার byte বড়টি আগে লেখা | sim8085.py dis বা trace; 3A 20 52 দেখাবে LDA 5220H |
ভুল T-state: INX ৪, LDAX ১৩, MOV A,M ৪ | Simulator-এর T= ঘর; Intel-এর টেবিল (৬, ৭, ৭) |
LXI-কে direct বা MVI M-কে শুধু immediate বলা | Instruction memory-র data ঘরে যায় কি না, নিজে জিজ্ঞেস করুন; trace-এ কোন ঘর বদলাল দেখুন |
| 8085-এ “relative jump” বা “indexed mode” আছে বলা | ২৪৬টি opcode-এর তালিকায় নেই; সব jump-এর লক্ষ্য পূর্ণ ১৬ বিটের ঠিকানা |
AI-কে কাজে লাগাতে আগে প্রসঙ্গ আর যাচাইয়ের পথ বলে দিন:
এই prompt-এর উত্তর মেলানো সহজ, কারণ program-টি এই পর্বের অনুশীলন ৩: সঠিক উত্তর A = E2, HL = 2052H, CY = 1, 2055H = 1B, মোট ৬৫ T-state, যা কোর্সের simulator-এ চালিয়ে পাওয়া। AI-এর টেবিল এই সংখ্যাগুলোর সঙ্গে না মিললে কোন লাইনে প্রথম অমিল, তা trace-এর সঙ্গে মিলিয়ে খুঁজুন; সাধারণত ভুলটি একটি T-state বা একটি byte-ক্রমে। AI-কে সবচেয়ে ভালো কাজে লাগানো যায় ব্যাখ্যা চাইতে (“কেন LXI immediate?”) আর অনুশীলনের নতুন প্রশ্ন বানাতে; উত্তরের সংখ্যা সবসময় simulator থেকে নিন।
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১8085 memory-কে “M” নামের একটি register হিসেবে encode করে (কোড 110). এই নকশার সুবিধা কী, আর এর দাম কোথায় দিতে হয়?
সুবিধাটি সরলতা আর জায়গার সাশ্রয়। ৮টি তিন বিটের কোডের একটি memory-কে দিলে MOV, ADD, SUB, CMP, INR, DCR এবং অন্য ALU instruction আলাদা “memory সংস্করণ” ছাড়াই memory-র সঙ্গে কাজ করতে পারে। ADD B = 80H, ADD M = 86H: শুধু শেষ তিন বিট আলাদা। Decoder-এর যুক্তিও সহজ থাকে, কারণ একই বিট-ছাঁচ সব জায়গায় খাটে। ১৯৭০-এর দশকের শুরুতে একটি chip-এ মাত্র কয়েক হাজার transistor বসত, তাই decode-এর সরলতা ছিল বাস্তব প্রয়োজন। এই ছাঁচ এসেছে ১৯৭২ সালের 8008 থেকে, আর 8080 (১৯৭৪) ও 8085 (১৯৭৬) তা প্রায় অপরিবর্তিত রেখেছে।
দাম তিন জায়গায়। প্রথমত, pointer একটিই: শুধু HL. দুটি array নিয়ে একসঙ্গে কাজ করতে হলে (যেমন উৎস আর গন্তব্য) দ্বিতীয়টির জন্য DE আর LDAX/STAX লাগে, যা শুধু A-র সঙ্গে চলে, অথবা বারবার XCHG করে HL আর DE বদলাতে হয়। এই পর্বের copy loop-এ তাই HL উৎস আর DE গন্তব্য। দ্বিতীয়ত, M-এর প্রতিটি ব্যবহার আসলে একটি অতিরিক্ত memory cycle: MOV A,B ৪ T, MOV A,M ৭ T; register-এর মতো দেখালেও M register-এর মতো দ্রুত নয়। তৃতীয়ত, ছাঁচের একটি ঘর অর্থহীন হয়ে যায়: MOV M,M (76H) কোনো কাজের নয়, তাই Intel সেখানে HLT বসিয়েছে। পরীক্ষায় “76H কেন HLT” প্রশ্নের উত্তর এই ছাঁচেই।
পরের নকশাগুলো দুই দিকে গেছে। Z80 HL-কে রেখে IX আর IY যোগ করেছে, যাতে আরও pointer আর offset পাওয়া যায়। 8086 register-এর বদলে একটি আলাদা ModR/M byte আনে, যেখানে memory-র ঠিকানা কয়েক রকম register আর displacement মিলিয়ে বলা যায়। আর RISC নকশা (ARM, RISC-V) উল্টো পথে: ALU কখনো memory ছোঁয় না, শুধু load আর store. তারা M-এর সুবিধা ছেড়ে দিয়েছে, কিন্তু পেয়েছে অনেক register আর সহজ pipeline.
মূল উপলব্ধি: Memory-কে register-এর মতো encode করা কম transistor-এ বেশি কাজের একটি চতুর সমাধান; তার দাম একটিমাত্র pointer আর প্রতিটি ব্যবহারে একটি বাড়তি memory cycle.
প্র ০২8085 instruction-এর ভেতরে ১৬ বিটের ঠিকানা কেন ছোট byte আগে রাখে? Big-endian হলে কি কোনো সমস্যা হতো?
প্রথমে মনে রাখুন, 8085-এর data bus ৮ বিটের, তাই JMP 2034H-এর দুটি ঠিকানা-byte দুটি আলাদা memory read-এ আসে, আগে 2001H, পরে 2002H. কোন byte আগে রাখা হবে, তা নকশাকারীর সিদ্ধান্ত। 8080 আর 8085 ছোট byte আগে রাখে, আর এই নিয়ম instruction-এর ভেতরে, LHLD/SHLD-এর data-তে, stack-এ (PUSH) আর assembler-এর DW-তে এক। এই ধারাবাহিকতাই সবচেয়ে বড় সুবিধা: একটি ১৬ বিটের মান যেখানেই থাকুক, পড়ার নিয়ম একটাই।
ছোট byte আগে রাখার একটি প্রচলিত যুক্তি হলো গণিত। ৮ বিটের CPU বহু-byte যোগ করে নিচু byte থেকে, কারণ carry নিচ থেকে ওপরে যায়; data ছোট ঠিকানা থেকে বড় ঠিকানার দিকে পড়লে byte-গুলো সেই ক্রমেই আসে। আরেকটি যুক্তি ঐতিহাসিক সামঞ্জস্য: 8008 আর 8080-এর ধারায় চলা software আর tool ভাঙতে কেউ চায়নি। তবে এটা মনে রাখা দরকার যে এই ক্রম কোনো প্রাকৃতিক নিয়ম নয়। একই যুগের Motorola 6800 উল্টো পথে গিয়েছিল: ১৬ বিটের ঠিকানা বড় byte আগে। দুটোই ঠিকঠাক কাজ করেছে।
Big-endian হলে CPU-র দিক থেকে বড় কোনো সমস্যা হতো না; ভেতরের W আর Z register-এ কোন byte কোথায় যাবে, শুধু সেই তার বদলাত। সমস্যা হয় মানুষের দিক থেকে: hex dump-এ C3 34 20 দেখে 2034H পড়তে চোখের অভ্যাস লাগে, আর হাতে assemble করার সময় উল্টো লেখার ভুল (এই পর্বের 3A 20 52, যা LDA 5220H) খুব সাধারণ। ১৯৭০-এর দশকে অনেক program trainer kit-এ hex টিপে ঢোকানো হতো, তাই এই ভুলটি তখন প্রতিদিনের ছিল। আজও firmware-এর hex file বা memory dump পড়ার সময় একই সতর্কতা লাগে।
মূল উপলব্ধি: Byte-ক্রম একটি চুক্তি; 8085-এর শক্তি হলো চুক্তিটি সব জায়গায় এক, আর দুর্বলতা হলো মানুষের চোখে তা উল্টো দেখায়, তাই disassembler দিয়ে যাচাইয়ের অভ্যাস দরকার।
প্র ০৩8085-এ indexed আর PC-relative mode নেই। এই অভাব program-কে কীভাবে প্রভাবিত করে, আর তখনকার programmer-রা কী করতেন?
Indexed mode থাকলে “array-র শুরু + i” ঠিকানা এক instruction-এ বলা যায়, যেমন Z80-এর LD A,(IX+5) বা 8086-এর MOV AL,[BX+SI]. 8085-এ এটি নেই, তাই দুটি পথ। এক, ক্রমানুসারে পড়লে pointer-কে প্রতি পাকে INX H দিয়ে এগোনো, যা এই পর্বের copy loop করে। দুই, যেকোনো i-এর ঘরে যেতে হলে হিসাব করা: LXI H,base, LXI D,i, DAD D, তারপর MOV A,M. চারটি instruction আর প্রায় ৩৭ T-state, যেখানে indexed mode-এ একটি instruction লাগত। Struct-এর মতো data, যেখানে একই base থেকে আলাদা offset-এ field, সেখানে খরচ আরও বাড়ে।
PC-relative না থাকার প্রভাব অন্য রকম। 8085-এর সব JMP আর CALL-এর লক্ষ্য পূর্ণ ১৬ বিটের ঠিকানা, যা program-এর byte-এ বাঁধা। তাই একটি program 2000H-এ চলার জন্য assemble করা হলে 3000H-এ কপি করে চালালে তার jump-গুলো পুরোনো ঠিকানায় যাবে আর program ভেঙে পড়বে। Position-independent code লেখা প্রায় অসম্ভব। সমাধান ছিল relocation: loader program বসানোর সময় প্রতিটি ঠিকানার byte ঠিক করে দিত, যার জন্য assembler আলাদা তালিকা রাখত কোন byte ঠিকানা। CP/M-এর মতো সেই যুগের অপারেটিং সিস্টেম program-কে একটি নির্দিষ্ট ঠিকানায় (সাধারণত 0100H) বসাত, যাতে এই ঝামেলা কম হয়।
আরেকটি খরচ কোডের মাপে। একটি ছোট loop-এর শেষে JNZ LOOP সবসময় ৩ byte; Z80-এর JR NZ ২ byte, কারণ সে শুধু −128 থেকে +127-এর দূরত্ব রাখে। হাজার হাজার শর্তযুক্ত লাফের program-এ এই এক byte মিলে বড় সঞ্চয়। আধুনিক নকশায় PC-relative প্রায় বাধ্যতামূলক: ARM Thumb-এর শাখা আর RISC-V-এর auipc দুটোই PC-relative, আর shared library ও firmware-এর নিরাপদ update অনেকটা এর ওপর নির্ভর করে।
মূল উপলব্ধি: যে mode ISA-তে নেই, তার কাজ কয়েকটি instruction মিলিয়ে করা যায়, কিন্তু প্রতিবার সময়, byte আর নমনীয়তায় দাম দিতে হয়; পরের প্রজন্মের CPU-র নতুন mode-গুলো ঠিক এই দামগুলো কমাতে এসেছে।
প্র ০৪8085-এর instruction ১ থেকে ৩ byte, RISC-V-এর মূল instruction সবসময় ৪ byte, আর ARM Cortex-M-এর Thumb-2 ২ বা ৪ byte. কোন নকশা কখন ভালো?
Variable-length encoding-এর বড় লাভ code density: সবচেয়ে বেশি ব্যবহৃত কাজ (MOV, ADD r, INX) মাত্র এক byte. 8085-এর যুগে memory ছিল ছোট আর দামি; একটি trainer kit বা যন্ত্রে কয়েক কিলোবাইট ROM থাকা স্বাভাবিক ছিল। এক byte বাঁচানো মানে একটি নতুন feature-এর জায়গা। এই পর্বের হিসাবে ২০২টি opcode এক byte-এর, যা দেখায় নকশাকারীরা সাধারণ কাজকে কতটা ছোট রাখতে চেয়েছিলেন। ৮ বিটের bus-এ আরেকটি লাভ: ছোট instruction কম memory read নেয়, তাই দ্রুতও।
অসুবিধা আসে decode-এ। কোথায় পরের instruction শুরু, তা জানতে আগেরটির opcode decode করতে হয়। 8085-এর মতো একবারে একটি instruction চালানো CPU-র জন্য এটি সমস্যা নয়। কিন্তু একসঙ্গে কয়েকটি instruction fetch আর decode করা আধুনিক CPU-র জন্য কঠিন: x86-এর ১ থেকে ১৫ byte-এর instruction decode করতে জটিল hardware লাগে। Fixed-length নকশা (RISC-V-এর ৪ byte) এখানে সরল: প্রতিটি instruction ঠিক ৪ byte পরে, decoder ছোট আর সমান্তরাল। দাম কম code density.
ARM এই টানাপোড়েনের মাঝামাঝি সমাধান খুঁজেছে। প্রথমে সব instruction ৪ byte (ARM state), পরে Thumb-এ ২ byte-এর ছোট রূপ, আর Thumb-2-তে ২ আর ৪ byte মিলিয়ে, যেখানে প্রথম halfword দেখেই মাপ বোঝা যায়। Cortex-M শুধু Thumb চালায়, কারণ microcontroller-এর flash ছোট আর code density সেখানে খুব গুরুত্বপূর্ণ। RISC-V-ও ঐচ্ছিক “C” extension দিয়ে ২ byte-এর compressed instruction যোগ করেছে, একই কারণে। অর্থাৎ বাস্তবে প্রায় সব এমবেডেড ISA শেষ পর্যন্ত কিছুটা variable-length হয়েছে, তবে 8085 বা x86-এর চেয়ে অনেক সুশৃঙ্খলভাবে: মাপ জানা যায় প্রথম কয়েকটি বিট থেকেই।
মূল উপলব্ধি: ছোট memory-র যন্ত্রে variable-length জেতে code density-তে, উচ্চ গতির CPU-তে fixed-length জেতে decode-এর সরলতায়; আধুনিক microcontroller দুইয়ের মাঝামাঝি, মাপ সহজে চেনা যায় এমন ২ আর ৪ byte বেছে নিয়েছে।
প্র ০৫8085-এ code আর data একই memory-তে, আর direct instruction-এর ঠিকানা program-এর byte-এ লেখা। এর ফলে program নিজেকেই বদলাতে পারে। এটি কি সুবিধা, নাকি বিপদ?
দুটোই। LDA 2050H-এর ঠিকানার byte দুটি memory-র সাধারণ ঘর, তাই অন্য একটি instruction (SHLD) সেখানে নতুন ঠিকানা লিখে দিলে পরের বার LDA অন্য ঘর পড়বে। একে বলে self-modifying code. Index register বা register indirect ছাড়া পুরোনো CPU-তে, যেমন প্রথম যুগের কিছু কম্পিউটারে, array পড়ার এটাই ছিল প্রধান কৌশল। 8085-এ register indirect থাকায় এর দরকার খুব কম, তবু কিছু পুরোনো program গতি বা byte বাঁচাতে এটি ব্যবহার করত।
বিপদ কয়েকটি। প্রথমত, program পড়ে আর বোঝা যায় না: listing-এ যা লেখা, চলার সময় তা সত্য নাও থাকতে পারে, আর debugging দুঃস্বপ্ন হয়। দ্বিতীয়ত, program ROM বা flash-এ থাকলে নিজের byte বদলাতেই পারে না, তাই এমবেডেড firmware-এ এই কৌশল অচল; আধুনিক microcontroller program চালায় flash থেকে। তৃতীয়ত, cache আর pipeline-যুক্ত আধুনিক CPU-তে instruction আর data-র পথ আলাদা, তাই নিজের code বদলালে বিশেষ নির্দেশ দিয়ে cache পরিষ্কার না করলে পুরোনো instruction-ই চলতে পারে। চতুর্থত, নিরাপত্তা: লেখা যায় এমন memory থেকে code চালানো আক্রমণের দরজা খোলে, তাই আধুনিক সিস্টেম memory-কে “লেখা যায়” আর “চালানো যায়” এই দুই ভাগে আলাদা রাখে।
একই memory-র অন্য বিপদটি এই পর্বেই সত্যিকারের run-এ দেখা গেল: ৩৮৫ byte-এর direct copy program-এর শেষ অংশে data বসে গেল, আর program কোনো error ছাড়াই ভুল পথে চলে ১০ লাখ instruction-এর সীমায় থামল। কেউ ইচ্ছা করে code বদলায়নি, শুধু memory-র হিসাব ভুল ছিল। 8085-এ code আর data আলাদা করার কোনো hardware পাহারা নেই; সেই দায়িত্ব memory map আর programmer-এর। Cortex-M-এ MPU আর flash-এর লেখা-নিষেধ এই ধরনের ভুলকে fault-এ পরিণত করে, যা চুপচাপ ভুল চলার চেয়ে অনেক ভালো (পর্ব ৬১, Watchdog আর fault handling).
মূল উপলব্ধি: Code আর data এক memory-তে থাকা নমনীয়তা দেয়, কিন্তু সেই নমনীয়তার পাহারা না থাকলে ভুল নীরবে ঘটে; আধুনিক firmware-এর নিয়ম হলো code কখনো বদলাবে না, আর memory map লিখে রাখা ও যাচাই করা।
অনুশীলন
প্রথমে নিজে হিসাব করুন বা লিখুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর কোর্সের simulator-এ চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — দুটি ১৬ বিটের মান অদলবদল: 2050H-এ একটি ১৬ বিটের মান (net ওজন
04E2H) আর 2052H-এ আরেকটি (দাম1FFCH), দুটিই little-endian. A register ব্যবহার না করে দুটির জায়গা বদলের একটি program লিখুন। প্রতিটি instruction-এর addressing mode, মোট byte আর মোট T-state বলুন।ORG 2000H START: LHLD 2050H ; direct: HL = 04E2H 3 byte, 16 T XCHG ; register/implicit: DE = 04E2H 1 byte, 4 T LHLD 2052H ; direct: HL = 1FFCH 3 byte, 16 T SHLD 2050H ; direct: 2050H = FC 1F 3 byte, 16 T XCHG ; HL = 04E2H 1 byte, 4 T SHLD 2052H ; direct: 2052H = E2 04 3 byte, 16 T HLT ; 1 byte, 5 Tমোট ১৫ byte আর ৭৭ T-state (৩ MHz-এ প্রায় 25.7 µs). কোর্সের simulator-এর ফল:
2050H: FC 1F E2 04,Instructions: 7 T-states: 77. A আর flag অপরিবর্তিত, কারণLHLD,SHLD,XCHGকোনো flag ছোঁয় না। A দিয়ে করলে চারটিLDA/STAজোড়া আর একটি অস্থায়ী register লাগত; ১৬ বিটের direct instruction কাজটিকে ছোট করে। -
ভুল খুঁজুন — একজন শিক্ষার্থীর program: উদ্দেশ্য: 2052H-এর byte A-তে আনা। চারটি চেষ্টা: (ক)
LDAX H(HL = 2052H ধরে); (খ)MOV A,2052H; (গ) trainer kit-এ হাতে ঢোকানো byte3A 20 52; (ঘ)LXI H,2052HতারপরMOV A,H. প্রতিটির ভুল কী, আর কোর্সের simulator কী বলে?(ক)
LDAXশুধু BC আর DE নেয়; assembler:assembly error: line 2: bad operand H for LDAX. ঠিক রূপMOV A,M. (খ)MOVশুধু register আর M-এর মধ্যে; ঠিকানা নিতে পারে না:bad MOV operands A,2052H. ঠিক রূপLDA 2052H. (গ) Byte-ক্রম উল্টো: CPU প্রথম ঠিকানা-byte-কে নিচু ধরে, তাই trace দেখায়2000 3A 20 52 LDA 5220H; কোনো error ছাড়া ভুল ঘর পড়ে (পরীক্ষায় 5220H-এ 99H রাখা ছিল, A = 99). ঠিক byte3A 52 20. (ঘ) সবচেয়ে চতুর ভুল, কারণ assemble হয় আর চলে:MOV A,Hregister addressing, তাই A =20, ঠিকানার উঁচু byte, memory-র data নয়। Trace:MOV A,H A=20. ঠিক রূপMOV A,M, যা দেয় A =FC. -
আগে বলুন, তারপর চালান — trace আর সময়: 2050H থেকে memory-তে
E2 04 FC 1F. Program:LXI H,2053H,MOV A,M,DCX H,ADD M,STA 2055H,LXI B,2050H,LDAX B,HLT. প্রতিটি instruction-এর mode বলুন, তারপর শেষে A, HL, CY, 2055H-এর মান, মোট byte, মোট T-state আর ৩ MHz-এ সময় বের করুন।Mode: immediate, register indirect, register, register indirect, direct, immediate, register indirect, implicit. ধাপ: HL = 2053H; A = [2053H] =
1F; HL = 2052H; A = 1F + [2052H] = 1F + FC = 11BH, তাই A =1B, CY = 1 (AC = 1, P = 1); 2055H ←1B; BC = 2050H; A = [2050H] =E2. শেষে A =E2, HL = 2052H, CY = 1 (LDAXflag বদলায় না), 2055H =1B. Byte: 3 + 1 + 1 + 1 + 3 + 3 + 1 + 1 = ১৪. T: 10 + 7 + 6 + 7 + 13 + 10 + 7 + 5 = ৬৫; ৩ MHz-এ 65 × 1/3 µs ≈ 21.67 µs. Simulator:Flags: S=0 Z=0 AC=1 P=1 CY=1 (F=15H),2050H: E2 04 FC 1F 00 1B,Instructions: 8 T-states: 65. -
হিসাব — হাতে encode আর decode: (ক)
MOV E,M,MVI M,05H,STA 2050HআরLXI SP,20FFH-এর machine code লিখুন। (খ) উল্টো দিকে: byte-ধারা7E 23 46 C3 00 20কোন instruction-গুলো? (গ) আরেকটি ধারা3A 52 20 47 1A 2F: কয়টি instruction, আর প্রতিটির mode কী?(ক)
MOV E,M= 01 011 110 =5EH.MVI M,05H= 00 110 110 =36H, তারপর05:36 05.STA 2050H=32 50 20.LXI SP,20FFH: SP-এর pair কোড 11, তাই 00 110 001 =31H, তারপর নিচু byte আগে:31 FF 20. (খ)7E= 01 111 110 =MOV A,M;23=INX H;46= 01 000 110 =MOV B,M;C3 00 20=JMP 2000H. অর্থাৎ HL-এর ঘর থেকে A, পরের ঘর থেকে B, তারপর শুরুতে ফিরে যাওয়া। (গ) চারটি:3A 52 20=LDA 2052H(direct),47=MOV B,A(register),1A=LDAX D(register indirect),2F=CMA(implicit); ছয় byte-এ চার mode. দুই দিকের সব byte কোর্সের simulator-এরasmlisting দিয়ে মেলানো, যেমনMVI M,05H-এর listing2001 36 05আরJMP 2000H-এর2003 C3 00 20.
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রম8085 যখন 2000H থেকে LDA 2052H (byte 3A 52 20) চালায়, ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- PC = 2000H থেকে opcode
3Afetch আর decode: ৩ byte-এর instruction - 2001H থেকে ঠিকানার নিচু byte
52পড়া - 2002H থেকে ঠিকানার উঁচু byte
20পড়া - Address bus-এ 2052H বসিয়ে memory থেকে data পড়া
- Data A-তে রাখা; PC = 2003H, মোট ১৩ T-state
8085-এর MOV A,M instruction-এর addressing mode কোনটি?
- Direct
- Register indirect
- Register
- Implicit
8085-এর STA 2050H instruction memory-তে কোন byte-ধারা হিসেবে বসে?
- 32 20 50
- 3A 50 20
- 32 50 20
- 32 50
নিচের কোনটি একটি বৈধ Intel 8085 instruction?
- LDAX H
- JR NZ,LOOP
- MOV A,2050H
- MVI M,05H
8085-এ LDA 2052H আর LDAX D (DE = 2052H) দুটিই A-তে একই byte আনে। এদের byte সংখ্যা আর T-state কত?
- LDA ৩ byte ১৩ T; LDAX ১ byte ৭ T
- দুটিই ৩ byte, ১৩ T
- LDA ৩ byte ১০ T; LDAX ১ byte ৪ T
- LDA ৩ byte ১৩ T; LDAX ১ byte ৪ T
8085-এর LXI H,2050H instruction সম্পর্কে কোন কথাটি ঠিক?
- এটি direct addressing, কারণ 2050H একটি ঠিকানা
- Machine code 21 20 50, আর H-এ প্রথমে 20 আসে
- এটি immediate addressing; ৩ byte, ১০ T-state, আর L = 50H, H = 20H
- এটি ১৩ T-state নেয়, কারণ 2050H থেকে data পড়ে
8085-এর MOV instruction-এর opcode-ছাঁচ 01 DDD SSS, যেখানে A = 111, B = 000, M = 110. তাহলে MOV A,M-এর opcode কত?
- 77H
- 7EH
- 76H
- 47H
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- পাঁচটি mode: immediate (
MVI,LXI), register (MOV B,A), direct (LDA,STA,LHLD,IN), register indirect (MOV A,M,LDAX D), implicit (CMA,RLC). - তিন মাপ: ১ byte (২০২টি opcode), ২ byte (১৮টি: ৮ বিটের data বা port), ৩ byte (২৬টি: ১৬ বিটের data বা ঠিকানা); প্রথম byte সবসময় opcode.
- ছোট byte আগে:
JMP 2034H=C3 34 20,LXI H,2050H=21 50 20; উল্টো লিখলে অন্য ঘর পড়া হয়, কোনো error ছাড়াই। - খরচ: register ৪ T, immediate ৭ বা ১০ T, register indirect ৭ T, direct ১৩ বা ১৬ T; প্রতিটি বাড়তি memory cycle ৩ T.
- বেছে নেওয়া: একটি ঘর একবার: direct; অনেক ঘর বা loop: register indirect. 8085-এ indexed, PC-relative আর memory indirect নেই; সেগুলো কয়েকটি instruction মিলিয়ে করতে হয়।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ১১ · 8085 assembly program — loop, array, BCD আর গুণ-ভাগপরবর্তী পর্বPointer আর loop দিয়ে পূর্ণ program, trace আর মোট T-state সহ।
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ০৯ · 8085-এর instruction setআগের পর্বপ্রতিটি instruction-এর কাজ, flag আর পাঁচটি দল; এই পর্বের mode-গুলো সেই instruction-এরই।
- পর্ব ০৫ · এমবেডেড কাজের সংখ্যাভিত্তিHex, little-endian আর flag, যা এই পর্বের byte পড়ার ভিত্তি।
- Computer Architecture পর্ব ২৮ · Addressing modeপাশের ট্র্যাকImmediate, register, base+offset আর PC-relative-এর তত্ত্ব, RISC-V দিয়ে।
- Computer Architecture পর্ব ২৭ · Instruction format আর encodingপাশের ট্র্যাকFixed-length encoding-এর বিট-field, 8085-এর সঙ্গে তুলনার জন্য।
- C প্রোগ্রামিং পর্ব ১৭ · পয়েন্টারপাশের ট্র্যাকRegister indirect-এর C রূপ: মান নয়, মানের ঠিকানা নিয়ে কাজ।