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

Memory interfacing আর address decoding — ROM, RAM আর chip select

Memory Interfacing and Address Decoding — ROM, RAM and Chip Select

Taught in Bangla, this lesson designs the memory map of an 8085 board with 8 KB ROM and 8 KB RAM, splitting address lines into those inside the chip and those that select it, and decoding with a 74LS138. It compares full and partial decoding, where mirror addresses appear, and runs an alias program in the course's 8085 simulator to show why a simulator does not reproduce mirroring. In-page Python checks maps for clashes, timing budgets are computed, and 8086 even and odd banks are traced on Unicorn.

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

  • ROM, EPROM আর SRAM chip-এর organization (যেমন 8K × 8) থেকে address আর data লাইনের সংখ্যা বের করা
  • একটি 8085 system-এর memory map নকশা করা আর প্রতিটি chip-এর শুরু আর শেষের ঠিকানা হিসাব করা
  • 74LS138 decoder-এর truth table পড়া আর তা দিয়ে chip select তৈরি করা
  • Full আর partial (linear select) decoding তুলনা করা, mirror ঠিকানা আর সংঘর্ষ খুঁজে বের করা
  • 8086-এর even আর odd bank, BHE̅ আর A0 দিয়ে byte আর word লেখার নিয়ম প্রয়োগ করা

১ · CPU-র ঠিকানা, chip-এর ঘর — memory interfacing কেন

বাজারঘরের smart scale-এর প্রথম রূপটি আমরা 8085 দিয়ে ভাবছি (পর্ব ০৭ থেকে ১৩). Program-কে কোথাও স্থায়ীভাবে থাকতে হবে, যাতে বিদ্যুৎ চলে গেলেও না মোছে; আর ওজন, tare, দামের মতো চলমান মান রাখতে লাগবে লেখা যায় এমন মেমরি। 8085-এর ভেতরে এর কোনোটাই নেই, শুধু register. তাই বাইরে chip বসাতে হয়: একটি ROM আর একটি SRAM. CPU আর এই chip-গুলোর মধ্যে তার জোড়া, আর কোন ঠিকানায় কোন chip সাড়া দেবে তা ঠিক করার কাজের নাম memory interfacing. এর কেন্দ্রে আছে address decoding.

উপমা — পোস্ট অফিসের ঠিকানা: একটি চিঠিতে লেখা “ঢাকা, মিরপুর, বাড়ি ৫০”. ডাক বিভাগ প্রথমে ওপরের অংশ দেখে (ঢাকা, মিরপুর) ঠিক করে কোন পোস্ট অফিসে চিঠি যাবে; সেখানকার পিয়ন শুধু “বাড়ি ৫০” দেখে ঘরে পৌঁছে দেন। CPU-র ১৬ বিটের ঠিকানাও তেমন দুই ভাগে চলে। ওপরের কয়েকটি bit “এলাকা”: কোন chip. নিচের bit-গুলো “বাড়ি নম্বর”: chip-এর ভেতরে কোন byte. যে circuit এলাকা দেখে পোস্ট অফিস বাছে, সেটিই decoder. আর যদি ডাক বিভাগ “ঢাকা” না দেখে শুধু “মিরপুর” দেখে, তাহলে অন্য শহরের মিরপুরের চিঠিও এখানে আসবে; এই পর্বের শেষ দিকের mirror ঠিকানার সমস্যা ঠিক এটাই।

পূর্বজ্ঞান এক লাইনে: 8085-এর address bus ১৬ বিটের, নিচের আটটি লাইন AD0–AD7 data-র সঙ্গে ভাগ করা, আর ALE সংকেতে একটি বাইরের latch (যেমন 74LS373) নিচের ঠিকানা ধরে রাখে; সেই সঙ্গে MEMR̅ আর MEMW̅ কীভাবে RD̅, WR̅ আর IO/M̅ থেকে তৈরি হয়, সব পর্ব ০৮-এ। 8086-এর segment আর ২০ বিটের physical address পর্ব ১৪-এ। Decoder circuit-এর লজিক নিজে Computer Architecture পর্ব ১২-এ, আর SRAM ও DRAM chip-এর ভেতরের গঠন Computer Architecture পর্ব ৪৯-এ; এখানে সেগুলো আবার শেখানো হবে না, আমরা chip-এর বাইরের তার জোড়ার কাজ করব। লেখার নিয়ম: ঠিকানা Intel-এর ধরনে শেষে H (2050H), আর বর্ণ দিয়ে শুরু হওয়া hex-এর আগে 0 (0A050H), কারণ course-এর assembler-এ সেটাই নিয়ম। Active-low সংকেতের নামের ওপর দাগ: CE̅, OE̅, CS1̅; টেবিলে জায়গা বাঁচাতে দাগ ছাড়াও লেখা হবে, কিন্তু 0 মানেই “সক্রিয়”।

Memory chip বাইরে থেকে দেখতে কেমন

প্রতিটি memory chip-এর পরিচয় তার organization: N × M, অর্থাৎ N টি ঠিকানা, প্রতিটিতে M bit. পুরোনো 8085 বই আর trainer kit-এ সবচেয়ে বেশি দেখা দুটি উদাহরণ নিচে, তথ্য datasheet থেকে। EPROM 2764: 64 Kbit, 8192 × 8 (SGS-Thomson-এর M27C64A datasheet, ১৯৯৫, একই pin-বিন্যাসের CMOS রূপ). SRAM 6264: 8192 word × 8 bit (Hitachi-র HM6264A datasheet). দুটিই ২৮ pin-এর, দুটিরই ঠিকানার pin A0–A12 আর data-র আটটি pin.

বিষয়2764 EPROM (8K × 8)6264 SRAM (8K × 8)
ঠিকানাA0–A12A0–A12
DataO0–O7 (শুধু output; ST-র নামে Q0–Q7)I/O1–I/O8 (দুই দিকেই)
Chip বাছাইCE̅ (ST-র নামে E̅)CS1̅ (active-low) আর CS2 (active-high)
Output চালুOE̅ (ST-র নামে G̅)OE̅
লেখাসাধারণ কাজে নেই; programmer-এ PGM̅ আর VPPWE̅
পড়ার শর্তCE̅ = 0, OE̅ = 0CS1̅ = 0, CS2 = 1, WE̅ = 1, OE̅ = 0
Datasheet-এর access time (উদাহরণ)M27C64A: 150 ns; পুরোনো কিছু 2764 grade 250 ns পর্যন্তHM6264A: 100, 120 বা 150 ns (grade অনুযায়ী)

Chip বাছাইয়ের pin-টিকে সাধারণভাবে বলে chip select. এটি 1 (নিষ্ক্রিয়) থাকলে chip ঘুমায়: datasheet অনুযায়ী তার data pin tri-state বা ভাসমান থাকে, আর বিদ্যুৎ খরচ অনেক কমে যায়। আলাদা output enable কেন, তার উত্তর ST-র datasheet নিজেই দিয়েছে: E̅ (chip enable) decode করে device বাছাইয়ের জন্য, আর G̅ (output enable) সব chip-এ একসঙ্গে CPU-র READ লাইনে জুড়তে হবে; এতে বাছাই না হওয়া chip কম বিদ্যুৎ খায়, আর output শুধু তখনই চালু হয় যখন সত্যিই পড়া হচ্ছে, ফলে bus contention হয় না। এই পর্বের প্রতিটি নকশা এই নিয়ম মেনে চলে: chip select আসে decoder থেকে, OE̅ আসে MEMR̅ থেকে, আর RAM-এর WE̅ আসে MEMW̅ থেকে।

২ · কয়টি address line — chip-এর ভেতরে আর বাইরে

প্রথম হিসাবটি সব interfacing প্রশ্নের ভিত্তি: N টি ঠিকানা আলাদা করতে n টি লাইন লাগে, যেখানে 2n = N. 8192 = 213, তাই 8 KB chip-এ ১৩টি লাইন, A0–A12. 8085-এর ১৬টি লাইনের বাকি তিনটি, A13, A14, A15, chip-এর ভেতরে যায় না; এদের কাজ chip বাছাই। প্রচলিত নামকরণে 27xx EPROM আর 6xxx SRAM-এর নামের শেষ অংশ প্রায়ই মোট kilobit বলে (2764 = 64 Kbit = 8 KB), যদিও সব নির্মাতা এই নিয়ম মানেনি, তাই সবসময় datasheet দেখুন। পরিচিত কয়েকটি chip:

Chip (উদাহরণ)OrganizationঠিকানাAddress line0000H থেকে শুরু করলে শেষ
2716 EPROM, 6116 SRAM2K × 82048১১ (A0–A10)07FFH
2732 EPROM4K × 84096১২ (A0–A11)0FFFH
2764 EPROM, 6264 SRAM8K × 88192১৩ (A0–A12)1FFFH
27128 EPROM16K × 816384১৪ (A0–A13)3FFFH
27256 EPROM, 62256 SRAM32K × 832768১৫ (A0–A14)7FFFH

এখান থেকে তিনটি সূত্র, যা পরীক্ষায় বারবার লাগে:

  1. শেষের ঠিকানা = শুরু + মাপ − 1. 2000H থেকে 8 KB (2000H byte) মানে 2000H + 2000H − 1 = 3FFFH, 4000H নয়। এক byte বেশি গোনা সবচেয়ে প্রচলিত ভুল।
  2. Chip-এর সংখ্যা = দরকারি মাপ ÷ এক chip-এর মাপ. 8 KB RAM 2K × 8 chip দিয়ে বানাতে 8 ÷ 2 = ৪টি chip. Chip ৪ bit চওড়া হলে (যেমন 1K × 4) এক byte-এর জন্য পাশাপাশি দুটি লাগে, তখন দুটির chip select একই।
  3. Decoder-এর লাইন = মোট লাইন − chip-এর লাইন. 8085-এ 16 − 13 = ৩, তাই 23 = ৮টি 8 KB-এর ঘর। 3-to-8 decoder ঠিক এই মাপের।

8085-এর বেলায় আরেকটি কথা: chip-এর A0–A7 সরাসরি CPU থেকে নয়, latch-এর output থেকে আসে, কারণ T2 থেকে ওই pin-গুলো data বহন করে (পর্ব ০৮). A8–A15 পুরো machine cycle জুড়ে স্থির থাকে, তাই সরাসরি জোড়া যায়। আর data bus D0–D7 (AD0–AD7) সব chip-এ সমান্তরালে যায়; কোন chip সেখানে byte চালাবে, তা ঠিক করে chip select আর OE̅.

৩ · Memory map নকশা — বাজারঘরের 8085 board

Memory map হলো ৬৪ KB ঠিকানা-জগতের কোন অংশে কোন chip, তার ছক। নকশার প্রথম প্রশ্ন: ROM কোথায়? উত্তর CPU ঠিক করে দেয়। 8085 reset-এর পরে program counter 0000H করে (পর্ব ০৮), অর্থাৎ তার reset vector 0000H. বিদ্যুৎ আসার মুহূর্তে RAM-এ কিছুই নেই, তাই 0000H-এ ROM থাকতেই হবে। RAM-কে বসাই ঠিক তার পরে, 2000H-এ। কোর্সের 8085 program-গুলো 2000H থেকে শুরু হয় আর data রাখে 2050H-এ; এই নকশায় সেগুলো ঠিক RAM-এর ভেতরে পড়ে, পুরোনো trainer kit-এর মতো, যেখানে monitor program থাকে ROM-এ আর ব্যবহারকারীর program RAM-এ।

