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

8085-এর pin, machine cycle আর timing diagram

8085 Pins, Machine Cycles and Timing Diagrams

Taught in Bangla, this lesson walks through the 8085's 40 pins in groups, using the Intel 8085AH datasheet for numbers and functions. It shows how ALE and a latch split AD0–AD7 into address and data, decodes machine cycles from IO/M, S1 and S0, and draws opcode fetch, memory read and memory write timing for MVI A,32H and STA 2050H. The course's 8085 simulator traces the 25 T-state program, and in-page Python computes clock time and wait states.

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

  • 8085-এর ৪০টি pin দলে দলে চেনা, আর প্রতিটির দিক (input, output, দুই দিক) ও কাজ বলা
  • ALE আর একটি latch দিয়ে AD0–AD7 থেকে ঠিকানা আর data আলাদা করার কারণ আর পদ্ধতি
  • IO/M, S1, S0 থেকে machine cycle-এর ধরন চেনা, আর RD, WR থেকে memory ও I/O-র চারটি নিয়ন্ত্রণ-সংকেত তৈরি করা
  • Opcode fetch, memory read আর memory write-এর timing diagram T-state ধরে আঁকা আর পড়া, MVI A,32H আর STA 2050H দিয়ে
  • Crystal থেকে T-state-এর সময়, নির্দেশের মোট সময় আর ধীর memory-র জন্য wait state হিসাব করা

১ · একটি chip, ৪০টি দরজা — 8085-এর pin কেন জানতে হয়

আগের পর্বে (পর্ব ০৭, 8085-এর গঠন) chip-এর ভেতরটা দেখা হয়েছে: ALU, accumulator, flag, register আর bus. এই পর্বে আমরা chip-এর বাইরের দিকে তাকাব। ভেতরের সব কাজ শেষ পর্যন্ত বাইরের জগতের সঙ্গে কথা বলে মাত্র ৪০টি pin দিয়ে: memory থেকে নির্দেশ আনা, data লেখা, keyboard বা display-এর সঙ্গে কথা বলা, interrupt শোনা। কোন pin কখন কী করে, তা না জানলে memory বা I/O chip জোড়া যায় না, আর কোনো সমস্যায় logic analyzer-এর ছবিও পড়া যায় না।

উপমা — পোস্ট অফিসের একটিমাত্র জানালা: ধরুন একটি ছোট পোস্ট অফিসে কাউন্টারের জানালা একটাই। প্রথমে কেরানি জানালা দিয়ে চিঠির ঠিকানা দেখান, পিয়ন সেটা খাতায় টুকে নেন (latch). তারপর একই জানালা দিয়ে আসল পার্সেল আদান-প্রদান হয়। জানালার ওপরের বাতি জ্বললে বোঝায় “এখন ঠিকানা দেখানো হচ্ছে” (ALE), আর একটি বোর্ডে লেখা থাকে কাজটা পার্সেল নেওয়া না দেওয়া (RD, WR). 8085-এর AD0–AD7 pin ঠিক এই জানালা, আর পুরো লেনদেনের ধাপগুলোই এই পর্বের machine cycle.

লেখার নিয়ম শুরুতেই বলে রাখি। ঠিকানা আর data Intel-এর ধরনে, শেষে H: 2050H, 3EH. কিছু সংকেত active-low: সংকেতটি 0 হলে কাজ হয়। এদের নামের ওপরে দাগ দেওয়া হয়, যেমন RD, WR, IO/M. টেবিল আর stepper-এ জায়গা বাঁচাতে দাগ ছাড়া শুধু RD, WR লেখা হবে, কিন্তু মনে রাখবেন: RD = 0 মানে “এখন পড়া হবে”। সব pin-এর তথ্য Intel-এর ১৯৮৭ সালের 8085AH/8085AH-2/8085AH-1 datasheet (order number 231718) থেকে নেওয়া; T-state-এর সংখ্যা কোর্সের reference lab-এর 8085 simulator থেকে, যা Intel-এর manual-এর টেবিল মেনে চলে (Spec decision 2).

ছবি ৮.১ — 8085-এর pin diagram (৪০-pin DIP)

বাঁয়ে pin ১–২০ ওপর থেকে নিচে, ডানে pin ৪০–২১; দাগ = active-low

8085-এর pin diagram 8085 1 40 2 39 3 38 4 37 5 36 6 35 7 34 8 33 9 32 10 31 11 30 12 29 13 28 14 27 15 26 16 25 17 24 18 23 19 22 20 21 X1 VCC X2 HOLD RESET OUT HLDA SOD CLK (OUT) SID RESET IN TRAP READY RST 7.5 IO/M RST 6.5 S1 RST 5.5 RD INTR WR INTA ALE AD0 S0 AD1 A15 AD2 A14 AD3 A13 AD4 A12 AD5 A11 AD6 A10 AD7 A9 VSS A8 bus নিয়ন্ত্রণ interrupt, serial power, clock
ছবি ৮.১ — Intel 8085AH datasheet-এর Figure 2 অনুযায়ী। Chip-এর খাঁজ (ওপরের অর্ধবৃত্ত) থেকে বাঁ দিকে নিচে নেমে pin ১, ২ … ২০, তারপর ডান দিকে নিচ থেকে ওপরে ২১ … ৪০. মনে রাখার একটি সূত্র: বাঁ দিকের নিচের আটটি (১২–১৯) AD0–AD7, ডান দিকের নিচের আটটি (২১–২৮) A8–A15; AD0–AD7 ওপর থেকে নিচে বাড়ে, আর A8–A15 নিচ থেকে ওপরে; তাই pin নম্বর আন্দাজ না করে ছবি থেকে পড়ুন।

নিচের টেবিলে দল ধরে প্রতিটি pin. “দিক” কলামে I = input (chip-এর ভেতরে আসে), O = output (chip থেকে বেরোয়), I/O = দুই দিকেই।

দলPin (নম্বর)দিককাজ
BusAD0–AD7 (১২–১৯)I/OT1-এ ঠিকানার নিচের byte, T2–T3-এ data; একে বলে multiplexed bus
BusA8–A15 (২১–২৮)Oঠিকানার ওপরের byte; I/O cycle-এ port-এর নম্বর
নিয়ন্ত্রণALE (৩০)OAddress Latch Enable: T1-এ 1, “AD-তে এখন ঠিকানা”
নিয়ন্ত্রণRD (৩২), WR (৩১)OActive-low: পড়া বা লেখার মুহূর্ত
StatusIO/M (৩৪), S1 (৩৩), S0 (২৯)Oকোন ধরনের machine cycle চলছে (অংশ ৪)
নিয়ন্ত্রণREADY (৩৫)I0 হলে CPU অপেক্ষা করে (wait state)
DMAHOLD (৩৯), HLDA (৩৮)I, Oঅন্য যন্ত্র bus চায়; CPU ছেড়ে দিয়ে জানায়
InterruptTRAP (৬), RST 7.5 (৭), RST 6.5 (৮), RST 5.5 (৯), INTR (১০)Iপাঁচটি interrupt অনুরোধ; বিস্তারিত পর্ব ১৩-তে
InterruptINTA (১১)OActive-low: INTR মেনে নেওয়ার সংকেত
SerialSID (৫), SOD (৪)I, Oএক বিটের serial in আর out, RIM/SIM দিয়ে
ClockX1, X2 (১, ২), CLK (৩৭)I, OCrystal জোড়ার pin; CLK = ভেতরের clock, বাইরের chip-এর জন্য
ResetRESET IN (৩৬), RESET OUT (৩)I, OActive-low reset input; reset চলছে জানানোর output
PowerVCC (৪০), VSS (২০)—+5 V আর ground

একটি জিনিস খেয়াল করুন: ঠিকানার লাইন ১৬টি (address bus A0–A15), তাই 216 = 65,536টি ঠিকানা, অর্থাৎ 64 KB memory. Data bus ৮ বিটের। কিন্তু ঠিকানার নিচের আটটি লাইন আর data-র আটটি লাইন একই pin ভাগ করে। কেন, আর তার দাম কী, সেটাই অংশ ৩-এর বিষয়।

Intel 8085 বাজারে আসে ১৯৭৬ সালে, ১৯৭৪ সালের 8080-এর উত্তরসূরি হিসেবে। নামের “5” নিয়ে প্রায়ই বলা হয় যে এটি একটিমাত্র +5 V supply-র ইঙ্গিত, কারণ 8080-এর লাগত তিনটি আলাদা ভোল্টেজ। এখানে যে datasheet ব্যবহার হয়েছে, সেটি পরের HMOS সংস্করণ 8085AH-এর (১৯৮৭); সেখানে লেখা আছে এটি পুরোনো 8085A-এর চেয়ে প্রায় ২০% কম power নেয়, আর 8080A-র software পুরোপুরি চালাতে পারে। Pin-এর বিন্যাস সব সংস্করণে একই।

২ · Clock, reset আর power — হৃৎস্পন্দন আর ঘুম ভাঙা

8085-এর ভেতরেই clock তৈরির circuit আছে; বাইরে শুধু X1 আর X2 pin-এ একটি crystal (বা LC, RC circuit) জুড়তে হয়। Datasheet-এর গুরুত্বপূর্ণ বাক্য: X1, X2-এর frequency ২ দিয়ে ভাগ হয়ে ভেতরের clock হয়। তাই crystal-এর frequency হতে হয় কাঙ্ক্ষিত clock-এর দ্বিগুণ। ভেতরের clock CLK pin (৩৭) দিয়ে বাইরেও আসে, যাতে অন্য chip একই তালে চলতে পারে। Clock-এর এক পর্যায় (এক period) হলো একটি T-state.

Datasheet তিনটি সংস্করণের কথা বলে: 8085AH-এর মূল clock ৩ MHz (৬ MHz crystal), 8085AH-2-এর ৫ MHz (১০ MHz crystal), 8085AH-1-এর ৬ MHz (১২ MHz crystal). এই কোর্সের সব হিসাব ৩ MHz clock ধরে, reference README-র নিয়মে: ১ T-state = 0.333 µs. নিচের ব্লক তিনটি chip-এর T-state আর আমাদের প্রথম program-এর সময় হিসাব করে।

# Crystal থেকে CLK আর T-state; একটি program-এর সময় (Intel datasheet: X1/X2 ÷ 2)
chips = [("8085AH", 6), ("8085AH-2", 10), ("8085AH-1", 12)]   # crystal, MHz
for name, xtal in chips:
    clk = xtal / 2                       # ভেতরে 2 দিয়ে ভাগ
    t_ns = 1000 / clk                    # এক T-state, ns
    print(f"{name:9} crystal {xtal:2} MHz -> CLK {clk:.0f} MHz, T = {t_ns:.1f} ns,"
          f" STA (13 T) = {13 * t_ns / 1000:.2f} µs")

