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

8085-এর গঠন — register, ALU, flag আর bus

8085 Architecture — Registers, ALU, Flags and Buses

Taught in Bangla, this lesson opens the 8085: 8-bit data, 16-bit addresses and 64 KB of memory. It draws the block diagram, separates programmer-visible registers from hidden ones such as temp, IR, W and Z, follows an ADD through the ALU and accumulator, and works out all five flags by hand. The course's 8085 simulator confirms the flag byte 55H after 96H + 6AH using PUSH PSW and POP B. It also covers the multiplexed AD0–AD7 bus, timing and control, interrupts and serial I/O.

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

  • 8085-এর block diagram নিজে আঁকা আর প্রতিটি block-এর কাজ এক লাইনে বলা
  • কোন register programmer দেখতে পান (A, B–L, SP, PC) আর কোনগুলো লুকানো (temp, IR, W, Z), আর register pair দিয়ে ১৬ বিটের মান রাখা
  • একটি ADD নির্দেশে data কোন block থেকে কোন block-এ যায়, তা ধাপে ধাপে বলা
  • যেকোনো ৮ বিট যোগের পরে পাঁচটি flag আর পুরো flag byte হাতে বের করা, আর simulator-এ মিলিয়ে দেখা
  • ৮ বিট data, ১৬ বিট ঠিকানা, 64 KB আর multiplexed AD0–AD7-এর হিসাব, যা পরীক্ষা আর ইন্টারভিউতে বারবার আসে

১ · 8085 এক নজরে — ৮ বিটের হিসাব, ১৬ বিটের ঠিকানা

মডিউল ১-এ আপনি দেখেছেন একটি microprocessor কী, আর কেন 8085 দিয়ে শুরু করা হয় (পর্ব ০৩, পর্ব ০২). এবার chip-টির ভেতরে ঢোকার পালা। Intel 8085 বাজারে আসে ১৯৭৬ সালে (কিছু তালিকায় ১৯৭৭)। এটি ৮ বিটের CPU: একবারে ৮ বিটের হিসাব করে, আর মেমরি থেকে একবারে ৮ বিট, অর্থাৎ এক byte আনে। কিন্তু ঠিকানা দেয় ১৬ বিটে। এই দুটি সংখ্যা, ৮ আর ১৬, পুরো পর্বের চাবি।

উপমা — বাজারঘরের গুদাম আর ক্যাশিয়ার: বাজারঘরের পেছনে একটি গুদাম, যার প্রতিটি তাকে একটি নম্বর। ক্যাশিয়ারের সামনে কয়েকটি ছোট ট্রে (register), আর একটি ক্যালকুলেটর (ALU). ক্যাশিয়ার একবারে একটি ট্রেতে মাত্র এক মুঠো (৮ বিট) জিনিস রাখতে পারেন, কিন্তু তাকের নম্বর লিখতে পারেন চার অঙ্কে, 0000 থেকে FFFF পর্যন্ত। তাই গুদাম বড় (৬৫,৫৩৬টি তাক), অথচ প্রতিবার আনা-নেওয়া এক মুঠো করে। একজন সহকারী (timing ও control unit) ঘণ্টা বাজিয়ে বলেন কখন নম্বর পাঠাতে হবে আর কখন জিনিস নিতে হবে।

হিসাবটি সোজা। ১৬টি ঠিকানার তারে প্রতিটি 0 বা 1, তাই ঠিকানা হয় 216 = 65536টি। প্রতিটি ঠিকানায় এক byte, তাই মোট 65536 byte = 64 × 1024 byte = 64 KB (কঠোরভাবে 64 KiB). এই পরিসরকে বলে address space. অন্যদিকে প্রতিটি register আর মেমরির ঘর ৮ বিটের, তাই unsigned অর্থে সবচেয়ে বড় মান 255. বাজারঘরের smart scale-এর ওজন যদি গ্রামে রাখতে হয়, ২৫৫ g-এর বেশি এক register-এ আঁটে না; সেজন্য 8085 দুটি register জোড়া বেঁধে ১৬ বিট বানাতে পারে, যা অংশ ৩-এ দেখবেন।

পূর্বজ্ঞান এক লাইনে: binary, hex আর flag-এর মৌলিক ধারণা পর্ব ০৫-এ, আর digital logic আর ALU-র তত্ত্ব Computer Architecture পর্ব ১৩-এ। লেখার নিয়ম: এই মডিউলে hex লেখা হবে Intel-এর ধরনে, শেষে H দিয়ে, যেমন 2050H, 0FFH; program শুরু হবে 2000H-এ আর data থাকবে 2050H-এর কাছে। প্রতিটি register, flag আর T-state-এর মান এসেছে কোর্সের reference simulator sim8085.py-এর সত্যিকারের run থেকে (পর্ব ০১-এ এর প্রথম পরিচয়, আর simulator কী করে, কী করে না, তা পর্ব ০৬-এ)।

বৈশিষ্ট্য8085-একেন জরুরি
Data bus আর ALU৮ বিটএকবারে এক byte; বড় সংখ্যা কয়েক ধাপে
Address bus১৬ বিট (A15–A0)64 KB মেমরি; I/O-র জন্য আলাদা ৮ বিটের port নম্বর (২৫৬টি port)
Pin৪০টিজায়গা বাঁচাতে AD0–AD7 ঠিকানা আর data ভাগ করে
Supplyএকটিমাত্র +5 V8080-এর তিনটি supply-এর জায়গায় একটি; নামের “5” এর প্রচলিত ব্যাখ্যা
Clockcrystal-এর অর্ধেক; কোর্সে 6 MHz crystal → 3 MHzএক T-state = 1 ÷ 3 MHz = 0.333 µs
Flagপাঁচটি: S, Z, AC, P, CYশর্তযুক্ত লাফ আর BCD হিসাবের ভিত্তি

২ · Block diagram — chip-এর ভেতরের ভাগগুলো

Intel-এর 8085 user's manual-এ chip-টির ভেতরের একটি block diagram আছে, আর পরীক্ষায় প্রায়ই সেটি এঁকে ব্যাখ্যা করতে বলা হয়। নিচের ছবিটি সেই ধারায় সরল করে আঁকা। মাঝখানের মোটা দাগটি অভ্যন্তরীণ data bus: ৮ বিট চওড়া একটি পথ, যা দিয়ে chip-এর ভেতরের সব block একে অপরের সঙ্গে byte আদান-প্রদান করে।

ছবি ৭.১ — 8085-এর block diagram

নীল = programmer দেখতে পান এমন register; ধূসর = লুকানো register; হলুদ = হিসাবের অংশ; বেগুনি = নিয়ন্ত্রণ; সবুজ = বাইরের bus-এর buffer

8085-এর block diagram Interrupt control INTR · INTA̅ · RST · TRAP Serial I/O control SID · SOD অভ্যন্তরীণ ৮ বিট data bus A Temp ALU Flag (F) Instructionregister (IR) Instructiondecoder ওmachine cycleencoding Timing ও control X1 X2 · CLK OUT · READY ALE · RD̅ · WR̅ · IO/M̅ S0 S1 · HOLD HLDA · RESET WZ BC DE HL SP (১৬ বিট) PC (১৬ বিট) Inc/Dec latch Address buffer Address/databuffer control সংকেত A15–A8ঠিকানা (উঁচু) AD7–AD0ঠিকানা + data
ছবি ৭.১ — Intel-এর 8085 manual-এর block diagram-এর সরল রূপ। ALU-র ফল অভ্যন্তরীণ bus দিয়ে A-তে ফেরে; register array-র ১৬ বিটের ঠিকানা দুই ভাগে বেরোয়: উঁচু byte address buffer দিয়ে A15–A8-এ, নিচু byte address/data buffer দিয়ে AD7–AD0-এ। W আর Z নির্দেশ চলার সময় CPU-র নিজের ব্যবহারের ঘর, কোনো নির্দেশ দিয়ে সরাসরি পড়া যায় না।

প্রতিটি block-এর কাজ এক লাইনে, পরীক্ষার খাতায় যেভাবে লিখবেন:

Blockকাজ
Accumulator (A)৮ বিট; প্রায় সব হিসাবের একটি operand আর ফলের জায়গা
Temp registerALU-র দ্বিতীয় operand ক্ষণিকের জন্য রাখে; programmer দেখতে পান না
ALU৮ বিটের যোগ, বিয়োগ, AND, OR, XOR, তুলনা, rotate, increment, decrement
Flag registerপাঁচটি flip-flop: শেষ হিসাবের ফলের চিহ্ন (S, Z, AC, P, CY)
Register arrayB, C, D, E, H, L (৮ বিট করে), SP আর PC (১৬ বিট), লুকানো W, Z, আর ঠিকানা বাড়ানো-কমানোর circuit
Instruction register (IR)মেমরি থেকে আনা opcode ধরে রাখে
Instruction decoder ও machine cycle encodingopcode বুঝে ঠিক করে কয়টি machine cycle লাগবে আর কোনটি কী ধরনের
Timing ও control unitclock থেকে T-state বানায়; ALE, RD̅, WR̅, IO/M̅, S0, S1-এর মতো সংকেত দেয়; READY, HOLD, RESET শোনে
Interrupt controlTRAP, RST 7.5, 6.5, 5.5 আর INTR-এর অনুরোধ নেয়, অগ্রাধিকার ঠিক করে (পর্ব ১৩)
Serial I/O controlSID pin থেকে এক বিট পড়া আর SOD pin-এ এক বিট লেখা, RIM আর SIM দিয়ে
Address buffer, address/data bufferভেতরের মান বাইরের pin-এ চালায়, বা pin থেকে ভেতরে আনে; দরকার হলে pin ভাসিয়ে রাখে

Buffer-গুলো tri-state: তিনটি অবস্থা, 0, 1, আর “বিচ্ছিন্ন” (high impedance). বিচ্ছিন্ন অবস্থা জরুরি, কারণ একই bus-এ মেমরি, I/O আর DMA controller-ও কথা বলে; একজন বলার সময় বাকিদের চুপ থাকতে হয়। HOLD সংকেত এলে 8085 নিজের bus buffer বিচ্ছিন্ন করে দেয় আর HLDA দিয়ে জানায়; DMA-র এই খেলা পর্ব ২৭-এ (8251 USART আর 8237 DMA controller). Control unit-এর নকশার তত্ত্ব, hardwired আর microprogrammed, পড়তে চাইলে Computer Architecture পর্ব ৩৩.