নকশার ধাপ
প্রশ্ন
হিসাব
মানচিত্র
  1. চাহিদা। Scale-এর program আর ওজন-দামের টেবিলের জন্য 8 KB ROM, চলমান মান আর stack-এর জন্য 8 KB RAM. Reset-এর পরে 8085 0000H থেকে নির্দেশ আনে, তাই ROM-এর জায়গা আগেই ঠিক।
  2. ভেতরের লাইন। 8192 = 213, তাই দুটি chip-ই A0–A12 নেয়। Chip-এর চোখে নিজের ঠিকানা সবসময় 0000H থেকে 1FFFH; CPU-র ঠিকানা কত, তা chip জানে না।
  3. বাছাইয়ের লাইন। বাকি তিনটি লাইন (A13–A15) আটটি সমান ঘর তৈরি করে, প্রতিটি 8 KB: 0000H, 2000H, 4000H … E000H থেকে শুরু। 3-to-8 decoder এক একটি ঘরের জন্য এক একটি output দেয়।
  4. শুরু আর শেষ। ROM ঘর ০-তে: 0000H থেকে 1FFFH. RAM ঘর ১-এ: 2000H + 2000H − 1 = 3FFFH. শেষের ঠিকানায় “− 1” না দিলে দুটি chip এক byte-এ মিশে যায়।
  5. ভবিষ্যতের জায়গা। Y2 থেকে Y7 খালি: 4000H–FFFFH, মোট 49152 byte. পরে cold-storage monitor-এর log রাখতে আরেকটি RAM লাগলে শুধু Y2-তে জুড়লেই 4000H–5FFFH পাওয়া যাবে, অন্য কোনো তার বদলাতে হবে না।

নকশাটি ছবিতে। বাঁ দিকে 8085, মাঝে latch আর decoder, ডানে দুটি chip. লক্ষ করুন, ছবিতে প্রতিটি তার কোথায় যায় তার চেয়েও জরুরি হলো কোন লাইন “ভেতরের” আর কোনটি “বাছাইয়ের”।

ছবি ২২.১ — বাজারঘরের 8085 board: 8 KB ROM আর 8 KB RAM, 74LS138 দিয়ে full decoding

নীল = ঠিকানা; সবুজ = chip বাছাই (Y0 → ROM-এর CE̅, Y1 → RAM-এর CS1̅); OE̅ আর WE̅-এর উৎস লেখা দিয়ে দেখানো

8085, latch, 74LS138 আর দুটি memory chip-এর সংযোগ 8085 AD0–7 ALE A8–15 IO/M RD WR 74LS373 latch ROM 2764 8K × 8 A0–A12 OE ← MEMR RAM 6264 8K × 8 OE ← MEMR WE ← MEMW 74LS138 C B A G2A G1=1 G2B=0 Y1 Y0 Y2–7 A0–A7 A8–A12 → A13–A15 → C B A ALE CS1 CE
ছবি ২২.১ — ঠিকানার ১৬টি লাইনের মধ্যে ১৩টি (A0–A12) দুটি chip-এ সমান্তরালে যায়, বাকি তিনটি (A13–A15) যায় decoder-এ। IO/M̅ যায় G2A̅-তে, তাই I/O-র cycle-এ (IO/M̅ = 1) decoder বন্ধ থাকে। RAM-এর CS2 (active-high) +5 V-এ বাঁধা। Data bus D0–D7 আর MEMR̅/MEMW̅-এর তার ছবিতে লেখা দিয়ে বোঝানো, যাতে ছোট পর্দায় জট না লাগে।

৪ · 74LS138 — তিন লাইন থেকে আট chip select

74LS138 একটি 3-to-8 decoder, ঠিক এই কাজের জন্যই বিখ্যাত। Motorola-র SN54/74LS138 datasheet নিজেই লিখেছে, chip-টি “high speed bipolar memory chip select address decoding”-এর জন্য উপযুক্ত। তথ্যগুলো সেই datasheet থেকে:

  • তিনটি নির্বাচনী input: datasheet-এর নামে A0, A1, A2 (pin ১, ২, ৩); TI আর বেশিরভাগ বইয়ের নামে A, B, C. C (A2) সবচেয়ে বড় ঘর।
  • তিনটি enable: দুটি active-low, E1̅ আর E2̅ (pin ৪, ৫; বইয়ের নামে G2A̅, G2B̅), আর একটি active-high, E3 (pin ৬; বইয়ের নামে G1).
  • আটটি output, সবগুলো active-low: O0–O7 বা Y0̅–Y7̅ (pin ১৫ থেকে ৯, আর ৭). Datasheet-এর বাক্য: G2A̅ আর G2B̅ LOW আর G1 HIGH না হলে সব output HIGH থাকে।
  • দেরি: ২৫ °C-এ address থেকে output পর্যন্ত সর্বোচ্চ 41 ns (tPHL, দুই স্তরের পথ), enable থেকে output সর্বোচ্চ 32 থেকে 38 ns (কোন enable তার ওপর নির্ভর করে).

Output active-low হওয়াটা কাকতালীয় নয়: memory chip-এর chip select-ও active-low, তাই decoder-এর output কোনো inverter ছাড়া সরাসরি CE̅ বা CS1̅-এ জোড়া যায়। নিচের Python ব্লক datasheet-এর truth table হুবহু মডেল করে, তারপর ছবি ২২.১-এর তার জোড়া ধরে কয়েকটি ঠিকানা decode করে। এটি আসল chip নয়, কোর্সের lab-এও 74LS138-এর কোনো emulation নেই; datasheet থেকে লেখা একটি ছোট মডেল, যা lab-এ পরীক্ষা করা হয়েছে।

# 74LS138-এর মডেল (Motorola SN54/74LS138 datasheet-এর truth table থেকে)
def ls138(c, b, a, g1, g2a, g2b):
    """Y0..Y7 ফেরত দেয়, active-low: বাছাই করা output-টিই শুধু 0"""
    y = [1] * 8
    if g1 == 1 and g2a == 0 and g2b == 0:      # তিনটি enable একসঙ্গে সক্রিয়
        y[c * 4 + b * 2 + a] = 0               # C = MSB, A = LSB
    return y

print("G1 G2A G2B  C B A   Y0..Y7")
for g1, g2a, g2b in [(0, 0, 0), (1, 1, 0), (1, 0, 1)]:
    print(f" {g1}   {g2a}   {g2b}   x x x   {''.join(map(str, ls138(0, 0, 0, g1, g2a, g2b)))}")
for n in range(8):
    c, b, a = n >> 2 & 1, n >> 1 & 1, n & 1
    print(f" 1   0   0   {c} {b} {a}   {''.join(map(str, ls138(c, b, a, 1, 0, 0)))}")

# বাজারঘরের 8085 board: A15 A14 A13 -> C B A, IO/M -> G2A, G1 = +5 V, G2B = GND
CHIP = {0: "ROM 2764", 1: "RAM 6264"}
def decode(addr, io_m=0):
    y = ls138(addr >> 15 & 1, addr >> 14 & 1, addr >> 13 & 1, 1, io_m, 0)
    low = [i for i in range(8) if y[i] == 0]
    if not low:
        return "no chip (decoder disabled)"
    i = low[0]
    return f"Y{i} low -> {CHIP.get(i, 'empty slot')}, inside-chip address {addr & 0x1FFF:04X}H"

print()
for addr in [0x0000, 0x1FFF, 0x2000, 0x2050, 0x3FFF, 0x4000, 0xFFFF]:
    print(f"{addr:04X}H  {addr >> 13:03b}  {decode(addr)}")
print("2050H with IO/M = 1:", decode(0x2050, io_m=1))

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

G1 G2A G2B  C B A   Y0..Y7
 0   0   0   x x x   11111111
 1   1   0   x x x   11111111
 1   0   1   x x x   11111111
 1   0   0   0 0 0   01111111
 1   0   0   0 0 1   10111111
 1   0   0   0 1 0   11011111
 1   0   0   0 1 1   11101111
 1   0   0   1 0 0   11110111
 1   0   0   1 0 1   11111011
 1   0   0   1 1 0   11111101
 1   0   0   1 1 1   11111110

0000H  000  Y0 low -> ROM 2764, inside-chip address 0000H
1FFFH  000  Y0 low -> ROM 2764, inside-chip address 1FFFH
2000H  001  Y1 low -> RAM 6264, inside-chip address 0000H
2050H  001  Y1 low -> RAM 6264, inside-chip address 0050H
3FFFH  001  Y1 low -> RAM 6264, inside-chip address 1FFFH
4000H  010  Y2 low -> empty slot, inside-chip address 0000H
FFFFH  111  Y7 low -> empty slot, inside-chip address 1FFFH
2050H with IO/M = 1: no chip (decoder disabled)

প্রথম তিন সারি datasheet-এর “disabled” সারি: কোনো একটি enable ভুল অবস্থায় থাকলে আটটি output-ই 1. পরের আট সারিতে প্রতিবার ঠিক একটি 0, আর তার অবস্থান C B A-র binary মান। নিচের অংশে 1FFFH আর 2000H পাশাপাশি দেখুন: এক byte-এর ব্যবধানে chip বদলে গেছে, আর দুই chip-এর ভেতরের ঠিকানা আবার 0000H থেকে শুরু। শেষ সারিটি সবচেয়ে গুরুত্বপূর্ণ: IO/M̅ = 1 হলে কেউ সাড়া দেয় না।

শেষ সারির কারণটি জানা দরকার। 8085 যখন IN 20H বা OUT 20H চালায়, port-এর ৮ বিটের ঠিকানা address bus-এর ওপরের আর নিচের দুই অর্ধেকেই বসে (A15–A8 আর A7–A0 দুটিতেই 20H; Intel-এর 8085 manual-এ এভাবেই বলা). A15–A13 তখন 001, অর্থাৎ IO/M̅-কে decoder-এ না জুড়লে RAM-এর Y1 সক্রিয় হয়ে যেত। Port-mapped I/O-র পুরো আলোচনা পর্ব ২৩-এ (I/O interfacing — memory-mapped বনাম isolated I/O আর polling); এখানে নিয়মটি মনে রাখুন: memory-র decoder-কে memory cycle-এর সংকেত দিয়ে gate করতে হয়।