T = 1 / 3                                # µs, 3 MHz clock (কোর্সের মান)
prog = [("MVI A,32H", 7), ("STA 2050H", 13), ("HLT", 5)]
total = 0
for ins, t in prog:
    total += t
    print(f"{ins:10} {t:2} T = {t * T:5.2f} µs   (মোট {total:2} T)")
print(f"পুরো program: {total} T = {total * T:.2f} µs")
print(f"এক সেকেন্ডে এমন program: {int(1e6 / (total * T))} বার")

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

8085AH    crystal  6 MHz -> CLK 3 MHz, T = 333.3 ns, STA (13 T) = 4.33 µs
8085AH-2  crystal 10 MHz -> CLK 5 MHz, T = 200.0 ns, STA (13 T) = 2.60 µs
8085AH-1  crystal 12 MHz -> CLK 6 MHz, T = 166.7 ns, STA (13 T) = 2.17 µs
MVI A,32H   7 T =  2.33 µs   (মোট  7 T)
STA 2050H  13 T =  4.33 µs   (মোট 20 T)
HLT         5 T =  1.67 µs   (মোট 25 T)
পুরো program: 25 T = 8.33 µs
এক সেকেন্ডে এমন program: 120000 বার

পরীক্ষায় সবচেয়ে সাধারণ ভুল হলো crystal-এর frequency দিয়েই T-state হিসাব করা: ৬ MHz ধরলে T = 166.7 ns, আর সব সময় অর্ধেক আসে। সঠিক নিয়ম: আগে ২ দিয়ে ভাগ, তারপর উল্টো। ৭, ১৩ আর ৫ T-state সংখ্যাগুলো কোর্সের simulator-এর (অংশ ৬-এ সত্যিকারের run); ব্লকটি শুধু সেগুলোকে সময়ে বদলেছে। শেষ লাইনটি দেখায়, ৩ MHz-এর একটি chip এক সেকেন্ডে এই ছোট program এক লাখ বিশ হাজার বার চালাতে পারত।

প্রথম তিন লাইনের শেষ কলাম দেখায়, একই নির্দেশ (১৩ T) দ্রুত chip-এ কম সময় নেয়, কিন্তু T-state-এর সংখ্যা বদলায় না। Program-এর গঠন আর chip-এর গতি, দুটো আলাদা প্রশ্ন: প্রথমটির উত্তর T-state, দ্বিতীয়টির উত্তর clock.

Datasheet আরেকটি সীমাও দেয়, যা অনেকে খেয়াল করেন না: 8085AH-এর clock period (tCYC) সর্বনিম্ন 320 ns, আবার সর্বোচ্চ 2000 ns. অর্থাৎ clock ৫০০ kHz-এর চেয়ে ধীর করা যায় না; ইচ্ছেমতো ধীর clock দিয়ে হাতে হাতে এক এক ধাপ চালানোর চেষ্টা এই chip-এ নিয়মের বাইরে। Program ধাপে ধাপে দেখার নিরাপদ উপায় তাই software-এ (যেমন কোর্সের simulator-এর trace), বা hardware-এ READY দিয়ে প্রতিটি machine cycle থামিয়ে রাখা, clock থামিয়ে নয়।

Reset. RESET IN (pin ৩৬) 0 করলে, datasheet অনুযায়ী, program counter শূন্য হয়, interrupt enable আর HLDA flip-flop বন্ধ হয়, আর bus ও নিয়ন্ত্রণ-লাইনগুলো tri-state (ভাসমান) হয়ে যায়। তাই reset-এর পরে CPU সবসময় 0000H থেকে প্রথম নির্দেশ আনে; সেখানে ROM থাকতেই হয়। কোর্সের simulator-এর reset অবস্থা Spec decision 6-এ লেখা (সব register 00H, SP = 0000H, RST 7.5/6.5/5.5 masked); আসল chip-এ datasheet সতর্ক করে যে reset অসমলয়ে আসে বলে ভেতরের register-এর মান অনিশ্চিত হতে পারে, তাই program কখনো reset-এর পরের register মানের ওপর ভরসা করে না।

Input-টি Schmitt trigger, তাই একটি সাধারণ resistor-capacitor জোড়া দিয়েই power-on reset বানানো যায়: datasheet-এর নমুনায় R = 75 kΩ, C = 1 µF, সঙ্গে একটি diode. নিয়ম দুটি: power আসার পরে VCC তার সর্বনিম্ন মানে পৌঁছানোর পরও অন্তত 10 ms RESET IN নিচু রাখতে হবে, আর চালু অবস্থায় reset দিতে হলে অন্তত তিনটি clock period. RESET OUT (pin ৩) জানায় যে CPU reset অবস্থায় আছে; এটি clock-এর সঙ্গে মেলানো, তাই বাইরের peripheral chip-কে একসঙ্গে reset করতে এটাই ব্যবহার হয়। VCC একটিমাত্র +5 V supply (±১০%), যা ১৯৭৪ সালের 8080-এর তিনটি supply-এর তুলনায় বড় সরলীকরণ ছিল।

৩ · Multiplexed bus আর ALE — এক জানালায় দুই কাজ

8085-এর ঠিকানা ১৬ বিট, data ৮ বিট, মোট ২৪টি লাইন। সঙ্গে নিয়ন্ত্রণ, interrupt, clock, power মিলিয়ে ৪০ pin-এ আঁটানো কঠিন। Intel-এর সমাধান: ঠিকানার নিচের ৮টি বিট আর data একই ৮টি pin ভাগ করবে, সময় ভাগ করে। একটি machine cycle-এর প্রথম T-state (T1)-এ AD0–AD7-এ থাকে ঠিকানার নিচের byte; T2 আর T3-এ একই pin data bus. বাইরে memory chip-এর কিন্তু পুরো cycle জুড়ে স্থির ঠিকানা দরকার। তাই T1-এর ঠিকানাটি কোথাও ধরে রাখতে হয়। এই কাজের নাম demultiplexing, আর যন্ত্রটি একটি ৮ বিটের latch.

কখন ধরে রাখতে হবে, তা বলে ALE (Address Latch Enable, pin ৩০). Datasheet অনুযায়ী ALE প্রতিটি machine cycle-এর প্রথম clock state-এ আসে, আর এর নামার কিনারা (falling edge) এমনভাবে রাখা যাতে ঠিকানার setup আর hold সময় নিশ্চিত হয়। ALE কখনো tri-state হয় না।

ছবি ৮.২ — ALE আর latch দিয়ে AD bus আলাদা করা

74LS373-এর মতো transparent latch; G = enable, OE = output চালু

ALE আর latch দিয়ে AD bus আলাদা করা 8085 74LS373 OE = 0 D G AD7–0 ALE latch D7–D0 A7–A0 A15–A8
ছবি ৮.২ — AD0–AD7 দুই জায়গায় যায়: সরাসরি memory-র data pin-এ, আর latch-এর D input-এ। ALE = 1 থাকা পর্যন্ত latch স্বচ্ছ, ঠিকানা ভেতর দিয়ে বেরোয়; ALE নামলেই latch শেষ মানটি ধরে রাখে, আর T2–T3-এ AD-তে data এলেও A0–A7 বদলায় না। Datasheet-এর Figure 9 এই সংযোগই দেখায় (সেখানে শুধু “LATCH” লেখা); বাস্তবে 74LS373 বা Intel-এর 8212 বহুল ব্যবহৃত।

কেন transparent latch, edge-triggered flip-flop নয়? দুটোই কাজ করে, কিন্তু transparent latch-এ ঠিকানা ALE ওঠার সঙ্গে সঙ্গেই বাইরে পৌঁছায়, ফলে memory আগেভাগে ঠিকানা decode শুরু করতে পারে। Latch আর flip-flop-এর পার্থক্যের তত্ত্ব Computer Architecture পর্ব ১৫-এ। আর Intel-এর নিজের 8155/8156 (RAM + I/O) আর 8755A (EPROM + I/O) chip-এর ভেতরেই এই latch আছে; datasheet বলে 8085AH, 8156H আর 8755A মিলে মাত্র তিনটি chip-এ একটি পূর্ণ system হয়। সেখানে ALE সরাসরি ওই chip-গুলোর ALE pin-এ যায়।

Latch বাছাইয়ে datasheet-এর সংখ্যাগুলো কাজে লাগে। 8085AH-এর A.C. characteristics অনুযায়ী (320 ns clock-এ মাপা) ALE-এর প্রস্থ অন্তত 140 ns, ALE নামার অন্তত 90 ns আগে থেকে AD0–AD7-এর ঠিকানা স্থির, আর ALE নামার পরেও অন্তত 100 ns ঠিকানা থাকে। তার মানে latch-কে এই ছোট জানালার মধ্যে ঠিকানা ধরে ফেলতে হবে: তার setup সময় 90 ns-এর কম আর hold সময় 100 ns-এর কম হলেই নিরাপদ। সাধারণ TTL latch এই সীমার মধ্যে সহজেই কাজ করে। দ্রুত সংস্করণ 8085AH-1-এ একই সংখ্যাগুলো অনেক ছোট (যেমন ALE-এর প্রস্থ অন্তত 50 ns), তাই সেখানে latch-ও দ্রুত হতে হয়। নকশার নিয়মটি সাধারণ: CPU যে সময় দেয়, বাইরের প্রতিটি chip-এর প্রয়োজন তার চেয়ে কম হতে হবে।

সাধারণ ভুল: ALE-কে “T2-তে data latch করার সংকেত” ভাবা। ALE ঠিকানা ধরে, data নয়; আর এটি শুধু T1-এ। দ্বিতীয় ভুল: latch বাদ দিয়ে AD0–AD7 সরাসরি memory-র A0–A7-এ জোড়া। তখন T2–T3-এ data আসার সঙ্গে সঙ্গে memory-র ঠিকানা বদলে যায়, আর ভুল ঘর পড়া হয়। এমন board প্রথম কয়েকটি নির্দেশ ঠিক চালাতেও পারে, কাকতালীয়ভাবে, যা ভুলটিকে আরও লুকিয়ে রাখে।

৪ · IO/M, S1, S0 — কোন ধরনের machine cycle চলছে

CPU একবার memory বা I/O-তে যাওয়ার কাজকে বলে machine cycle. একটি নির্দেশ এক থেকে পাঁচটি machine cycle নেয়। Datasheet বলছে ৭ ধরনের machine cycle সম্ভব, আর কোনটি চলছে তা ঠিক করে তিনটি status signal: IO/M, S1, S0. এরা machine cycle-এর শুরুতে (T1) ঠিক হয় আর পুরো cycle জুড়ে স্থির থাকে, তাই বাইরের circuit আগে থেকেই প্রস্তুত হতে পারে। RD আর WR আসে পরে, ঠিক লেনদেনের মুহূর্তে।