৩ · Register — যা দেখেন, আর যা দেখেন না

Register হলো CPU-র ভেতরের সবচেয়ে দ্রুত ঘর। মেমরি থেকে একটি byte আনতে 8085-এর অন্তত একটি machine cycle (৩টি T-state) লাগে, কিন্তু register থেকে register-এ নেওয়া (MOV B,A) শেষ হয় opcode fetch-এর ৪টি T-state-এই। তাই ভালো program যতটা পারে register-এ কাজ করে। 8085-এর programmer যে register-গুলো নির্দেশ দিয়ে ছুঁতে পারেন, তার পুরো তালিকা:

Registerমাপকাজজোড়া
A৮ বিটaccumulator: হিসাবের operand আর ফল; I/O-র IN/OUT শুধু A দিয়েA + F = PSW
B, C৮ বিট করেসাধারণ কাজ; প্রায়ই counterBC
D, E৮ বিট করেসাধারণ কাজ; দ্বিতীয় pointerDE
H, L৮ বিট করেসাধারণ কাজ; বিশেষত মেমরির pointer, M মানে [HL]HL
SP১৬ বিটstack pointer: stack-এর শীর্ষের ঠিকানা—
PC১৬ বিটprogram counter: পরের byte-এর ঠিকানা—
F৮ বিট (৫টি ব্যবহৃত)flag; সরাসরি MOV করা যায় নাPSW-এর নিচু byte

ছয়টি সাধারণ register তিনটি register pair হিসেবেও কাজ করে: BC, DE, HL. জোড়ায় প্রথম নামটি উঁচু byte, দ্বিতীয়টি নিচু byte; তাই H = 20H আর L = 50H মানে HL = 2050H. LXI H,2050H এক নির্দেশে দুটিই ভরে, INX H পুরো ১৬ বিট এক বাড়ায়, আর MOV M,A A-র মান লেখে HL যে ঠিকানা দেখায় সেখানে। A আর F মিলে আরেকটি ১৬ বিটের একক, PSW (Program Status Word), যা শুধু PUSH PSW আর POP PSW-এ ব্যবহার হয়। নিচের ব্লকে জোড়া বাঁধার হিসাব নিজে চালিয়ে দেখুন।

# 8085-এর register মডেল: ৮ বিটের ঘর, জোড়া বাঁধলে ১৬ বিট
r = {"A": 0x96, "B": 0x6A, "C": 0x00, "D": 0x00, "E": 0x00, "H": 0x20, "L": 0x50}

def pair(hi, lo):                      # উঁচু register বাঁয়ে, নিচু ডানে
    return r[hi] << 8 | r[lo]

for hi, lo in ["BC", "DE", "HL"]:
    print(f"{hi}{lo} = {r[hi]:02X}H:{r[lo]:02X}H -> {pair(hi, lo):04X}H = {pair(hi, lo)}")