LDA 2050H-এর data পড়ার cycle
কী ঘটছে
সংকেত
ফল
  1. ঠিকানা bus-এ। LDA 2050H-এর data পড়ার cycle-এর T1-এ 8085 A15–A8-এ 20H আর AD7–AD0-এ 50H দেয়, ALE = 1. ALE নামার সময় 74LS373 নিচের 50H ধরে রাখে (পর্ব ০৮).
  2. দুই ভাগ। 2050H = 0010 0000 0101 0000. ওপরের তিন bit 001 যায় decoder-এ; নিচের ১৩ bit, যার মান 0050H, যায় দুটি chip-এ একসঙ্গে। দুটি chip-ই “0050H নম্বর ঘর” শোনে, কিন্তু উত্তর দেবে শুধু একটি।
  3. Enable পরীক্ষা। G1 স্থায়ীভাবে 1, G2B স্থায়ীভাবে 0, আর memory cycle বলে IO/M̅ = 0, তাই G2A̅ = 0. তিনটি শর্ত মিলেছে: decoder চালু।
  4. একটি output নামে। C B A = 001 = ১, তাই শুধু Y1 = 0. RAM-এর CS1̅ = 0, RAM জাগে। Y0 = 1 বলে ROM-এর CE̅ = 1: ROM-এর data pin ভাসমান থাকে, bus-এ কোনো লড়াই হয় না।
  5. Byte bus-এ। T2-তে RD̅ নামে, তাই MEMR̅ = 0, RAM-এর OE̅ = 0. RAM তার 0050H ঘরের byte (আগে লেখা 55H) D7–D0-এ রাখে, আর 8085 তা A-তে নেয়।

৫ · Partial decoding — কম gate, কিন্তু mirror ঠিকানা

ছবি ২২.১-এর নকশায় চিপের বাইরের সব ওপরের লাইন (A13, A14, A15) decoder দেখেছে। একে বলে full বা absolute decoding: প্রতিটি chip ঠিক একটি পরিসরে থাকে। কিন্তু ছোট system-এ, যেখানে মাত্র দুটি chip, decoder chip-টিও বাড়তি মনে হতে পারে। তখন অনেক নকশা কিছু লাইন উপেক্ষা করে; একে বলে partial decoding. সবচেয়ে সরল রূপ linear select: একটি address লাইন সরাসরি chip select-এ।

বাজারঘরের board-এ এমন একটি নকশা হলো: শুধু A13 দেখা। A13 সরাসরি ROM-এর CE̅-এ (A13 = 0 হলে ROM বাছাই), আর একই A13 RAM-এর CS2-তে, যা active-high (A13 = 1 হলে RAM). 6264-এর এই দ্বিতীয় chip select থাকায় একটি inverter-ও লাগে না; RAM-এর CS1̅-কে 0-তে বাঁধলেই হলো। OE̅ আর WE̅ আগের মতো MEMR̅ আর MEMW̅ থেকে, যারা নিজেরাই IO/M̅ দিয়ে gate করা। Decoder chip শূন্য। দাম কোথায়? A14 আর A15 এখন কেউ দেখে না, তাই তাদের চার রকম মান (00, 01, 10, 11) একই chip-এ পৌঁছায়: প্রতিটি chip ৬৪ KB-এর মধ্যে চারবার দেখা দেয়। এই ঘটনার নাম address aliasing, অনেক বইয়ে foldback বা mirror. নিয়ম: উপেক্ষিত লাইন k টি হলে প্রতিটি chip 2k বার দেখা দেয়।

CPU-র ঠিকানা → chip আর ভেতরের ঘর
ঠিকানা
A15 A14 (উপেক্ষিত)
A13
A12–A0
আসলে কোথায়
  1. মূল ঠিকানা। 2050H-এ A13 = 1, তাই RAM; ভেতরের ঘর 0050H. Full decoding-এর নকশায় যা হতো, এখানেও তাই।
  2. প্রথম mirror. 6050H শুধু A14-এ আলাদা। A14 কেউ দেখে না, A13 এখনো 1, নিচের ১৩ bit একই: একই RAM, একই ঘর। 6050H-এ লেখা মানে 2050H বদলানো।
  3. দ্বিতীয় mirror. 0A050H শুধু A15-এ আলাদা: আবার একই ঘর। Assembler-এ বর্ণ দিয়ে শুরু বলে লিখতে হয় 0A050H.
  4. তৃতীয় mirror. 0E050H-এ A15 আর A14 দুটিই 1, তবু একই ঘর। দুটি উপেক্ষিত লাইন, তাই 22 = ৪টি ঠিকানা একটি byte-এর।
  5. ROM-এরও mirror. 4050H-এ A13 = 0, তাই ROM-এর 0050H ঘর, যেন 0050H পড়া হচ্ছে। ROM-এর চারটি কপি: 0000H, 4000H, 8000H, C000H থেকে।

সত্যিকারের run — simulator কী দেখায়, আর কেন

Mirror হাতে-কলমে পরীক্ষা করার একটি পুরোনো কৌশল: একটি চিহ্ন-byte লিখে সন্দেহজনক ঠিকানা থেকে পড়া। নিচের program 2050H-এ 55H লেখে, তারপর 6050H, 0A050H আর 0E050H পড়ে ফল 2060H–2062H-এ রাখে। কোর্সের 8085 simulator-এ চালানো হলো (reference lab-এর sim8085.py, Python 3.13.5):

; alias.asm - write a marker to RAM, read it back through other addresses
;@show 2050H 1
;@show 2060H 3
        ORG 2000H
START:  MVI A,55H       ; marker byte
        STA 2050H       ; RAM cell 0050H (A13 = 1)
        LDA 6050H       ; differs from 2050H only in A14
        STA 2060H
        LDA 0A050H      ; differs only in A15
        STA 2061H
        LDA 0E050H      ; differs in A15 and A14
        STA 2062H
        HLT
$ python -B sim8085.py asm alias.asm
2000  3E 55        5  START:  MVI A,55H       ; marker byte
2002  32 50 20     6          STA 2050H       ; RAM cell 0050H (A13 = 1)
2005  3A 50 60     7          LDA 6050H       ; differs from 2050H only in A14
2008  32 60 20     8          STA 2060H
200B  3A 50 A0     9          LDA 0A050H      ; differs only in A15
200E  32 61 20    10          STA 2061H
2011  3A 50 E0    11          LDA 0E050H      ; differs in A15 and A14
2014  32 62 20    12          STA 2062H
2017  76          13          HLT
$ python -B sim8085.py run alias.asm
A=00 B=00 C=00 D=00 E=00 H=00 L=00 SP=0000 PC=2018
Flags: S=0 Z=0 AC=0 P=0 CY=0   (F=00H)
Memory 2050H..2050H:
  2050H: 55
Memory 2060H..2062H:
  2060H: 00 00 00
Instructions: 9   T-states: 103

Listing-এ ঠিকানাগুলো little-endian-এ: 3A 50 60 মানে LDA 6050H, নিচের byte আগে। ফলের তিনটি byte-ই 00. কারণ simulator কোনো decoding মডেল করে না: Spec decision 6 অনুযায়ী তার মেমরি ৬৪ KB-এর পূর্ণ, প্রতিটি ঘর আলাদা, শুরুতে সব 00H. অর্থাৎ simulator যেন একটি “নিখুঁত full decoding”-এর board, যেখানে ৬৪ KB-ই RAM. ৯টি নির্দেশে ১০৩ T-state (MVI ৭, প্রতিটি LDA/STA ১৩, HLT ৫), যা Spec decision 2-এর টেবিলের সঙ্গে মেলে। আসল partial-decoding board-এ কী হতো, তা দেখতে নিচের ব্লক program-এর memory-কাজগুলো (listing থেকে নেওয়া) দুটি মডেলে আবার চালায়।

# alias.asm-এর memory কাজগুলো দুই রকম memory-তে আবার চালানো
# (ক) simulator-এর মতো: পুরো 64 KB আলাদা আলাদা ঘর (Spec decision 6)
# (খ) linear select board: A13 = 0 হলে ROM, A13 = 1 হলে RAM; A15, A14 উপেক্ষিত
ops = [("W", 0x2050), ("R", 0x6050), ("W", 0x2060),
       ("R", 0xA050), ("W", 0x2061), ("R", 0xE050), ("W", 0x2062)]
flat = bytearray(0x10000)
ram = bytearray(0x2000)                  # একটিমাত্র 8 KB RAM chip
rom = bytearray(0x2000)                  # ROM-এ লেখা যায় না

def board_cell(addr):
    chip = "RAM" if addr >> 13 & 1 else "ROM"
    return chip, addr & 0x1FFF           # A12-A0 যায় chip-এর ভেতরে

a_flat = a_board = 0x55                  # MVI A,55H
print(" op  addr   flat sim | board: chip cell   data")
for kind, addr in ops:
    chip, cell = board_cell(addr)
    if kind == "W":                      # STA: A-কে লেখা
        flat[addr] = a_flat
        if chip == "RAM":
            ram[cell] = a_board
    else:                                # LDA: A-তে পড়া
        a_flat = flat[addr]
        a_board = ram[cell] if chip == "RAM" else rom[cell]
    print(f"  {kind}  {addr:04X}H  {a_flat:02X}       | {chip} {cell:04X}H  {a_board:02X}")
print("flat  2060H..2062H:", flat[0x2060:0x2063].hex(" ").upper())
print("board 2060H..2062H:", ram[0x0060:0x0063].hex(" ").upper())

# ভুল ধারণা: 6000H-কে খালি RAM ভেবে সেখানে 0AAH লেখা
chip, cell = board_cell(0x6050)
ram[cell] = 0xAA
print(f"STA 6050H (0AAH) -> {chip} cell {cell:04X}H; now [2050H] = {ram[0x0050]:02X}H")

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

 op  addr   flat sim | board: chip cell   data
  W  2050H  55       | RAM 0050H  55
  R  6050H  00       | RAM 0050H  55
  W  2060H  00       | RAM 0060H  55
  R  A050H  00       | RAM 0050H  55
  W  2061H  00       | RAM 0061H  55
  R  E050H  00       | RAM 0050H  55
  W  2062H  00       | RAM 0062H  55
flat  2060H..2062H: 00 00 00
board 2060H..2062H: 55 55 55
STA 6050H (0AAH) -> RAM cell 0050H; now [2050H] = AAH

বাঁ কলাম simulator-এর সত্যিকারের ফল (2060H: 00 00 00) হুবহু মেলায়, তাই মডেলের “flat” অংশ ঠিক আছে। ডান কলাম partial-decoding board: প্রতিটি পড়া একই ঘর 0050H-এ পৌঁছেছে, তাই তিনবারই 55H. শেষ লাইন বিপদটি দেখায়: কেউ 6000H-কে খালি জায়গা ভেবে সেখানে 0AAH লিখলে আসলে 2050H-এর ওজনের মান মুছে যায়, কোনো ত্রুটি-বার্তা ছাড়া। এই কারণে simulator-এ “ঠিক চলে” এমন program আসল board-এ ভিন্ন আচরণ করতে পারে; simulator-কে বিশ্বাস করার আগে জানতে হয় সে hardware-এর কোন অংশ মডেল করে না।

Memory map checker — mirror আর সংঘর্ষ গুনে দেখা