Machine cycleIO/MS1S0RDWRINTAT-state
Opcode fetch (OF)011011৪ বা ৬
Memory read (MR)010011৩
Memory write (MW)001101৩
I/O read (IOR)110011৩
I/O write (IOW)101101৩
INTR স্বীকার (INA)111110৬
Bus idle (BI), যেমন DAD010111৩
Haltz00zz1—

টেবিলটি Intel datasheet-এর Table 3 (z = tri-state). তিনটি জিনিস মনে রাখার মতো। এক, S1 S0 = 1 1 মানে fetch, 1 0 মানে read, 0 1 মানে write, 0 0 মানে halt: S1-কে datasheet “আগাম read/write খবর” বলে। দুই, opcode fetch আর memory read-এ বাইরের সংকেত একই রকম (IO/M = 0, RD = 0); শুধু S0 দেখে বোঝা যায় এটি নির্দেশের প্রথম byte কি না। তিন, DAD-এর bus idle cycle-এ status দেখতে memory read-এর মতো, কিন্তু RD বা WR কিছুই নামে না, আর datasheet-এর Table 4-এর নোট অনুযায়ী DAD-এর দ্বিতীয় আর তৃতীয় cycle-এ ALE-ও তৈরি হয় না।

Memory আর I/O chip-এর জন্য বাইরে প্রায়ই চারটি আলাদা active-low সংকেত বানানো হয়: MEMR, MEMW, IOR, IOW. 8085 memory আর I/O-এর জন্য আলাদা ঠিকানা-জগৎ রাখতে পারে, যাকে বলে isolated বা port-mapped I/O (তত্ত্ব Computer Architecture পর্ব ৫১-এ, আর 8085-এর ব্যবহারিক দিক এই কোর্সের পর্ব ২৩-এ)। সংকেত চারটি তৈরি হয় IO/M আর RD/WR থেকে:

  1. MEMR = RD OR IO/M: memory read-এ RD = 0, IO/M = 0, তাই OR-এর ফল 0, অর্থাৎ সক্রিয়।
  2. MEMW = WR OR IO/M.
  3. IOR = RD OR (NOT IO/M): I/O read-এ IO/M = 1, তার উল্টো 0, RD = 0, তাই ফল 0.
  4. IOW = WR OR (NOT IO/M).

চারটি OR gate আর একটি NOT gate, বা একটি 74LS138 decoder দিয়েও কাজটি হয় (decoder-এর তত্ত্ব Computer Architecture পর্ব ১২-এ)। এই নকশার পুরো truth table অনুশীলন ১-এ।

৫ · Machine cycle আর T-state — opcode fetch ধাপে ধাপে

প্রতিটি নির্দেশ শুরু হয় একটি opcode fetch দিয়ে: program counter-এর ঠিকানা থেকে নির্দেশের প্রথম byte, অর্থাৎ opcode, আনা। Datasheet বলে, একটি machine cycle সাধারণত তিনটি T-state, ব্যতিক্রম opcode fetch, যা সাধারণত চারটি বা ছয়টি। প্রথম তিনটি T-state-এ bus-এর কাজ, শেষেরগুলোতে CPU ভেতরে opcode decode করে (datasheet-এর Table 4-এ T4–T6-এ AD bus tri-state). একটি নির্দেশের সব machine cycle মিলে হয় instruction cycle.

নিচের stepper-এ ঠিকানা 2000H থেকে MVI A,32H-এর opcode 3EH আনা হচ্ছে, যা দেখানো হয়েছে একটি timing diagram-এ: বাঁ থেকে ডানে সময়, প্রতিটি সারিতে একটি সংকেত। একক লাইনের সংকেতে উঁচু = 1, নিচু = 0. Bus-এর সারিতে ষড়ভুজের ভেতরে মান লেখা; ড্যাশ দেওয়া মাঝের লাইন মানে ভাসমান (tri-state), আর “xx” মানে অনির্দিষ্ট। ছবিটি চওড়া, ফোনে পাশে টেনে দেখুন।

8085-এর opcode fetch machine cycle M1 OF T1 T2 T3 T4 CLK A15–A8 AD7–AD0 ALE RD IO/M S1 S0 20H xx 00H 3EH 11
এই T-state-এ pin-এর অবস্থা
A15–A8
AD7–AD0
ALE · RD
IO/M S1 S0
  1. T1: ঠিকানা বাইরে. PC = 2000H: ওপরের byte 20H যায় A15–A8-এ, নিচের byte 00H যায় AD7–AD0-এ। ALE = 1, তাই latch ঠিকানা নেয়, আর ALE নামার সময় ধরে রাখে। একই মুহূর্তে IO/M = 0, S1 S0 = 1 1: বাইরের জগৎ জানল, এটি memory থেকে opcode fetch.
  2. T2: পড়ার নির্দেশ. ALE = 0, AD bus কিছুক্ষণ ভাসমান (CPU ঠিকানা সরিয়ে নিল), তারপর RD = 0. Memory latch-এ রাখা ঠিকানা 2000H পড়ে opcode 3EH AD bus-এ রাখে। এই T-state-এই CPU READY দেখে: READY = 0 হলে এখানে wait state ঢোকে (অংশ ৭)। ফাঁকে PC বেড়ে 2001H হয়।
  3. T3: opcode ভেতরে. AD bus-এ স্থির 3EH. CPU সেটি instruction register (IR)-এ নেয়, আর T3-এর শেষ দিকে RD আবার 1 হয়। ঠিকানা A15–A8 এখনো 20H, কারণ memory-কে পুরো সময় স্থির ঠিকানা দিতে হয়।
  4. T4: decode. Bus-এর কাজ শেষ: AD ভাসমান, A15–A8 অনির্দিষ্ট (datasheet-এর Table 4 আর নোট ১), কিন্তু IO/M আর S1 S0 স্থির থাকে। ভেতরে decoder বোঝে 3EH = MVI A, আর এর পরে memory থেকে আরও এক byte আনতে হবে। তাই এর পরে আসবে একটি memory read cycle.

পরীক্ষায় timing diagram আঁকতে বললে এই ক্রমে এগোলে ভুল কম হয়:

  1. নির্দেশের byte গুনে machine cycle-এর তালিকা করুন: প্রতিটি byte পড়তে একটি (প্রথমটি OF), তারপর data পড়া বা লেখার cycle.
  2. প্রতিটি cycle-এর T-state-এর ঘর আঁকুন: OF ৪ (বা ৬), বাকিগুলো ৩; ওপরে M1, M2 … লিখুন।
  3. প্রতিটি cycle-এর T1-এ ALE-এর একটি pulse, আর A15–A8 ও AD7–AD0-এ ঠিকানা লিখুন।
  4. Read cycle-এ T2–T3-এ RD নিচু আর AD-তে memory-র data; write cycle-এ WR নিচু আর AD-তে CPU-র data.
  5. পুরো cycle জুড়ে IO/M আর S1 S0-এর মান লিখুন, শেষে মোট T-state যোগ করে সময়ে বদলান।

উপমা — স্কুলের ঘণ্টা, পিরিয়ড আর দিন: T-state হলো দেয়ালঘড়ির এক টিক, সবচেয়ে ছোট একক। Machine cycle একটি পিরিয়ড: কয়েকটি টিক জুড়ে একটি নির্দিষ্ট কাজ, যেমন “বাংলা ক্লাস” বা “অঙ্ক ক্লাস”; শুরুতে ঘণ্টা বাজে (ALE), যাতে সবাই জানে নতুন পিরিয়ড শুরু হলো, আর বোর্ডে লেখা থাকে কোন ক্লাস (IO/M, S1, S0). Instruction cycle পুরো একটি দিনের রুটিন: কয়েকটি পিরিয়ড মিলে একটি কাজ সম্পূর্ণ। পরীক্ষায় তিনটি শব্দ গুলিয়ে ফেলা খুব সাধারণ, এই ক্রমটি মনে রাখলে ভুল হয় না: টিক < পিরিয়ড < দিন।

কোন নির্দেশে opcode fetch ছয়টি T-state? যেগুলোর ভেতরে ১৬ বিটের কাজ আছে, যেমন INX, DCX, SPHL, PCHL, আর stack-এ লেখার আগে SP কমাতে হয় এমন PUSH, CALL, RST, সঙ্গে শর্তযুক্ত CALL আর RET. এগুলোতে T5–T6-এ bus অলস থাকে, ভেতরে কাজ চলে। নিচের ব্লক কয়েকটি নির্দেশকে machine cycle-এ ভাঙে আর যোগফল মেলায় কোর্সের simulator-এর T-state টেবিলের সঙ্গে, যা Spec decision 2 মেনে চলে। নিয়মগুলো Intel-এর 8080/8085 manual-এর টেবিল থেকে।

# নির্দেশ -> machine cycle-এর ক্রম (Intel 8080/8085 manual); যোগফল = T-state
LEN = {"OF": 4, "OF6": 6, "MR": 3, "MW": 3, "IOR": 3, "IOW": 3, "BI": 3}
RULE = {"MVI": "OF MR", "LXI": "OF MR MR", "LDA": "OF MR MR MR",
        "STA": "OF MR MR MW", "LHLD": "OF MR MR MR MR", "SHLD": "OF MR MR MW MW",
        "LDAX": "OF MR", "STAX": "OF MW", "IN": "OF MR IOR", "OUT": "OF MR IOW",
        "JMP": "OF MR MR", "CALL": "OF6 MR MR MW MW", "RET": "OF MR MR",
        "PUSH": "OF6 MW MW", "POP": "OF MR MR", "RST": "OF6 MW MW",
        "XTHL": "OF MR MR MW MW", "DAD": "OF BI BI", "INX": "OF6", "DCX": "OF6",
        "SPHL": "OF6", "PCHL": "OF6"}
IMM = {"ADI", "ACI", "SUI", "SBI", "ANI", "XRI", "ORI", "CPI"}
COND = {"NZ", "Z", "NC", "C", "PO", "PE", "P", "M"}

def cycles(ins, taken=True):
    op, _, arg = ins.partition(" ")
    if op == "MVI" and arg.startswith("M"): c = "OF MR MW"
    elif op in RULE: c = RULE[op]
    elif op in IMM: c = "OF MR"
    elif op == "MOV": c = "OF MR" if arg.endswith("M") else ("OF MW" if arg.startswith("M") else "OF")
    elif op in ("INR", "DCR"): c = "OF MR MW" if arg == "M" else "OF"
    elif op[0] == "J" and op[1:] in COND: c = "OF MR MR" if taken else "OF MR"     # শর্তযুক্ত jump
    elif op[0] == "C" and op[1:] in COND: c = "OF6 MR MR MW MW" if taken else "OF6 MR"
    elif op[0] == "R" and op[1:] in COND: c = "OF6 MR MR" if taken else "OF6"     # শর্তযুক্ত return
    else: c = "OF MR" if arg == "M" else "OF"                  # ALU r/M, অন্যগুলো
    return c.split()