print("৮ বিটে সবচেয়ে বড়:", 2**8 - 1, "| ১৬ বিটের ঠিকানা:", 2**16, "টি ঘর =", 2**16 // 1024, "KiB")

addr = pair("H", "L")                  # HL একটি ঠিকানা: 2050H
high, low = addr >> 8, addr & 0xFF     # A15–A8 আর AD7–AD0
print(f"{addr:04X}H -> A15-A8 = {high:02X}H, AD7-AD0 = {low:02X}H")
print(f"A15-A8 বিট: {high:08b}  AD7-AD0 বিট: {low:08b}")

total = r["A"] + r["B"]                # 150 g + 106 g, ৮ বিটে আঁটে?
print(f"{r['A']} + {r['B']} = {total} -> A = {total & 0xFF:02X}H, CY = {total >> 8}")

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

BC = 6AH:00H -> 6A00H = 27136
DE = 00H:00H -> 0000H = 0
HL = 20H:50H -> 2050H = 8272
৮ বিটে সবচেয়ে বড়: 255 | ১৬ বিটের ঠিকানা: 65536 টি ঘর = 64 KiB
2050H -> A15-A8 = 20H, AD7-AD0 = 50H
A15-A8 বিট: 00100000  AD7-AD0 বিট: 01010000
150 + 106 = 256 -> A = 00H, CY = 1

প্রথম লাইনে খেয়াল করুন: B = 6AH (দশমিকে 106) একা থাকলে 106, কিন্তু BC জোড়ায় B উঁচু byte, তাই BC = 6A00H = 27136. জোড়ার মান বুঝতে কোনটি উঁচু, তা জানা জরুরি। পঞ্চম লাইন অংশ ৬-এর বিষয়: HL-এর ঠিকানা 2050H বাইরে যাওয়ার সময় উঁচু byte 20H যায় A15–A8 pin-এ, নিচু byte 50H যায় AD7–AD0-এ। শেষ লাইনে বাজারঘরের দুটি ওজন, 150 g আর 106 g: যোগফল 256, যা ৮ বিটে আঁটে না, তাই A-তে থাকে 00H আর বাড়তি 1 যায় carry-তে। এই যোগটিই পরের অংশে chip-এর ভেতর দিয়ে চালাব।

এবার লুকানো register. Temp register ALU-র দ্বিতীয় operand রাখে। IR opcode রাখে। W আর Z হলো CPU-র নিজের খাতা: যেমন LDA 2050H চলার সময় ঠিকানার দুই byte মেমরি থেকে এসে আগে W আর Z-এ বসে, তারপর সেখান থেকে ঠিকানা হিসেবে বাইরে যায়; CALL আর JMP-ও লক্ষ্যের ঠিকানা এভাবে জমায়। এগুলো কোনো নির্দেশে নাম ধরে পড়া বা লেখা যায় না, তাই exam-এর “programmer's model”-এ এদের নাম থাকে না, কিন্তু block diagram-এ থাকে।

মূল ধারণা

8085-এর “programmer's model” মানে: ৮ বিটের A, B, C, D, E, H, L; ১৬ বিটের SP আর PC; আর পাঁচটি flag. বাকি সব (temp, IR, W, Z) hardware-এর ভেতরের কাজের জন্য। পরীক্ষায় “8085-এ কয়টি register” প্রশ্নে এই দুই ভাগ আলাদা করে লিখুন।

বাজারঘরের smart scale-এর সংখ্যা 8085-এর register-এ

কোর্সের running project-এর smart scale-এর সংখ্যাগুলো (reference lab-এর README, “বাজারঘর devices”) একবার 8085-এর চোখে দেখুন। Capacity 5000 g = 1388H, ১৩ বিট লাগে। 1250 g-এর net ওজন = 04E2H: HL-এ রাখলে H = 04H, L = E2H. ADC-র ১২ বিটের মান, যেমন 1400 g-এ 1380 count = 0564H, আর 1250 g-এর দাম 8188 পয়সা = 1FFCH. অর্থাৎ device-এর প্রায় কোনো সংখ্যাই এক register-এ আঁটে না; প্রতিটির জন্য একটি register pair লাগে, আর যোগ করতে হয় দুই ধাপে: নিচু byte-এ ADD, উঁচু byte-এ carry-সহ ADC (বা HL-এ DAD).

দামের সূত্র price = (net_g × 6550 + 500) ÷ 1000-এর মাঝের গুণফল আরও বড়: 1250 g-এ 8,188,000 = 7CF060H (২৩ বিট), আর 5000 g-এ 32,750,500 (২৫ বিট)। 8085-এ গুণ বা ভাগের কোনো নির্দেশ নেই, তাই এই হিসাব হতো কয়েক byte জুড়ে বারবার যোগ আর shift-এর loop-এ, শত শত T-state ধরে (গুণ-ভাগের program পর্ব ১১-এ)। মডিউল ৫ থেকে একই কাজ ৩২ বিটের Cortex-M-এ একটি muls আর একটি udiv-এ হবে। Register-এর চওড়া কেন গুরুত্বপূর্ণ, বাজারঘরের দাঁড়িপাল্লাই তার সবচেয়ে সহজ উদাহরণ।

ইতিহাসের পাতা থেকে: 8080 (১৯৭৪) চালাতে বাইরে একটি clock generator chip আর একটি system controller chip লাগত, আর তিনটি আলাদা supply voltage. 8085-এর নকশাকারেরা এই সহায়ক কাজগুলোর বড় অংশ একই chip-এ টেনে আনলেন, একটিমাত্র +5 V supply-তে, আর নির্দেশের তালিকা প্রায় অপরিবর্তিত রাখলেন, যাতে 8080-এর program চলে। ফলে register আর flag-এর মডেল দুটি chip-এ এক; বদল এসেছে মূলত bus আর pin-এর দিকে (multiplexed AD0–AD7, ALE, SID/SOD, নতুন interrupt লাইন)। এই পর্বের প্রায় সব কথা তাই 8080-এর জন্যও খাটে, শুধু অংশ ৬ আর ৭-এর pin-গুলো ছাড়া।

৪ · ALU আর accumulator — একটি যোগের পুরো পথ

একটি ছোট program দিয়ে block-গুলোকে কাজ করতে দেখি। বাজারঘরের একজন কর্মচারী দুটি ব্যাগ ওজন করলেন, 106 g আর 150 g. 8085 দুটি ওজন যোগ করবে, তারপর ১৬ বিটের ফল মেমরির 2050H (নিচু byte) আর 2051H (উঁচু byte)-এ রাখবে।

; দুটি ওজন যোগ, ফল ১৬ বিটে: 2050H = low byte, 2051H = high byte
;@show 2050H 2
        ORG 2000H
START:  MVI B,6AH       ; B <- 106 (g)
        MVI A,96H       ; A <- 150 (g)
        ADD B           ; A <- A + B : 100H -> A=00H, CY=1, Z=1
        LXI H,2050H     ; HL <- 2050H (memory pointer)
        MOV M,A         ; [2050H] <- A (low byte)
        INX H           ; HL <- 2051H
        MVI A,00H       ; MVI does not touch flags
        ACI 00H         ; A <- 0 + 0 + CY = 01H
        MOV M,A         ; [2051H] <- A (high byte)
        HLT

প্রথম তিনটি নির্দেশে চিপের ভেতরে কী হয়, নিচের stepper-এ block ধরে দেখুন। লাল দাগ দেওয়া block-গুলো সেই ধাপে কাজ করছে। MVI B,6AH আগেই শেষ (মোট ৭টি T-state), B = 6AH, আর PC এখন 2002H.

Memory2002H–2004H
Address bufferA15–A8
Address/data bufferAD7–AD0
PCপরের byte-এর ঠিকানা
IRopcode
Decoderকী করতে হবে
Timing ও controlALE, RD̅, IO/M̅
B6AH
Aaccumulator
Tempলুকানো
ALU আর flagS Z AC P CY
এই ধাপে
cycle
ঠিকানা
AD7–AD0
IR
A · Temp
S Z AC P CY
মোট T
  1. PC থেকে ঠিকানা বাইরে। PC = 2002H. উঁচু byte 20H যায় address buffer দিয়ে A15–A8-এ, নিচু byte 02H যায় address/data buffer দিয়ে AD7–AD0-এ। Timing ও control ALE তোলে, যাতে বাইরের latch 02H ধরে রাখে। এটি opcode fetch machine cycle-এর (M1) প্রথম T-state.
  2. Opcode ভেতরে আসে। RD̅ নামে, মেমরি 2002H-এর byte 3EH আটটি AD তারে রাখে। Address/data buffer এবার উল্টো দিকে কাজ করে: বাইরে থেকে ভেতরে। 3EH অভ্যন্তরীণ bus দিয়ে IR-এ বসে।
  3. Decode. Decoder 3EH দেখে বোঝে: MVI A, আরও এক byte (data) পড়তে হবে, তাই আরেকটি memory read machine cycle লাগবে। PC এখন 2003H. এই T-state-এ বাইরের bus-এ কিছু হয় না।
  4. Data byte সোজা A-তে। M2 (memory read): 2003H বাইরে যায়, মেমরি 96H ফেরত দেয়, 96H অভ্যন্তরীণ bus দিয়ে A-তে। MVI ALU ছোঁয় না, তাই কোনো flag বদলায় না। MVI A,96H শেষ: 4 + 3 = ৭টি T-state, মোট ১৪.
  5. পরের opcode: 80H. আবার opcode fetch: PC 2004H বাইরে, মেমরি দেয় 80H, IR-এ বসে। PC হয় 2005H.
  6. B যায় temp-এ। Decoder 80H থেকে বোঝে ADD B: register থেকে, তাই আর কোনো machine cycle নয়। B-র মান 6AH অভ্যন্তরীণ bus দিয়ে temp register-এ যায়; A (96H) আর temp (6AH) ALU-র দুই input-এ।
  7. ফল A-তে, flag বদল। 96H + 6AH = 100H. নিচের ৮ বিট 00H যায় A-তে, বিট ৮-এর 1 যায় CY-তে। Z = 1 (ফল শূন্য), AC = 1, P = 1, S = 0. ADD B একটিমাত্র machine cycle, ৪টি T-state; মোট ১৮. সত্যিকারের trace-এও ঠিক এই মান।

একটি সতর্কতা: stepper-এ ALU-র যোগ আর A-তে লেখা দেখানো হয়েছে T4-এর পরে। Intel-এর টেবিল (reference lab-এর Spec decision 2) শুধু বলে ADD r মোট ৪টি T-state নেয়; ভেতরে ঠিক কোন clock-এর কিনারায় ফল A-তে লেখা হয়, কোর্সের simulator তা মডেল করে না, সে প্রতিটি নির্দেশ একবারে চালায় আর T-state যোগ করে। পরীক্ষার উত্তরে মোট T-state আর machine cycle-এর ধরনই দরকার, এবং সেগুলো এই টেবিল থেকে।

এখন পুরো program কোর্সের পূর্ণ simulator-এ (সত্যিকারের run, sim8085.py, Python 3.13.5; কোর্সের নিজের pure Python tool). আগে asm দিয়ে byte, তারপর trace দিয়ে প্রতিটি নির্দেশের পরের অবস্থা (C, D, E আর SP-এর কলাম বাদ, সবগুলো 00):

$ python -B sim8085.py asm arch.asm
2000  06 6A     MVI B,6AH
2002  3E 96     MVI A,96H
2004  80        ADD B
2005  21 50 20  LXI H,2050H
2008  77        MOV M,A
2009  23        INX H
200A  3E 00     MVI A,00H
200C  CE 00     ACI 00H
200E  77        MOV M,A
200F  76        HLT
Start: 2000H   Bytes: 16

$ python -B sim8085.py trace arch.asm
2004  80        ADD B        A=00 B=6A H=00 L=00 PC=2005 S=0 Z=1 AC=1 P=1 CY=1  T=4  total=18
2005  21 50 20  LXI H,2050H  A=00 B=6A H=20 L=50 PC=2008 S=0 Z=1 AC=1 P=1 CY=1  T=10 total=28
200C  CE 00     ACI 00H      A=01 B=6A H=20 L=51 PC=200E S=0 Z=0 AC=0 P=0 CY=0  T=7  total=55
...
Memory 2050H..2051H:
  2050H: 00 01
Instructions: 10   T-states: 67

(trace-এর দশটি লাইনের তিনটি দেখানো হয়েছে; বাকিগুলো নিচের stepper-এ।) ফল: 2050H = 00, 2051H = 01, অর্থাৎ ১৬ বিটের 0100H = 256 g. মোট ৬৭টি T-state, 3 MHz-এ 67 ÷ 3 = 22.33 µs. খেয়াল করুন LXI H,2050H-এর byte 21 50 20: ঠিকানার নিচু byte আগে, উঁচু byte পরে (little-endian), যা পর্ব ০৫-এ দেখেছেন।

2000MVI B,6AH2002MVI A,96H2004ADD B2005LXI H,2050H2008MOV M,A2009INX H200AMVI A,00H200CACI 00H200EMOV M,A200FHLT
নির্দেশের পরে
A
B
HL
S Z AC P CY
2050H 2051H
T · মোট
  1. MVI B,6AH. B = 6AH (106). দুই machine cycle: opcode fetch (4 T) আর data পড়া (3 T). Flag সব 0, রিসেটের পরের মতো (Spec decision 6).
  2. MVI A,96H. A = 96H (150). এটিও ৭ T. MVI শুধু মান রাখে, flag ছোঁয় না।
  3. ADD B. 96H + 6AH = 100H: A = 00H, আর Z, AC, P, CY চারটিই 1. মাত্র ৪ T, কারণ operand register-এ, মেমরিতে যেতে হয় না।
  4. LXI H,2050H. HL = 2050H: তিন machine cycle (4 + 3 + 3 = 10 T), কারণ opcode-এর পরে ঠিকানার দুটি byte পড়তে হয়। Flag অপরিবর্তিত, CY = 1 এখনো রয়ে গেছে।
  5. MOV M,A. A-র 00H লেখা হলো HL-এর ঠিকানা 2050H-এ। ঘরটি আগেও 00 ছিল, তাই চোখে বদল নেই, কিন্তু একটি memory write machine cycle হয়েছে: 4 + 3 = ৭ T.
  6. INX H. HL = 2051H. ১৬ বিট বাড়ানোর কাজ করে register array-র incrementer/decrementer, ALU নয়; তাই flag বদলায় না। ৬ T.
  7. MVI A,00H. A = 00H. এখানেই flag না-ছোঁয়ার সুবিধা: CY = 1 নিরাপদে রয়ে গেল, যা পরের নির্দেশের দরকার।
  8. ACI 00H. A = 0 + 0 + CY = 01H. এটি ALU-র কাজ, তাই flag নতুন করে বসে: সব 0 (ফল 01H, একটিমাত্র 1, তাই P = 0).
  9. MOV M,A. 2051H-এ 01H. মেমরিতে এখন 00 01: little-endian-এ 0100H = 256 g.
  10. HLT. CPU থামে, ৫ T. মোট ১০টি নির্দেশ, ৬৭টি T-state = 22.33 µs (3 MHz).

এবার একই program নিজের ব্রাউজারে চালান। নিচের ব্লকটি পাতার ভেতরে রাখা একটি ছোট 8085 emulator mini85.py ব্যবহার করে; এটি reference simulator sim8085.py-এর সংক্ষিপ্ত রূপ, শুধু এই পর্বের নির্দেশগুলো চেনে, কিন্তু প্রতিটি নির্দেশে data কোন পথে গেল, তা-ও ছাপে। লেখকের lab-এ দুটির ফল মেলানো হয়েছে: এই program, ৩০০টি এলোমেলো program (মোট ৯,৯৪৭টি নির্দেশ) আর ADC-র সব ১,৩১,০৭২টি operand-জোড়ায় register, flag, মেমরি আর T-state হুবহু এক।

from mini85 import CPU                 # পাতার ভেতরের mini85.py (sim8085.py-র ছোট রূপ)

prog = [0x06, 0x6A,                    # 2000H  MVI B,6AH   (106 g)
        0x3E, 0x96,                    # 2002H  MVI A,96H   (150 g)
        0x80,                          # 2004H  ADD B
        0x21, 0x50, 0x20,              # 2005H  LXI H,2050H
        0x77,                          # 2008H  MOV M,A
        0x23,                          # 2009H  INX H
        0x3E, 0x00,                    # 200AH  MVI A,00H
        0xCE, 0x00,                    # 200CH  ACI 00H
        0x77,                          # 200EH  MOV M,A
        0x76]                          # 200FH  HLT
cpu = CPU(prog)
while True:
    at, txt, t, path = cpu.step()
    r = cpu.r
    print(f"{at:04X} {txt:11} A={r['A']:02X} B={r['B']:02X} HL={cpu.hl():04X} "
          f"{cpu.flags()} T={t} total={cpu.T}")
    print(f"      পথ: {path}")
    if txt == "HLT":
        break
lo, hi = cpu.mem[0x2050], cpu.mem[0x2051]
print(f"[2050H]={lo:02X}H [2051H]={hi:02X}H -> {hi << 8 | lo} g, {cpu.T} T = {cpu.T / 3:.2f} us")

আসল আউটপুট (ব্রাউজারের Python; প্রথম ছয়টি নির্দেশ আর শেষ লাইন):

2000 MVI B,6AH   A=00 B=6A HL=0000 S=0 Z=0 AC=0 P=0 CY=0 T=7 total=7
      পথ: data byte → internal bus → B
2002 MVI A,96H   A=96 B=6A HL=0000 S=0 Z=0 AC=0 P=0 CY=0 T=7 total=14
      পথ: data byte → internal bus → A
2004 ADD B       A=00 B=6A HL=0000 S=0 Z=1 AC=1 P=1 CY=1 T=4 total=18
      পথ: B → temp; A + temp → ALU → A, flag
2005 LXI H,2050H A=00 B=6A HL=2050 S=0 Z=1 AC=1 P=1 CY=1 T=10 total=28
      পথ: দুই byte → HL
2008 MOV M,A     A=00 B=6A HL=2050 S=0 Z=1 AC=1 P=1 CY=1 T=7 total=35
      পথ: A → internal bus → M (HL = ঠিকানা)
2009 INX H       A=00 B=6A HL=2051 S=0 Z=1 AC=1 P=1 CY=1 T=6 total=41
      পথ: incrementer/decrementer, flag অপরিবর্তিত
...
[2050H]=00H [2051H]=01H -> 256 g, 67 T = 22.33 us

প্রতিটি লাইনের মান সত্যিকারের sim8085.py trace আর আগের stepper-এর সঙ্গে মেলে। “পথ” লাইনগুলো দেখায় কোন নির্দেশ কোন block ব্যবহার করে: MVI আর MOV শুধু অভ্যন্তরীণ bus, তাই flag অপরিবর্তিত; ADD, ACI ALU দিয়ে যায়, তাই flag নতুন করে বসে; INX register array-র নিজস্ব incrementer ব্যবহার করে। mini85.py-এর step()-এর if/elif শাখাগুলোই decoder-এর কাজ, আর fetch() হলো opcode fetch আর memory read. এখানে us মানে µs (ASCII-তে লেখা)।

৫ · Flag register — পাঁচটি বিট, প্রতিটির ঠিক অর্থ

8085-এর flag register ৮ বিটের, কিন্তু পাঁচটি বিট ব্যবহার হয়। বিটের অবস্থান পরীক্ষায় হুবহু চাওয়া হয়: বাঁ থেকে D7 S, D6 Z, D5 —, D4 AC, D3 —, D2 P, D1 —, D0 CY. কোর্সের simulator-এ ফাঁকা তিনটি বিট সবসময় 0 (Spec decision 3), তাই flag byte = S×80H + Z×40H + AC×10H + P×04H + CY×01H.

বিটFlagকখন 1কাজে লাগে
D7 (80H)S signফলের বিট ৭ = 1signed অর্থে ঋণাত্মক; JM, JP
D6 (40H)Z zeroফলের আটটি বিটই 0সমান কি না, loop শেষ কি না; JZ, JNZ
D4 (10H)AC auxiliary carryবিট ৩ থেকে বিট ৪-এ carryশুধু DAA-র BCD সংশোধন; কোনো শর্তযুক্ত লাফ নেই
D2 (04H)P parityফলে 1-এর সংখ্যা জোড়serial data-র ভুল ধরা; JPE, JPO
D0 (01H)CY carryযোগে বিট ৭ থেকে carry, বিয়োগে borrowবহু-byte হিসাব, unsigned তুলনা; JC, JNC

দুটি কথা মনে রাখুন। প্রথমত, 8085-এ overflow flag নেই; signed overflow ধরতে হয় চিহ্নের নিয়মে (পর্ব ০৫). দ্বিতীয়ত, সব নির্দেশ flag বদলায় না: data transfer (MOV, MVI, LXI, LDA) কোনো flag ছোঁয় না; INX/DCX-ও না; INR/DCR CY ছাড়া বাকি চারটি বদলায়; DAD শুধু CY (Spec decision 4). পুরো টেবিল পর্ব ০৯-এ (8085-এর instruction set). এবার 96H + 6AH-এর flag byte একটি একটি বিট করে গড়ে তুলি।

হিসাব আর flag
হিসাব
S Z AC P CY
D7…D0
F
  1. দুটি operand. A = 96H = 1001 0110, B = 6AH = 0110 1010. D5, D3, D1 সবসময় 0, বাকি পাঁচটি এখনো অজানা।
  2. AC: নিচের nibble. 6 + A = 16 = 1 0000: বিট ৩ থেকে বিট ৪-এ carry গেল, তাই AC = 1 (D4).
  3. CY: পুরো যোগ। 150 + 106 = 256 = 1 0000 0000: নয় বিট লাগে। বিট ৭ থেকে বেরোনো 1-ই CY, তাই CY = 1 (D0).
  4. S আর Z: ফল দেখে। A-তে থাকে নিচের আট বিট, 0000 0000. বিট ৭ = 0, তাই S = 0; সব বিট 0, তাই Z = 1. “ফল শূন্য” অথচ আসল যোগফল 256: Z আর CY একসঙ্গে পড়লেই পুরো সত্য।
  5. P: 1 গোনা। 00H-এ 1 একটিও নেই; শূন্য একটি জোড় সংখ্যা, তাই P = 1 (D2).
  6. Flag byte জোড়া। 0101 0101 = 40H + 10H + 04H + 01H = 55H. এটিই PSW-এর নিচু byte.
  7. Simulator-এ যাচাই। F সরাসরি পড়ার কোনো নির্দেশ নেই, কিন্তু PUSH PSW A আর F-কে stack-এ রাখে, আর POP B সেগুলো B আর C-তে তোলে। সত্যিকারের run-এ C = 55H (নিচে)।

সত্যিকারের run (sim8085.py; stack 2800H থেকে নিচে নামে, stack-এর পুরো গল্প পর্ব ১২-তে):

; flagbyte.asm — PUSH PSW, তারপর POP B -> C = F
        LXI SP,2800H
        MVI B,6AH
        MVI A,96H
        ADD B           ; S Z AC P CY = 0 1 1 1 1
        PUSH PSW        ; [27FFH] <- A, [27FEH] <- F
        POP B           ; B <- A, C <- F
        HLT

$ python -B sim8085.py run flagbyte.asm
A=00 B=00 C=55 D=00 E=00 H=00 L=00 SP=2800 PC=200B
Flags: S=0 Z=1 AC=1 P=1 CY=1   (F=55H)
Memory 27FEH..27FFH:
  27FEH: 55 00
Instructions: 7   T-states: 55

মেমরিতে 27FEH = 55H (F) আর 27FFH = 00H (A): PSW-এর নিচু byte F নিচু ঠিকানায়। এবার আরও কয়েকটি যোগ একসঙ্গে। নিচের ব্লক Spec decision 4-এর নিয়মে flag byte বানায়; একই নিয়ম লেখকের lab-এ সব ৬৫,৫৩৬টি ADD-জোড়ায় (carry-সহ ১,৩১,০৭২টি) reference simulator-এর সঙ্গে মেলানো হয়েছে।

# ADD-এর পরে 8085-এর flag byte: S Z 0 AC 0 P 0 CY (Spec decision 3–4)
def add8(a, b):
    t = a + b
    r = t & 0xFF
    bits = {"S": r >> 7,                              # বিট ৭: ফলের MSB
            "Z": int(r == 0),                         # বিট ৬: ফল শূন্য
            "AC": int((a & 0x0F) + (b & 0x0F) > 0x0F),# বিট ৪: বিট ৩ থেকে carry
            "P": int(bin(r).count("1") % 2 == 0),     # বিট ২: জোড় সংখ্যক 1
            "CY": t >> 8}                             # বিট ০: বিট ৭ থেকে carry
    pos = {"S": 7, "Z": 6, "AC": 4, "P": 2, "CY": 0}
    f = sum(v << pos[k] for k, v in bits.items())
    return r, bits, f

for a, b in [(0x49, 0x56), (0x96, 0x6A), (0xFA, 0x0B), (0x08, 0x08), (0xF0, 0x10)]:
    r, bits, f = add8(a, b)
    show = " ".join(f"{k}={v}" for k, v in bits.items())
    print(f"{a:02X}H + {b:02X}H = {r:02X}H  {show}  F = {f:08b} = {f:02X}H")

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

49H + 56H = 9FH  S=1 Z=0 AC=0 P=1 CY=0  F = 10000100 = 84H
96H + 6AH = 00H  S=0 Z=1 AC=1 P=1 CY=1  F = 01010101 = 55H
FAH + 0BH = 05H  S=0 Z=0 AC=1 P=1 CY=1  F = 00010101 = 15H
08H + 08H = 10H  S=0 Z=0 AC=1 P=0 CY=0  F = 00010000 = 10H
F0H + 10H = 00H  S=0 Z=1 AC=0 P=1 CY=1  F = 01000101 = 45H

প্রথম লাইনটি পর্ব ০১-এর প্রথম program-এর যোগ: F = 84H, ঠিক যা simulator সেখানে দেখিয়েছিল। চতুর্থ লাইনটি লক্ষ করুন: 08H + 08H-এ CY = 0 অথচ AC = 1, কারণ carry হয়েছে বিট ৩ থেকে, বিট ৭ থেকে নয়। শেষ লাইনে উল্টোটা: F0H + 10H-এ CY = 1 কিন্তু AC = 0, কারণ নিচের nibble দুটিই 0. Z আর CY দুটোই 1 হয় দ্বিতীয় আর শেষ লাইনে, অর্থাৎ ফল ঠিক 256 হলে।

Flag-এর আসল কাজ সিদ্ধান্ত নেওয়া। বাজারঘরের smart scale ওজন capacity ছাড়ালে display-এ OVERLOAD দেখায়। 8085-এ এমন প্রশ্নের উত্তর আসে CMP নির্দেশ থেকে: ALU A − operand হিসাব করে, কিন্তু ফল A-তে রাখে না, শুধু flag বসায়। CY = 1 মানে A ছোট (borrow হয়েছে), Z = 1 মানে দুটি সমান (Spec decision 4). তারপর JC, JNC বা JZ flag দেখে লাফ দেয় বা দেয় না। অর্থাৎ ALU আর flag register মিলে CPU-র “যদি-তাহলে”-র hardware; এর পুরো ব্যবহার পর্ব ০৯-এ।

আরও গভীরে: Intel-এর manual 8085-এর flag byte-এর D5, D3, D1-কে অব্যবহৃত বলে। কিন্তু chip-টি বাজারে আসার কয়েক বছর পরে স্বাধীন গবেষকেরা দেখান যে D1-এ একটি signed overflow flag (প্রায়ই V নামে) আর D5-এ আরেকটি flag (K বা X5 নামে) আছে, সঙ্গে দশটি নথিভুক্ত নয় এমন opcode. Intel এগুলো কখনো আনুষ্ঠানিকভাবে সমর্থন করেনি, তাই নির্ভরযোগ্য program, পরীক্ষা আর এই কোর্সের simulator ধরে নেয় ওই তিনটি বিট 0 আর ওই opcode-গুলো নেই (Spec decision 1 ও 3). আরেকটি সূক্ষ্ম পার্থক্য: ANA-র পরে 8085 AC = 1 করে, অথচ পূর্বসূরি 8080 করে না; তাই 8080-এর emulator দিয়ে 8085-এর flag যাচাই করলে এই একটি জায়গায় অমিল দেখা যায় (Spec decision 4 ও 12).

৬ · Bus — ৮ বিটের data, ১৬ বিটের ঠিকানা আর multiplexed AD0–AD7

CPU বাইরের জগতের সঙ্গে কথা বলে তিন দল তার দিয়ে, যাকে একসঙ্গে বলে system bus. Address bus (১৬টি লাইন, একমুখী: CPU থেকে বাইরে) বলে কোন ঘর। Data bus (৮টি লাইন, দ্বিমুখী) আনে বা নেয় আসল byte. Control bus বলে কখন আর কী: পড়া (RD̅), লেখা (WR̅), মেমরি না I/O (IO/M̅), আর ঠিকানা কখন বৈধ (ALE). তারের নামের ওপরের দাগ মানে active low: 0 হলে সক্রিয়।

হিসাব করলে ১৬ + ৮ = ২৪টি তার শুধু ঠিকানা আর data-র জন্য। কিন্তু 8085-এর মাত্র ৪০টি pin, আর তার মধ্যে supply, clock, interrupt, serial, DMA আর control-এর জন্যও pin লাগে। Intel-এর সমাধান: ঠিকানার নিচের ৮ বিট আর data একই আটটি pin ভাগ করবে, সময় ভাগ করে। এই pin-গুলোর নাম AD0–AD7, আর এমন bus-কে বলে multiplexed bus. ঠিকানার উঁচু ৮ বিট (A8–A15) নিজস্ব pin-এ থাকে।

উপমা — একই রাস্তায় রিকশা আর মালগাড়ি: ধরুন বাজারঘরের সামনের গলি এত সরু যে একবারে একটিই চলতে পারে। সকালে প্রথমে একজন দৌড়ে গিয়ে গুদামের তাকের নম্বর দিয়ে আসেন (ঠিকানা), গুদামের দারোয়ান সেই নম্বর খাতায় টুকে রাখেন (latch); তারপর একই গলি দিয়ে মাল আসে (data). দারোয়ান নম্বর টুকে না রাখলে মাল আসার সময় তিনি ভুলে যেতেন কোন তাক থেকে আনতে হবে। ALE হলো সেই মুহূর্তের হাঁক: “এখন যা যাচ্ছে, সেটা ঠিকানা, লিখে রাখুন”।

বাইরের latch (প্রায়ই 74LS373-এর মতো ৮ বিটের chip) ALE = 1 থাকার সময় AD0–AD7-এর মান পার হতে দেয়, আর ALE নামার সময় মানটি আটকে রাখে। ফলে মেমরি পুরো machine cycle জুড়ে A0–A7 পায় latch থেকে, আর A8–A15 সরাসরি CPU থেকে। এই ছোট ব্যবস্থার নাম demultiplexing; এর circuit আর timing diagram আঁকা শিখবেন পর্ব ০৮-এ (8085-এর pin, machine cycle আর timing diagram). Address latch enable, সংক্ষেপে ALE, প্রতিটি machine cycle-এর প্রথম T-state-এ একবার 1 হয়। নিচের stepper-এ arch.asm-এর ADD B opcode-টি (80H, ঠিকানা 2004H) আনার চারটি T-state.

Pin আর ভেতরের অবস্থা
T-state
A15–A8
AD7–AD0
latch-এর আউটপুট
ALE · RD̅
IO/M̅ · S1 S0
IR · PC
  1. T1: ঠিকানা বাইরে। PC = 2004H. A15–A8-এ 20H, AD7–AD0-এ 04H. ALE = 1, তাই latch 04H পার হতে দিচ্ছে। IO/M̅ = 0 (মেমরি), আর S1 S0 = 1 1 মানে opcode fetch; এই দুই status বিট বাইরের যন্ত্রকে বলে কোন ধরনের machine cycle চলছে।
  2. T2: ঠিকানা আটকে, data-র পালা। ALE নেমে গেছে, latch 04H ধরে রেখেছে। RD̅ = 0: মেমরিকে পড়ার আদেশ। মেমরি 2004H-এর byte 80H আটটি AD তারে রাখে; একই তার এখন data বহন করছে।
  3. T3: byte ভেতরে। RD̅ আবার 1-এ ওঠার সময় CPU 80H নিয়ে IR-এ রাখে। IR-এ আগের opcode 3EH (MVI A)-এর জায়গায় এখন 80H.
  4. T4: decode. Decoder 80H থেকে বোঝে ADD B. Opcode fetch-এর এই শেষ T-state-এ AD তার ভাসমান (buffer বিচ্ছিন্ন), A15–A8-এর মান অনির্দিষ্ট; PC 2005H দেখায়।
  5. শেষ। ADD B-এর আর কোনো machine cycle নেই, তাই মোট ৪টি T-state = 4 × 0.333 µs ≈ 1.33 µs. পরের T1-এ 2005H বাইরে যাবে, LXI H-এর opcode আনতে।

IO/M̅, S1 আর S0 মিলে machine cycle-এর ধরন বলে: opcode fetch 0 1 1, memory read 0 1 0, memory write 0 0 1, I/O read 1 1 0, I/O write 1 0 1 (Intel 8085 manual). I/O-র ঠিকানা মাত্র ৮ বিট (port 00H–FFH), আর IN/OUT চলার সময় সেই ৮ বিট A15–A8 আর AD7–AD0, দুই জায়গাতেই একই মানে দেখা যায়। মেমরি আর I/O আলাদা জগতে রাখার এই পদ্ধতি (isolated I/O) বনাম মেমরির ঠিকানায় I/O রাখা (memory-mapped I/O), তা পর্ব ২৩-এ (I/O interfacing). Bus-এর সাধারণ তত্ত্ব পড়তে চাইলে Computer Architecture পর্ব ৫১.

৭ · Timing ও control, interrupt আর serial I/O — বাকি তিনটি block

Timing ও control unit পুরো chip-এর তাল রাখে। X1 আর X2 pin-এ একটি crystal লাগালে ভেতরের oscillator চলে, আর 8085 সেই কম্পাঙ্ককে ২ দিয়ে ভাগ করে নিজের clock বানায়; বাইরের অন্য chip-এর জন্য সেটি CLK OUT pin-এ দেয়। কোর্সের হিসাবে 6 MHz crystal, তাই CPU clock 3 MHz আর এক T-state = 0.333 µs. প্রতিটি নির্দেশ এক থেকে পাঁচটি machine cycle, আর প্রতিটি machine cycle ৩ থেকে ৬টি T-state. পরীক্ষার হিসাবের ধাপ, arch.asm-এর জন্য:

  1. Crystal 6 MHz; CPU clock f = 6 MHz ÷ 2 = 3 MHz.
  2. এক T-state = 1 ÷ f = 1 ÷ (3 × 106 Hz) = 0.333 µs.
  3. মোট T = 7 + 7 + 4 + 10 + 7 + 6 + 7 + 7 + 7 + 5 = 67 (Spec decision 2-এর টেবিল থেকে, simulator-এর সঙ্গে মিলিয়ে).
  4. সময় = 67 × 0.333 µs = 22.33 µs (ঠিক মান 67 ÷ 3 µs).

Control unit বাইরের কয়েকটি সংকেত শোনেও। READY = 0 থাকলে CPU ধীর মেমরির জন্য অপেক্ষা করে (wait state; কোর্সের simulator-এ wait state নেই, Spec decision 2). RESET IN̅ এলে PC = 0000H থেকে শুরু, আর interrupt-এর mask সেট হয়ে যায় (Spec decision 6). HOLD এলে bus ছেড়ে দেয়।

Interrupt control পাঁচটি interrupt লাইন সামলায়: TRAP (mask করা যায় না), RST 7.5, RST 6.5, RST 5.5 (প্রতিটির নিজস্ব নির্দিষ্ট ঠিকানা) আর INTR (বাইরের যন্ত্র নির্দেশ দেয়, CPU INTA̅ দিয়ে সাড়া দেয়)। অগ্রাধিকার TRAP > RST 7.5 > RST 6.5 > RST 5.5 > INTR (Spec decision 7). Serial I/O control দুটি pin: SID (serial input data) আর SOD (serial output data); RIM SID-এর বিট A-র বিট ৭-এ আনে, SIM A-র বিট ৭ SOD-এ পাঠায়। এই দুটি নির্দেশ interrupt-এর mask পড়া-লেখারও কাজ করে, আর 8080-এ এগুলো ছিল না: 8085-এর একমাত্র নতুন দুটি নির্দেশ। পুরো বিবরণ পর্ব ১৩-এ (8085-এর interrupt). একটি ব্যবহারিক কথা: SOD-এ একটি LED জুড়লে কোনো বাড়তি I/O chip ছাড়াই 8085-এর একটি “status বাতি” পাওয়া যায়, ঠিক যেভাবে আজকের microcontroller-এ একটি GPIO pin দিয়ে board-এর LED জ্বালানো হয়।

বিষয়80808085Z80
Supplyতিনটিএকটি, +5 Vএকটি, +5 V
Clock generatorবাইরে আলাদা chipchip-এর ভেতরেবাইরে একটি সরল clock
Data আর নিচু ঠিকানাআলাদা pinAD0–AD7 ভাগ করেআলাদা pin
Serial pin, RIM/SIMনেইSID, SOD, RIM, SIMনেই
RegisterA, B–L, SP, PCএকইএকই, সঙ্গে IX, IY, বিকল্প সেট আর আরও কয়েকটি
Flag-এ overflowনেইনথিভুক্ত নেইআছে (P/V)

পরীক্ষা ও ইন্টারভিউতে: এই পর্ব থেকে প্রায়ই আসা প্রশ্ন আর এক লাইনের উত্তর।
১. 8085 কত বিটের, কত মেমরি ছুঁতে পারে? ৮ বিট data, ১৬ বিট ঠিকানা, তাই 64 KB.
২. Flag register-এর বিন্যাস? D7 S, D6 Z, D4 AC, D2 P, D0 CY; D5, D3, D1 অব্যবহৃত।
৩. AD0–AD7 কেন multiplexed, কীভাবে আলাদা হয়? Pin বাঁচাতে; ALE দিয়ে বাইরের latch-এ নিচু ঠিকানা আটকে।
৪. Accumulator-এর বিশেষত্ব? প্রায় সব ALU কাজের একটি operand আর ফলের জায়গা, আর IN/OUT-এর একমাত্র register.
৫. SP আর PC কত বিটের, কেন? ১৬ বিট, কারণ দুটিই মেমরির ঠিকানা রাখে।

৮ · AI-এর যুগে 8085-এর গঠন যাচাই

“8085-এর block diagram ব্যাখ্যা করুন” লিখলে AI assistant সুন্দর একটি উত্তর দেয়। সমস্যা হয় খুঁটিনাটিতে, আর পরীক্ষায় নম্বর থাকে সেখানেই। সাধারণ ভুলগুলো আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
8085-এর flag-এ overflow বা 8086-এর DF, IF, TF বসিয়ে দেয়; বা Z80-এর IX, IY register যোগ করেIntel 8085 manual-এর flag আর register তালিকা; এই পর্বের টেবিল
Flag-এর বিটের অবস্থান ভুল বলে (যেমন CY-কে D7-এ)PUSH PSW, POP B চালিয়ে C-র মান দেখা; 55H-এর মতো জানা মান দিয়ে পরীক্ষা
“INR A 0FFH থেকে 00H হলে CY = 1” বা “MOV flag বদলায়” দাবি করেSimulator-এর trace-এ প্রতিটি নির্দেশের পরের flag দেখা (Spec decision 4)
T-state ভুল দেয়, যেমন সব নির্দেশ ৪ T, বা MOV M,A ৪ TIntel-এর টেবিল (Spec decision 2); simulator-এর T= কলাম
Data bus ১৬ বিট বলে, কারণ HL বা SP ১৬ বিটRegister pair ১৬ বিট মান রাখে, কিন্তু bus দিয়ে যায় এক byte করে; LXI-এর তিন machine cycle এর প্রমাণ
Clock = crystal ধরে সময় হিসাব করেDatasheet: CPU clock crystal-এর অর্ধেক; কোর্সে 3 MHz

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

আমি Intel 8085 (8080 বা Z80 নয়) শিখছি। 6 MHz crystal, CPU clock 3 MHz. ১. MVI B,6AH; MVI A,96H; ADD B; HLT চলার পরে A, B আর S Z AC P CY-এর মান কী? প্রতিটি flag কেন সেই মান পেল, এক লাইনে বলো। ২. Flag byte (F)-এর hex মান কত? বিটের অবস্থান D7 থেকে D0 পর্যন্ত লিখে দেখাও। ৩. প্রতিটি নির্দেশের machine cycle আর T-state আলাদা করে দাও, Intel 8085 user's manual-এর টেবিল ধরে। নিশ্চিত না হলে বলো, অনুমান কোরো না। ৪. 8086 বা Z80-এর কোনো register, flag বা নির্দেশ উত্তরে আনবে না।

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

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

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

প্র ০১8085 ঠিকানার নিচের ৮ বিট আর data একই pin-এ পাঠায়। ৪০ pin-এ এই আপসের লাভ আর দাম কী, আর পরের chip-গুলো এই পথে গেল কি?

১৯৭০-এর দশকে chip-এর package বড় করা মানে বেশি খরচ, বড় board আর বেশি তার জোড়া। ৪০ pin-এর DIP তখনকার প্রচলিত মাপ ছিল। 8085-এর নকশাকারদের লক্ষ্য ছিল 8080-এর তুলনায় পুরো system সস্তা আর সরল করা: একটিমাত্র +5 V supply, chip-এর ভেতরে clock generator, আর সঙ্গে interrupt আর serial pin. এত কিছু ৪০ pin-এ আঁটাতে কোথাও pin বাঁচাতে হতো। ঠিকানার নিচের ৮ বিট আর data-কে একই pin-এ পাঠিয়ে আটটি pin খালি হলো, আর সেগুলো গেল নতুন কাজে।

দাম দুটি। প্রথমত, বাইরে একটি latch লাগে, আর সঠিক সময়ে ALE দিয়ে ঠিকানা ধরতে হয়; board-এর নকশায় একটি বাড়তি chip আর একটু বেশি সাবধানতা। দ্বিতীয়ত, প্রতিটি machine cycle-এর প্রথম T-state ঠিকানার জন্য বাঁধা, তাই data একই সময়ে চলতে পারে না; bus-এর ব্যবহার কিছুটা ধীর। Intel এই দাম কমাতে 8085-এর জন্য বিশেষ সহযোগী chip বানিয়েছিল, যেমন 8155 আর 8355, যেগুলো নিজেরাই multiplexed bus বোঝে আর ভেতরে latch রাখে। ফলে ছোট system-এ বাইরের latch-ও লাগত না: তিনটি chip-এ পুরো কম্পিউটার।

পরের প্রজন্মে একই কৌশল আরও বড় আকারে দেখা যায়। ১৯৭৮ সালের 8086 ২০ বিটের ঠিকানা আর ১৬ বিটের data-কে AD0–AD15 আর A16–A19/S3–S6-এ ভাগ করে, আবার ALE দিয়ে (পর্ব ২১). আধুনিক বহু bus-ও ঠিকানা আর data একই তারে পাঠায়, যেমন PCI-তে। আবার উল্টো উদাহরণও আছে: একই সময়ের Z80 আলাদা pin রেখেছিল, যাতে বাইরের নকশা সহজ হয়। আজকের microcontroller-এ CPU আর মেমরি একই chip-এ, তাই ভেতরের bus অনেক চওড়া আর আলাদা, আর এই আপসের দরকার পড়ে না; কিন্তু বাইরের দিকে, যেমন SPI বা I2C-তে, অল্প তারে অনেক কাজের একই চিন্তা আবার ফিরে আসে।

মূল উপলব্ধি: Multiplexing pin আর খরচ বাঁচায়, দাম দেয় বাইরের latch আর bus-এর গতিতে; কোন দিকে ঝুঁকবেন, তা ঠিক করে সেই যুগের package আর system-এর খরচ।

প্র ০২প্রায় সব হিসাবের ফল কেন A-তেই যায়? Accumulator-কেন্দ্রিক নকশার সুবিধা আর অসুবিধা কী, আর আধুনিক RISC CPU কেন অন্য পথে গেছে?

Accumulator-এর ধারণা কম্পিউটারের শুরুর দিন থেকে। একটি নির্দিষ্ট register যদি সবসময় একটি operand আর ফলের জায়গা হয়, তাহলে নির্দেশে শুধু অন্য operand-এর নাম লিখলেই চলে। 8085-এ ADD B-এর পুরো নির্দেশ এক byte: উঁচু পাঁচ বিট বলে “ADD”, নিচের তিন বিট বলে কোন register (B = 000). দুটি register-এর নাম রাখতে গেলে আরও বিট লাগত, অর্থাৎ বড় opcode আর বেশি মেমরি। ১৯৭০-এর দশকে মেমরি ছিল দামি, আর প্রতিটি বাড়তি byte মানে বাড়তি fetch আর বাড়তি সময়। Hardware-ও সরল: ALU-র একটি input সবসময় A থেকে, অন্যটি temp থেকে; ফল সবসময় A-তে।

অসুবিধা দেখা যায় program লেখার সময়। প্রতিটি হিসাবের আগে মান A-তে আনতে হয়, পরে A থেকে সরাতে হয়, কারণ পরের হিসাব A মুছে দেবে। এই পর্বের arch.asm-এ ফলের উঁচু byte বানাতে আগে MVI A,00H দিয়ে A খালি করতে হয়েছে; অথচ A-র আগের মান ততক্ষণে মেমরিতে রাখা হয়ে গেছে বলে কাজ চলেছে। বড় program-এ এই আনা-সরানো (MOV) নির্দেশের একটি বড় অংশ নেয়, আর compiler-এর পক্ষে ভালো কোড বানানো কঠিন, কারণ একটিমাত্র “ব্যস্ত” register-এর জন্য সব মানের টানাটানি।

১৯৮০-এর দশকে মেমরি সস্তা হলো আর compiler হয়ে উঠল প্রধান কোড-লেখক। তখন RISC নকশা (ARM, MIPS, পরে RISC-V) তিন-operand নির্দেশ বেছে নিল: add r0, r1, r2, যেকোনো register থেকে যেকোনো register-এ। নির্দেশ বড় হলো (৩২ বিট), কিন্তু register অনেক (১৬ বা ৩২টি), আর অপ্রয়োজনীয় আনা-সরানো প্রায় উঠে গেল। 8086 মাঝামাঝি পথে গিয়েছিল: দুই-operand নির্দেশ, যেকোনো সাধারণ register-এ ফল, কিন্তু গুণ-ভাগ আর I/O-তে AX-এর বিশেষ ভূমিকা রয়ে গেল, যা আজকের x86-এও আছে। Cortex-M-এর Thumb নির্দেশের অনেকগুলো আবার দুই-operand, ১৬ বিটে আঁটানোর জন্য: পুরোনো আপস নতুন রূপে, কোডের আকার কমাতে।

মূল উপলব্ধি: Accumulator ছোট নির্দেশ আর সরল hardware দেয়, দাম দেয় বাড়তি আনা-সরানোয়; মেমরি সস্তা আর compiler শক্তিশালী হওয়ার পরে বহু register-এর নকশা জিতেছে।

প্র ০৩Auxiliary carry flag দিয়ে কোনো শর্তযুক্ত লাফ নেই, তবু 8085 এটি রাখে। কেন? আর parity flag-এর পেছনের ইতিহাস কী?

AC-এর একটিমাত্র ক্রেতা: DAA নির্দেশ। 8085-এর যুগে ক্যালকুলেটর, ক্যাশ রেজিস্টার, মিটার আর ঘড়ির মতো যন্ত্রে সংখ্যা রাখা হতো BCD-তে, প্রতিটি nibble-এ একটি দশমিক অঙ্ক। দুটি BCD byte binary-তে যোগ করার পরে ফল সংশোধন করতে হয়: নিচের অঙ্কে ৯-এর বেশি হলে বা নিচের অঙ্ক থেকে carry গেলে 06H যোগ। নিচের nibble থেকে carry গেছে কি না, যোগের পরে ফল দেখে আর বোঝা যায় না, যেমন 08H + 08H = 10H দেখতে বৈধ BCD, অথচ দশমিকে ৮ + ৮ = ১৬. তাই ALU যোগের সময়ই বিট ৩-এর carry একটি flip-flop-এ রেখে দেয়: AC. DAA সেটি পড়ে ঠিক করে 06H লাগবে কি না (Spec decision 5). Programmer-এর এটি সরাসরি পরীক্ষা করার দরকার পড়ে না, তাই JAC-এর মতো কোনো নির্দেশ রাখা হয়নি; opcode-এর জায়গা বাঁচল।

Parity-র গল্প আরও পুরোনো। Serial যোগাযোগ আর terminal-এর যুগে প্রতিটি অক্ষরের সঙ্গে একটি parity বিট পাঠানো হতো, যাতে একটি বিট উল্টে গেলে গ্রাহক ধরতে পারে। Intel-এর 8008 আর 8080 প্রথম দিকে terminal-জাতীয় কাজের জন্য ভাবা হয়েছিল, তাই প্রতিটি হিসাবের পরে parity hardware-এ হিসাব হয়ে flag-এ থাকে, আর JPE/JPO দিয়ে সরাসরি পরীক্ষা করা যায়। software-এ একই কাজ করতে আটটি বিট গুনতে কয়েক ডজন নির্দেশ লাগত। 8085 আর 8086 এই ঐতিহ্য ধরে রেখেছে, যাতে পুরোনো program চলে।

আজকের ARM Cortex-M-এ AC বা parity কোনোটিই নেই: N, Z, C, V আর saturation-এর Q. BCD প্রায় উঠে গেছে, আর UART-এর parity hardware নিজেই হিসাব করে। RISC-V-এ flag-ই নেই। এভাবে প্রতিটি flag একটি যুগের প্রধান কাজের চিহ্ন বহন করে। পরীক্ষায় তাই প্রশ্ন আসে “AC কোথায় লাগে”, আর উত্তর একটিই: DAA, BCD যোগের পরে।

মূল উপলব্ধি: AC আর P তখনকার প্রধান কাজ, BCD আর serial যোগাযোগ, থেকে এসেছে; hardware যা সস্তায় একবার হিসাব করতে পারে, তা flag-এ রেখে দেওয়া software-এর অনেক নির্দেশ বাঁচায়।

প্র ০৪8085 “৮ বিটের CPU”, অথচ তার SP, PC আর register pair ১৬ বিটের, আর DAD ১৬ বিট যোগ করে। তাহলে একটি CPU-কে কত বিটের বলা হয় কীসের ভিত্তিতে?

সাধারণ প্রথা হলো ALU আর data bus-এর চওড়া ধরে বলা, কারণ সেটিই এক নির্দেশে স্বাভাবিকভাবে কত বড় সংখ্যার হিসাব হয় তা ঠিক করে। 8085-এর ALU ৮ বিটের, data bus ৮ বিটের, accumulator ৮ বিটের; তাই ৮ বিটের CPU. ঠিকানার ১৬ বিট আলাদা প্রশ্ন: সেটি বলে কত মেমরি ছোঁয়া যায়। 8085 এই দুই চাহিদা মেটাতে কিছু ১৬ বিটের যন্ত্র রেখেছে, কিন্তু সেগুলো আসলে ঠিকানার কাজের জন্য। PC আর SP ঠিকানা রাখে, register pair বেশিরভাগ সময় pointer, আর INX/DCX চলে register array-র নিজস্ব incrementer/decrementer-এ, ALU-তে নয়।

DAD ব্যতিক্রমের মতো দেখায়: HL ← HL + rp, ১৬ বিটের যোগ। কিন্তু Intel-এর টেবিলে এর সময় ১০টি T-state, যা opcode fetch-এর পরে আরও দুটি bus-ছাড়া machine cycle; অর্থাৎ ভেতরে ৮ বিটের ALU দুবার কাজ করে, আগে নিচু byte, পরে carry-সহ উঁচু byte. আর এটি শুধু CY বদলায়, বাকি flag নয় (Spec decision 4), কারণ এর আসল উদ্দেশ্য ঠিকানা হিসাব, সাধারণ গণিত নয়। মেমরিতেও ১৬ বিটের মান যায় এক byte করে: LXI H,2050H-এ তিনটি machine cycle, প্রতিটিতে এক byte, আর SHLD-এ দুটি আলাদা লেখা।

অন্য chip-এ এই প্রশ্ন আরও জটিল। 8088 ভেতরে ১৬ বিটের (8086-এর মতো), কিন্তু বাইরের data bus ৮ বিটের, যাতে IBM PC সস্তা ৮ বিটের মেমরি আর peripheral ব্যবহার করতে পারে। Motorola 68000-এর register ৩২ বিটের, ALU ১৬ বিটের, data bus ১৬ বিটের; কেউ বলেন ১৬ বিটের, কেউ ৩২. আধুনিক ৬৪ বিটের PC-ও ঠিকানার জন্য সাধারণত পুরো ৬৪টি বিট ব্যবহার করে না। তাই “কত বিটের” বললে আসলে কোন মাপের কথা, সেটি স্পষ্ট করা ভালো অভ্যাস: register, ALU, data bus, না ঠিকানা।

মূল উপলব্ধি: “৮ বিটের CPU” মানে ৮ বিটের ALU আর data bus; ১৬ বিটের register আর ঠিকানা আছে মেমরি ছোঁয়ার জন্য, আর সেগুলোর হিসাবও ভেতরে byte ধরে চলে।

প্র ০৫8085 আর আজকের একটি ARM Cortex-M microcontroller-এর গঠন পাশাপাশি রাখলে কোন ধারণাগুলো একই রয়ে গেছে, আর কোনগুলো বদলেছে?

মূল চক্র একই: PC থেকে ঠিকানা, মেমরি থেকে নির্দেশ, decode, ALU-তে হিসাব, flag-এ ফলের চিহ্ন। Cortex-M-এও PC আছে (r15), stack pointer আছে (r13), আর flag আছে APSR-এর N, Z, C, V-তে (পর্ব ০৫-এ দেখেছেন)। Interrupt-এর ধারণাও এক: বাইরের সংকেতে চলতি কাজ থামিয়ে একটি নির্দিষ্ট ঠিকানার কোড চালানো, অগ্রাধিকার মেনে। 8085-এর TRAP যেমন mask করা যায় না, Cortex-M-এও NMI তেমনই। তাই 8085-এর block diagram বুঝলে Cortex-M-এর ছবিটি বড় আকারের একই ছবি মনে হয়।

বদলেছে মাপ আর কাঠামো। Cortex-M-এ ১৬টি ৩২ বিটের register, প্রায় সবগুলো সাধারণ কাজের; accumulator-এর বিশেষ ভূমিকা নেই। Bus ৩২ বিটের, আর ঠিকানা ৩২ বিটের, তাই 4 GB-এর address space, যেখানে flash, SRAM আর peripheral register একই মানচিত্রে বসে (পর্ব ৩১). বাইরের multiplexed bus নেই: মেমরি আর peripheral chip-এর ভেতরেই, তাই latch বা ALE-র দরকার নেই। Instruction আর data আলাদা bus-এ আসতে পারে (Harvard-ধাঁচ, পর্ব ০৩), আর ছোট pipeline আছে, ফলে বেশিরভাগ নির্দেশ এক-দুই clock-এ শেষ হয়, 8085-এর মতো ৪ থেকে ১৮ T-state নয়। Interrupt সামলায় NVIC, যার অগ্রাধিকার programmer ঠিক করেন, 8085-এর মতো hardware-এ বাঁধা নয় (পর্ব ৩০).

আরেকটি বড় বদল clock আর শক্তিতে। 8085 crystal থেকে একটি নির্দিষ্ট clock নেয় আর সবসময় চলে; Cortex-M-এর microcontroller-এ clock tree, PLL আর sleep mode, যাতে ব্যাটারির যন্ত্র মাসের পর মাস চলে (পর্ব ৩৩). বাজারঘরের দুটি device এই পার্থক্যের সুবিধা নেয়: smart scale-এর হিসাব 8085-এ সম্ভব, কিন্তু ১২ বিটের ADC, timer, UART আর MQTT একসঙ্গে চালাতে Cortex-M-এর মতো chip দরকার, যা মডিউল ৫ থেকে কোর্সের virtual বাজারঘর board-এ করবেন।

মূল উপলব্ধি: fetch–decode–execute, register, flag, stack আর interrupt চিরকালীন; বদলেছে চওড়া, register-এর সংখ্যা, এক chip-এ সব কিছু আঁটানো আর শক্তি বাঁচানোর কৌশল।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — ওজন যোগ আর flag রাখা: একটি 8085 program লিখুন যা 2050H আর 2051H-এর দুটি ওজন (গ্রামে, ৮ বিট করে) যোগ করে, ১৬ বিটের ফল 2052H (নিচু) আর 2053H (উঁচু)-এ রাখে, আর যোগের ঠিক পরের flag byte 2054H-এ রাখে। HL-কে pointer হিসেবে ব্যবহার করুন। 0C8H (200 g) আর 96H (150 g) দিয়ে ফল কী হবে?
    ;@set 2050H 0C8H,96H
            ORG 2000H
    START:  LXI SP,2800H
            LXI H,2050H     ; HL -> first weight
            MOV A,M         ; A <- [2050H]
            INX H
            MOV B,M         ; B <- [2051H]
            ADD B           ; A <- A + B, flags
            PUSH PSW        ; A and F to stack
            POP D           ; D <- A, E <- F
            INX H
            MOV M,A         ; [2052H] <- low byte
            MVI A,00H
            ACI 00H         ; A <- CY
            INX H
            MOV M,A         ; [2053H] <- high byte
            INX H
            MOV M,E         ; [2054H] <- F
            HLT

    সত্যিকারের run-এর ফল: 2050H: C8 96 5E 01 01, ১৭টি নির্দেশ, ১২৪টি T-state. 200 + 150 = 350 = 015EH, তাই 2052H = 5EH আর 2053H = 01H. Flag byte 01H: শুধু CY = 1; S = 0 (5EH-এর বিট ৭ = 0), Z = 0, AC = 0 (8 + 6 = 14, carry নেই), P = 0 (5EH = 0101 1110, পাঁচটি 1). Flag byte যোগের ঠিক পরে ধরা জরুরি, কারণ পরের ACI flag বদলে দেয়। এজন্যই PUSH PSW/POP D আগে, আর MVI ও INX flag না ছোঁয়ায় CY পরে ACI-র জন্য টিকে থাকে।

  2. ভুল খুঁজুন — carry ধরার ফাঁদ: একজন লিখলেন: MVI A,0FFH, INR A, JC OVER, MVI B,00H, HLT, OVER: MVI B,01H, HLT. তাঁর দাবি: “255 + 1-এ carry হয়, তাই B = 01H হবে।” আসলে B কত হয়, কেন, আর কীভাবে ঠিক করবেন?

    B = 00H. INR CY ছোঁয় না (Spec decision 4; Intel-এর manual-ও তাই বলে)। সত্যিকারের trace-এ INR A-এর পরে A = 00, S=0 Z=1 AC=1 P=1 CY=0; JC লাফ দেয় না (৭ T, not taken), তাই MVI B,00H চলে। মোট ৩০ T. ঠিক করার দুই উপায়: (ক) INR A-এর জায়গায় ADI 01H, যা CY বসায়: সত্যিকারের run-এ F=55H, JC লাফ দেয় (১০ T), B = 01H, মোট ৩৬ T. (খ) INR রেখে JZ দিয়ে পরীক্ষা, কারণ 0FFH থেকে বাড়লে ফল 00H, Z = 1. শিক্ষা: counter বাড়াতে INR-এর flag না-ছোঁয়া CY একটি সুবিধা, কিন্তু carry ধরতে এটি ফাঁদ।

  3. আগে বলুন, তারপর চালান — flag byte: MVI A,0A7H, MVI B,3CH, ADD B, MOV C,A, HLT. শেষে A, C, পাঁচটি flag, flag byte আর মোট T-state কত?

    A7H + 3CH = E3H (167 + 60 = 227, ২৫৫-এর কম, তাই CY = 0). S = 1 (E3H = 1110 0011, বিট ৭ = 1), Z = 0, AC = 1 (7 + C = 19, নিচের nibble থেকে carry), P = 0 (পাঁচটি 1, বিজোড়), CY = 0. Flag byte = 80H + 10H = 90H. MOV C,A flag ছোঁয় না, তাই C = E3H আর F অপরিবর্তিত। T = 7 + 7 + 4 + 4 + 5 = 27. সত্যিকারের run: A=E3 B=3C C=E3, Flags: S=1 Z=0 AC=1 P=0 CY=0 (F=90H), Instructions: 5 T-states: 27.

  4. হিসাব — bus, মেমরি আর সময়: (ক) 8085-এর ঠিকানার লাইন থেকে মোট মেমরি কত, আর ৮ KB-এর একটি ROM 0000H থেকে বসালে তার শেষ ঠিকানা কত? (খ) STA 2052H-এর opcode fetch-এর T1-এ A15–A8 আর AD7–AD0-এ কী থাকবে, যদি নির্দেশটি 2004H-এ থাকে? (গ) arch.asm-এর ৬৭টি T-state একটি 10 MHz crystal-এ চলা 8085-এ (যেমন 8085AH-2-এর মতো দ্রুত সংস্করণে) কত µs নেবে?

    (ক) ১৬টি লাইন: 216 = 65536 byte = 64 KB. ৮ KB = 8192 = 2000H byte, তাই ROM 0000H থেকে 1FFFH. এজন্যই কোর্সের program 2000H থেকে শুরু: ROM-এর ঠিক পরের ঠিকানা, বহু প্রশিক্ষণ-kit-এর মতো (পর্ব ২২-এ address decoding). (খ) Opcode fetch-এ ঠিকানা হলো নির্দেশের নিজের ঠিকানা, operand নয়: A15–A8 = 20H, AD7–AD0 = 04H; ALE = 1, IO/M̅ = 0, S1 S0 = 1 1. 2052H বাইরে যায় পরে, চতুর্থ machine cycle-এ (memory write). (গ) Clock = 10 ÷ 2 = 5 MHz, এক T-state = 0.2 µs, সময় = 67 × 0.2 = 13.4 µs. 3 MHz-এ ছিল 22.33 µs. Python-এ 67 / 5 = 13.4 আর 67 / 3 = 22.333… দিয়ে মেলানো। (দ্রুত সংস্করণের সর্বোচ্চ clock datasheet ভেদে আলাদা; প্রশ্নে যা দেওয়া, তা-ই ধরুন।)

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

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

ক্রম8085-এ ADD B নির্দেশ আনা আর চালানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. PC-র ঠিকানা A15–A8 আর AD7–AD0-এ যায়, ALE = 1
  2. Latch নিচু ঠিকানা আটকায়, RD̅ = 0 হয়
  3. মেমরির opcode 80H AD তার দিয়ে IR-এ আসে
  4. Decoder বোঝে ADD B, আর কোনো machine cycle লাগবে না
  5. B-র মান temp register-এ, A আর temp ALU-তে যোগ হয়
  6. ফল A-তে যায় আর পাঁচটি flag নতুন করে বসে

8085-এ A = 96H আর B = 6AH. ADD B-এর পরে flag byte (S Z 0 AC 0 P 0 CY ক্রমে) কত?

  • 45H
  • 55H
  • 0FFH
  • 01H

8085-এর address bus ১৬ বিট আর data bus ৮ বিট। নিচের কোন কথাটি ঠিক?

  • মেমরি সর্বোচ্চ 28 = 256 byte
  • মেমরি সর্বোচ্চ 128 KB, কারণ ১৬ × ৮ = ১২৮
  • মেমরি সর্বোচ্চ 64 KB, আর একবারে এক byte আনা-নেওয়া হয়
  • HL ১৬ বিট বলে data bus-ও আসলে ১৬ বিট

8085-এ ALE সংকেতের কাজ কী?

  • বাইরের latch-কে AD0–AD7-এর নিচু ঠিকানা ধরে রাখতে বলা
  • মেমরিকে পড়ার আদেশ দেওয়া
  • মেমরি আর I/O আলাদা করা
  • Interrupt স্বীকার করা

8085-এ CY = 1 অবস্থায় MVI A,00H তারপর INX H চলল। এরপর CY কত, আর কেন?

  • CY = 0, কারণ A-তে 00H রাখলে সব flag মুছে যায়
  • CY = 0, কারণ INX ১৬ বিট যোগ করে carry হিসাব করে
  • CY অনির্দিষ্ট হয়ে যায়
  • CY = 1, কারণ MVI আর INX কোনো flag ছোঁয় না

8085-এর কোন register programmer কোনো নির্দেশ দিয়ে নাম ধরে পড়তে বা লিখতে পারেন না?

  • SP
  • Temp register আর W, Z
  • L
  • F, কারণ এটি কোনোভাবেই ছোঁয়া যায় না

একটি 8085 6 MHz crystal-এ চলে। MVI B,6AH (৭ T), MVI A,96H (৭ T), ADD B (৪ T) আর HLT (৫ T) চলতে কত সময় লাগে?

  • প্রায় 3.83 µs
  • ৮.৬৭ µs
  • প্রায় 7.67 µs
  • ১.৩৩ µs

শব্দকোষ

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

মনে রাখুন

  1. ৮ আর ১৬: ৮ বিটের ALU আর data bus, ১৬ বিটের ঠিকানা: 216 = 65536 byte = 64 KB; I/O port ৮ বিটে, ২৫৬টি।
  2. Block-এর কাজ: register array রাখে, ALU হিসাব করে, IR আর decoder বোঝে, timing ও control তাল রাখে, buffer বাইরে কথা বলে; interrupt আর serial I/O নিজস্ব block.
  3. Register: A, B, C, D, E, H, L (৮ বিট), জোড়ায় BC, DE, HL; SP, PC ১৬ বিট; PSW = A + F; temp, IR, W, Z লুকানো।
  4. Flag byte: D7 S, D6 Z, D4 AC, D2 P, D0 CY; 96H + 6AH → A = 00H, F = 55H. MOV, MVI, LXI, INX flag ছোঁয় না; INR CY ছোঁয় না।
  5. AD0–AD7: T1-এ নিচু ঠিকানা, পরে data; ALE দিয়ে বাইরের latch ঠিকানা ধরে। Clock = crystal ÷ 2; 3 MHz-এ এক T-state 0.333 µs.

পরের পর্বে: পর্ব ০৮ (8085-এর pin, machine cycle আর timing diagram). ৪০টি pin একটি একটি করে, ALE আর latch দিয়ে demultiplexing-এর circuit, আর opcode fetch, memory read, memory write-এর timing diagram আঁকা, MVI আর STA দিয়ে।

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

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