হাতে mirror গোনা ছোট নকশায় চলে, কিন্তু নতুন chip যোগ করার সময় ভুল সহজেই ঢোকে। প্রতিটি chip-এর শর্তকে একটি mask আর একটি মান দিয়ে লেখা যায়: chip সাড়া দেয় যখন (ঠিকানা AND mask) = match. Mask-এ সেই bit-গুলো 1, যেগুলো decoder দেখে। নিচের checker ৬৪ KB-এর প্রতিটি ঠিকানা পরীক্ষা করে বলে কোন chip কয়বার দেখা দেয়, কত byte খালি, আর কোথাও দুটি chip একসঙ্গে সাড়া দেয় কি না। তৃতীয় নকশাটি ইচ্ছা করে ভুল: A13-only board-এ পরে একটি নতুন RAM2 যোগ করা হয়েছে, পূর্ণভাবে 6000H-এ decode করে।

# Memory-map checker: chip সাড়া দেয় যখন (addr & mask) == match
# mask = যে address bit-গুলো decoder দেখে; বাকি ওপরের bit উপেক্ষিত
def ranges(addrs):
    out = []
    for a in addrs:
        if out and a == out[-1][1] + 1:
            out[-1][1] = a
        else:
            out.append([a, a])
    return out

def check(title, chips):
    owners = [[] for _ in range(0x10000)]
    for name, mask, match in chips:
        for a in range(0x10000):
            if a & mask == match:
                owners[a].append(name)
    print("==", title)
    for name, mask, match in chips:
        r = ranges([a for a in range(0x10000) if name in owners[a]])
        txt = ", ".join(f"{s:04X}-{e:04X}" for s, e in r)
        print(f"  {name:5} copies={len(r)}: {txt}")
    clash = [a for a in range(0x10000) if len(owners[a]) > 1]
    free = sum(1 for o in owners if not o)
    print(f"  free bytes: {free}, clash bytes: {len(clash)}", end="")
    print(f" (first {clash[0]:04X}H: {'+'.join(owners[clash[0]])})" if clash else "")

check("full decoding: A15-A13 to 74LS138",
      [("ROM", 0xE000, 0x0000), ("RAM", 0xE000, 0x2000)])
check("partial (linear select): A13 only",
      [("ROM", 0x2000, 0x0000), ("RAM", 0x2000, 0x2000)])
check("A13-only RAM + new RAM2 decoded at 6000H",
      [("ROM", 0x2000, 0x0000), ("RAM", 0x2000, 0x2000),
       ("RAM2", 0xE000, 0x6000)])

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

== full decoding: A15-A13 to 74LS138
  ROM   copies=1: 0000-1FFF
  RAM   copies=1: 2000-3FFF
  free bytes: 49152, clash bytes: 0
== partial (linear select): A13 only
  ROM   copies=4: 0000-1FFF, 4000-5FFF, 8000-9FFF, C000-DFFF
  RAM   copies=4: 2000-3FFF, 6000-7FFF, A000-BFFF, E000-FFFF
  free bytes: 0, clash bytes: 0
== A13-only RAM + new RAM2 decoded at 6000H
  ROM   copies=4: 0000-1FFF, 4000-5FFF, 8000-9FFF, C000-DFFF
  RAM   copies=4: 2000-3FFF, 6000-7FFF, A000-BFFF, E000-FFFF
  RAM2  copies=1: 6000-7FFF
  free bytes: 0, clash bytes: 8192 (first 6000H: RAM+RAM2)

Full decoding-এ প্রতিটি chip একবার, আর 49152 byte (48 KB) খালি, যা ধাপে ধাপে নকশার হিসাবের সঙ্গে মেলে। Linear select-এ খালি byte শূন্য: দুটি chip মিলে পুরো ৬৪ KB “দখল” করেছে, যদিও আসল মেমরি মাত্র 16 KB. তৃতীয় নকশায় 6000H–7FFFH-এ 8192 byte-এ দুটি chip একসঙ্গে সাড়া দেয়: পড়ার সময় দুটি chip একই data bus-এ ভিন্ন byte চালাবে, অর্থাৎ bus contention. নতুন chip যোগ করার আগে পুরোনো partial decoding-কে full করতে হয়, অন্তত নতুন chip-এর পরিসরে পুরোনো chip-কে নিষ্ক্রিয় রাখতে হয়।

ছবি ২২.২ — একই দুটি chip, দুই রকম decoding-এ ৬৪ KB-এর মানচিত্র

ওপরে বড় ঠিকানা; নীল = ROM, সবুজ = RAM, ধূসর = খালি; হালকা রং = mirror

Full আর partial decoding-এর memory map Full শুধু A13 E000H C000H A000H 8000H 6000H 4000H 2000H 0000H Y7 খালি Y6 খালি Y5 খালি Y4 খালি Y3 খালি Y2 খালি Y1 RAM Y0 ROM RAM mirror ROM mirror RAM mirror ROM mirror RAM mirror ROM mirror RAM ROM
ছবি ২২.২ — বাঁয়ে প্রতিটি chip একবার, ছয়টি ঘর ভবিষ্যতের জন্য খালি। ডানে একই দুটি chip চারবার করে, পালা করে: A13 প্রতি 8 KB পরপর 0 আর 1 হয়, তাই ROM আর RAM-এর ঘর ডোরাকাটা দাগের মতো সাজে। ডানের নকশায় নতুন chip বসানোর কোনো জায়গা নেই।

তাহলে partial decoding কি সবসময় খারাপ? না। Chip-এর সংখ্যা চিরকাল স্থির থাকবে এমন ছোট, সস্তা যন্ত্রে এটি gate আর board-এর জায়গা বাঁচায়, আর program যদি শুধু মূল ঠিকানাগুলো ব্যবহার করে, mirror কোনো ক্ষতি করে না। সমস্যা হয় তিন জায়গায়: পরে chip যোগ করতে গেলে, ভুল pointer যখন “অব্যবহৃত” ঠিকানায় লিখে আসল data নষ্ট করে, আর memory test যখন ভুল মাপ জানায়। একটি সাধারণ RAM-size test একের পর এক 8 KB ঘরে লিখে পড়ে দেখে কোথায় মেমরি শেষ; partial decoding-এ প্রতিটি ঘরেই “RAM পাওয়া যায়”, তাই test ভাবে ৩২ KB RAM আছে।

৬ · Timing — decoder-এর দেরি আর memory-র access time

তার ঠিকমতো জুড়লেই কাজ শেষ নয়; chip-কে সময়মতো উত্তরও দিতে হবে। প্রতিটি memory chip-এর datasheet-এ একটি সংখ্যা থাকে, memory access time: ঠিকানা আর chip select স্থির হওয়ার কত পরে data pin-এ বৈধ byte আসে। CPU-র datasheet-এ উল্টো দিকের সংখ্যা: ঠিকানা দেওয়ার কত পরে সে data নিয়ে নেবে। দ্বিতীয়টি প্রথমটির চেয়ে বড় না হলে ভুল byte পড়া হবে। ঠিকানা-পথে decoder বসলে তার দেরি যোগ হয়, কারণ chip select আসে decoder পার হয়ে।

একটি আনুমানিক হিসাব, ধাপে ধাপে (সংখ্যাগুলোর উৎস বন্ধনীতে; 8085-এর সংখ্যাটি Intel-এর MCS-80/85 manual-এর টেবিলে উল্লেখিত মান, chip-এর grade আর clock অনুযায়ী ভিন্ন হতে পারে, তাই নিজের নকশায় নিজের chip-এর datasheet দেখবেন):

  1. 8085A, 3 MHz-এর কাছাকাছি clock-এ: ঠিকানা বৈধ হওয়া থেকে data নেওয়া পর্যন্ত সর্বোচ্চ সময় tAD ≈ 575 ns.
  2. 74LS138: address থেকে output সর্বোচ্চ 41 ns (Motorola datasheet, ২৫ °C).
  3. একটি ধীর 2764 grade: access time 250 ns.
  4. পথের মোট দেরি ≈ 41 ns + 250 ns = 291 ns; হাতে থাকে প্রায় 575 ns − 291 ns = 284 ns.

এই হিসাবে latch-এর দেরি আর board-এর তারের দেরি ধরা হয়নি, কিন্তু হাতে যথেষ্ট সময় আছে: wait state লাগবে না। Chip ধীর হলে, বা CPU-র দ্রুততর grade (বেশি clock) ব্যবহার করলে, এই ব্যবধান কমে যায়; তখন READY লাইন দিয়ে wait state ঢোকাতে হয় (পর্ব ০৮). কোর্সের simulator এই সময় মডেল করে না: Spec decision 2 অনুযায়ী তাতে কোনো wait state নেই।

সাবধান — “সময় পার হলেও একবার কাজ করেছে”: Access time-এর হিসাব সবচেয়ে খারাপ অবস্থার (সর্বোচ্চ তাপমাত্রা, সবচেয়ে কম supply voltage, সবচেয়ে ধীর chip) জন্য করতে হয়। টেবিলে বসা একটি board ঘরের তাপমাত্রায় ঠিক চললেও গরমে বা অন্য ব্যাচের chip-এ মাঝে মাঝে ভুল byte পড়তে পারে, আর এমন ভুল খুঁজে পাওয়া কঠিন। সর্বোচ্চ (max) কলামের সংখ্যা দিয়েই হিসাব করুন, typical দিয়ে নয়।

৭ · 8086-এর memory — even আর odd bank

8086-এর data bus ১৬ বিটের, কিন্তু মেমরি তবু byte-ঠিকানার: প্রতিটি ঠিকানায় একটি byte, আর একটি word দুটি পাশাপাশি ঠিকানায় little-endian ক্রমে (পর্ব ১৪). তাই 1 MB মেমরিকে দুটি ৮ বিটের bank-এ ভাগ করা হয়: সব জোড় ঠিকানার byte এক bank-এ, D0–D7-এ জোড়া (even বা low bank); সব বিজোড় ঠিকানার byte অন্য bank-এ, D8–D15-এ (odd বা high bank). প্রতিটি bank-এ 512 KB, আর CPU-র A0 bank বাছাইয়ের কাজে যায়, তাই chip-এর ভেতরের ঠিকানা আসে A1 থেকে। কোন bank এই cycle-এ কাজ করবে, তা জানায় দুটি সংকেত: A0 আর BHE̅ (bus high enable). Intel-এর 8086 datasheet-এর টেবিল:

BHE̅A0কী স্থানান্তর হয়উদাহরণ
00পুরো word (দুই bank)জোড় ঠিকানায় word
01ওপরের byte, বিজোড় ঠিকানা থেকে বা-তে (odd bank)বিজোড় ঠিকানায় byte
10নিচের byte, জোড় ঠিকানা থেকে বা-তে (even bank)জোড় ঠিকানায় byte
11কিছুই না—

BHE̅ pin-টি কোথায় আর কোন T-state-এ বৈধ, minimum আর maximum mode-এ bus cycle কেমন, আর 8088-এ (৮ বিটের data bus) কেন bank লাগে না, সেসব পর্ব ২১-এ (8086-এর minimum আর maximum mode, bus cycle আর 8088). এখানে interfacing-এর দিকটি: বিজোড় ঠিকানায় একটি word লিখলে কী হয়। কোর্সের 8086 runner-এ একটি ছোট program চালানো হলো: smart scale-এর 1250 g-এর দাম, 8188 পয়সা = 1FFCH, একবার জোড় আর একবার বিজোড় ঠিকানায় (NASM 3.02, Unicorn 2.1.4; trace থেকে শুধু শুরু আর IP রাখা):