TSTATE = {"MVI A,32H": 7, "STA 2050H": 13, "LDA 2050H": 13, "MOV A,M": 7,
          "INX H": 6, "PUSH B": 12, "CALL 2100H": 18, "DAD B": 10, "OUT 02H": 10}
for ins, t in TSTATE.items():
    cs = cycles(ins)
    s = sum(LEN[c] for c in cs)
    print(f"{ins:10} {len(cs)} cycle: {' + '.join(f'{c}({LEN[c]})' for c in cs)} = {s} {'✓' if s == t else '✗'}")
for ins, t in [("JNZ 2000H", 7), ("CNZ 2100H", 9), ("RNZ", 6)]:
    cs = cycles(ins, taken=False)
    print(f"{ins:10} শর্ত মেলেনি: {' + '.join(cs)} = {sum(LEN[c] for c in cs)} (table: {t})")

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

MVI A,32H  2 cycle: OF(4) + MR(3) = 7 ✓
STA 2050H  4 cycle: OF(4) + MR(3) + MR(3) + MW(3) = 13 ✓
LDA 2050H  4 cycle: OF(4) + MR(3) + MR(3) + MR(3) = 13 ✓
MOV A,M    2 cycle: OF(4) + MR(3) = 7 ✓
INX H      1 cycle: OF6(6) = 6 ✓
PUSH B     3 cycle: OF6(6) + MW(3) + MW(3) = 12 ✓
CALL 2100H 5 cycle: OF6(6) + MR(3) + MR(3) + MW(3) + MW(3) = 18 ✓
DAD B      3 cycle: OF(4) + BI(3) + BI(3) = 10 ✓
OUT 02H    3 cycle: OF(4) + MR(3) + IOW(3) = 10 ✓
JNZ 2000H  শর্ত মেলেনি: OF + MR = 7 (table: 7)
CNZ 2100H  শর্ত মেলেনি: OF6 + MR = 9 (table: 9)
RNZ        শর্ত মেলেনি: OF6 = 6 (table: 6)

প্রতিটি যোগফল simulator-এর টেবিলের সঙ্গে মিলেছে। কয়েকটি লক্ষ করুন। LDA আর STA দুটোই ১৩ T, পার্থক্য শুধু শেষ cycle-এ: একটি read, অন্যটি write. INX H-এ memory-তে যাওয়াই নেই, তবু ৬ T. DAD-এর দুটি bus idle cycle-এ CPU ১৬ বিটের যোগ করে, bus ব্যবহার না করে। আর শর্তযুক্ত jump-এ শর্ত না মিললে 8085 ঠিকানার দ্বিতীয় byte আর পড়ে না, তাই ১০-এর জায়গায় ৭. লেখকের lab-এ একই cycles() function কোর্সের sim8085.py-এর ২৪৬টি opcode-এর প্রতিটিতে, শর্ত মেলা আর না মেলা দুই ক্ষেত্রেই, চালানো হয়েছে: ৪৯২টি তুলনার সবগুলো মিলেছে (HLT-কে opcode fetch-এর ৪ T আর এক T-state halt হিসেবে ধরে; Intel মোট ৫ T বলে)।

৬ · MVI A,32H আর STA 2050H — পুরো timing diagram

এখন দুটি পূর্ণ নির্দেশ। আগে সত্যিকারের run: কোর্সের 8085 simulator-এ (পরিচয় পর্ব ০৬-এ) program assemble করে চালানো (সত্যিকারের run, sim8085.py, কোর্সের reference lab, Python 3.13.5; ফাইল mvista.asm, লেখকের lab-এ)।

$ python -B sim8085.py asm mvista.asm
2000               3          ORG 2000H
2000  3E 32        4  START:  MVI A,32H       ; OF + MR       = 7 T
2002  32 50 20     5          STA 2050H       ; OF + MR + MR + MW = 13 T
2005  76           6          HLT             ; 5 T

$ python -B sim8085.py trace mvista.asm
2000  3E 32     MVI A,32H      A=32 … PC=2002 … T=7  total=7
2002  32 50 20  STA 2050H      A=32 … PC=2005 … T=13 total=20
2005  76        HLT            A=32 … PC=2006 … T=5  total=25
Memory 2050H..2050H:
  2050H: 32
Instructions: 3   T-states: 25

(Trace-এর লাইনগুলো ছোট করা: …-এর জায়গায় B থেকে L, SP আর flag, যার সবই 00 বা 0.) Listing থেকে memory-র byte-গুলো পাওয়া গেল: 2000H-এ 3E, 2001H-এ 32, তারপর 2002H থেকে 32 50 20. লক্ষ করুন, STA-র opcode-ও 32H, আর data-ও 32H: একই byte, ভিন্ন অর্থ; কোনটি কী, তা ঠিক করে কোন machine cycle-এ byte-টি এলো। ঠিকানা 2050H memory-তে উল্টো ক্রমে বসে, 50 আগে, 20 পরে (little-endian, পর্ব ০৫)।

MVI A,32H-এর timing diagram M1 OF T1 T2 T3 T4 M2 MR T1 T2 T3 CLK A15–A8 AD7–AD0 ALE RD IO/M S1 S0 20H xx 20H 00H 3EH 01H 32H 11 10
CPU-র ভেতরে আর bus-এ
Bus-এ ঠিকানা
AD-তে data
IR · A
PC
মোট T
  1. M1, T1. Opcode fetch শুরু: ঠিকানা 2000H, ALE = 1, IO/M S1 S0 = 0 1 1. ঠিক আগের stepper-এর প্রথম ধাপ।
  2. M1, T2–T3. RD = 0, memory দেয় 3EH, যা IR-এ যায়। PC বেড়ে 2001H. A এখনো 00H.
  3. M1, T4. Decode: 3EH মানে “A-তে একটি immediate byte”. Bus চুপ। CPU ঠিক করে, পরের machine cycle হবে memory read, ঠিকানা PC = 2001H.
  4. M2, T1. নতুন machine cycle, তাই আবার ALE = 1 আর নতুন ঠিকানা 2001H. এবার S1 S0 = 1 0, অর্থাৎ memory read, opcode নয়। এই cycle-এ T4 নেই।
  5. M2, T2–T3. Memory দেয় 32H, যা সরাসরি A-তে যায়; PC হয় 2002H, পরের নির্দেশের ঠিকানা। মোট ৪ + ৩ = ৭ T = 7 × 0.333 µs = 2.33 µs, simulator-এর T=7-এর সঙ্গে মিল।

STA 2050H তিন byte-এর নির্দেশ: opcode, তারপর ঠিকানার নিচের byte, তারপর ওপরের byte. CPU-কে আগে তিনটি byte পড়তে হয়, তারপর লিখতে হয়। ঠিকানার byte দুটি CPU রাখে ভেতরের দুটি অস্থায়ী register-এ, যাদের পাঠ্যবইয়ে প্রায়ই W আর Z বলা হয় (programmer এগুলো সরাসরি দেখতে পান না)।

STA 2050H-এর timing diagram M1 OF T1 T2 T3 T4 M2 MR T1 T2 T3 M3 MR T1 T2 T3 M4 MW T1 T2 T3 CLK A15–A8 AD7–AD0 ALE RD WR IO/M S1 S0 20H xx 20H 20H 20H 02H 32H 03H 50H 04H 20H 50H 32H 11 10 10 01
Machine cycle ধরে
Cycle · ঠিকানা
AD-তে data
[2050H]
মোট T · সময়
  1. M1: opcode fetch, ৪ T. ঠিকানা 2002H থেকে 32H আসে IR-এ। Decode বলে: STA, আরও দুটি byte লাগবে। মোট ৪ T = 1.33 µs.
  2. M2: memory read, ৩ T. ঠিকানা 2003H থেকে 50H, ভেতরের Z register-এ। এটি গন্তব্যের নিচের byte.
  3. M3: memory read, ৩ T. ঠিকানা 2004H থেকে 20H, W-তে। এখন CPU জানে গন্তব্য W Z = 2050H. মোট ১০ T.
  4. M4: memory write, ৩ T. এবার ঠিকানা আসে PC থেকে নয়, W Z থেকে: A15–A8 = 20H, AD-তে T1-এ 50H. S1 S0 = 0 1. T2-তে CPU নিজেই AD-তে data 32H রাখে আর WR = 0 করে; RD পুরো সময় 1. Datasheet বলে data WR-এর পেছনের কিনারায় (ওঠার মুহূর্তে) স্থির থাকে, memory তখনই লেখে।
  5. মোট. ৪ + ৩ + ৩ + ৩ = ১৩ T = 13 × 0.333 µs = 4.33 µs. Memory-তে [2050H] = 32H, simulator-এর 2050H: 32-এর সঙ্গে মিল। Read cycle-এ AD bus ঠিকানা আর data-র মাঝে ভাসমান হয়, write cycle-এ হয় না: data দেয় CPU নিজেই, তাই দিক বদলের দরকার নেই।

পাঁচ ধরনের machine cycle পাশাপাশি রাখলে পার্থক্য স্পষ্ট হয়। সব তথ্য datasheet-এর Table 3, Table 4 আর basic system timing অংশ থেকে:

CycleTT1-এ ঠিকানাT2–T3-এ AD চালায়নামে
OF৪/৬PCMemory (opcode)RD
MR৩PC, HL বা W ZMemory (data)RD
MW৩HL, SP বা W ZCPU (data)WR
IOR৩Port, দুই অর্ধেকেইI/O যন্ত্রRD
IOW৩Port, দুই অর্ধেকেইCPU (data)WR

“T1-এ ঠিকানা” কলামটি মনে রাখার মতো: নির্দেশের byte আনার সময় ঠিকানা আসে PC থেকে, কিন্তু data-র ঠিকানা আসে নির্দেশের ধরন অনুযায়ী অন্য জায়গা থেকে: MOV A,M-এ HL, PUSH-এ SP, STA/LDA-তে নির্দেশের ভেতর থেকে পড়া W Z. ঠিকানার এই উৎসগুলোই পর্ব ১০-এর addressing mode.