; banks.asm - one word at an even and at an odd address
        org 100h
        mov ax, 8188        ; price of 1250 g in paisa = 1FFCh
        mov [0200h], ax     ; even address: low byte -> even bank
        mov [0205h], ax     ; odd address: low byte -> odd bank
        hlt
$ python -B run8086.py banks.asm --trace --mem 0200h,8
1000:0100  B8FC1F         mov ax,0x1ffc        ... IP=0103
1000:0103  A30002         mov [0x200],ax       ... IP=0106
1000:0106  A30502         mov [0x205],ax       ... IP=0109
----
----
1000:0200  FC 1F 00 00 00 FC 1F 00
[exit code 0 via HLT, 4 instructions]

DS = 1000H (Spec decision 13), তাই offset 0200H মানে physical 10200H, আর 0205H মানে 10205H. দুই জায়গাতেই নিচের byte FCH আগে, ওপরের 1FH পরে। কিন্তু runner শুধু ফল দেখায়, bus cycle নয়: Unicorn একটি ৩৮৬-শ্রেণির CPU-র নির্দেশ চালায়, 8086-এর pin-স্তরের আচরণ নয় (Spec decision 15 আর 16). Bus-এ কী ঘটত, তা datasheet-এর টেবিল থেকে নিচের মডেল দেখায়। এর শেষে একটি 8086 ROM-এর হিসাবও আছে: 8086-এর reset vector FFFF0H (reset-এ CS = FFFFH, IP = 0000H), তাই 8086-এ ROM বসে ঠিকানা-জগতের একেবারে ওপরে, 8085-এর ঠিক উল্টো। দুটি 8 KB chip (একটি even, একটি odd) মিলে 16 KB ROM হয় FC000H–FFFFFH.

# 8086-এর দুই bank: even bank D0-D7 (A0 = 0), odd bank D8-D15 (BHE = 0)
# Intel 8086 datasheet-এর BHE/A0 টেবিল; banks.asm-এর দুটি word লেখা
def bus_cycles(addr, value, width):
    """প্রতিটি bus cycle-এ BHE, A0, কোন bank আর কোন byte"""
    data = value.to_bytes(width, "little")      # low byte আগে (little-endian)
    cycles = []
    if width == 2 and addr % 2 == 0:            # জোড় ঠিকানা: এক cycle-এ পুরো word
        cycles.append((addr, 0, 0, f"even<-{data[0]:02X}  odd<-{data[1]:02X}"))
    else:
        for i, b in enumerate(data):
            a = addr + i
            if a % 2 == 0:
                cycles.append((a, 1, 0, f"even<-{b:02X}  (D0-D7)"))
            else:
                cycles.append((a, 0, 1, f"odd <-{b:02X}  (D8-D15)"))
    return cycles

for addr in (0x10200, 0x10205):                 # DS = 1000H, offset 0200H / 0205H
    print(f"word 1FFCH -> {addr:05X}H:")
    for n, (a, bhe, a0, what) in enumerate(bus_cycles(addr, 0x1FFC, 2), 1):
        print(f"  cycle {n}: address {a:05X}H  BHE={bhe} A0={a0}  {what}")

# 16 KB ROM (দুটি 8 KB chip) FC000H-FFFFFH-এ; chip-এর A0-A12 = CPU-র A1-A13
for addr in (0xFC000, 0xFC001, 0xFFFF0):
    bank = "odd" if addr & 1 else "even"
    print(f"{addr:05X}H -> {bank} chip, inside-chip address {(addr >> 1) & 0x1FFF:04X}H")

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

word 1FFCH -> 10200H:
  cycle 1: address 10200H  BHE=0 A0=0  even<-FC  odd<-1F
word 1FFCH -> 10205H:
  cycle 1: address 10205H  BHE=0 A0=1  odd <-FC  (D8-D15)
  cycle 2: address 10206H  BHE=1 A0=0  even<-1F  (D0-D7)
FC000H -> even chip, inside-chip address 0000H
FC001H -> odd chip, inside-chip address 0000H
FFFF0H -> even chip, inside-chip address 1FF8H

জোড় ঠিকানায় একটি cycle-এই দুই byte যায়, দুই bank একসঙ্গে। বিজোড় ঠিকানায় দুটি cycle: প্রথমে নিচের byte FCH odd bank-এ, ডেটা bus-এর ওপরের অর্ধেক দিয়ে; তারপর ওপরের byte 1FH পরের জোড় ঠিকানায়, নিচের অর্ধেক দিয়ে। মেমরির শেষ অবস্থা runner-এর FC 1F 00 00 00 FC 1F 00-এর সঙ্গে মেলে; পার্থক্য শুধু সময়ে। একেই বলে misaligned access, আর Intel-এর clock টেবিলে এর জন্য বাড়তি clock ধরা আছে (পর্ব ১৫). ROM-এর অংশে FC000H আর FC001H দুই chip-এর একই ভেতরের ঘর 0000H: একটি word-এর দুই অর্ধেক। CPU-র প্রথম নির্দেশ আসে FFFF0H থেকে, অর্থাৎ even chip-এর 1FF8H ঘর আর odd chip-এর একই ঘর থেকে।

mov [0205h],ax (AX = 1FFCH, DS = 1000H)
ঘটনা
BHE · A0
Even bank (D0–D7)
Odd bank (D8–D15)
Bus cycle মোট
  1. জোড় ঠিকানা, এক cycle. 10200H-এ word: A0 = 0, BHE̅ = 0, দুই bank একসঙ্গে। FCH নিচের অর্ধেকে even bank-এর 10200H-এ, 1FH ওপরের অর্ধেকে odd bank-এর 10201H-এ।
  2. বিজোড় ঠিকানা, প্রথম cycle. 10205H বিজোড়: BHE̅ = 0, A0 = 1, শুধু odd bank জাগে। নিচের byte FCH যায়, কিন্তু D8–D15 দিয়ে, কারণ odd bank সেখানে জোড়া। Even bank-এর chip select বন্ধ, তাই 10204H অক্ষত।
  3. দ্বিতীয় cycle. ঠিকানা 10206H, জোড়: BHE̅ = 1, A0 = 0, শুধু even bank. ওপরের byte 1FH যায় D0–D7 দিয়ে। এবার odd bank বন্ধ, তাই 10207H অক্ষত।
  4. ফল আর দাম। মেমরিতে FCH আর 1FH ঠিক জায়গায়, runner-এর ফলের মতো। কিন্তু একটি নির্দেশে দুটি bus cycle লাগল। এজন্য 8086-এর program-এ word data জোড় ঠিকানায় রাখা ভালো; NASM-এ align 2 এই কাজ করে।

Interfacing-এর নিয়মটি এখান থেকেই আসে। RAM-এ লেখার সময় দুই bank-এর chip select আলাদা হতেই হবে: even bank-এর chip বাছাই হবে decoder-এর output আর A0 = 0 দুটি একসঙ্গে হলে, odd bank-এর chip decoder আর BHE̅ = 0 হলে। শুধু decoder দিয়ে দুটি chip একসঙ্গে বাছাই করলে mov byte [0205h], al-এর মতো একটি byte লেখায় CPU-র ছেড়ে দেওয়া অর্ধেকের অনির্দিষ্ট মানও পাশের ঘরে লেখা হয়ে যেত। ROM-এর বেলায় নিয়মটি নরম: পড়লে কিছু নষ্ট হয় না, তাই অনেক নকশায় দুটি ROM chip পড়ার সময় একসঙ্গে বাছাই হয়, আর CPU দরকারি অর্ধেকটি নেয়।

আরও গভীরে: Chip-এর বাইরে আমরা যে decoding করলাম, chip-এর ভেতরেও তা আবার হয়। Hitachi-র HM6264A datasheet-এর block diagram-এ 8192 × 8 = 65536 bit সাজানো একটি 256 × 256 memory array-তে, সঙ্গে একটি row decoder আর একটি column decoder: ১৩টি ঠিকানার লাইনের কিছু সারি বাছে, বাকিগুলো কলাম। অর্থাৎ CPU-র ঠিকানা তিন স্তরে decode হয়: board-এর 74LS138 chip বাছে, chip-এর row decoder একটি word line চালু করে, আর column decoder সেই সারি থেকে আট bit তুলে আনে (ভেতরের গঠন Computer Architecture পর্ব ৪৯-এ). আজকের microcontroller-এ বাইরের দুই স্তর chip-এর ভেতরেই চলে গেছে: flash, SRAM আর peripheral register সবই একই silicon-এ, আর তাদের ঠিকানা-ভাগ ঠিক করে chip-এর bus matrix. তবু mirror হারায়নি: যেমন ST-র STM32F1 reference manual জানায়, BOOT pin অনুযায়ী 0x00000000 ঠিকানায় main flash বা system memory-র একটি alias দেখা যায়।

পরীক্ষা ও ইন্টারভিউতে: “16 KB মেমরিতে কয়টি address line?” → ১৪ (214 = 16384). “2000H থেকে 8 KB-এর শেষ ঠিকানা?” → 3FFFH (শুরু + মাপ − 1). “Full আর partial decoding-এর পার্থক্য?” → full-এ সব ওপরের লাইন decode হয়, প্রতিটি chip একবার; partial-এ কিছু লাইন উপেক্ষিত, k টি উপেক্ষিত লাইনে প্রতিটি chip 2k বার দেখা দেয়, কিন্তু gate কম লাগে। “74LS138 কখন চালু?” → G1 = 1, G2A̅ = 0, G2B̅ = 0; output active-low. “8086-এ BHE̅ = 0, A0 = 1 মানে?” → শুধু odd bank, D8–D15 দিয়ে একটি byte. “8085-এ ROM 0000H-এ, 8086-এ ওপরে কেন?” → reset vector: 8085-এ 0000H, 8086-এ FFFF0H.

৮ · AI-এর যুগে memory interfacing-এর উত্তর যাচাই