Timing diagram ছবিতে থাকে, কিন্তু logic analyzer দেয় টেবিল: প্রতিটি clock-এ প্রতিটি লাইনের মান। নিচের ব্লক একই দুটি নির্দেশের ২০টি T-state-এর এমন একটি টেবিল ছাপে, datasheet-এর Table 3 আর Table 4-এর নিয়ম মেনে (zz = ভাসমান, xx = অনির্দিষ্ট)। এটি একটি সরল মডেল: প্রতিটি সংকেতের এক T-state-এর ভেতরের নির্দিষ্ট মুহূর্ত দেখায় না।

# MVI A,32H; STA 2050H — প্রতিটি T-state-এ bus-এ কী থাকে (Intel datasheet Table 3, 4)
mem = {0x2000: 0x3E, 0x2001: 0x32, 0x2002: 0x32, 0x2003: 0x50, 0x2004: 0x20}
STATUS = {"OF": "0 11", "MR": "0 10", "MW": "0 01"}         # IO/M, S1 S0
A = 0
cycles = [("OF", 0x2000), ("MR", 0x2001),                  # MVI A,32H
          ("OF", 0x2002), ("MR", 0x2003), ("MR", 0x2004), ("MW", None)]
print("T   cycle  A15-8 AD7-0 ALE RD WR IO/M S1S0")
t = 0
for kind, addr in cycles:
    if kind == "MW":                                        # STA: ঠিকানা = W Z
        addr = mem[0x2004] << 8 | mem[0x2003]
    data = A if kind == "MW" else mem.get(addr, 0)
    n = 4 if kind == "OF" else 3
    for k in range(1, n + 1):
        t += 1
        hi, ad = f"{addr >> 8:02X}", f"{addr & 0xFF:02X}"   # T1: ঠিকানা
        rd = wr = "1"
        if k in (2, 3):
            ad = f"{data:02X}" if (k == 3 or kind == "MW") else "zz"
            if kind == "MW": wr = "0"
            else: rd = "0"
        if k == 4: hi, ad = "xx", "zz"                      # T4: decode
        ale = "1" if k == 1 else "0"
        io, s = STATUS[kind].split()
        print(f"{t:<3} {kind}-T{k}  {hi}    {ad}    {ale}   {rd}  {wr}  {io}    {s}")
    if kind == "MR" and addr == 0x2001: A = data            # MVI শেষ
    if kind == "MW": mem[addr] = data
print(f"মোট {t} T-state; A = {A:02X}H, [2050H] = {mem[0x2050]:02X}H")

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

T   cycle  A15-8 AD7-0 ALE RD WR IO/M S1S0
1   OF-T1  20    00    1   1  1  0    11
2   OF-T2  20    zz    0   0  1  0    11
3   OF-T3  20    3E    0   0  1  0    11
4   OF-T4  xx    zz    0   1  1  0    11
5   MR-T1  20    01    1   1  1  0    10
6   MR-T2  20    zz    0   0  1  0    10
7   MR-T3  20    32    0   0  1  0    10
8   OF-T1  20    02    1   1  1  0    11
9   OF-T2  20    zz    0   0  1  0    11
10  OF-T3  20    32    0   0  1  0    11
11  OF-T4  xx    zz    0   1  1  0    11
12  MR-T1  20    03    1   1  1  0    10
13  MR-T2  20    zz    0   0  1  0    10
14  MR-T3  20    50    0   0  1  0    10
15  MR-T1  20    04    1   1  1  0    10
16  MR-T2  20    zz    0   0  1  0    10
17  MR-T3  20    20    0   0  1  0    10
18  MW-T1  20    50    1   1  1  0    01
19  MW-T2  20    32    0   1  0  0    01
20  MW-T3  20    32    0   1  0  0    01
মোট 20 T-state; A = 32H, [2050H] = 32H

ALE-এর কলামে ছয়টি 1, প্রতিটি machine cycle-এর T1-এ একটি করে: ALE গুনেই machine cycle গোনা যায়। RD পাঁচবার নামে (তিনটি read আর দুটি fetch-এ), WR একবার। ১৮ নম্বর লাইনে ঠিকানা 2050H, যা আগের দুটি read থেকে আসা 50 আর 20 জোড়া লাগিয়ে তৈরি। সারির সংখ্যা ২০ = ৭ + ১৩, simulator-এর total=20 (HLT-এর আগে)।

আরও গভীরে: Datasheet-এর প্রথম পাতায় লেখা “1.3 µs instruction cycle (8085AH)” আসলে চার T-state-এর একটি opcode fetch: সর্বনিম্ন clock period 320 ns, আর 4 × 320 = 1280 ns ≈ 1.3 µs; 8085AH-2-এ 4 × 200 = 0.8 µs, 8085AH-1-এ 4 × 167 ≈ 0.67 µs. তাই বিজ্ঞাপনের “instruction cycle” মানে সবচেয়ে ছোট নির্দেশের সময়। Datasheet-এর A.C. characteristics প্রতিটি কিনারার সময় ns-এ দেয়, যেমন 8085AH-এ ALE-এর প্রস্থ (tLL) অন্তত 140 ns, আর Table 5 এগুলোকে T-এর সূত্রে লেখে, যাতে অন্য clock-এ হিসাব করা যায়। আমাদের পরের অংশের wait state-এর হিসাব এই টেবিল থেকেই।

৭ · READY, HOLD আর বাকি pin — সময় বদলানোর উপায়

READY আর wait state. 3 MHz-এ একটি read cycle-এ memory ঠিকানা পাওয়ার পর data দিতে সময় পায় সীমিত। Memory ধীর হলে সে READY (pin ৩৫) 0 করে রাখে, আর CPU T2-এর পরে এক বা একাধিক বাড়তি T-state অপেক্ষা করে, যার নাম wait state (TWAIT). READY আবার 1 হলে T3 শুরু হয়। Datasheet-এর Table 5 সময়টি দেয় সূত্রে: 8085AH-এর জন্য tAD (ঠিকানা বৈধ হওয়া থেকে data বৈধ হওয়া পর্যন্ত সর্বোচ্চ সময়) = (5/2 + N)·T − 225 ns, যেখানে N = wait state-এর সংখ্যা।

# ধীর memory-র জন্য কয়টি wait state? Intel 8085AH datasheet, Table 5:
# tAD (address থেকে data দেওয়ার সর্বোচ্চ সময়) = (5/2 + N)·T − 225 ns
import math

T = 1000 / 3                                   # ns, 3 MHz clock
def t_ad(n):
    return (2.5 + n) * T - 225

for n in range(3):
    print(f"N = {n} wait state: memory পায় সর্বোচ্চ {t_ad(n):6.1f} ns")

def waits_needed(access_ns):
    n = math.ceil((access_ns + 225) / T - 2.5)  # tAD(N) >= access
    return max(0, n)

for name, acc in [("RAM", 450), ("EPROM", 700), ("পুরোনো EPROM", 1000)]:
    n = waits_needed(acc)
    print(f"{name:13} {acc:5} ns -> N = {n}, প্রতিটি read cycle {3 + n} T"
          f" = {(3 + n) * T:6.1f} ns")

# STA 2050H-এর চারটি cycle-এ প্রতিটিতে 1টি করে wait state হলে
print("STA, 0 wait:", 13, "T;  1 wait/cycle:", 13 + 4, "T =",
      f"{(13 + 4) * T / 1000:.2f} µs")

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

N = 0 wait state: memory পায় সর্বোচ্চ  608.3 ns
N = 1 wait state: memory পায় সর্বোচ্চ  941.7 ns
N = 2 wait state: memory পায় সর্বোচ্চ 1275.0 ns
RAM             450 ns -> N = 0, প্রতিটি read cycle 3 T = 1000.0 ns
EPROM           700 ns -> N = 1, প্রতিটি read cycle 4 T = 1333.3 ns
পুরোনো EPROM   1000 ns -> N = 2, প্রতিটি read cycle 5 T = 1666.7 ns
STA, 0 wait: 13 T;  1 wait/cycle: 17 T = 5.67 µs

হিসাবের ধাপ, ৭০০ ns-এর EPROM-এর জন্য: (১) N = 0-তে সময় (2.5)(333.3) − 225 = 608.3 ns, যা ৭০০-এর কম, তাই চলবে না। (২) N = 1-এ 941.7 ns ≥ 700 ns, চলবে। (৩) তাই প্রতিটি read cycle ৩-এর জায়গায় ৪ T. এখানে ধরা হয়েছে memory-র access time-ই একমাত্র দেরি; বাস্তবে latch আর address decoder-এর দেরিও যোগ করতে হয়, তাই নকশায় হাতে কিছুটা সময় রাখা হয়। শেষ লাইন: STA-র চারটি cycle-এর প্রতিটিতে একটি wait state হলে ১৩ T হয় ১৭ T. সংখ্যাগুলো datasheet-এর সূত্র থেকে; কোর্সের simulator wait state মডেল করে না (Spec decision 2, “No wait states”).

Datasheet একটি ছোট circuit-ও দেখায় (Figure 6), যা দুটি D flip-flop দিয়ে প্রতিটি machine cycle-এ ঠিক একটি wait state ঢোকায়: ALE-এর পরে READY এক clock-এর জন্য নামে। পুরোনো ধীর EPROM-এর সঙ্গে দ্রুত 8085 চালানোর এটিই প্রচলিত উপায় ছিল।

HOLD আর HLDA. কখনো অন্য একটি যন্ত্র, যেমন একটি DMA controller, CPU-কে বাদ দিয়ে সরাসরি memory-তে data সরাতে চায়। সে HOLD (pin ৩৯) 1 করে। Datasheet অনুযায়ী CPU চলতি bus লেনদেন শেষ করে bus ছেড়ে দেয়: ঠিকানা, data, RD, WR আর IO/M tri-state হয়, আর HLDA (pin ৩৮) 1 হয়ে জানায় “bus এখন আপনার”. ভেতরের কাজ চলতে পারে, কিন্তু bus লাগলে CPU অপেক্ষা করে। HOLD নামলে HLDA নামে, আর তার আধা clock পরে CPU bus ফিরে নেয়। 8237 DMA controller দিয়ে পুরো ব্যবস্থা পর্ব ২৭-এ, আর DMA-র architecture-স্তরের তত্ত্ব Computer Architecture পর্ব ৫২-এ।

Interrupt আর serial pin, এক নজরে. TRAP, RST 7.5, RST 6.5, RST 5.5 আর INTR, এই পাঁচটি interrupt input. Datasheet-এর Table 2 অনুযায়ী অগ্রাধিকার TRAP সবচেয়ে বেশি, তারপর 7.5, 6.5, 5.5, শেষে INTR; লাফের ঠিকানা TRAP 24H, RST 7.5 3CH, RST 6.5 34H, RST 5.5 2CH. INTR মেনে নিলে CPU RD-এর বদলে INTA নামায়, আর বাইরের যন্ত্র তখন data bus-এ একটি RST বা CALL নির্দেশ রাখে। SID আর SOD এক বিটের serial লাইন: RIM SID-এর বিট A-এর বিট ৭-এ আনে, SIM SOD-এ বিট পাঠায়। কোর্সের simulator-এ RIM/SIM-এর নিয়ম Spec decision 7-এ। এই সব কিছু বিস্তারিত পর্ব ১৩ (8085-এর interrupt)-এ।