Memory interfacing-এর প্রশ্নে AI assistant দ্রুত একটি পরিষ্কার টেবিল আর circuit-এর বর্ণনা দেয়, আর বেশিরভাগ সময় মূল ধারণা ঠিক থাকে। ভুল ঢোকে খুঁটিনাটিতে: এক byte-এর হিসাব, কোনো pin-এর polarity, একটি ভুলে যাওয়া gate. এমন ভুল কাগজে নির্ভুল দেখায়, ধরা পড়ে শুধু board-এ। নিচের ভুলগুলো সবচেয়ে বেশি দেখা যায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
শেষের ঠিকানায় এক বেশি: “2000H থেকে 8 KB = 2000H–4000H”শুরু + মাপ − 1 নিজে হিসাব; map checker-এ দুই chip-এর সংঘর্ষ দেখা
74LS138-এর output active-high ধরে inverter বসায়, বা enable-এর polarity উল্টো লেখেDatasheet-এর truth table: সব output HIGH, শুধু বাছাই করা LOW
A, B, C-তে লাইনগুলো উল্টো ক্রমে জোড়ে (A15 → A)প্রতিটি output-এর পরিসর ঠিকানা ধরে decode করে মেলানো
Decoder-এ IO/M̅ বাদ দেয়, ফলে I/O cycle-এ memory সাড়া দেয়IN/OUT-এ port ঠিকানা A15–A8-এও বসে, তা মনে রেখে enable পরীক্ষা
Partial decoding-এর mirror অংশকে “খালি” বলে, নতুন chip সেখানে বসায়উপেক্ষিত লাইন গুনে 2k কপি হিসাব; checker-এ clash
8086-এ RAM-এর দুই bank একই chip select-এ, বা শুধু A0 দিয়ে বাছাইBHE̅/A0 টেবিল ধরে byte লেখার cycle ট্রেস করা
8085 আর 8086-এর reset ঠিকানা গুলিয়ে ফেলে, বা chip-এর access time ও pin নম্বর বানিয়ে বলেIntel-এর manual আর chip-নির্মাতার datasheet; উৎস না দিলে সংখ্যা গ্রহণ না করা

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

আমি Intel 8085 (8086 বা Z80 নয়) দিয়ে memory interfacing শিখছি। Hex Intel-এর ধরনে, শেষে H. ১. একটি 8 KB EPROM (8K × 8) 0000H-এ আর একটি 8 KB SRAM 2000H-এ বসাতে 74LS138 দিয়ে full decoding-এর নকশা দাও: কোন address লাইন chip-এ, কোনটি decoder-এর A, B, C-তে, আর G1, G2A, G2B কোথায়। ২. প্রতিটি chip-এর শুরু আর শেষের ঠিকানা দেখাও, শেষের ঠিকানা "শুরু + মাপ − 1" দিয়ে হিসাব করে। ৩. 74LS138-এর output active-high না active-low, আর কোন enable কোন polarity-র, datasheet-এর নাম দিয়ে বলো। ৪. IO/M কেন decoder-এ লাগে, তা IN বা OUT নির্দেশের উদাহরণ দিয়ে ব্যাখ্যা করো। ৫. কোনো access time বা pin নম্বর দিলে কোন datasheet থেকে, তা বলো; নিশ্চিত না হলে "নিশ্চিত নই" লেখো।

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

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

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

প্র ০১8085-এর ROM থাকে ঠিকানা-জগতের নিচে, 8086-এর ওপরে। এই পার্থক্য কোথা থেকে এল, আর পুরো একটি কম্পিউটারের memory map-এ এর প্রভাব কী?

পার্থক্যের মূলে reset vector: চালু হওয়ার মুহূর্তে CPU কোন ঠিকানা থেকে প্রথম নির্দেশ আনবে। 8085 (১৯৭৬) তার পূর্বসূরি 8080-এর ধারা মেনে reset-এ program counter শূন্য করে, তাই প্রথম নির্দেশ 0000H-এ। এর সঙ্গে আরেকটি নিয়ম জড়িত: 8085-এর RST নির্দেশ আর hardware interrupt-এর লাফের ঠিকানাগুলোও নিচের দিকে, 0000H থেকে 003CH-এর মধ্যে (পর্ব ১৩). তাই নিচের অঞ্চলে স্থায়ী মেমরি রাখাই স্বাভাবিক, আর RAM বসে তার ওপরে। এই পর্বের বাজারঘর board ঠিক এভাবেই।

8086 (১৯৭৮)-এর নকশাকারীরা অন্য পথ নিলেন। Reset-এ CS = FFFFH আর IP = 0000H, তাই প্রথম নির্দেশ আসে FFFF0H থেকে, 1 MB-এর শেষ থেকে মাত্র ১৬ byte নিচে। সেখানে সাধারণত একটি far jump থাকে, যা ROM-এর আসল শুরুতে লাফ দেয়। অন্যদিকে 8086-এর interrupt vector table বসে একেবারে নিচে, 00000H থেকে 003FFH (পর্ব ২০), আর সেই টেবিল program চলার সময় বদলাতে হয়, তাই সেখানে RAM দরকার। ফলে 8086 system-এর স্বাভাবিক মানচিত্র: নিচে RAM, ওপরে ROM. 8085-এর ঠিক উল্টো, আর কারণটিও ঠিক উল্টো দিকের প্রয়োজন।

এই সিদ্ধান্তের প্রভাব পরের কয়েক দশক টিকে ছিল। ১৯৮১ সালের IBM PC 8088 দিয়ে তৈরি, যার reset একই; তার BIOS ROM বসেছিল 1 MB-এর একেবারে ওপরে, আর RAM নিচ থেকে বাড়ত, মাঝখানে video আর অন্য adapter-এর জায়গা। নিচের 640 KB-এর সেই পরিচিত সীমা এই মানচিত্রেরই ফল বলে বহুল প্রচলিত ব্যাখ্যা আছে: RAM ওপরের দিকে বাড়লে একসময় adapter আর ROM-এর অঞ্চলে ধাক্কা খায়। পরের x86 প্রজন্মগুলোও reset vector ঠিকানা-জগতের একেবারে ওপরের কাছেই রেখেছে, আর মাদারবোর্ডের firmware chip সেখানে decode হয়।

Microcontroller-এ ধারণাটি একই, রূপ ভিন্ন। ARM Cortex-M reset-এ ঠিকানা 0x00000004-এর word থেকে reset handler-এর ঠিকানা পড়ে (পর্ব ৩২-এ boot আর startup code), তাই সেখানে স্থায়ী মেমরি থাকতেই হয়; অনেক chip-এ 0x00000000-এর অঞ্চলে boot pin অনুযায়ী flash (বা অন্য boot মেমরি)-এর একটি alias দেখা যায়, যেমন STM32F1-এর reference manual (RM0008)-এ বর্ণিত বলে জানা যায়। কোর্সের বাজারঘর board-এ reset সরাসরি flash-এর শুরু 0x08000000 থেকে MSP আর 0x08000004 থেকে PC পড়ে (Spec decision 18). অর্থাৎ যেকোনো CPU-র memory map নকশার প্রথম প্রশ্ন একই থাকে: reset-এর পরে CPU কোথায় তাকায়, আর সেখানে কি এমন মেমরি আছে যা বিদ্যুৎ ছাড়াও program ধরে রাখে?

মূল উপলব্ধি: Memory map-এর কাঠামো ঠিক করে CPU-র reset vector আর interrupt টেবিলের অবস্থান; 8085-এ দুটিই নিচে বলে ROM নিচে, 8086-এ reset ওপরে আর vector টেবিল নিচে বলে ROM ওপরে আর RAM নিচে।

প্র ০২Partial decoding gate বাঁচায়, কিন্তু mirror তৈরি করে। একজন নকশাকার কখন জেনেশুনে এটি বেছে নেবেন, আর কখন এটি ভবিষ্যতের জন্য ফাঁদ?

১৯৭০ আর ৮০-র দশকের board-এ প্রতিটি TTL chip-এর জন্য জায়গা, বিদ্যুৎ আর তার জোড়ার শ্রম লাগত। দুটি memory chip-এর একটি ছোট controller-এ একটি 74LS138 বাদ দেওয়া মানে একটি chip কম, ষোলোটি solder joint কম, আর কিছু milliampere কম। এই পর্বের A13-only নকশা 6264-এর active-high CS2 কাজে লাগিয়ে একটি inverter-ও লাগায়নি। যে যন্ত্রের মেমরি কোনোদিন বাড়বে না, যার program হাতে লেখা আর সব ঠিকানা জানা, সেখানে mirror কার্যত অদৃশ্য: program কখনো 6050H ছোঁয় না, তাই সেটি 2050H-এর প্রতিচ্ছবি কি না তাতে কিছু আসে যায় না। এই যুক্তিতে বহু পুরোনো যন্ত্রে, আর পরীক্ষার বইয়ের অনেক উদাহরণে, linear select দেখা যায়।

ফাঁদটি লুকিয়ে থাকে তিন জায়গায়। প্রথম, সম্প্রসারণ: পরে কেউ নতুন chip যোগ করতে চাইলে দেখবেন পুরো ৬৪ KB আগেই “দখল” হয়ে আছে; এই পর্বের map checker দেখিয়েছে, নতুন RAM2 6000H-এ বসালে ৮১৯২ byte-এ দুটি chip একসঙ্গে data bus চালায়। তখন পুরোনো decoding নতুন করে নকশা করতে হয়, যা তৈরি board-এ ব্যয়বহুল। দ্বিতীয়, ভুল pointer: একটি bug যদি “অব্যবহৃত” 6000H অঞ্চলে লেখে, full decoding-এ সেটি শূন্যে হারাত বা কিছুই হতো না, কিন্তু partial decoding-এ চুপচাপ আসল data, যেমন smart scale-এর tare, বদলে দেয়। Bug-এর লক্ষণ দেখা দেয় সম্পূর্ণ অন্য জায়গায়, আর খোঁজা কঠিন হয়। তৃতীয়, নির্ণয়ের ভুল: স্বয়ংক্রিয় memory-size test প্রতিটি mirror-কে নতুন মেমরি ভাবে।

তাই পেশাদার নিয়মটি প্রায় এমন: partial decoding করলে mirror-এর তালিকা নকশার কাগজে লিখে রাখা, firmware-এ শুধু মূল ঠিকানা ব্যবহার করা, আর সম্প্রসারণের সম্ভাবনা থাকলে শুরু থেকেই full decoding বা অন্তত একটি অতিরিক্ত decoder output রেখে দেওয়া। আজ PLD বা FPGA-তে decoding লিখলে বাড়তি লাইন decode করার খরচ প্রায় শূন্য, তাই নতুন নকশায় partial decoding-এর অর্থনৈতিক যুক্তি অনেকটাই দুর্বল। তবে microcontroller-এর peripheral register-এ আজও mirror দেখা যায়, যেখানে chip-নির্মাতা ঠিকানার কিছু bit উপেক্ষা করে silicon বাঁচান; datasheet-এ “reserved” লেখা অঞ্চলে না লেখার নিয়মের একটি কারণ এটিও।

মূল উপলব্ধি: Partial decoding স্থির, ছোট নকশায় বৈধ সাশ্রয়, কিন্তু এর দাম দিতে হয় সম্প্রসারণে আর bug খোঁজায়; mirror-এর তালিকা না রাখলে এটি ভবিষ্যতের রক্ষণাবেক্ষণকারীর জন্য ফাঁদ।

প্র ০৩Memory chip-এ chip select আর output enable দুটি আলাদা pin কেন? দুটিকে একই সংকেতে জুড়লে কী সমস্যা হতে পারে?

একটি pin দিয়েই কাজ চালানো যেত বলে মনে হয়: chip বাছাই হলে data দেবে, না হলে ভাসমান থাকবে। কিন্তু chip-নির্মাতারা দুটি কাজ আলাদা করেছেন, আর ST-র M27C64A datasheet “two line output control” অংশে কারণটি সরাসরি লিখেছে। EPROM সাধারণত বড় memory array-তে একাধিক chip-এর সঙ্গে ব্যবহৃত হয়, আর দুই-লাইনের নিয়ন্ত্রণ দুটি জিনিস নিশ্চিত করে: সবচেয়ে কম বিদ্যুৎ খরচ, আর output-এ bus contention না হওয়ার পূর্ণ নিশ্চয়তা। নির্দেশনাও স্পষ্ট: chip enable decode করে device বাছাইয়ের প্রধান সংকেত হবে, আর output enable সব device-এ একসঙ্গে system-এর READ লাইনে যাবে।

বিদ্যুতের দিকটি সহজ। Chip enable নিষ্ক্রিয় হলে chip standby-তে যায়: M27C64A-এর datasheet-এ সক্রিয় অবস্থায় 30 mA আর standby-তে 100 µA. একটি board-এ আটটি EPROM থাকলে মাত্র একটি সক্রিয়, বাকি সাতটি প্রায় কিছুই খায় না। Output enable এই কাজ করে না; সেটি শুধু output buffer খোলে বা বন্ধ করে।

Contention-এর দিকটি সময়ের। Decoder-এর output ঠিকানা বদলানোর সঙ্গে সঙ্গে বদলায়, আর ঠিকানা বদলের মুহূর্তে কয়েক ns-এর জন্য decoder-এর একাধিক output অস্থির থাকতে পারে, বা পুরোনো chip বন্ধ হওয়ার আগেই নতুন chip চালু হতে পারে। শুধু chip select দিয়ে output চালু হলে সেই ক্ষণিক মুহূর্তে দুটি chip একই data লাইনে উল্টো মান চালাতে পারে: বড় current, শব্দ, আর দীর্ঘ মেয়াদে chip-এর ক্ষতি। Output enable-কে CPU-র RD̅-এর সঙ্গে বাঁধলে output খোলে শুধু তখনই, যখন CPU সত্যিই পড়ছে, আর ততক্ষণে ঠিকানা আর decoder স্থির হয়ে গেছে। লেখার cycle-এ RD̅ নিষ্ক্রিয়, তাই CPU যখন data bus চালাচ্ছে তখন memory চুপ থাকে; SRAM-এর বেলায় এটি আরও জরুরি, কারণ তার data pin দুই দিকেরই।

দুটিকে একই সংকেতে জুড়লে আরেকটি সমস্যা: chip-এর data দেওয়ার সময় তখন chip enable থেকে মাপা হয়, যা সাধারণত output enable-এর সময়ের চেয়ে বেশি; তাই প্রতিটি পড়া ধীর হয়। ঠিক এই কারণেই 8085-এর নকশায় MEMR̅ আর MEMW̅ আলাদা তৈরি করা হয় (পর্ব ০৮), আর এই পর্বের প্রতিটি নকশায় chip select এসেছে decoder থেকে, OE̅ এসেছে MEMR̅ থেকে।

মূল উপলব্ধি: Chip select ঠিক করে “কে”, output enable ঠিক করে “কখন”; দুটি আলাদা থাকায় বাছাই না হওয়া chip ঘুমায় আর data bus-এ একসঙ্গে দুজনের কথা বলার ঝুঁকি থাকে না।

প্র ০৪8086-এর ১৬ বিটের bus-এ মেমরিকে দুই bank-এ ভাগ করার নকশা থেকে আজকের alignment-এর নিয়ম পর্যন্ত কী শিক্ষা টিকে আছে?

8086-এর নকশাকারীদের সামনে দুটি চাওয়া ছিল। ১৬ বিটের data bus দিয়ে এক cycle-এ একটি word আনা, যাতে 8080-এর তুলনায় গতি বাড়ে; আবার 8080-এর মতো প্রতিটি byte-এর নিজের ঠিকানা রাখা, যাতে পুরোনো ধাঁচের program আর text-এর কাজ সহজ থাকে। দুই bank-এর নকশা দুটিই দেয়। জোড় ঠিকানার word-এ দুই bank একসঙ্গে, এক cycle. একক byte-এ একটি bank, আর BHE̅ ও A0 জানিয়ে দেয় কোনটি। বিজোড় ঠিকানার word-ও নিষিদ্ধ নয়, শুধু দুটি cycle লাগে, যা এই পর্বের মডেল দেখিয়েছে। Intel-এর clock টেবিলে এই বাড়তি খরচ লেখা আছে, আর পর্ব ১৫ ও ১৯-এ তার হিসাব এসেছে।

এর একটি পরিণতি হলো hardware-এ বাড়তি দায়িত্ব। RAM-এর দুই bank-এর chip select আলাদা না হলে byte লেখায় পাশের byte নষ্ট হয়; একজন board নকশাকারের কাছে BHE̅ তাই ঐচ্ছিক নয়। একই সময়ে Intel 8088 বাজারে আনে, ভেতরে একই CPU কিন্তু বাইরে ৮ বিটের data bus: একটি bank, BHE̅ নেই, আর তখনকার সস্তা ৮ বিটের support chip সরাসরি জোড়া যায়। ১৯৮১ সালের IBM PC 8088 বেছে নিয়েছিল, আর প্রচলিত ব্যাখ্যা হলো এতে board আর peripheral সস্তা ও সহজ হয়েছিল; বিনিময়ে প্রতিটি word-এ দুটি bus cycle.

আজকের শিক্ষাটি alignment. প্রায় প্রতিটি আধুনিক CPU-র bus ৩২ বা ৬৪ বিট চওড়া, আর ভেতরে byte-lane বা byte-enable সংকেত আছে, যা 8086-এর BHE̅ আর A0-এর বড় রূপ। Natural alignment-এ রাখা ডেটা এক লেনদেনে আসে; ভুল জায়গায় রাখলে দুটি লেনদেন লাগে, বা কিছু architecture-এ সরাসরি fault হয়। ARM Cortex-M0-এর মতো ছোট core-এ unaligned word পড়লে fault হয়, যেখানে Cortex-M3/M4 সাধারণ load-store-এ তা সামলায় কিন্তু ধীরে (পর্ব ২৯-এ Cortex-M-এর গঠন). C compiler এই কারণেই struct-এর ভেতরে padding বসায়, আর network packet-এর মতো “packed” data পড়তে সাবধান হতে হয় (পর্ব ৩৯-এ এমবেডেড memory).

আরেকটি টিকে থাকা ধারণা হলো, “ঠিকানা” আর “bus-এর লাইন” এক নয়। 8086-এ chip-এর A0 আসে CPU-র A1 থেকে, কারণ CPU-র A0 bank বাছাইয়ে খরচ হয়। ৩২ বিটের bus-এ chip-এর ঠিকানা শুরু হয় CPU-র A2 থেকে। Datasheet পড়ার সময় এই স্থানান্তর না বুঝলে register বা মেমরির ঠিকানা ভুল হিসাব হয়; AI-এর উত্তরেও এই ভুল প্রায়ই দেখা যায়।

মূল উপলব্ধি: 8086-এর দুই bank byte-ঠিকানা আর চওড়া bus-এর মিলন; সেখান থেকে আসা byte-enable আর alignment-এর নিয়ম আজও প্রতিটি CPU-তে কাজ করে, শুধু bus চওড়া হয়েছে।

প্র ০৫অতিবেগুনি আলোয় মোছা EPROM থেকে আজকের on-chip flash: এই পরিবর্তন memory interfacing-এর কাজকে কীভাবে বদলেছে, আর কী একই রয়ে গেছে?

EPROM-এর উদ্ভাবন সাধারণত Intel-এর Dov Frohman-এর নামে, ১৯৭১ সালে, 1702 chip দিয়ে বলা হয়। এর আগে ROM-এর তথ্য কারখানায় mask দিয়ে লেখা হতো, বা PROM-এ একবার fuse পুড়িয়ে; ভুল হলে chip ফেলে দিতে হতো। EPROM-এ floating gate-এ চার্জ রেখে bit লেখা যেত, আর chip-এর quartz জানালা দিয়ে অতিবেগুনি আলো ফেলে পুরোটা মুছে আবার লেখা যেত (মোছার সময় নির্মাতা ভেদে কয়েক মিনিট থেকে বেশি)। 8085-এর যুগের firmware তৈরির চক্র ছিল: program লেখা, EPROM programmer-এ পোড়ানো, board-এর socket-এ বসানো, পরীক্ষা, ভুল পেলে UV eraser-এ মোছা, আবার শুরু। এই পর্বের 2764 সেই ধারার একটি জনপ্রিয় সদস্য।

পরের ধাপ বিদ্যুৎ দিয়ে মোছা: EEPROM, তারপর flash, যার উদ্ভাবন Toshiba-র Fujio Masuoka-র নামে ১৯৮০-এর দশকে বলে স্বীকৃত। Flash বড় block একসঙ্গে মোছে, তাই ঘন আর সস্তা। এক সময় flash আর SRAM দুটিই CPU-র সঙ্গে একই silicon-এ উঠে এল, আর জন্ম নিল আজকের microcontroller (পর্ব ০৩). এতে board-স্তরের memory interfacing প্রায় উধাও: STM32 বা ATmega328P-এর ভেতরেই flash, SRAM আর peripheral register-এর ঠিকানা স্থির, বাইরে কোনো 74LS138 লাগে না। Firmware বদলাতে আর chip খুলতে হয় না, debug probe বা bootloader দিয়ে মিনিটে নতুন program বসে, এমনকি দূর থেকে OTA update-ও সম্ভব (পর্ব ৭৫ আর ৭৭).

তবু তিনটি জিনিস একই রয়ে গেছে। প্রথম, memory map: কোন ঠিকানায় flash, কোথায় SRAM, কোথায় peripheral, তা এখন datasheet আর linker script-এ লেখা (পর্ব ৩১-এ memory map আর linker script); ভুল ঠিকানায় variable বসালে ফল এই পর্বের ভুল decoding-এর মতোই। দ্বিতীয়, timing: flash-এর access time CPU-র clock-এর চেয়ে ধীর হলে আজও wait state লাগে, শুধু এখন নাম “flash wait state”, আর clock বাড়ালে register-এ সেটি বাড়াতে হয় (পর্ব ৩৩-এ clock আর power). তৃতীয়, বাইরের মেমরি পুরোপুরি হারায়নি: বড় display বা data log-এর জন্য বাইরের SRAM বা flash যোগ করতে হলে chip-এর external memory controller আবার chip select, address আর timing-এর একই প্রশ্ন তোলে।

এ কারণেই 8085-এর decoding শেখা আজও অর্থবহ। এটি সবচেয়ে সরল জায়গা, যেখানে ঠিকানার bit থেকে একটি chip-এর জেগে ওঠা পর্যন্ত প্রতিটি ধাপ নিজের চোখে দেখা যায়।

মূল উপলব্ধি: Memory chip CPU-র ভেতরে চলে আসায় board-এর decoder হারিয়েছে, কিন্তু memory map, chip select আর access time-এর ধারণা নতুন নামে প্রতিটি microcontroller-এ বেঁচে আছে।

অনুশীলন