বাজারঘরের একটি I/O উদাহরণ. ধরুন বাজারঘরের দাঁড়িপাল্লার একটি পুরোনো 8085 board port 01H থেকে একটি byte পড়ে memory-তে রাখে, আর ৯.৮৩ টাকার পয়সার BCD byte 83H port 02H-এর display-এ পাঠায় (BCD দামের নিয়ম পর্ব ০৫-এ)। IN আর OUT দুটোই OF + MR + I/O cycle = ১০ T. I/O cycle-এ IO/M = 1, আর datasheet বলে port-এর ৮ বিটের ঠিকানা A15–A8 আর AD7–AD0 দুই জায়গাতেই আসে, তাই port 02H-এর জন্য bus-এ দেখা যায় 0202H. সত্যিকারের run (sim8085.py run inout.asm, port-এর মান ;@in 01H 3CH pragma দিয়ে, Spec decision 10):

A=83 B=00 C=00 D=00 E=00 H=00 L=00 SP=0000 PC=200A
Flags: S=0 Z=0 AC=0 P=0 CY=0   (F=00H)
Memory 2050H..2050H:
  2050H: 3C
OUT port 02H <- 83H  (at T=40)
Instructions: 5   T-states: 45

মোট ৪৫ T = ১৫ µs. OUT-এর লগে T=40 হলো OUT শেষ হওয়ার মুহূর্তের মোট T-state (১০ + ১৩ + ৭ + ১০), তারপর HLT-এর ৫.

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

  • ALE কী কাজ করে, কখন সক্রিয়? প্রতিটি machine cycle-এর T1-এ 1 হয়; নামার কিনারায় বাইরের latch AD0–AD7 থেকে ঠিকানার নিচের byte ধরে রাখে।
  • Memory write-এ IO/M, S1, S0? 0, 0, 1; opcode fetch 0, 1, 1; I/O read 1, 1, 0.
  • LDA 2050H-এর machine cycle আর T-state? OF, MR, MR, MR; ৪ + ৩ + ৩ + ৩ = ১৩ T; ৩ MHz-এ 4.33 µs.
  • ৬ MHz crystal-এ এক T-state? Clock ৩ MHz, T = 0.333 µs; crystal-এর frequency সরাসরি ব্যবহার করা ভুল।
  • কোন নির্দেশে opcode fetch ৬ T? INX, DCX, PUSH, CALL, RST, SPHL, PCHL, আর শর্তযুক্ত CALL ও RET.

৮ · AI-এর যুগে pin আর timing-এর উত্তর যাচাই

8085-এর pin আর timing নিয়ে প্রশ্ন করলে AI assistant দ্রুত সুন্দর উত্তর দেয়, কিন্তু এই বিষয়ে তার ভুলগুলো ঠিক সেই জায়গায়, যেখানে নম্বর বা বিটের ক্রম লাগে। আমাদের দেখা সাধারণ ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
Pin নম্বর গুলিয়ে ফেলা (যেমন ALE-কে ৩০-এর বদলে অন্য নম্বর), বা S0 আর S1-এর ক্রম উল্টানোIntel datasheet-এর Figure 2 আর Table 1; S1 S0 = 1 1 মানে fetch
8086-এর নিয়ম 8085-এ চাপানো: 8086-এর minimum mode-এ pin-এর নাম M/IO (memory-তে 1), 8085-এ IO/M (memory-তে 0)দুটি chip-এর datasheet আলাদা করে দেখা; 8086-এর bus পর্ব ২১-এ
Z80-এর সংকেত (MREQ, IORQ, M1) 8085-এর বলে লেখা8085-এর ৪০টি pin-এর তালিকায় নামটি আছে কি না
সব opcode fetch-কে ৪ T ধরা, বা ALE-কে T2-তে বসানোনির্দেশের T-state কোর্সের simulator-এ চালিয়ে মেলানো; ALE শুধু T1-এ
Crystal-এর frequency দিয়েই T-state হিসাবDatasheet: X1/X2-এর frequency ২ দিয়ে ভাগ হয়
Wait state-এর সংখ্যা আন্দাজে বলাDatasheet-এর Table 5-এর সূত্রে হাতে হিসাব

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

আমি Intel 8085AH (৬ MHz crystal) নিয়ে কাজ করছি। নির্দেশ: LXI H,2050H তারপর MOV M,A. ১. প্রতিটি নির্দেশকে machine cycle-এ ভাঙো (OF, MR, MW ইত্যাদি), প্রতিটির T-state আর মোট T-state দাও। ২. প্রতিটি machine cycle-এ IO/M, S1, S0, আর A15–A8 ও AD7–AD0-এ T1-এ কোন মান থাকবে, একটি টেবিলে লেখো। প্রোগ্রাম 2000H থেকে শুরু। ৩. মোট সময় µs-এ দাও, আর বলো crystal থেকে clock কীভাবে পেলে। ৪. যেখানে নিশ্চিত নও, অনুমান না করে বলো; Z80 বা 8086-এর নিয়ম মেশাবে না।

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

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

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

প্র ০১Intel কেন 8085-এ ঠিকানা আর data একই pin-এ মেশাল? এই সিদ্ধান্তের লাভ আর দাম কী, আর আজকের chip-এ এর ছায়া কোথায়?

১৯৭৪ সালের 8080 চালাতে তিনটি power supply লাগত, আর clock আর bus নিয়ন্ত্রণের জন্য পাশে দুটি সহায়ক chip, 8224 (clock generator) আর 8228 (system controller). ১৯৭৬ সালের 8085-এর লক্ষ্য ছিল এই বোঝা কমানো। Datasheet নিজেই বলে, 8085AH 8224 আর 8228-এর সব কাজ ভেতরে নিয়েছে, আর একটিমাত্র +5 V-এ চলে। কিন্তু ভেতরে নতুন কাজ আনলে বাইরে নতুন pin লাগে: clock-এর X1, X2, CLK; reset-এর দুটি pin; ALE, S0, S1, IO/M; পাঁচটি interrupt; SID, SOD. প্যাকেজ রইল ৪০ pin-এর, যা তখন সস্তা আর প্রচলিত। জায়গা বের করার সবচেয়ে বড় উপায় ছিল ঠিকানার নিচের ৮টি লাইনকে data-র সঙ্গে ভাগ করা: এক ধাক্কায় ৮টি pin মুক্ত।

দাম তিন রকম। এক, বাইরে একটি latch আর ALE-এর সংযোগ লাগে, অর্থাৎ board-এ একটি বাড়তি chip, যদি না Intel-এর 8155/8156 বা 8755A-এর মতো latch-সহ chip ব্যবহার হয়। Datasheet সেই কারণেই তিন chip-এর “minimum system”-এর কথা বলে। দুই, সময়: প্রতিটি machine cycle-এর একটি অংশ ঠিকানা দেখাতে খরচ হয়, আর read cycle-এ CPU-কে AD bus ছেড়ে দিয়ে দিক বদলের জন্য অপেক্ষা করতে হয় (timing diagram-এর ভাসমান অংশ)। তিন, নকশার জটিলতা: data আর ঠিকানার লাইন আলাদা না থাকায় board-এর ভুল খুঁজতে timing diagram পড়তে জানতে হয়।

এই কৌশল হারিয়ে যায়নি। ১৯৭৮ সালের 8086-ও AD0–AD15 মিশ্র রেখেছিল, ALE-সহ। ১৯৮০ সালের 8051 microcontroller বাইরের memory-র জন্য port 0-এ একই কৌশল নেয়, ALE pin আর বাইরের latch দিয়ে। আজকের কিছু microcontroller-এর বাইরের memory controller-এও multiplexed মোড থাকে, যেখানে pin কম রাখাই লক্ষ্য। আবার উল্টো দিকে, আধুনিক Cortex-M chip-এ flash আর SRAM chip-এর ভেতরেই, তাই CPU-র bus বাইরে আসেই না; সেখানে pin বাঁচে peripheral-এর জন্য, যেমন GPIO আর UART (পর্ব ০৩-এর তুলনা মনে করুন)।

মূল উপলব্ধি: Pin সীমিত সম্পদ; multiplexing পরিসর বাঁচায় সময় আর বাইরের circuit-এর দামে, আর এই আদান-প্রদান আজও chip নকশার একটি মৌলিক প্রশ্ন।

প্র ০২Opcode fetch কেন চারটি T-state নেয়, যেখানে memory read তিনটিতে শেষ হয়? আর কিছু নির্দেশে ছয়টি কেন? আধুনিক CPU এই সময় কীভাবে বাঁচায়?

Memory থেকে একটি byte আনার bus-কাজ তিনটি T-state-এই শেষ: T1-এ ঠিকানা, T2-তে পড়ার সংকেত, T3-এ data নেওয়া। Memory read cycle-এ এর পরে আর কিছু করার নেই, কারণ byte-টি কোথায় যাবে তা আগেই জানা (যেমন MVI-এর দ্বিতীয় byte সরাসরি A-তে)। কিন্তু opcode fetch-এর পরে CPU এখনো জানে না নির্দেশটি কী। T4-এ ভেতরের decoder opcode পড়ে ঠিক করে, পরের machine cycle কী হবে: আর কোনো byte লাগবে কি না, read না write, memory না I/O. অনেক এক-byte নির্দেশ, যেমন MOV A,B বা ADD B, T4-এর মধ্যেই কাজও সেরে ফেলে, তাই তাদের মোট সময় ৪ T.

ছয় T-state লাগে যখন ভেতরে আরও কাজ, বিশেষ করে ১৬ বিটের হিসাব। INX H একটি ১৬ বিটের register জোড়া এক বাড়ায়, যার জন্য ভেতরের incrementer/decrementer ব্যবহার হয়; PUSH আর CALL লেখার আগে SP কমাতে হয়; SPHL আর PCHL একটি জোড়া পুরো সরিয়ে নেয়। এই কাজগুলো T5–T6-এ, bus অলস রেখে। Datasheet-এর block diagram-এ “incrementer/decrementer address latch” নামে এই অংশটি দেখা যায়। পরীক্ষায় তাই একটি প্রিয় প্রশ্ন: INX H memory ছোঁয় না, তবু ৬ T কেন? উত্তর: fetch-এর পরে দুটি বাড়তি state ভেতরের ১৬ বিটের কাজে।