প্রথমে নিজে নকশা বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তরের ঠিকানা আর ফল এই পর্বের মডেলগুলো দিয়ে lab-এ যাচাই করা।

  1. নকশা — 2 KB-এর ঘরে তিনটি chip: একটি 8085 system-এ একটি 4 KB EPROM (4K × 8) 0000H থেকে, আর দুটি 2 KB SRAM (2K × 8) ঠিক তার পরে পরপর বসাতে হবে, 74LS138 দিয়ে full decoding. কোন লাইন chip-এ আর কোনটি decoder-এ যাবে, কোন output কোন chip-এ, আর প্রতিটির পরিসর কী?

    সবচেয়ে ছোট chip 2 KB = 211, তাই decoder-এর ঘর 2 KB মাপের: A0–A10 সব chip-এ, A11, A12, A13 যায় decoder-এর A, B, C-তে। Full decoding-এর জন্য A14 আর A15-কেও 0 হতে হবে: A15 → G2A̅, A14 → G2B̅, আর G1 = IO/M̅-এর উল্টো (একটি inverter), যাতে শুধু memory cycle-এ চালু হয়। মডেলে হিসাব করা ঘর: Y0 0000H–07FFH, Y1 0800H–0FFFH, Y2 1000H–17FFH, Y3 1800H–1FFFH, Y4 2000H–27FFH … Y7 3800H–3FFFH. EPROM 4 KB দুটি ঘর নেয় (0000H–0FFFH), তাই তার CE̅ = Y0̅ AND Y1̅ (একটি AND gate: যেকোনো একটি 0 হলে ফল 0). EPROM-এর A11 আসে CPU-র A11 থেকে। RAM1-এর CS1̅ ← Y2: 1000H–17FFH; RAM2-এর CS1̅ ← Y3: 1800H–1FFFH. Y4–Y7 খালি: 2000H–3FFFH. 4000H-এর ওপরে কোনো chip সাড়া দেয় না।

  2. ভুল খুঁজুন — উল্টো তার: একজন ছবি ২২.১-এর board বানাতে গিয়ে A13 জুড়েছেন decoder-এর C-তে আর A15 জুড়েছেন A-তে (A14 ঠিকই B-তে). RAM আছে Y1-এ। কোর্সের program STA 2050H করে, তারপর LDA 2050H. কী ঘটবে, আর RAM আসলে কোন ঠিকানায় পাওয়া যাবে?

    2050H-এ A15 A14 A13 = 0 0 1. উল্টো তারে C = A13 = 1, B = A14 = 0, A = A15 = 0, অর্থাৎ C B A = 100 = ৪: Y4 নামে, যেখানে কোনো chip নেই। STA-এর byte কোথাও লেখা হয় না, আর LDA-র সময় data bus ভাসমান থাকে, তাই যা পড়া হবে তা অনির্দিষ্ট (প্রায়ই FFH, কিন্তু নিশ্চিত নয়)। মডেলে প্রতিটি 8 KB ঘর ধরে decode করলে: 0000H → Y0, 2000H → Y4, 4000H → Y2, 6000H → Y6, 8000H → Y1, A000H → Y5, C000H → Y3, E000H → Y7. তাই RAM (Y1) আসলে 8000H–9FFFH-এ। ROM Y0-তে, আর 0000H-এ A15 = A14 = A13 = 0 বলে ঠিক জায়গায় থাকে, তাই board চালু হয় আর ভুলটি প্রথমে চোখে পড়ে না। শিক্ষা: শুধু 0000H পরীক্ষা যথেষ্ট নয়; প্রতিটি chip-এর একটি ঠিকানায় লিখে পড়ে দেখুন।

  3. আগে বলুন, তারপর যাচাই — শুধু A15 দেখা board: একটি নকশায় 8 KB ROM-এর CE̅-এ সরাসরি A15, আর 8 KB RAM বাছাই হয় A15 = 1 হলে (6264-এর CS2-তে A15). A13 আর A14 কেউ দেখে না। ROM আর RAM-এর সব পরিসর লিখুন। MVI A,77H / STA 8050H / LDA 0A050H-এর পরে A কত? আর কোর্সের program 2000H-এ বসাতে চাইলে কী সমস্যা?

    দুটি লাইন উপেক্ষিত, তাই প্রতিটি chip 22 = ৪ বার। ROM (A15 = 0): 0000H, 2000H, 4000H, 6000H থেকে শুরু চারটি 8 KB ঘর, অর্থাৎ 0000H–7FFFH পুরোটা। RAM (A15 = 1): 8000H, A000H, C000H, E000H থেকে, অর্থাৎ 8000H–FFFFH. 8050H আর 0A050H দুটির ভেতরের ঘর 0050H (A12–A0 একই), আর দুটিতেই A15 = 1: একই RAM-এর একই ঘর, তাই A = 77H. সমস্যা: এই board-এ 2000H ROM-এর mirror (মডেল: “2050H is ROM? True”), তাই সেখানে program লোড করা যায় না, আর কোর্সের 2050H-এ data লেখা হারিয়ে যাবে। এই নকশায় program আর data 8000H-এর ওপরে রাখতে হতো।

  4. হিসাব — 8086-এর 16 KB RAM: একটি 8086 board-এ দুটি 6264 (8K × 8) দিয়ে 16 KB RAM 00000H থেকে। CPU-র কোন লাইন chip-এর A0–A12-এ যাবে, কোন লাইন decode হবে, দুই chip-এর chip select কীভাবে? তারপর বলুন: (ক) mov byte [0005h], 0AAh (DS = 0000H), (খ) mov [0006h], ax, (গ) mov [0007h], ax (AX = 1FFCH): প্রতিটিতে কয়টি bus cycle, BHE̅ আর A0 কত, কোন chip-এর কোন ভেতরের ঘর?

    16 KB = দুই bank × 8 KB. Chip-এর A0–A12 ← CPU-র A1–A13; CPU-র A0 আর BHE̅ bank বাছে। পরিসর 00000H–03FFFH, তাই A14–A19 সব 0 হলে decoder-এর RAMSEL̅ = 0. Even chip-এর CS1̅ = RAMSEL̅ OR A0, odd chip-এর CS1̅ = RAMSEL̅ OR BHE̅; দুটির OE̅ ← MEMR̅ (বা RD̅), WE̅ ← WR̅. মডেলের ফল: (ক) 00005H বিজোড়: ১ cycle, BHE̅ = 0, A0 = 1, odd chip-এর ঘর 0002H-এ AAH (D8–D15 দিয়ে). (খ) 00006H জোড়: ১ cycle, BHE̅ = 0, A0 = 0, দুই chip-এর ঘর 0003H: even-এ FCH, odd-এ 1FH. (গ) 00007H বিজোড়: ২ cycle; প্রথমে BHE̅ = 0, A0 = 1, odd chip-এর 0003H-এ FCH; তারপর ঠিকানা 00008H, BHE̅ = 1, A0 = 0, even chip-এর 0004H-এ 1FH. (ক)-তে even chip বাছাই হলে তার 0002H ঘর (ঠিকানা 00004H) নষ্ট হতো; আলাদা chip select ঠিক এটাই আটকায়।

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

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

ক্রমএকটি 8085 system-এ ROM আর RAM জোড়ার নকশার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. কত মেমরি লাগবে আর reset vector কোথায়, তা ঠিক করা
  2. প্রতিটি chip-এর organization থেকে ভেতরের address line গোনা
  3. শুরু আর শেষের ঠিকানা দিয়ে memory map আঁকা
  4. নিচের address line আর data bus সব chip-এ জোড়া
  5. ওপরের লাইন decoder-এ দিয়ে তার output chip select-এ জোড়া
  6. OE আর WE-তে MEMR আর MEMW দিয়ে map-এ সংঘর্ষ নেই কি না যাচাই করা

একটি 8K × 8 SRAM chip-এর ভেতরের ঘর বাছতে কয়টি address line লাগে?

  • ৮টি
  • ১০টি
  • ১৩টি
  • ১৬টি

একটি 74LS138-এ G1 = 1, G2A̅ = 0, G2B̅ = 0, আর C B A = 1 0 1. কোন output-এর মান 0?

  • Y2
  • Y5
  • সবগুলো
  • একটিও না

একটি 8085 board-এ 8 KB RAM শুধু A13 = 1 দেখে বাছাই হয়; A14 আর A15 কেউ দেখে না। ৬৪ KB ঠিকানা-জগতে RAM কয়বার দেখা দেয়?

  • ১ বার
  • ২ বার
  • ৮ বার
  • ৪ বার

8086-এর একটি bus cycle-এ BHE̅ = 0 আর A0 = 1. কী স্থানান্তর হচ্ছে?

  • বিজোড় ঠিকানার একটি byte, D8–D15 দিয়ে
  • জোড় ঠিকানার পুরো word
  • জোড় ঠিকানার একটি byte, D0–D7 দিয়ে
  • কিছুই স্থানান্তর হয় না

একটি 8085 system-এর memory map-এ ROM কেন 0000H থেকে শুরু হতেই হয়?

  • ROM শুধু নিচের ঠিকানায় দ্রুত চলে
  • Stack সবসময় 0000H-এ থাকে
  • Reset-এর পরে CPU 0000H থেকে প্রথম নির্দেশ আনে
  • 74LS138-এর Y0 শুধু ROM-এ জোড়া যায়

8085-এর memory decoder (74LS138)-এর একটি enable-এ IO/M̅ জোড়া হয়। এটি না জুড়লে কোন সমস্যা হতে পারে?

  • Decoder ধীর হয়ে wait state লাগবে
  • I/O নির্দেশের সময় কোনো memory chip ভুল করে সাড়া দিতে পারে
  • ALE কাজ করবে না
  • ROM-এ লেখা শুরু হবে

শব্দকোষ

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

মনে রাখুন

  1. লাইন গোনা: N টি ঠিকানায় log2N টি লাইন (8K → ১৩); বাকি ওপরের লাইন chip বাছাইয়ে; শেষের ঠিকানা = শুরু + মাপ − 1.
  2. Memory map: reset vector ROM-এর জায়গা ঠিক করে: 8085-এ 0000H, 8086-এ FFFF0H. বাজারঘর board: ROM 0000H–1FFFH, RAM 2000H–3FFFH.
  3. 74LS138: G1 = 1, G2A̅ = G2B̅ = 0 হলে C B A-র মানের output 0, বাকি 1; IO/M̅ একটি enable-এ, যাতে I/O cycle-এ memory চুপ থাকে।
  4. Partial decoding: k টি উপেক্ষিত লাইনে প্রতিটি chip 2k বার; gate কম, কিন্তু mirror, সংঘর্ষ আর ভুল memory test-এর ঝুঁকি।
  5. 8086: even bank D0–D7 (A0 = 0), odd bank D8–D15 (BHE̅ = 0); chip-এর A0 = CPU-র A1; বিজোড় ঠিকানার word-এ দুই cycle; RAM-এর দুই bank আলাদা chip select-এ।

পরের পর্বে: পর্ব ২৩ (I/O interfacing — memory-mapped বনাম isolated I/O আর polling). একই decoder দিয়ে এবার LED আর switch-এর port: IN আর OUT, latch আর buffer, আর কখন port-কে মেমরির ঠিকানাতেই বসানো ভালো।

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

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