8085 প্রতিটি নির্দেশ মোটামুটি পালা করে করে: আনা, বোঝা, করা। আধুনিক CPU এই ধাপগুলোকে pipeline-এ সাজায়, যাতে একটি নির্দেশ decode হওয়ার সময় পরেরটি আনা হচ্ছে, আর আরেকটির কাজ চলছে। Multi-cycle নকশা আর তার control unit-এর তত্ত্ব Computer Architecture পর্ব ৩৪-এ, pipeline পরের পর্বগুলোতে। Cortex-M3-এও তিন ধাপের একটি ছোট pipeline আছে, তাই সেখানে “এক নির্দেশ = কত clock” প্রশ্নের উত্তর নির্দেশের ক্রমের ওপরও নির্ভর করে; কোর্সের বাজারঘর board ইচ্ছে করে এক নির্দেশ = এক cycle ধরে (Spec decision 17), আসল সময়ের জন্য ARM-এর নথি দেখতে হয়।

মূল উপলব্ধি: T-state-এর সংখ্যা ভেতরের কাজের মানচিত্র: চতুর্থ state decode-এর, পঞ্চম-ষষ্ঠ ১৬ বিটের কাজের; আধুনিক CPU এই কাজগুলো একসঙ্গে চালিয়ে সময় বাঁচায়।

প্র ০৩Wait state কি শুধু পুরোনো যুগের ব্যাপার? আজকের microcontroller-এ ধীর memory আর দ্রুত CPU-র মিল কীভাবে হয়?

1970-80-এর দশকে EPROM প্রায়ই CPU-র চেয়ে ধীর ছিল। Datasheet-এর সূত্রে 8085AH ৩ MHz-এ কোনো wait state ছাড়া memory-কে প্রায় 608 ns দেয়; এর চেয়ে ধীর chip হলে READY নামিয়ে wait state ঢোকাতে হতো। Datasheet-এর Figure 6-এর দুটি flip-flop-এর circuit প্রতিটি machine cycle-এ একটি করে wait state দেয়: সহজ, কিন্তু দ্রুত RAM-এও অকারণে দেরি হয়। ভালো নকশায় address decoder দেখে শুধু ধীর chip-এর ঠিকানায় READY নামানো হতো। Wait state-এর দাম সরাসরি হিসাব করা যায়: এই পর্বের ব্লকে প্রতিটি cycle-এ একটি wait state দিলে STA ১৩ থেকে ১৭ T, প্রায় ৩১% বেশি সময়।

সমস্যাটি আজও আছে, শুধু রূপ বদলেছে। আধুনিক microcontroller-এর ভেতরের flash memory CPU-র উচ্চ clock-এর তুলনায় ধীর। উদাহরণ হিসেবে, STMicroelectronics-এর STM32F103-এর reference manual (RM0008) অনুযায়ী flash-এর LATENCY setting system clock ২৪ MHz পর্যন্ত শূন্য wait state, ৪৮ MHz পর্যন্ত এক, আর ৭২ MHz পর্যন্ত দুই wait state চায়; firmware-কে clock বাড়ানোর আগেই এটি ঠিক করতে হয়, না হলে CPU ভুল নির্দেশ পড়তে পারে। ক্ষতি পুষিয়ে নিতে এসব chip-এ prefetch buffer থাকে, যা আগেভাগে কয়েকটি নির্দেশ এনে রাখে। Clock বাড়ানোর এই ধাপগুলো পর্ব ৩৩ (Clock, reset আর power domain)-এ দেখা হবে।

আরও বড় পরিসরে, cache-ও একই প্রশ্নের উত্তর: ধীর DRAM আর দ্রুত CPU-র মাঝে রাখা ছোট দ্রুত memory-র স্তর। 8085-এর READY pin তাই একটি চিরকালীন নকশা-সমস্যার সবচেয়ে সরল রূপ: যে পক্ষ ধীর, সে অন্য পক্ষকে অপেক্ষা করতে বলতে পারে। এটি একধরনের handshake; I2C-এর clock stretching (পর্ব ৫১) ঠিক এই ধারণার serial রূপ, যেখানে ধীর device clock লাইন নিচু ধরে রেখে master-কে থামায়।

মূল উপলব্ধি: দ্রুত আর ধীর অংশের মিলন সবসময় অপেক্ষার নিয়ম চায়; 8085-এর READY থেকে আজকের flash wait state আর I2C clock stretching একই ধারণার ভিন্ন রূপ।

প্র ০৪HOLD পেলে 8085 সঙ্গে সঙ্গে bus ছাড়ে না, চলতি লেনদেন শেষ করে। কেন? আর একাধিক bus master-এর ব্যবস্থায় এমন নিয়ম কেন দরকার?

ধরুন CPU একটি memory write-এর মাঝখানে: ঠিকানা bus-এ, WR নিচু, data AD-তে। এখন হঠাৎ সব লাইন ভাসিয়ে দিলে memory একটি অর্ধেক লেখা পায়: ঠিকানা বদলে যেতে পারে WR ওঠার আগেই, আর ভুল ঘরে আবর্জনা লেখা হয়। Read-এর মাঝে থামলে CPU একটি অসম্পূর্ণ byte নেয়। তাই datasheet-এর নিয়ম: CPU চলতি bus transfer শেষ করে তবেই bus ছাড়ে, আর HLDA দিয়ে জানায়। Hold-এর timing diagram দেখায় HOLD T2-তে এলে CPU T3 শেষ করে, তারপর THOLD state-এ bus ভাসায়। Bus ফেরত দেওয়াও একইভাবে সাবধানে: HLDA নামার আধা clock পরে CPU আবার চালক।

এটি একটি ছোট arbitration protocol: একজন অনুরোধ করে, অন্যজন নিরাপদ মুহূর্তে মেনে নিয়ে জানায়। একাধিক যন্ত্র যখন একই তার চালাতে পারে, তখন যেকোনো মুহূর্তে ঠিক একজনই চালাবে, এই নিয়ম না থাকলে দুই output একসঙ্গে উল্টো মান চালিয়ে bus-এ সংঘর্ষ (bus contention) ঘটায়, যা ভুল data দেয় আর chip গরমও করতে পারে। Tri-state output ঠিক এই কারণেই: যে চালক নয়, সে নিজেকে বিচ্ছিন্ন করে। 8085-এর datasheet তাই খেয়াল করে বলে কোন pin HOLD-এ tri-state হয় (ঠিকানা, data, RD, WR, IO/M) আর কোনটি কখনো হয় না (ALE).

আধুনিক microcontroller-এ ব্যাপারটি chip-এর ভেতরে চলে গেছে। একটি Cortex-M chip-এ CPU আর DMA controller দুজনেই bus master, আর তাদের মাঝে একটি bus matrix arbitration করে; কখনো দুজনে একসঙ্গে আলাদা memory-তে যেতে পারে, একই memory-তে গেলে একজনকে অপেক্ষা করতে হয়। এর ফলে DMA চললে CPU-র কোনো নির্দেশ মাঝে মাঝে একটু দেরি পায়, যা real-time হিসাবে মাথায় রাখতে হয়। DMA-র ব্যবহারিক দিক পর্ব ৪৬-এ, আর 8085-এর সঙ্গে 8237 পর্ব ২৭-এ।

মূল উপলব্ধি: ভাগ করা bus-এ নিরাপত্তার মূল নিয়ম হলো লেনদেনের সীমানায় হাতবদল আর এক মুহূর্তে একজন চালক; HOLD/HLDA এর সবচেয়ে সরল উদাহরণ।

প্র ০৫Timing diagram পড়ার দক্ষতা কি শুধু 8085-এর পরীক্ষার জন্য? একজন embedded প্রকৌশলী বাস্তবে এটি কোথায় কাজে লাগান, আর কোর্সের simulator এখানে কতটা সাহায্য করে?

Datasheet-এর প্রায় প্রতিটি interface অধ্যায় শেষ হয় একটি timing diagram আর একটি সময়ের টেবিল দিয়ে, 8085-এর A.C. characteristics-এর মতোই: কোন কিনারার কত ns আগে বা পরে কোন লাইন স্থির থাকতে হবে। SPI-এর clock আর data-র সম্পর্ক (পর্ব ৫০), I2C-এর start আর stop শর্ত (পর্ব ৫১), একটি LCD display-এর enable pulse-এর প্রস্থ, একটি ADC-র conversion-এর পরে কখন data পড়া যাবে, সবই এই ভাষায় লেখা। 8085-এর diagram সেই ভাষার সবচেয়ে সহজ ব্যাকরণ: কয়েকটি লাইন, তিন বা চারটি T-state, স্পষ্ট কারণ-ফল।

বাস্তবে board কাজ না করলে প্রকৌশলী একটি logic analyzer বা oscilloscope লাগিয়ে লাইনগুলোর আসল আকার দেখেন, তারপর datasheet-এর diagram-এর সঙ্গে মেলান: chip select কি clock-এর আগে নেমেছে? data কি যথেষ্ট আগে স্থির? এই পর্বের bus-trace ব্লকের টেবিলটি একটি logic analyzer-এর রপ্তানি করা টেবিলের মতো দেখতে, ইচ্ছে করেই। এই কোর্সে আসল hardware বা logic analyzer চালানো হয়নি; যা দেখানো হয়েছে তা datasheet-এর নিয়ম থেকে তৈরি মডেল।

কোর্সের 8085 simulator কী পারে আর কী পারে না, সেটাও স্পষ্ট থাকা দরকার। Simulator প্রতিটি নির্দেশের মোট T-state Intel-এর টেবিল থেকে নির্ভুল গোনে (Spec decision 2), তাই delay loop বা program-এর সময়ের হিসাব যাচাই করতে এটি চমৎকার; পর্ব ১২-এর delay subroutine এর ওপর দাঁড়াবে। কিন্তু এটি pin-স্তরের সংকেত, wait state বা HOLD মডেল করে না; machine cycle-এর ভাঙন এই পর্বে Intel-এর manual থেকে নিয়ে simulator-এর মোট সংখ্যার সঙ্গে মেলানো হয়েছে। আসল সময়ের প্রশ্নে চূড়ান্ত উৎস সবসময় datasheet, আর বাস্তব board-এ মাপা সংকেত।

মূল উপলব্ধি: Timing diagram হলো hardware-এর চুক্তিপত্র; 8085-এ এটি পড়তে শিখলে আধুনিক যেকোনো serial bus বা peripheral-এর datasheet পড়া সহজ হয়।

অনুশীলন

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

  1. নকশা — চারটি নিয়ন্ত্রণ-সংকেত: 8085-এর IO/M, RD আর WR থেকে চারটি active-low সংকেত MEMR, MEMW, IOR, IOW তৈরির logic নকশা করুন (gate-এর সংখ্যা কম রেখে)। তারপর opcode fetch, memory write, I/O read আর I/O write, এই চার machine cycle-এ চারটি সংকেতের মান একটি টেবিলে দেখান।

    Active-low output চাই, আর প্রতিটি তখনই 0 হবে যখন দুটি শর্তই “সক্রিয়” (0). দুটি 0-এর ফল 0, বাকি সব ক্ষেত্রে 1: এটি OR gate. তাই MEMR = RD + IO/M, MEMW = WR + IO/M, IOR = RD + (NOT IO/M), IOW = WR + (NOT IO/M). লাগে চারটি দুই-input OR gate আর একটি NOT. লেখকের lab-এ truth table চালিয়ে পাওয়া মান:

    IO/M RD WR | MEMR MEMW IOR IOW | cycle
     0    0  1 |  0    1    1   1  | memory read / opcode fetch
     0    1  0 |  1    0    1   1  | memory write
     1    0  1 |  1    1    0   1  | I/O read
     1    1  0 |  1    1    1   0  | I/O write

    প্রতিটি সারিতে ঠিক একটি সংকেত 0, তাই একসঙ্গে দুটি chip সাড়া দেয় না। AND gate দিয়ে করলে ভুল হতো: memory read-এ 0 AND 0 = 0 ঠিক, কিন্তু I/O read-এও RD = 0 থাকায় 1 AND 0 = 0, অর্থাৎ memory-ও সাড়া দিত। বিকল্প: একটি 74LS138 decoder-এ IO/M, RD, WR দিয়ে output বেছে নেওয়া। HOLD বা reset-এ এই লাইনগুলো ভাসমান হয়, তাই datasheet-এর Figure 9-এর মতো pull-up resistor দিয়ে RD, WR-কে 1-এ রাখা ভালো।

  2. ভুল খুঁজুন — একটি timing-এর উত্তর: একজন লিখলেন: “LDA 2050H-এর machine cycle OF (৪) + MR (৩) + MW (৩) + MR (৩) = ১৩ T. প্রতিটি cycle-এর T2-তে ALE 1 হয়ে ঠিকানা latch করে। ৬ MHz crystal-এ এক T = 1/6 µs, তাই সময় 2.17 µs.” কয়টি ভুল, আর ঠিক উত্তর কী?

    তিনটি ভুল। (১) Machine cycle-এর ধরন: LDA শুধু পড়ে: opcode, ঠিকানার নিচের byte, ওপরের byte, তারপর 2050H থেকে data. তাই OF + MR + MR + MR. যোগফল ১৩ ঠিক এসেছে কাকতালীয়ভাবে, কারণ MW-ও ৩ T; কিন্তু S1 S0 আর RD/WR-এর পুরো ছবি ভুল হতো। (২) ALE T1-এ, T2-তে নয়। (৩) Crystal ৬ MHz মানে clock ৩ MHz, এক T = 0.333 µs; সময় 13 × 0.333 = 4.33 µs. ভুল উত্তরটি (2.17 µs) ঠিক অর্ধেক, যা crystal-কে clock ভাবার চিহ্ন; মজার ব্যাপার, ঠিক এই সময়টি আসত ১২ MHz crystal-এর 8085AH-1-এ (clock.py ব্লকের তৃতীয় লাইন)। লেখকের lab-এ দুটি মানই হিসাব করা: 4.33 আর 2.17; আর ১৩ T কোর্সের simulator-এর LDA-র মানের সঙ্গে মেলে।

  3. আগে বলুন, তারপর চালান — I/O program: 2000H থেকে: IN 01H, STA 2050H, MVI A,83H, OUT 02H, HLT. প্রতিটি নির্দেশের machine cycle আর T-state লিখুন, মোট T আর ৩ MHz-এ সময় বলুন। OUT-এর শেষ machine cycle-এ IO/M, S1, S0 কী, আর ঠিকানা bus-এ কী দেখা যাবে?

    IN 01H: OF + MR + IOR = ১০ T. STA 2050H: OF + MR + MR + MW = ১৩ T. MVI A,83H: OF + MR = ৭ T. OUT 02H: OF + MR + IOW = ১০ T. HLT: ৫ T. মোট ১০ + ১৩ + ৭ + ১০ + ৫ = ৪৫ T = 15.0 µs. কোর্সের simulator-এর সত্যিকারের run-এ Instructions: 5 T-states: 45, আর OUT port 02H <- 83H (at T=40), অর্থাৎ OUT শেষ হয় ৪০তম T-state-এ। IOW cycle-এ IO/M = 1, S1 S0 = 0 1, WR = 0. Port-এর ঠিকানা A15–A8 আর AD7–AD0 দুই জায়গায়ই আসে (datasheet-এর basic system timing অংশ), তাই ঠিকানা bus-এ 0202H; T2–T3-এ AD-তে data 83H.

  4. হিসাব — ধীর EPROM-এ program-এর সময়: একটি 8085AH ৩ MHz-এ চলে, আর program রাখা ৭০০ ns access time-এর একটি EPROM-এ; data 2050H-ও সেই একই ধীর memory-র এলাকায় ধরুন (সরল রাখতে)। Datasheet-এর সূত্র tAD = (5/2 + N)·T − 225 ns দিয়ে প্রতি machine cycle-এ কয়টি wait state লাগবে বের করুন, তারপর MVI A,32H, STA 2050H, HLT-এর মোট T-state আর সময় দিন।

    ধাপ ১: T = 333.3 ns. N = 0-তে tAD = 2.5 × 333.3 − 225 = 608.3 ns < 700 ns, চলবে না; N = 1-এ 941.7 ns ≥ 700 ns, চলবে। তাই প্রতিটি read বা write machine cycle-এ (opcode fetch-সহ, কারণ READY প্রতিটিতে T2-তে দেখা হয়) একটি wait state. ধাপ ২: machine cycle গুনুন: MVI ২টি (OF, MR), STA ৪টি, HLT-এর opcode fetch ১টি, মোট ৭টি। ধাপ ৩: wait ছাড়া ২৫ T (simulator), wait-সহ ২৫ + ৭ = ৩২ T. প্রতি নির্দেশে: ৭ → ৯, ১৩ → ১৭, ৫ → ৬. ধাপ ৪: সময় 32 × 0.333 = 10.67 µs, আগের 8.33 µs-এর জায়গায়। সব সংখ্যা লেখকের lab-এর একটি ছোট script-এ হিসাব করা; simulator wait state গোনে না (Spec decision 2), তাই বাড়তি ৭ T আলাদা করে যোগ করতে হয়েছে।

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

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

ক্রম8085-এর একটি opcode fetch machine cycle-এর ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. IO/M = 0, S1 S0 = 1 1 হয়; PC-র ঠিকানা A15–A8 আর AD7–AD0-এ যায়
  2. ALE 1 হয়ে নামে, বাইরের latch ঠিকানার নিচের byte ধরে রাখে
  3. RD নিচু হয়, memory AD bus-এ opcode রাখে
  4. CPU opcode-টি instruction register-এ নেয়, RD আবার উঁচু হয়
  5. T4-এ CPU opcode decode করে, AD bus ভাসমান থাকে

8085-এ ALE সংকেত একটি machine cycle-এর কোন T-state-এ 1 হয়, আর কেন?

  • T2-তে, data latch করার জন্য
  • T1-এ, AD0–AD7-এর ঠিকানা latch করার জন্য
  • T4-এ, decode শেষ হওয়ার পরে
  • পুরো machine cycle জুড়ে

8085-এর একটি machine cycle-এ IO/M = 0, S1 = 0, S0 = 1. এটি কোন machine cycle?

  • Opcode fetch
  • Memory read
  • Memory write
  • I/O write

8085-এর STA 2050H নির্দেশের machine cycle-এর ক্রম আর মোট T-state কোনটি?

  • OF, MR, MR, MW; ১৩ T
  • OF, MR, MR, MR; ১৩ T
  • OF, MW; ৭ T
  • OF (৬ T), MR, MR, MW; ১৫ T

একটি 8085 board-এ ৬ MHz-এর crystal লাগানো। একটি T-state কত সময়ের?

  • প্রায় 0.167 µs
  • ১ µs
  • প্রায় 0.083 µs
  • প্রায় 0.333 µs

8085-এর নিচের কোন নির্দেশের opcode fetch machine cycle ছয়টি T-state নেয়?

  • MOV A,B
  • INX H
  • LDA 2050H
  • ADD B

8085 একটি memory read cycle-এর T2-তে READY pin 0 পায়। কী ঘটে?

  • CPU reset হয়ে 0000H থেকে শুরু করে
  • CPU bus ছেড়ে দিয়ে HLDA = 1 করে
  • CPU এক বা একাধিক wait state ঢুকিয়ে READY 1 হওয়ার অপেক্ষা করে
  • CPU একটি interrupt service routine-এ লাফ দেয়

শব্দকোষ

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

মনে রাখুন

  1. ৪০ pin, পাঁচ দল: bus (AD0–AD7 ১২–১৯, A8–A15 ২১–২৮), নিয়ন্ত্রণ-status (ALE ৩০, WR ৩১, RD ৩২, S1 ৩৩, IO/M ৩৪, S0 ২৯, READY ৩৫, HOLD ৩৯, HLDA ৩৮), interrupt-serial, clock-reset, power (VCC ৪০, VSS ২০).
  2. ALE আর latch: T1-এ AD0–AD7-এ ঠিকানা, ALE = 1; ALE নামলে latch ঠিকানা ধরে রাখে, তারপর একই লাইনে data.
  3. Status: IO/M S1 S0 = 0 1 1 fetch, 0 1 0 memory read, 0 0 1 memory write, 1 1 0 I/O read, 1 0 1 I/O write; MEMR = RD + IO/M ইত্যাদি OR gate দিয়ে।
  4. Machine cycle: OF ৪ বা ৬ T, বাকিগুলো ৩ T; MVI A,32H = OF + MR = ৭ T, STA 2050H = OF + MR + MR + MW = ১৩ T.
  5. সময়ের হিসাব: clock = crystal ÷ ২; ৩ MHz-এ ১ T = 0.333 µs; ধীর memory-র জন্য READY = 0 মানে wait state, সংখ্যা datasheet-এর tAD সূত্রে।

পরের পর্বে: পর্ব ০৯ (8085-এর instruction set — data transfer, arithmetic, logical আর branch). এই পর্বে নির্দেশগুলোকে bus-এর চোখে দেখলেন; পরের পর্বে দেখবেন প্রতিটি দল কী করে, কোন flag বদলায়, আর কোথায় ফাঁদ।

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

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