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

8251 USART আর 8237 DMA controller

The 8251 USART and the 8237 DMA Controller

Taught in Bangla, this lesson covers the 8251A USART: C/D addressing, mode and command words (4EH and 37H), status bits, baud rate from TxC and the bits of one frame. It then covers the 8237A DMA controller: four channels with address and count registers, the DREQ, HRQ, HOLD, HLDA and DACK handover, terminal count, and single, block, demand and cascade modes. The setup code runs in the course's 8085 simulator, while in-page Python models frames and DMA copies.

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

  • 8251A-এর block, pin আর C/D̅ দিয়ে data ও control আলাদা করা ব্যাখ্যা করা
  • যেকোনো serial format থেকে mode word আর command word বিট ধরে বানানো, আর status byte পড়ে অবস্থা বলা
  • একটি async frame বিট ধরে আঁকা, baud rate আর timer-এর count হিসাব করা, receiver-এর sampling আর framing error বোঝা
  • 8237A-এর register, byte pointer flip-flop, mode word আর count-এর N − 1 নিয়ম দিয়ে একটি channel সাজানো
  • HOLD/HLDA হাতবদল, single, block আর demand mode, আর memory-to-memory copy ধাপে ধাপে মেলানো, AI-এর উত্তর যাচাইসহ

১ · দুই সহকারী — একজন চিঠি পাঠায়, আরেকজন মাল সরায়

বাজারঘরের smart scale ওজন মেপে দাম বের করে, আর সেই দাম একটি তারের মাধ্যমে দোকানের হিসাবের কম্পিউটারে বা রসিদ-printer-এ পাঠাতে চায়: price=9.83 Tk, শেষে লাইন ভাঙার দুটি অক্ষর, মোট ১৫টি byte. একটি তারে একটির পর একটি বিট পাঠানোকে বলে serial যোগাযোগ। পর্ব ১৩-এ এই কাজ 8085-এর SOD pin দিয়ে করেছিলেন: প্রতিটি বিটের জন্য SIM, মাঝে T-state গুনে অপেক্ষা। ২৪০০ baud-এ একটি byte পাঠাতে লেগেছিল ১২৫১৯ T, আর পুরো সময় CPU অন্য কিছু করতে পারেনি; interrupt এলে বিটের দৈর্ঘ্য নষ্ট হয়, তাই interrupt-ও বন্ধ রাখতে হয়। একে বলে bit-banging. পুরো লাইনে প্রায় ১৫ গুণ, অর্থাৎ ৬০ ms-এর বেশি সময় CPU বন্দি।

দ্বিতীয় সমস্যা ভিন্ন ধরনের। Scale-এর memory-তে কয়েকটি দামের একটি টেবিল আছে, যা মাঝে মাঝে আরেক জায়গায় (যেমন display-এর buffer-এ) কপি করতে হয়। Reference lab-এর block_move.asm দেখিয়েছে, 8085-এর loop-এ প্রতিটি byte কপি করতে ৪০ T লাগে: পড়া, লেখা, দুটি pointer বাড়ানো, count কমানো, লাফ। প্রতিটি byte দুইবার CPU-র ভেতর দিয়ে যায়, আর নির্দেশ fetch করতেও bus খরচ হয়। Disk বা দ্রুত যন্ত্র থেকে হাজার হাজার byte এলে এই খরচ অসহ্য হয়ে ওঠে।

Intel-এর উত্তর ছিল দুটি সহকারী chip. 8251A USART (universal synchronous/asynchronous receiver/transmitter) serial-এর পুরো বিট-কাজ নিজে করে; CPU শুধু একটি byte দেয় বা নেয়। আর 8237A DMA controller CPU-র কাছ থেকে কিছুক্ষণের জন্য bus ধার নিয়ে নিজেই memory আর যন্ত্রের মধ্যে, বা memory-র এক জায়গা থেকে আরেক জায়গায়, byte সরায়। দুটিই 8080/8085 পরিবারের সহায়ক chip হিসেবে ১৯৭০-এর দশকের শেষভাগে এসেছিল (সঠিক সাল উৎসভেদে আলাদা), আর 8086/8088-এর সঙ্গেও একইভাবে চলেছে।

উপমা — পোস্ট অফিসের কেরানি আর আড়তের কুলি: দোকানদার চিঠি লিখে কেরানির হাতে দেন; খামে ভরা, ঠিকানা আর ডাকটিকিট লাগানো, ডাকে পাঠানো কেরানির কাজ (8251: start বিট, parity, stop বিট আর সময়)। কেরানির টেবিলে একটি চিঠি রাখার জায়গা খালি হলেই তিনি ডাকেন “পরেরটা দিন” (TxRDY). আর আড়তে মালিক কুলি-সর্দারকে শুধু বলেন, “এই গুদামের ছয় বস্তা ওই গুদামে নিন” (8237: ঠিকানা আর সংখ্যা)। সর্দার রাস্তা চান (HOLD), মালিক রাস্তা ছেড়ে দেন (HLDA), কুলিরা বস্তা গুনে গুনে সরায়, শেষ বস্তায় হাঁক দেয় (EOP), তারপর রাস্তা আবার মালিকের।

লেখার নিয়ম আগের পর্বগুলোর মতো: সংখ্যা Intel-এর ধরনে, শেষে H (4EH, 0C1H; অক্ষর দিয়ে শুরু হলে সামনে 0); বিটের নকশা টেবিলে 0100 1110b. CPU-র clock 3 MHz (6 MHz crystal), এক T-state = 0.333 µs. এই পর্বের নকশায় 8251A বসেছে port 0C0H (data) আর 0C1H (control/status)-এ, আর 8237A বসেছে 70H–7FH-এ; দুটিই port-mapped I/O. 8085-এর program কোর্সের reference lab-এর sim8085.py-তে চালানো (lab-এর পরিচয় পর্ব ০৬-এ)। কিন্তু lab 8251 বা 8237 chip emulate করে না। তাই এই পর্বের জন্য Intel-এর দুটি datasheet থেকে দুটি ছোট model লেখা হয়েছে: usart8251.py (8251A, order number 205222-002) আর dma8237.py (8237A, order number 231466-005). লেখকের lab-এ datasheet-এর টেবিল আর বাক্যের সঙ্গে মিলিয়ে এদের ১৫টি পরীক্ষা পাস করেছে। নিচের ব্লকগুলোতে chip-এর প্রতিক্রিয়া আসে এই model থেকে, আর CPU-র byte ও সময় আসে simulator-এর সত্যিকারের run থেকে; দুটি আলাদা রাখা হয়েছে, যাতে কোনটি কার কাজ, স্পষ্ট থাকে।

২ · 8251A-এর গঠন, pin আর দুটি ঠিকানা

8251A একটি ২৮ pin-এর chip. Datasheet-এর block diagram-এ সাতটি অংশ: data bus buffer (CPU-র সঙ্গে ৮ বিটের দুই দিকের পথ), read/write control logic (কে কী পড়ছে বা লিখছে), modem control (DSR̅, DTR̅, CTS̅, RTS̅), transmit buffer আর transmit control, receive buffer আর receive control. Transmit buffer একটি parallel থেকে serial shift register, receive buffer উল্টোটি। Datasheet-এর ভাষায় chip-টি “full-duplex, double-buffered”: একই সময়ে পাঠানো আর নেওয়া চলে (full-duplex), আর প্রতিটি দিকে shift register-এর আগে একটি অতিরিক্ত byte রাখার জায়গা আছে।

দলPinকাজ
CPU-র দিকD7–D0, RD̅, WR̅, CS̅, C/D̅, CLK, RESETbyte আদান-প্রদান; C/D̅ বেছে নেয় data না control
পাঠানোTxD, TxC̅, TxRDY, TxEMPTYserial বিট বাইরে; TxC̅-এর নামার ধারে বিট সরে
নেওয়াRxD, RxC̅, RxRDY, SYNDET/BRKDETserial বিট ভেতরে; RxC̅-এর ওঠার ধারে নমুনা
ModemDSR̅, DTR̅, CTS̅, RTS̅সাধারণ কাজের ১ বিটের input/output; CTS̅ = 0 না হলে পাঠানো শুরু হয় না

CPU কোন register-এর সঙ্গে কথা বলছে, তা ঠিক করে C/D̅ (control/data) আর RD̅ বা WR̅. Datasheet-এর টেবিলটি হুবহু:

C/D̅RD̅WR̅CS̅কাজএই নকশায়
00108251A-এর data → data bus (পাওয়া byte পড়া)IN 0C0H
0100data bus → 8251A-এর data (পাঠানোর byte)OUT 0C0H
1010status → data busIN 0C1H
1100data bus → control (mode বা command)OUT 0C1H
X110data bus ভাসমান (3-state)—
XXX1data bus ভাসমান (3-state)—

তাই সংযোগটি সহজ: 8085-এর A0 যায় C/D̅-তে, আর A7–A1 = 1100 000 হলে একটি address decoder (পর্ব ২২) CS̅ নামায়; chip সাড়া দেয় 0C0H আর 0C1H-এ। Datasheet বলে CLK সাধারণত CPU-র clock-এর সঙ্গে জোড়া থাকে আর তার frequency “greater than 30 times the Receiver or Transmitter data bit rates” হতে হবে; এখানে 3 MHz, যা ২৪০০ baud-এর ১২৫০ গুণ। বিটের সময় আসে TxC̅ আর RxC̅ থেকে, যা সাধারণত একটি programmable timer-এর output; 8253/8254-এর counter দিয়ে এই clock বানানো পর্ব ২৫-এর বিষয়। নিচের ছবিতে দুটি chip একসঙ্গে, পুরো পর্বের নকশা:

ছবি ২৭.১ — 8085, memory, 8251A আর 8237A একই bus-এ

HOLD/HLDA দিয়ে bus-এর মালিকানা বদলায়; 8251-এর RxRDY যেতে পারে 8237-এর DREQ2-তে

8085, memory, 8251A আর 8237A-এর সংযোগ 8085 CPUmemory 8237A8251A 3 MHz2000H… latch (A15–A8) 70H–7FHC0H, C1H system bus TxD, RxD → কম্পিউটার TxC ← 3 MHz ÷ 78 HOLDHLDA HRQHLDA ADSTB DREQ2DACK2 RxRDYTxRDY→INT
ছবি ২৭.১ — Pin-এর নাম Intel-এর 8251A আর 8237A datasheet অনুসারে; 8237A-কে 8085-এর সঙ্গে জোড়ার ধরন 8237A datasheet-এর Figure 8 (8237A System Interface)-এর সরল রূপ। ঠিকানা আর scale-এর নকশা এই কোর্সের নিজের, কাল্পনিক। TxC̅ আর RxC̅ আসে একটি timer থেকে (3 MHz ÷ 78); TxRDY যেতে পারে একটি interrupt লাইনে।

একটি সূক্ষ্ম বিষয় পরীক্ষায় প্রায়ই আসে। TxRDY নামে একটি pin আছে, আবার status byte-এর D0-ও TxRDY. দুটি এক নয়। Datasheet-এর Figure 13-এর টীকা অনুযায়ী status বিট = শুধু “transmit buffer খালি”, আর pin = buffer খালি এবং CTS̅ = 0 এবং command-এর TxEN = 1. তাই transmitter বন্ধ থাকলে status-এ TxRDY = 1 দেখালেও pin নিচে থাকে, আর সেই pin-এ জোড়া interrupt আসে না। CPU-কে byte দিতে ডাকার জন্য pin-টি interrupt লাইনে, আর polling-এর জন্য status বিট; polling আর interrupt-চালিত I/O-র তুলনা পর্ব ২৩-এ।

৩ · Mode, command আর status — তিনটি byte-এর ভাষা

8251A-এর একটি মাত্র control ঠিকানা (0C1H), অথচ সেখানে দুই ধরনের byte যায়। কোনটি কী, তা ঠিক হয় ক্রম দিয়ে, byte-এর কোনো বিট দিয়ে নয়। Datasheet-এর Figure 7 অনুযায়ী reset-এর (বাইরের RESET pin বা ভেতরের internal reset) ঠিক পরের প্রথম control byte হলো mode word; sync mode হলে তারপর এক বা দুটি sync অক্ষর; তারপর থেকে প্রতিটি control byte হলো command word, যতবার খুশি। আবার mode বদলাতে হলে command-এর D6 (IR, internal reset) = 1 লিখে chip-কে mode-এর অপেক্ষায় ফেরাতে হয়।

Async mode word (Figure 8): D1 D0 = baud rate factor (00 হলে sync mode, 01 = ×1, 10 = ×16, 11 = ×64); D3 D2 = অক্ষরের দৈর্ঘ্য (00 = ৫, 01 = ৬, 10 = ৭, 11 = ৮ বিট); D4 = PEN (parity চালু); D5 = EP (1 = even, 0 = odd); D7 D6 = stop বিট (01 = ১, 10 = ১.৫, 11 = ২, 00 = অবৈধ)।

বিটD7 D6D5D4D3 D2D1 D0
নামS2 S1EPPENL2 L1B2 B1
অর্থstop বিট: 01 = ১, 10 = ১.৫, 11 = ২1 = even1 = parity চালুদৈর্ঘ্য − ৫01 = ×1, 10 = ×16, 11 = ×64
4EH010011 (৮)10 (×16)
7AH011110 (৭)10 (×16)

Sync mode-এ (D1 D0 = 00) ওপরের দুটি বিটের অর্থ বদলায়: D7 = SCS (1 = একটি sync অক্ষর, 0 = দুটি), D6 = ESD (1 = SYNDET pin input, অর্থাৎ বাইরের circuit sync খুঁজে দেয়)। Sync মানে বিট-clock প্রেরক আর গ্রাহকের মধ্যে ভাগ করা, আর অক্ষরগুলো ফাঁক ছাড়া টানা চলে; প্রতিটি অক্ষরে start/stop বিট নেই, শুরু চেনা যায় sync অক্ষর দিয়ে। এই কারণে datasheet-এ sync-এর সর্বোচ্চ হার 64K baud, async-এর 19.2K baud. আজকের এমবেডেড কাজে প্রায় সব সময় async, তাই এই পর্বের মূল উদাহরণ async.

Command word (Figure 12), D0 থেকে D7: TxEN (পাঠানো চালু), DTR (1 হলে DTR̅ pin = 0), RxE (নেওয়া চালু), SBRK (TxD-কে জোর করে 0 রাখা, “break”), ER (PE, OE, FE error flag মোছা), RTS (1 হলে RTS̅ pin = 0), IR (internal reset), EH (sync-এ hunt mode). Status word (Figure 13), D0 থেকে D7: TxRDY, RxRDY, TxEMPTY, PE (parity error), OE (overrun error), FE (framing error), SYNDET/BRKDET, DSR. Datasheet আরও বলে, status-এর হালনাগাদ প্রকৃত ঘটনা থেকে সর্বোচ্চ ২৮টি clock পিছিয়ে থাকতে পারে।

নিচের ব্লকে model-এর ফাংশন: mode_word() প্রয়োজন থেকে byte বানায়, decode_mode() byte থেকে অর্থ বলে, names() command আর status-এর বিটের নাম পড়ে। শেষ অংশটি power-up-এর একটি বাস্তব সমস্যা দেখায়, যা নিচে ব্যাখ্যা করা হলো।

# 8251A-এর mode, command আর status word (usart8251 = এই পর্বের model, Intel-এর datasheet থেকে)
from usart8251 import mode_word, decode_mode, command_word, names, CMD, STAT, USART

for kw in (dict(), dict(data_bits=7, parity="even"), dict(stop=2, factor=64),
           dict(data_bits=7, parity="odd", stop=1, factor=1)):
    w = mode_word(**kw)
    print(f"mode {w:02X}H = {w:08b}b  {decode_mode(w)}")
print(f"mode 1CH = {decode_mode(0x1C)}")

cmd = command_word(txen=1, dtr=1, rxe=1, er=1, rts=1)
print(f"\ncommand {cmd:02X}H: {names(cmd, CMD)}")
for s in (0x05, 0x84, 0x12):
    print(f"status  {s:02X}H: {names(s, STAT)}")

# power-up: chip কোন অবস্থায় জেগেছে জানা নেই -> 00H, 00H, 00H, 40H
print()
for first in ("mode", "sync1", "sync2", "command"):
    u = USART(state=first)
    path = [u.state]
    for v in (0x00, 0x00, 0x00, 0x40):
        u.write(1, v)
        path.append(u.state)
    print(" -> ".join(path))

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

mode 4EH = 01001110b  async x16, 8 data, no parity, 1 stop
mode 7AH = 01111010b  async x16, 7 data, even parity, 1 stop
mode CFH = 11001111b  async x64, 8 data, no parity, 2 stop
mode 59H = 01011001b  async x1, 7 data, odd parity, 1 stop
mode 1CH = sync, 8 data, odd parity, 2 sync char, SYNDET out

command 37H: TxEN DTR RxE ER RTS
status  05H: TxRDY TxEMPTY
status  84H: TxEMPTY DSR
status  12H: RxRDY OE

mode -> sync1 -> sync2 -> command -> mode
sync1 -> sync2 -> command -> command -> mode
sync2 -> command -> command -> command -> mode
command -> command -> command -> command -> mode

প্রথম চার লাইন পরীক্ষার সবচেয়ে প্রচলিত নকশা: 4EH (৮ বিট, parity নেই, ১ stop, “8N1”) আর 7AH (৭ বিট, even parity, ১ stop, “7E1”). 1CH-এর D1 D0 = 00, তাই সেটি sync mode, আর তখন D7 D6 stop বিট নয়। 12H মানে একটি অক্ষর পড়ার অপেক্ষায় (RxRDY) আর তার আগের একটি অক্ষর হারিয়ে গেছে (OE).

শেষ চার লাইন datasheet-এর “Internal Reset on Power-up” টীকার কারণ। Power চালুর মুহূর্তে chip mode, sync অক্ষর বা command, যেকোনো অবস্থায় জাগতে পারে। Intel-এর পরামর্শ: “worst-case” ধরে নিয়ে control ঠিকানায় তিনবার 00H লিখুন (sync mode, দুটি sync অক্ষর), তারপর internal reset 40H. চারটি শুরুই শেষ হয় একই জায়গায়, “mode”-এর অপেক্ষায়। মাঝের 00H command হিসেবে পড়লেও ক্ষতি নেই, কারণ তাতে কিছুই চালু হয় না।

নিয়ম

8251A-এর control ঠিকানায় ক্রম: (power-up-এ 00H, 00H, 00H, 40H) → mode word → (sync হলে sync অক্ষর) → command word. Async mode word = stop · EP · PEN · দৈর্ঘ্য − ৫ · factor; 4EH = 8N1 ×16. Error flag মোছে command-এর ER (D4), পড়া নয়।

৪ · একটি frame, বিট ধরে — দাঁড়িপাল্লার দামের লাইন

কোনো কিছু পাঠানোর না থাকলে TxD উঁচু (1) থাকে; datasheet একে বলে “marking”. Async-এ প্রতিটি অক্ষর একটি স্বয়ংসম্পূর্ণ frame: প্রথমে একটি start বিট (0), তারপর data বিট, ছোট বিট (D0) আগে, তারপর থাকলে একটি parity বিট, শেষে এক বা একাধিক stop বিট (1). গ্রাহকের কাছে আলাদা clock তার নেই; start বিটের নামার ধার থেকেই সে সময় গোনা শুরু করে। তাই দুই পক্ষকে একই baud rate-এ একমত থাকতে হয়।

Baud-এর হিসাব, ধাপে ধাপে. লক্ষ্য ২৪০০ baud, mode 4EH (×16), timer-এর input clock 3 MHz.

  1. প্রয়োজনীয় TxC = 2400 × 16 = 38400 Hz.
  2. Timer-এর ভাগফল = 3,000,000 ÷ 38400 = 78.125; পূর্ণসংখ্যা লাগে, তাই 78.
  3. আসল TxC = 3,000,000 ÷ 78 = 38461.54 Hz; আসল baud = 38461.54 ÷ 16 = 2403.85.
  4. ত্রুটি = 2403.85 ÷ 2400 − 1 = +0.16%, অনেক কম (কতটা চলে, ভাবনার প্রশ্ন ৫-এ)।
  5. এক বিটের সময় = 16 × 78 = 1248 CPU clock = 1248 T = 416.0 µs; ১০ বিটের এক frame = 12480 T ≈ 4.16 ms.

বাজারঘরের দামের লাইনের একটি অক্ষর ধরা যাক, '9' = 39H = 0011 1001. ছোট বিট আগে, তাই D0…D7 = 1 0 0 1 1 1 0 0. নিচের ছবিতে পুরো frame:

ছবি ২৭.২ — TxD-তে '9' (39H), 8N1, এক বিট = 416 µs

উঁচু = 1, নিচু = 0; দুই প্রান্তে idle (উঁচু); ছোট গোল দাগ = গ্রাহক যেখানে নমুনা নেয় (বিটের মাঝখানে)

'9' অক্ষরের async frame 0100111001 S01234567E S = start, 0–7 = D0–D7, E = stop ১ বিট = 1248 T, পুরো frame = 12480 T
ছবি ২৭.২ — Datasheet-এর Figure 9 (Asynchronous Mode)-এর ধাঁচে আঁকা; বিটের মান model-এর frame(0x39) থেকে। লক্ষ করুন, data-র শেষ দুটি বিট (D6, D7) 0, তাই stop বিটের আগে লাইন নিচে থাকে; stop বিট না পেলে গ্রাহক framing error বলে।

এবার ধাপে ধাপে দেখুন CPU-র একটি OUT-এর পরে 8251A কী করে। সময় গোনা হয়েছে OUT-এর মুহূর্ত থেকে, T-state-এ।

1MVI A,39H / OUT 0C0H2TxD: start বিট3TxD: D0 D14TxD: D2 D35TxD: D4 D56TxD: D6 D77TxD: stop বিট8TxD: idle (marking)
TxD আর status (model)
TxD এ পর্যন্ত
সময় (T)
TxRDY · TxEMPTY
  1. OUT 0C0H, A = 39H. C/D̅ = 0, WR̅ নামে: byte যায় transmit buffer-এ। Datasheet অনুযায়ী WR̅-এর ধারেই TxRDY নামে। Shifter খালি থাকলে byte সঙ্গে সঙ্গে shifter-এ চলে যায়।
  2. Start বিট, ০ থেকে ১২৪৮ T. Shifter byte নিয়েছে, buffer আবার খালি, তাই TxRDY = 1: CPU এখনই পরের অক্ষর দিতে পারে (double buffering). TxD নিচে নামে; গ্রাহকের কাছে এটিই “অক্ষর শুরু” সংকেত।
  3. D0 = 1, D1 = 0. প্রতিটি বিট ১৬টি TxC̅ পালস, অর্থাৎ ১২৪৮ T. বিট সরে TxC̅-এর নামার ধারে। 39H-এর ছোট বিট আগে যায়।
  4. D2 = 0, D3 = 1. ৩৭৪৪ থেকে ৬২৪০ T. CPU এই সময় সম্পূর্ণ মুক্ত; শুধু status পড়লে TxEMPTY = 0 দেখবে।
  5. D4 = 1, D5 = 1. 0011 1001-এর ওপরের দিকের দুটি 1. TxD এখন পর্যন্ত 0100111.
  6. D6 = 0, D7 = 0. ASCII অক্ষরে D7 সবসময় 0. ৮৭৩৬ থেকে ১১২৩২ T.
  7. Stop বিট = 1. ১১২৩২ থেকে ১২৪৮০ T. Mode word-এ ১ stop বলা ছিল। Parity চালু থাকলে এর আগে একটি parity বিট বসত, আর frame হতো ১১ বিটের।
  8. ১২৪৮০ T-এর পরে. নতুন byte দেওয়া হয়নি, তাই shifter আর buffer দুটোই খালি: TxEMPTY = 1, লাইন উঁচু। পুরো frame-এ ১২৪৮০ T = 4.16 ms; CPU-র খরচ শুধু দুটি নির্দেশ, ১৭ T.

গ্রাহক কীভাবে পড়ে. Datasheet-এর “Asynchronous Mode (Receive)” অংশ অনুযায়ী RxD-তে নামার ধার দেখলে 8251A start বিট সন্দেহ করে, তারপর বিটের মাঝখানে আবার দেখে (×16-এ আটটি RxC̅ পরে)। তখনো নিচু হলে সেটি আসল start বিট; উঁচু হলে সেটি ছিল একটি noise spike, যা উপেক্ষা হয়। এর নাম false start bit detection. তারপর প্রতি ১৬ clock-এ, প্রতিটি বিটের মাঝখানে, একটি নমুনা। Stop বিটের জায়গায় 0 পেলে framing error (FE). নিচের ব্লকে model-এর sample() তিনটি পরিস্থিতিতে '9' পড়ে।

# '9' (39H)-এর async frame, baud-এর হিসাব আর receiver-এর sampling (usart8251 model)
from usart8251 import frame, sample

bits = frame(0x39)                               # 8 data, no parity, 1 stop (mode 4EH)
print("TxD:", " ".join(f"{n}={b}" for n, b in bits))

clk, div, factor = 3_000_000, 78, 16             # 8085 CLK OUT, timer count, x16
txc = clk / div
baud = txc / factor
print(f"TxC = {txc:.2f} Hz, baud = {baud:.2f} ({(baud / 2400 - 1) * 100:+.2f} %)")
print(f"1 bit = {factor * div} T = {factor * div / 3:.1f} us, 1 frame = {10 * factor * div} T")

def line_of(bits, t0=1.0, spike=None):           # RxD level at sender-bit time t
    def line(t):
        if spike and spike[0] <= t < spike[1]:
            return 0
        i = int((t - t0) // 1) if t >= t0 else -1
        return bits[i][1] if 0 <= i < len(bits) else 1
    return line

for title, kw, ratio in (("ঠিক baud", {}, 1.0),
                         ("noise spike", dict(spike=(0.30, 0.45)), 1.0),
                         ("receiver 2640 baud", {}, 2640 / 2400)):
    byte, fe, times = sample(line_of(bits, **kw), ratio=ratio)
    at = " ".join(f"{t - 1:.2f}" for t in times)     # bit-time from the start edge
    print(f"{title}: {byte:02X}H FE={fe}")
    print(f"   samples: {at}")

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

TxD: start=0 D0=1 D1=0 D2=0 D3=1 D4=1 D5=1 D6=0 D7=0 stop=1
TxC = 38461.54 Hz, baud = 2403.85 (+0.16 %)
1 bit = 1248 T = 416.0 us, 1 frame = 12480 T
ঠিক baud: 39H FE=0
   samples: 1.50 2.50 3.50 4.50 5.50 6.50 7.50 8.50 9.50
noise spike: 39H FE=0
   samples: 1.50 2.50 3.50 4.50 5.50 6.50 7.50 8.50 9.50
receiver 2640 baud: 79H FE=1
   samples: 1.39 2.29 3.21 4.11 5.02 5.93 6.84 7.75 8.66

samples লাইনের সংখ্যাগুলো start বিটের নামার ধার থেকে বিট-সময়ে মাপা: D0 থাকে ১ থেকে ২-এর মধ্যে, তাই আদর্শ নমুনা ১.৫০-এ, আর stop বিটের নমুনা ৯.৫০-এ। Noise spike (০.৩০ থেকে ০.৪৫ বিট-সময়, প্রায় আড়াইটি RxC̅) মাঝখানের পরীক্ষায় ধরা পড়েছে, তাই ফল অপরিবর্তিত। কিন্তু গ্রাহক ১০% দ্রুত (২৬৪০ baud) হলে নমুনা ক্রমে আগে সরে যায়: D6-এর নমুনা ৬.৮৪-এ, যা আসলে D5-এর জায়গা (1), তাই byte হলো 79H; আর stop-এর নমুনা ৮.৬৬-এ, D7-এর 0-তে, তাই FE = 1. ভুল বিট আর framing error একসঙ্গে, ভুল baud-এর চেনা লক্ষণ।

পুরো লাইন, সত্যিকারের run. নিচের program 8251A-কে power-up নিয়মে reset করে, 4EH আর 37H লেখে, তারপর প্রতিটি অক্ষরের আগে status-এর D0 (TxRDY) poll করে price=9.83 Tk আর CR LF পাঠায়। Simulator 8251A চেনে না, তাই ;@in 0C1H 05H pragma দিয়ে status সবসময় “TxRDY, TxEMPTY” রাখা হয়েছে (Spec decision 10): এতে শুধু CPU-র দিকটি দেখা যায়।

~/lab$ python -B sim8085.py asm usart.asm
2000  AF           4  START:  XRA A           ; worst-case reset: 00H three times
2001  D3 C1        5          OUT 0C1H
...
200B  3E 4E       10          MVI A,4EH       ; mode: async x16, 8 data, no parity, 1 stop
200D  D3 C1       11          OUT 0C1H
200F  3E 37       12          MVI A,37H       ; command: RTS, ER, RxE, DTR, TxEN
2011  D3 C1       13          OUT 0C1H
2013  21 27 20    14          LXI H,MSG
2016  DB C1       15  NEXT:   IN 0C1H         ; status
2018  E6 01       16          ANI 01H         ; D0 = TxRDY
201A  CA 16 20    17          JZ NEXT
201D  7E          18          MOV A,M
201E  D3 C0       19          OUT 0C0H        ; character to the transmit buffer
2020  23          20          INX H
2021  FE 0A       21          CPI 0AH         ; LF ends the line
2023  C2 16 20    22          JNZ NEXT
2026  76          23          HLT
2027  70 72 69    24  MSG:    DB 'price=9.83 Tk',0DH,0AH
...
~/lab$ python -B sim8085.py run usart.asm
OUT port C1H <- 00H  (at T=14)
OUT port C1H <- 00H  (at T=24)
OUT port C1H <- 00H  (at T=34)
OUT port C1H <- 40H  (at T=51)
OUT port C1H <- 4EH  (at T=68)
OUT port C1H <- 37H  (at T=85)
OUT port C0H <- 70H  (at T=136)
OUT port C0H <- 72H  (at T=200)
...
OUT port C0H <- 0DH  (at T=968)
OUT port C0H <- 0AH  (at T=1032)
Instructions: 132   T-states: 1057

প্রথম ছয়টি OUT ঠিক “নিয়ম”-বাক্সের ক্রম। তারপর প্রতি অক্ষরে ৬৪ T (IN ১০ + ANI ৭ + না-নেওয়া JZ ৭ + MOV ৭ + OUT ১০ + INX ৬ + CPI ৭ + JNZ ১০)। কিন্তু 1057 T = 0.35 ms-এ ১৫টি অক্ষর তারে যেতে পারে না; ধ্রুব status-টিই এখানে মিথ্যা। তাই লেখকের lab-এ একই program reference-এর simulator আর এই পর্বের model জুড়ে চালানো হয়েছে, যেখানে প্রতিটি IN 0C1H সেই T-state-এ model-এর আসল status পায় আর প্রতিটি frame ১২৪৮০ T নেয়: অক্ষরগুলো তারে গেছে T = 136, 12616, 25096 … 174856-এ, শেষ stop বিট শেষ হয়েছে T = 187336-এ (62.45 ms). CPU HLT-এ পৌঁছেছে ১৬২৪৬৩ T-এ, ১৮০৬৬টি নির্দেশ চালিয়ে, যার মধ্যে ৫৯৯৩ বার status পড়া। অর্থাৎ polling-এ CPU-র ৫৪ ms প্রায় পুরোটাই অপেক্ষা।

তবু bit-banging-এর চেয়ে বড় পার্থক্য আছে: বিটের সময় এখন hardware রাখে, তাই loop-এর মাঝে একটি interrupt এলে কোনো বিট লম্বা হয় না, শুধু পরের অক্ষর একটু দেরিতে যায়। আরও ভালো নকশায় TxRDY pin জোড়া হয় একটি level-triggered interrupt লাইনে, যেমন RST 6.5, বা 8259 PIC-এর একটি IR লাইনে (পর্ব ২৬); তখন CPU অন্য কাজ করে, আর প্রতি ১২৪৮০ T-এ একবার ISR এসে একটি অক্ষর দেয়। অক্ষর দেওয়ার মূল কাজটুকু ওপরের ৬৪ T, অর্থাৎ ১২৪৮০ T-এর মাত্র 0.51%; ISR-এ ঢোকা আর বেরোনোর খরচ যোগ হলেও এক শতাংশের কাছাকাছি থাকে।

দুটি সাধারণ ভুল: (১) command-এ TxEN দিতে ভুলে যাওয়া, বা CTS̅ pin উঁচু রেখে দেওয়া: status-এ TxRDY = 1 দেখায় (buffer খালি), কিন্তু একটি বিটও বের হয় না, আর TxRDY pin-এর interrupt আসে না। Modem না থাকলে CTS̅ সাধারণত ground-এ জোড়া হয়। (২) Mode word দুবার লেখা: দ্বিতীয়টি তখন command হিসেবে পড়া হয়। 4EH command হিসেবে = 0100 1110: D6 = IR, chip আবার mode-এর অপেক্ষায় চলে যায়, আর পরের 37H হয়ে যায় একটি অদ্ভুত mode word.

৫ · 8237A — CPU-কে বাদ দিয়ে data সরানো

DMA (direct memory access)-এর মূল ধারণা, আর polling ও interrupt-এর সঙ্গে তুলনা, Computer Architecture কোর্সের পর্ব ৫২-এ আছে। এখানে আমরা একটি আসল chip-এর register-স্তরে নামব। 8237A একটি ৪০ pin-এর chip; datasheet-এর প্রথম পাতার কথায় চারটি “independent DMA channel”, প্রতিটির “full 64K address and word count capability”, আর 5 MHz-এর 8237A-5-এ সেকেন্ডে সর্বোচ্চ 1.6 MByte. Chip-এর ভেতরে মোট ৩৪৪ বিটের register (datasheet-এর Figure 3):

Registerআকার × সংখ্যাকাজ
Base address, base word count১৬ বিট × ৪ করেশুরুর মান মনে রাখে (autoinitialize-এর জন্য); পড়া যায় না
Current address, current word count১৬ বিট × ৪ করেচলার সময়ের ঠিকানা আর বাকি সংখ্যা; প্রতি transfer-এ বদলায়
Temporary address, temporary word count১৬ বিট × ১ করেভেতরের হিসাবের জায়গা
Mode৬ বিট × ৪প্রতি channel-এর mode, দিক, autoinitialize
Command, status, temporary৮ বিট × ১ করেপুরো chip-এর নিয়ম; কে TC-তে পৌঁছেছে; memory-to-memory-র মাঝের byte
Mask, request৪ বিট × ১ করেকোন channel বন্ধ; software দিয়ে DMA চাওয়া

CPU এই register-গুলোতে পৌঁছায় চারটি ঠিকানা-লাইন A3–A0 আর IOR̅/IOW̅ দিয়ে; এই নকশায় 8237A-এর CS̅ নামে 70H–7FH-এ। Datasheet-এর Figure 6 আর 7 মিলিয়ে ঠিকানার টেবিল:

PortA3–A0লেখা (OUT)পড়া (IN)
70H, 72H, 74H, 76H0000, 0010, 0100, 0110channel 0–3-এর base ও current addresscurrent address
71H, 73H, 75H, 77H0001, 0011, 0101, 0111channel 0–3-এর base ও current word countcurrent word count
78H1000commandstatus
79H1001request—
7AH1010single mask বিট—
7BH1011mode—
7CH1100clear byte pointer flip-flop—
7DH1101master cleartemporary register
7EH1110clear mask register—
7FH1111সব mask বিট একসঙ্গে—

১৬ বিট, কিন্তু data bus ৮ বিট. Address আর count ১৬ বিটের, অথচ CPU একবারে একটি byte লেখে। তাই একই port-এ পরপর দুবার লিখতে হয়: আগে নিচের byte, পরে ওপরের। কোনটি কোন byte, তা মনে রাখে একটি ভেতরের byte pointer flip-flop (datasheet-এ “first/last flip-flop”), যা প্রতিটি পড়া বা লেখায় উল্টে যায়। Datasheet-এর নির্দেশ: নতুন address বা count লেখার বা পড়ার আগে 7CH-এ (Clear Byte Pointer) একটি লেখা, যাতে flip-flop জানা অবস্থায়, 0-তে থাকে। 7CH, 7DH আর 7EH-এর মতো software command-এ data bus-এর byte দেখা হয় না; শুধু ঠিকানাটিই আদেশ।

Count-এর N − 1 নিয়ম. Datasheet-এর ভাষায়: “The actual number of transfers will be one more than the number programmed … (i.e., programming a count of 100 will result in 101 transfers).” প্রতি transfer-এর পরে count এক কমে; 0000H থেকে FFFFH-এ গড়ালে TC (terminal count) হয়, আর EOP̅ pin-এ একটি pulse আসে। তাই ৬টি byte-এর জন্য লিখতে হয় 0005H, ২৫৬টির জন্য 00FFH, আর 0000H লিখলে একটি byte. Mode register-এর বিট:

বিটD7 D6D5D4D3 D2D1 D0
অর্থ00 demand, 01 single, 10 block, 11 cascade0 = ঠিকানা +1, 1 = −11 = autoinitialize00 verify, 01 write, 10 read, 11 অবৈধchannel 0–3
88H10 block0010 read00 = ch0
85H10 block0001 write01 = ch1
46H01 single0001 write10 = ch2

“Write” আর “read” নাম memory-র দিক থেকে: write transfer মানে I/O যন্ত্র থেকে memory-তে লেখা (IOR̅ আর MEMW̅ একসঙ্গে), read transfer মানে memory থেকে পড়ে যন্ত্রে দেওয়া (MEMR̅ আর IOW̅ একসঙ্গে), আর verify-তে ঠিকানা আর count চলে কিন্তু কোনো read/write সংকেত সক্রিয় হয় না। Command register-এর গুরুত্বপূর্ণ বিট: D0 = memory-to-memory চালু, D1 = channel 0-এর ঠিকানা স্থির (একই byte দিয়ে একটি block ভরা), D2 = পুরো controller বন্ধ, D3 = compressed timing, D4 = rotating priority, D6 আর D7 = DREQ ও DACK-এর polarity. Reset বা master clear-এর পরে command = 0 আর চারটি channel-ই masked.

ঠিকানা কীভাবে bus-এ যায়. 8237A-এর নিজের মাত্র আটটি ঠিকানা-output, A7–A0 (A3–A0 দুই দিকের)। ওপরের আট বিট A15–A8 সে DMA cycle-এর শুরুতে data bus DB7–DB0-এ দেয়, আর ADSTB pulse দিয়ে একটি বাইরের ৮ বিটের latch-এ ধরিয়ে রাখে; AEN সেই latch-এর output bus-এ খোলে আর CPU-র নিজের ঠিকানা-buffer বন্ধ রাখে। তাই ঠিকানার জগৎ ১৬ বিট, ৬৪ KB. 8086-এর ১ MB জগতে ব্যবহার করতে হলে ওপরের চারটি বিটের জন্য আলাদা একটি “page” register লাগে, যা প্রতি ৬৪ KB-এর সীমানা পেরোতে পারে না।

৬ · HOLD আর HLDA — bus-এর হাতবদল

একটি bus-এ এক মুহূর্তে একজনই চালক থাকতে পারে, যাকে বলে bus master. DMA মানে কিছুক্ষণের জন্য 8237A-কে bus master বানানো। পর্ব ০৮-এ দেখেছেন, 8085-এর HOLD pin উঁচু হলে CPU চলতি bus লেনদেন শেষ করে ঠিকানা, data, RD̅, WR̅ আর IO/M̅ tri-state করে আর HLDA উঁচু করে। 8237A-এর HRQ যায় HOLD-এ, CPU-র HLDA আসে 8237A-এর HLDA-তে। যন্ত্রের সঙ্গে 8237A-এর হাতবদল চলে DREQ আর DACK দিয়ে, একটি দুই-ধাপের handshake. 8086-এর minimum mode-এর একই HOLD/HLDA পর্ব ২১-এ।

Datasheet-এ 8237A-এর প্রতিটি অবস্থা একটি পূর্ণ clock: SI (idle; CPU তাকে program করতে পারে), S0 (HRQ দেওয়া হয়েছে, HLDA-র অপেক্ষা), S1 (ওপরের ঠিকানা latch-এ দেওয়া), S2, S3, S4 (আসল transfer), আর ধীর যন্ত্রের জন্য READY দিয়ে SW (wait). এবার বাজারঘরের একটি নকশা: দোকানের কম্পিউটার serial-এ দামের টেবিল পাঠাচ্ছে, আর 8251A-এর RxRDY জোড়া 8237A-এর DREQ2-তে; channel 2 single mode, write transfer, ঠিকানা 2100H, ১৬টি byte (count 000FH). ধরা যাক প্রথম byte এসেছে D7H.

18251: RxRDY = 1 → DREQ228237: HRQ = 1 → HOLD38085: bus ছাড়ে, HLDA = 14S1: AEN, ADSTB, A15–A85S2–S4: IOR + MEMW6address +1, count −17HRQ = 0 → HLDA = 08CPU-র machine cycle
লাইন আর register (model)
HOLD · HLDA
AEN · DACK2
bus-এর মালিক
8237-এর state
address · count
  1. RxRDY = 1. 8251A একটি পূর্ণ অক্ষর পেয়েছে। এই লাইন সরাসরি DREQ2-তে; channel 2 unmasked, তাই অনুরোধ বৈধ। Datasheet অনুযায়ী DACK না আসা পর্যন্ত DREQ ধরে রাখতে হয়, আর RxRDY ঠিক তাই করে।
  2. HRQ = 1, S0. 8237A CPU-র HOLD উঁচু করে, আর অপেক্ষা করে। এই সময়েও CPU নিজের কাজ চালায়।
  3. HLDA = 1. 8085 চলতি machine cycle শেষ করে bus-এর লাইনগুলো ভাসিয়ে দেয় আর HLDA দেয়। এখন bus 8237A-এর। CPU ভেতরের কাজ চালাতে পারে, কিন্তু পরের bus cycle-এ আটকে থাকে।
  4. S1: ঠিকানার ওপরের অর্ধেক. AEN = 1. 8237A DB7–DB0-এ 21H দিয়ে ADSTB pulse দেয়; latch সেটি A15–A8-এ ধরে। A7–A0 = 00H সরাসরি তার নিজের pin থেকে।
  5. S2–S4: একই সঙ্গে IOR̅ আর MEMW̅. DACK2 = 1 দেখে 8251A-এর data register (একটি ছোট glue logic দিয়ে CS̅ আর C/D̅ = 0) data bus-এ D7H দেয়, আর memory সেটি 2100H-এ লেখে। Byte-টি 8237A-এর ভেতরে ঢোকেই না: datasheet-এর ভাষায় “The data is not read into or driven out of the 8237A in I/O-to-memory … transfers.” একেই বলে flyby transfer.
  6. Address +1, count −1. Current address 2101H, count 000EH. 8251A-এর data পড়া হয়েছে, তাই RxRDY নেমে যায়, DREQ2-ও।
  7. HRQ = 0. Single mode-এ প্রতি byte-এর পরে 8237A HRQ নামায়। CPU HLDA নামিয়ে bus ফিরে নেয়।
  8. CPU-র অন্তত একটি machine cycle. Datasheet বলে, DREQ চালু থাকলেও single mode 8085-এর মতো CPU-কে দুই transfer-এর মাঝে “one full machine cycle” দেয়। পরের অক্ষর এলে পুরো চক্র আবার; ১৬তম byte-এ count FFFFH, TC.

চারটি mode. Datasheet-এর “Active Cycle” অংশ অনুযায়ী:

  • Single: প্রতি DREQ-এ ঠিক একটি transfer, তারপর bus ফেরত। CPU কখনো দীর্ঘ সময় আটকে থাকে না; একে পুরোনো বইয়ে cycle stealing বলা হয়।
  • Block: একটি DREQ-এ (DACK পর্যন্ত ধরে রাখলেই হয়) TC বা বাইরের EOP̅ পর্যন্ত একটানা; দ্রুততম, কিন্তু CPU পুরো সময় bus পায় না। Block mode-এ software request-ও দেওয়া যায়।
  • Demand: যতক্ষণ DREQ উঁচু, ততক্ষণ চলে; যন্ত্রের data ফুরালে DREQ নামায়, bus CPU-র কাছে যায়, আর মাঝের ঠিকানা আর count current register-এ থেকে যায়। Demand mode ধীর-দ্রুত মেশানো যন্ত্রের জন্য।
  • Cascade: সেই channel-এ আরেকটি 8237A-এর HRQ/HLDA জোড়া হয়, আর এই channel শুধু অগ্রাধিকার দেয়, নিজে কোনো ঠিকানা দেয় না। Cascade দিয়ে channel-এর সংখ্যা বাড়ে।

অগ্রাধিকার স্বাভাবিকভাবে স্থির: DREQ0 সবচেয়ে বেশি, DREQ3 সবচেয়ে কম; command-এর D4 দিয়ে rotating, যাতে শেষ সেবা পাওয়া channel সবার শেষে যায়। নিচের ব্লকে একই ৬টি byte তিন mode-এ: প্রতিটি অক্ষর একটি clock, c = CPU bus পাচ্ছে, h = HRQ-এর পরে HLDA-র অপেক্ষা (S0), 1 = S1, D = S2/S3/S4. Model ধরে নিয়েছে HLDA আসে এক clock-এ আর CPU-র machine cycle তিন clock (8085-এর memory read-এর মতো)।

# Single, block আর demand mode-এ bus কার হাতে (dma8237 model; ৬ byte, channel 2)
from dma8237 import DMA, mode_word, decode_mode

def job(mode, **kw):
    dma = DMA(base=0x70)
    dma.out(0x7B, mode_word(2, kind="write", mode=mode))
    for port, v in ((0x7C, 0), (0x74, 0x00), (0x74, 0x21), (0x75, 5), (0x75, 0)):
        dma.out(port, v)                       # ch2: address 2100H, count 6 - 1
    line = dma.io_job(2, 6, mode, cpu_cycle=3, **kw)
    dma_clk = line.count("D") + line.count("1")
    print(f"{mode:6} {line}")
    print(f"       DMA {dma_clk} clk, wait {line.count('h')}, CPU {line.count('c')};"
          f" ch2 -> {dma.cur_addr[2]:04X}H, status {dma.inp(0x78):02X}H")

print(decode_mode(mode_word(2, kind="write", mode="single")))
job("single")
job("block")
job("demand", dreq=(2, 4))                     # device not ready after bytes 2 and 4

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

ch2: single, write, address +1, autoinit off
single h1DDDccch1DDDccch1DDDccch1DDDccch1DDDccch1DDD
       DMA 24 clk, wait 6, CPU 15; ch2 -> 2106H, status 04H
block  h1DDDDDDDDDDDDDDDDDD
       DMA 19 clk, wait 1, CPU 0; ch2 -> 2106H, status 04H
demand h1DDDDDDccch1DDDDDDccch1DDDDDD
       DMA 21 clk, wait 3, CPU 6; ch2 -> 2106H, status 04H

তিনটিতেই শেষে ঠিকানা 2106H আর status 04H (D2 = channel 2 TC-তে পৌঁছেছে)। পার্থক্য সময়ের ভাগে। Block-এ S1 মাত্র একবার, কারণ ছয়টি ঠিকানার ওপরের byte একই (21H): datasheet অনুযায়ী S1 আসে শুধু যখন A15–A8 নতুন করে latch করতে হয়, তাই একটানা transfer-এ প্রতি byte তিন clock. Single-এ প্রতিটি byte একটি নতুন সেবা, তাই প্রতিবার অপেক্ষা আর S1, মোট বেশি clock, কিন্তু CPU পাঁচবার bus পেয়েছে। Model-টি প্রতিটি নতুন সেবা S1 দিয়ে শুরু করে; আসল chip-এর ns-স্তরের সময় datasheet-এর timing diagram-এ, এখানে দেখানো হয়নি।

৭ · Block transfer — দামের টেবিল কপি, count ধরে ধরে

বাজারঘরের scale-এর memory-তে 2050H থেকে তিনটি দামের একটি ছোট টেবিল: আলুর দর ৬৫.৫০ টাকা/kg-এ ১৫০ g, ৫০০ g আর ১২৫০ g-এর দাম, পয়সায় ৯৮৩, ৩২৭৫ আর ৮১৮৮ (কোর্সের reference README-এর হিসাব)। প্রতিটি ১৬ বিটের, ছোট byte আগে: D7 03, CB 0C, FC 1F, মোট ৬ byte. এগুলো কপি করতে হবে 2060H-এ। এটি memory থেকে memory, কোনো I/O যন্ত্র নেই। 8237A-এর memory-to-memory ব্যবস্থায় channel 0 উৎস, channel 1 গন্তব্য; command-এর D0 = 1 দিয়ে চালু, আর শুরু হয় channel 0-এ একটি software request দিয়ে। প্রতিটি byte দুই ধাপে: S11–S14-এ উৎস থেকে পড়ে 8237A-এর temporary register-এ, S21–S24-এ সেখান থেকে গন্তব্যে। Datasheet: “Eight states are required for a single transfer.” কাজ শেষ হয় channel 1-এর count FFFFH হলে।

সত্যিকারের run (python -B sim8085.py run dma.asm --mem 2050H:6); টেবিলের byte ;@set pragma দিয়ে বসানো:

~/lab$ python -B sim8085.py asm dma.asm
2000  D3 7D        4  START:  OUT 7DH         ; master clear (data ignored)
2002  3E 01        5          MVI A,01H       ; command: memory-to-memory enable
2004  D3 78        6          OUT 78H
2006  3E 88        7          MVI A,88H       ; mode ch0: block, read, +1
2008  D3 7B        8          OUT 7BH
200A  3E 85        9          MVI A,85H       ; mode ch1: block, write, +1
200C  D3 7B       10          OUT 7BH
200E  D3 7C       11          OUT 7CH         ; clear byte pointer flip-flop
...
2027  3E 04       24          MVI A,04H       ; software request, ch0
2029  D3 79       25          OUT 79H
202B  76          26          HLT
~/lab$ python -B sim8085.py run dma.asm --mem 2050H:6
Memory 2050H..2055H:
  2050H: D7 03 CB 0C FC 1F
OUT port 7DH <- 00H  (at T=10)
OUT port 78H <- 01H  (at T=27)
OUT port 7BH <- 88H  (at T=44)
OUT port 7BH <- 85H  (at T=61)
OUT port 7CH <- 85H  (at T=71)
OUT port 70H <- 50H  (at T=88)
OUT port 70H <- 20H  (at T=105)
OUT port 72H <- 60H  (at T=122)
OUT port 72H <- 20H  (at T=139)
OUT port 73H <- 05H  (at T=156)
OUT port 73H <- 00H  (at T=170)
OUT port 79H <- 04H  (at T=187)
Instructions: 23   T-states: 192

দুটি জিনিস লক্ষ করুন। OUT 7DH আর OUT 7CH-এ A-তে যা ছিল (00H, 85H) তা-ই গেছে, কিন্তু software command-এ সেই byte অর্থহীন। আর program-টির খরচ ১৯২ T, অর্থাৎ DMA সাজাতেই CPU-র কিছু কাজ লাগে। Simulator 8237A চেনে না, তাই 2060H-এ কিছু লেখা হয়নি; নিচের stepper আর ব্লক এই OUT-লগ model-এ দিয়ে transfer দেখায়।

1OUT 79H, 04H: request ch02S11–S14: MEMR [ch0] → temp3S21–S24: MEMW temp → [ch1]4ch0 +1, ch1 +1, count −15count = FFFFH: TC, EOP6HRQ = 0, status পড়া
8237A-এর register (model)
ch0 address
ch1 address
ch1 count
temporary
clock
  1. Software request. Request register-এ 04H = 0000 0100: D2 = 1 (set), D1 D0 = 00 (channel 0). Command-এ memory-to-memory চালু, তাই 8237A HRQ দেয়; model-এ HLDA আসে clock ২-এ। ch1 count 0005H = ৬ − ১.
  2. প্রথম byte, clock ১০. আট clock: 2050H থেকে D7H temporary register-এ, তারপর 2060H-এ। দুটি ঠিকানাই এক বাড়ে, ch1 count 0004H.
  3. দ্বিতীয় byte, clock ১৮. 03H: প্রথম দামের ওপরের byte. 2060H–2061H এখন D7 03 = 03D7H = ৯৮৩ পয়সা = ৯.৮৩ টাকা।
  4. তৃতীয় byte, clock ২৬. CBH; count 0002H.
  5. চতুর্থ byte, clock ৩৪. 0CH: 0CCBH = ৩২৭৫ পয়সা (৫০০ g, ৩২.৭৫ টাকা)। Count 0001H.
  6. পঞ্চম byte, clock ৪২. FCH; count 0000H. শূন্য মানেই শেষ নয়: আরও একটি byte বাকি, এটিই N − 1 নিয়ম।
  7. ষষ্ঠ byte, clock ৫০. 1FH; count 0000H থেকে FFFFH: TC, EOP̅ pulse. 1FFCH = ৮১৮৮ পয়সা (১২৫০ g, ৮১.৮৮ টাকা)।
  8. Bus ফেরত, clock ৫১. HRQ নামে, CPU HLDA নামায়। CPU status পড়লে 02H (model-এ channel 1-এর TC বিট); পড়ামাত্র D3–D0 মুছে যায়। মোট ৬ × ৮ = ৪৮ clock transfer-এ।
# দামের টেবিল 2050H -> 2060H, 8237A memory-to-memory (dma8237 = এই পর্বের model)
from dma8237 import DMA

# sim8085-এর সত্যিকারের run-এর OUT লগ (port, byte), dma.asm থেকে হুবহু
OUTS = [(0x7D, 0x00), (0x78, 0x01), (0x7B, 0x88), (0x7B, 0x85), (0x7C, 0x85),
        (0x70, 0x50), (0x70, 0x20), (0x72, 0x60), (0x72, 0x20),
        (0x73, 0x05), (0x73, 0x00), (0x79, 0x04)]

mem = bytearray(0x10000)
mem[0x2050:0x2056] = bytes([0xD7, 0x03, 0xCB, 0x0C, 0xFC, 0x1F])   # 983, 3275, 8188 paisa
dma = DMA(base=0x70)
for port, v in OUTS:
    print(f"OUT {port:02X}H <- {v:02X}H  {dma.out(port, v)}")

print()
n = dma.mem_to_mem(mem, hlda_wait=2)
print(f"\n{n} bytes; 2060H: {mem[0x2060:0x2066].hex(' ').upper()}")
for i in range(0, 6, 2):
    print(f"  {0x2060 + i:04X}H = {mem[0x2060 + i] | mem[0x2061 + i] << 8} paisa")
print(f"status = {dma.inp(0x78):02X}H, next read = {dma.inp(0x78):02X}H")
print(f"ch1 address = {dma.cur_addr[1]:04X}H, count = {dma.cur_cnt[1]:04X}H")

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

OUT 7DH <- 00H  master clear
OUT 78H <- 01H  command
OUT 7BH <- 88H  mode ch0: block, read, address +1, autoinit off
OUT 7BH <- 85H  mode ch1: block, write, address +1, autoinit off
OUT 7CH <- 85H  clear byte pointer
OUT 70H <- 50H  ch0 address low
OUT 70H <- 20H  ch0 address high
OUT 72H <- 60H  ch1 address low
OUT 72H <- 20H  ch1 address high
OUT 73H <- 05H  ch1 count low
OUT 73H <- 00H  ch1 count high
OUT 79H <- 04H  request ch0 = 1

clk   2: HRQ=1 ... HLDA=1, AEN=1
clk  10: [2050H] -> [2060H] = D7H  ch1 count 0004H
clk  18: [2051H] -> [2061H] = 03H  ch1 count 0003H
clk  26: [2052H] -> [2062H] = CBH  ch1 count 0002H
clk  34: [2053H] -> [2063H] = 0CH  ch1 count 0001H
clk  42: [2054H] -> [2064H] = FCH  ch1 count 0000H
clk  50: [2055H] -> [2065H] = 1FH  ch1 count FFFFH  TC, EOP
clk  51: HRQ=0 -> CPU drops HLDA, bus back to the CPU

6 bytes; 2060H: D7 03 CB 0C FC 1F
  2060H = 983 paisa
  2062H = 3275 paisa
  2064H = 8188 paisa
status = 02H, next read = 00H
ch1 address = 2066H, count = FFFFH

OUT-লগের প্রতিটি লাইনের অর্থ model ঠিকানা থেকে বের করেছে, ঠিক 8237A-এর মতো: একই 70H-এ দুটি লেখা, প্রথমটি নিচের byte, দ্বিতীয়টি ওপরের, কারণ 7CH flip-flop 0 করেছিল। শেষে count FFFFH; datasheet বলে autoinitialize না থাকলে TC-এর পরে count এই মানেই থাকে, আর channel-এর mask বিট set হয়। দ্বিতীয়বার status পড়লে 00H, কারণ TC বিট পড়ামাত্র মোছে। OUTS-এ count-এর 0x05 বদলে 0x00 করে চালিয়ে দেখুন: একটি byte কপি হবে।

লাভ কতটা, হিসাব করে. Reference-এর block_move.asm একই কাজ CPU দিয়ে করে; count ৬ আর ২৫৫ দিয়ে সত্যিকারের run-এ মোট ২৬৯ T আর ১০২২৯ T (দুটিই = 27 + 40N − 3 + 5, শেষের ৫ HLT-এর)। 8237A একই 3 MHz clock-এ চললে memory-to-memory-তে প্রতি byte ৮ clock, আর সাজানোর খরচ ১৯২ T:

  1. ৬ byte: CPU ২৬৯ T; DMA ১৯২ + ৬ × ৮ = ২৪০ clock. লাভ সামান্য, কারণ সাজানোর খরচই বড়।
  2. ২৫৫ byte: CPU ১০২২৯ T = 3.41 ms; DMA ১৯২ + ২৫৫ × ৮ = ২২৩২ clock = 0.74 ms, প্রায় সাড়ে চার গুণ দ্রুত।
  3. I/O থেকে memory-তে (flyby) একটানা block-এ প্রতি byte ৩ clock, কারণ byte একবারই bus পেরোয়; memory-to-memory-তে দুবার।

ছোট কাজে DMA সাজানোর খরচ লাভ খেয়ে ফেলে; বড় block আর দ্রুত যন্ত্রেই DMA-র আসল জয়।

আরও গভীরে: প্রচলিত বিবরণ অনুযায়ী আসল IBM PC (১৯৮১) একটি 8237A ব্যবহার করত: channel 0 DRAM refresh-এর জন্য, channel 2 floppy disk-এর জন্য, আর ঠিকানার ওপরের বিটগুলোর জন্য আলাদা page register. PC/AT-এ দ্বিতীয় একটি 8237A cascade mode-এ যোগ হয়েছিল। মজার বিষয়, সেই PC-র serial port-এ 8251A নয়, অন্য নির্মাতার 8250 UART ব্যবহৃত হয়েছিল, যার register-বিন্যাস আজকের PC-র “16550-ধাঁচের” UART-এ টিকে আছে। আজকের microcontroller-এ DMA controller chip-এর ভেতরেই, আর CPU ও DMA দুজনেই bus master; একটি bus matrix তাদের মাঝে arbitration করে (bus arbitration). Circular buffer আর double buffering-সহ আধুনিক DMA পর্ব ৪৬ (DMA — CPU ছাড়া data সরানো, circular buffer আর double buffering)-এ, আর MCU-র UART পর্ব ৪৯ (UART — baud rate, frame, parity আর ring buffer)-এ; কোর্সের ভার্চুয়াল বাজারঘর board-এর UART-এর register (SR, DR, BRR, CR1) সেখানে কাজে লাগবে।

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

  • “8251-এর mode word: async, ×16, ৮ বিট, parity নেই, ১ stop?” → 01 00 11 10 = 4EH.
  • “Async ৯৬০০ baud, ×16-এর জন্য TxC কত?” → 9600 × 16 = 153.6 kHz.
  • “8237-এ ১০২৪ byte সরাতে count কত লিখবেন?” → ১০২৩ = 03FFH; TC হয় count 0000H থেকে FFFFH হলে।
  • “DMA-তে HOLD আর HLDA কে দেয়?” → HOLD দেয় DMA controller (HRQ), HLDA দেয় CPU, চলতি machine cycle শেষে।
  • “Memory-to-memory DMA-তে কোন channel?” → channel 0 উৎস, channel 1 গন্তব্য; শুরু software request-এ।

৮ · AI-এর যুগে 8251 আর 8237-এর কোড যাচাই

এই দুটি chip-এ AI assistant-এর ভুল ধরা কঠিন, কারণ কোড দেখতে ঠিক লাগে আর assemble-ও হয়; ভুল ধরা পড়ে কেবল তারের ওপারে, অর্থহীন অক্ষরে বা memory-র ভুল জায়গায় লেখা byte-এ। সাধারণ ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
Mode word-এর বিট উল্টায় (stop বিট D1 D0-তে বা factor D7 D6-তে)Intel-এর Figure 8; decode_mode() দিয়ে উল্টো দিক থেকে পড়ুন
Command-এর আগে mode, এই ক্রম ভাঙে, বা mode দুবার লেখেControl byte-গুলো ক্রমে লিখে model-এর state দেখুন
Baud-এর জন্য timer-এর count ভুল, ×16 ভুলে যায়হাতে হিসাব: count = clock ÷ (baud × factor), ত্রুটি % বের করুন
8237-এ count = N লেখে (N − 1 নয়)Datasheet-এর “100 → 101 transfers” বাক্য; model-এ চালিয়ে byte গুনুন
Address লেখার আগে clear byte pointer দেয় নাProgram-এ OUT 7CH খুঁজুন; ঠিকানা পড়ে মিলিয়ে দেখুন
“Read transfer” মানে যন্ত্র থেকে পড়া ভাবেনাম memory-র দিক থেকে: read = memory থেকে যন্ত্রে
8085 কোডে 8086-এর OUT DX,AL মেশায়কোর্সের 8085 simulator-এ assemble করুন

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

আমি Intel 8085 (3 MHz) দিয়ে একটি পুরোনো ধাঁচের board বানাচ্ছি। 8251A USART আছে port 0C0H (data, C/D = 0) আর 0C1H (control/status)-এ, TxC আর RxC আসে 3 MHz ÷ 78 থেকে। 8237A DMA আছে 70H–7FH-এ। Intel-এর mnemonic আর 2050H ধরনের hex চাই। ১. 8251A-এর power-up reset ক্রমসহ init কোড লেখো: async, ×16, ৮ বিট, even parity, ১ stop. Mode আর command word বিট ধরে ব্যাখ্যা করো। ২. আসল baud rate আর ২৪০০ থেকে ত্রুটি % হিসাব করো। ৩. 8237A-এর channel 2 সাজাও: single mode, write transfer (8251 থেকে memory), ঠিকানা 2100H, ১৬ byte. Count কত লিখবে আর কেন, byte pointer flip-flop কোথায় মুছবে, বলো। ৪. 8086 বা Z80-এর নির্দেশ ব্যবহার করবে না। কোনো বিট বা pin নিয়ে নিশ্চিত না হলে অনুমান না করে বলো।

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

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

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

প্র ০১8085-এ SID আর SOD থাকতেও Intel কেন আলাদা 8251 বানাল? Sync আর async দুটোই এক chip-এ রাখার কারণ কী?

SID আর SOD মাত্র দুটি pin, আর তাদের পেছনে কোনো সময়ের hardware নেই। পর্ব ১৩-এর হিসাবে ২৪০০ baud-এ একটি byte পাঠাতে CPU-র ১২৫১৯ T লাগে, আর সেই সময় অন্য সব interrupt বন্ধ রাখতে হয়, নইলে বিট লম্বা হয়ে যায়। নেওয়ার দিকে সমস্যা আরও বড়: start বিট কখন আসবে কেউ জানে না, তাই CPU-কে অনবরত SID দেখতে হয়, অথবা start বিটকে একটি interrupt-এ জুড়ে তারপর T গুনে প্রতিটি বিটের মাঝখান খুঁজতে হয়। এক byte পাঠানো আর নেওয়া একসঙ্গে, অর্থাৎ full-duplex, প্রায় অসম্ভব। একটি ছোট control board-এ একটি সাধারণ terminal জোড়ার জন্য এটুকু চলে; কিন্তু দোকানের হিসাবের কম্পিউটার বা একটি modem-এর সঙ্গে সারাদিন কথা বলতে হলে চলে না।

8251A এই সব কাজ hardware-এ নেয়: start বিটের খোঁজ, মাঝখানে নমুনা, false start বাতিল, parity হিসাব, framing আর overrun ধরা, আর দুই দিকে একটি করে অতিরিক্ত byte-এর buffer. CPU-র কাজ শুধু অক্ষরপ্রতি একটি IN বা OUT, আর সেটিও interrupt দিয়ে।

Sync আর async এক chip-এ রাখার কারণ তখনকার বাজার। Datasheet-এর ভূমিকায় বলা আছে, chip-টি “virtually any serial data transmission technique presently in use (including IBM bi-sync)” সমর্থন করে। ১৯৭০-এর দশকে বড় কম্পিউটার আর terminal-এর মাঝে দ্রুত লাইনে sync protocol চলত, কারণ প্রতি অক্ষরে start/stop বিটের ২০% অতিরিক্ত খরচ নেই; আর সস্তা terminal, printer আর modem-এ চলত async. একটি chip দুটোই পারলে নির্মাতারা এক নকশায় দুই বাজারে বিক্রি করতে পারে, আর ক্রেতা board না বদলে software দিয়ে format বদলাতে পারেন। আজ sync-এর ধারণা অন্যভাবে টিকে আছে: SPI আর I2C-তে আলাদা clock তার থাকে (পর্ব ৫০ আর ৫১), আর USB বা Ethernet clock-কে data-র ভেতরেই encode করে।

মূল উপলব্ধি: SID/SOD সময়ের কাজ CPU-কে দেয়, 8251 সেই কাজ hardware-এ নেয়; sync আর async একসঙ্গে রাখা ছিল এক chip-এ সব বাজার ধরার নকশা।

প্র ০২Single, block আর demand mode — কোনটি কখন? CPU-র interrupt latency আর যন্ত্রের গতির মধ্যে টানাপোড়েন কীভাবে মেলাবেন?

DMA-র মূল দ্বন্দ্ব হলো bus একটিই। Block mode-এ 8237A একটি DREQ-এ TC পর্যন্ত bus ধরে রাখে; এটি দ্রুততম, কারণ HOLD/HLDA হাতবদল আর S1 একবারই। এই পর্বের model-এ ছয়টি byte block-এ ১৯ clock, single-এ ২৪. কিন্তু block চলার পুরো সময় CPU কোনো নির্দেশ fetch করতে পারে না, আর CPU interrupt নেয় শুধু নির্দেশের সীমানায়। ৬৪ KB-এর একটি block মানে কয়েক লাখ clock; এর মাঝে timer-এর interrupt এলে তা অপেক্ষা করবে, আর display-এর refresh বা serial-এর একটি অক্ষর হারিয়ে যেতে পারে।

Single mode উল্টো দিকে ঝোঁকে। প্রতি byte-এর পরে bus ফেরত, আর datasheet অনুযায়ী 8085 বা 8086-এর মতো CPU-তে মাঝে অন্তত একটি পূর্ণ machine cycle নিশ্চিত। CPU ধীর হয়, থামে না; interrupt latency প্রায় বদলায় না। কিন্তু প্রতি byte-এ আলাদা হাতবদল, তাই মোট সময় বেশি। ধীর যন্ত্রের জন্য, যেমন ২৪০০ baud-এর serial, যেখানে প্রতি ৪ ms-এ একটি byte আসে, single mode স্বাভাবিক পছন্দ: বাড়তি clock-এর খরচ নগণ্য।

Demand mode মাঝামাঝি, আর যন্ত্রকেই সিদ্ধান্ত নিতে দেয়। ছোট FIFO-ওয়ালা একটি যন্ত্র, যেমন disk controller, buffer ভরলে DREQ তোলে, খালি হলে নামায়; প্রতিবার কয়েকটি byte একটানা যায়, তারপর CPU bus পায়। মাঝের ঠিকানা আর count current register-এ থাকে, তাই কাজ যেখানে থেমেছিল সেখান থেকে চলে। নকশার প্রশ্নগুলো তাই: যন্ত্র কত দ্রুত byte দেয়, তার buffer কত বড়, আর সিস্টেমে সবচেয়ে কঠোর interrupt deadline কত। Block-এর দৈর্ঘ্য × প্রতি byte-এর clock যদি সেই deadline-এর চেয়ে কম হয়, block নিরাপদ; নইলে demand বা single. আজকের microcontroller-এ একই প্রশ্ন “burst size” আর bus-এর অগ্রাধিকার হিসেবে আসে (পর্ব ৪৬)।

মূল উপলব্ধি: Mode বাছাই মানে bus-এর সময় CPU আর যন্ত্রের মাঝে ভাগ করা; দ্রুততম mode সবসময় সেরা নয়, যদি তাতে সিস্টেমের সময়ের প্রতিশ্রুতি ভাঙে।

প্র ০৩8237-এর count কেন N − 1, TC কেন FFFFH-এ? আর byte pointer flip-flop কীভাবে একটি interrupt-এর কারণে নীরব ভুল ঘটাতে পারে?

Count-এর নিয়মের পেছনে hardware-এর সরলতা। প্রতিটি transfer-এর পরে count এক কমে, আর “শেষ” চেনা হয় borrow দিয়ে: ১৬ বিটের একটি decrementer 0000H থেকে FFFFH-এ গেলে একটি borrow বেরোয়, যা একটি সাধারণ gate-এই পাওয়া যায়। “0-তে পৌঁছালে থামা” করতে হলে ১৬টি বিটের প্রতিটি পরীক্ষা করা লাগত, আর count 0 লিখলে কী হবে, তা নিয়ে আলাদা নিয়ম লাগত। Borrow-নিয়মে 0 লেখা মানে একটি byte, FFFFH লেখা মানে ৬৫৫৩৬টি, অর্থাৎ পুরো ৬৪ KB; datasheet যাকে বলে “full 64K … word count capability”. দামটি হলো programmer-এর মনে রাখার দায়: N টি byte-এর জন্য N − 1. AI আর মানুষ দুজনেই এখানে প্রায়ই একটি বাড়তি byte লেখে, আর সেই বাড়তি byte পরের buffer-এর প্রথম ঘর নষ্ট করে।

Byte pointer flip-flop-এর সমস্যা আরও সূক্ষ্ম। ১৬ বিটের register-এ পৌঁছানোর একমাত্র পথ একই port-এ দুটি ৮ বিটের লেখা বা পড়া, আর কোনটি নিচের byte তা মনে রাখে একটি ভাগ করা flip-flop. ধরুন main program channel 2-এর ঠিকানার নিচের byte লিখেছে, এখন flip-flop = 1. ঠিক তখন একটি interrupt এল, আর ISR channel 1-এর বাকি count পড়ল, দুটি IN. Flip-flop দুবার উল্টে আবার 1. ISR ফিরলে main ওপরের byte লেখে, ঠিক জায়গায়। সব ঠিক? এখন ধরুন ISR শুধু একটি byte পড়ল, অথবা নিজের কাজের আগে OUT 7CH দিল। ফেরার পরে main-এর “ওপরের byte” চলে যাবে নিচের byte-এ, আর ঠিকানা হবে সম্পূর্ণ অন্য কিছু। এই পর্বের অনুশীলন ২-এ ঠিক এমন একটি ভুলে ঠিকানা 2100H-এর বদলে 0021H হয়েছে।

প্রতিকার তিনটি: 8237 সাজানোর পুরো অংশে interrupt বন্ধ (DI … EI), প্রতিটি ১৬ বিটের লেখার আগে OUT 7CH, আর ISR-এ 8237-এর register না ছোঁয়া। Datasheet আরও সতর্ক করে, unmasked channel program করার মাঝে DREQ এলে মাত্র এক byte ঠিকানা লেখা অবস্থায় DMA শুরু হতে পারে; তাই আগে channel mask, শেষে unmask. এটি Operating Systems পর্ব ২২-এর race condition-এর hardware-রূপ: একটি ভাগ করা অবস্থা, দুটি পথ, আর মাঝখানে বাধা।

মূল উপলব্ধি: N − 1 আর FFFFH-এ TC hardware-কে সরল রাখে; byte pointer flip-flop একটি ভাগ করা অবস্থা, তাই তাকে atomic অংশে রাখা programmer-এর দায়িত্ব।

প্র ০৪DMA চলার সময় CPU আর DMA একই memory দেখে। 8085-এ কোনো cache নেই, তবু কী ভুল হতে পারে? আজকের microcontroller-এ সমস্যা কীভাবে বড় হয়?

8085-এর জগতে memory একটিই আর CPU-র কোনো cache নেই, তাই DMA একটি byte লেখামাত্র CPU-র পরের পড়ায় নতুন মান আসে। তবু দুটি ভুল সম্ভব। প্রথমটি সময়ের: program যদি DMA শেষ হওয়ার আগেই buffer পড়তে শুরু করে, সে অর্ধেক পুরোনো, অর্ধেক নতুন data পাবে। ঠিক পথ হলো TC-এর খবর নেওয়া: EOP̅ থেকে একটি interrupt, বা status-এর TC বিট পড়া, আর তারপরই buffer ছোঁয়া। দ্বিতীয়টি মালিকানার: DMA যে buffer-এ লিখছে, CPU-ও যদি একই সময়ে সেখানে লেখে, কার মান টিকবে তা নির্ভর করে কে শেষে লিখল তার ওপর।

আজকের Cortex-M-এর মতো chip-এ এই দুটি সমস্যার সঙ্গে আরও দুটি যোগ হয়। একটি compiler-এর: C-তে একটি buffer বা একটি “শেষ হয়েছে” flag যদি volatile না হয়, compiler ধরে নিতে পারে মান বদলায়নি, কারণ সে DMA-কে দেখতে পায় না; loop-এর ভেতরে পড়া মান register-এ রেখে দেয়, আর program কখনো শেষ দেখে না। volatile আর optimization-এর ফাঁদ পর্ব ৩৪-এর বিষয়। অন্যটি cache-এর: data cache-ওয়ালা chip-এ, যেমন কিছু Cortex-M7, CPU পুরোনো মান cache থেকে পড়তে পারে অথচ DMA memory-তে নতুন মান লিখেছে; উল্টো দিকে CPU-র লেখা cache-এ বসে থাকে, DMA memory থেকে পুরোনো মান পাঠায়। তখন DMA-র আগে cache “clean” আর পরে “invalidate” করতে হয়, বা buffer non-cacheable এলাকায় রাখতে হয়।

আরও একটি প্রভাব সময়ের। Block DMA চলার সময় CPU-র memory access অপেক্ষা করে, তাই একটি program-এর চলার সময় শুধু তার নিজের নির্দেশে নির্ভর করে না; ISR-এর worst-case সময় হিসাবের সময় DMA-র bus দখলও ধরতে হয়। Real-time নকশায় এটিকে বলে interference, আর পর্ব ৫৪-এর WCET-এর আলোচনায় এটি গুরুত্বপূর্ণ।

মূল উপলব্ধি: DMA মানে memory-র দ্বিতীয় একজন লেখক; কে কখন buffer-এর মালিক, তা TC, volatile আর (cache থাকলে) cache-রক্ষণাবেক্ষণ দিয়ে স্পষ্ট রাখতে হয়।

প্র ০৫Baud rate-এর কতটা ত্রুটি চলে? ×16 sampling কেন, আর 3 MHz থেকে ৯৬০০ baud বানানো কেন ঝামেলার?

Async-এ গ্রাহকের সময় মেলে কেবল start বিটের নামার ধারে, তারপর সে নিজের clock-এ চলে। শেষ নমুনা, অর্থাৎ stop বিটের মাঝখান, 8N1-এ ধার থেকে ৯.৫ বিট-সময় পরে। দুই পক্ষের হারে পার্থক্য থাকলে সেই নমুনা সরে যায়; সরণ আধা বিটের বেশি হলে নমুনা পাশের বিটে পড়ে। তাই আদর্শ অবস্থায় মোট ত্রুটির সীমা মোটামুটি 0.5 ÷ 9.5 ≈ 5.3%. বাস্তবে ধার চেনার অনিশ্চয়তা (×16-এ এক RxC̅ পর্যন্ত, অর্থাৎ ১/১৬ বিট), তারের ধারের ঢাল আর noise এই সীমা কমায়; তাই প্রচলিত নিয়মে দুই পক্ষ মিলিয়ে কয়েক শতাংশের মধ্যে থাকা ভালো, আর প্রতিটি পক্ষ নিজে আরও কম। এই পর্বের ব্লকে ১০% ত্রুটিতে ভুল byte আর framing error দুটোই দেখেছেন।

×16 কেন? ×1-এ গ্রাহক বিটের মাঝখান খুঁজে পায় না; সে শুধু clock-এর ধারে পড়ে, তাই প্রেরকের সঙ্গে clock-এর phase মেলা দরকার, যা async-এর উদ্দেশ্যের বিরুদ্ধে। ×16-এ প্রতিটি বিট ১৬ ভাগে ভাগ, তাই ধার চেনা যায় এক ভাগের মধ্যে, মাঝখান খোঁজা যায় আট ভাগ পরে, আর noise spike বাতিলের সুযোগ থাকে। ×64 আরও সূক্ষ্ম, কিন্তু একই baud-এ চারগুণ দ্রুত clock লাগে।

3 MHz-এর সমস্যা গণিতের। ৯৬০০ × ১৬ = 153600 Hz; 3,000,000 ÷ 153600 = 19.53, পূর্ণসংখ্যায় ২০, তাই আসল baud ৯৩৭৫, ত্রুটি −2.34%. অন্য পক্ষও যদি উল্টো দিকে একটু সরে থাকে, সীমার কাছে চলে যায়। এই কারণেই serial-এর জন্য আলাদা crystal-এর প্রচলন হয়েছিল, যেমন 1.8432 MHz, যা 115200 × 16-এর সমান; সেখান থেকে ৯৬০০, ১৯২০০, ৩৮৪০০ সব baud পূর্ণসংখ্যায় ভাগ হয়, ত্রুটি শূন্য। আজকের microcontroller-এর UART-এ ভগ্নাংশ-ভাগক (fractional divider) থাকে, যা এই ত্রুটি কমায়; BRR-এর হিসাব পর্ব ৪৯-এ।

মূল উপলব্ধি: Async টিকে থাকে মাত্র এক frame সময় মিলিয়ে রাখার ওপর; তাই baud-এর ত্রুটি হিসাব করা নকশার অংশ, আর clock-এর frequency বাছাই সেই হিসাব থেকেই আসে।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — serial থেকে DMA-তে দামের টেবিল: দোকানের কম্পিউটার 8251A-এর মাধ্যমে ১৬ byte পাঠাবে। 8251A-এর RxRDY জোড়া 8237A-এর DREQ2-তে (ঠিকানা 70H–7FH). Channel 2-কে single mode, write transfer, ঠিকানা 2100H, ঠিকানা বাড়ানো, autoinitialize ছাড়া সাজানোর 8085 program লিখুন। সাজানোর সময় channel যেন অনুরোধ না নেয়, আর অন্য channel-এর নিয়ম যেন না বদলায়।

    Mode word: 01 (single) · 0 (+1) · 0 (autoinit নেই) · 01 (write) · 10 (ch2) = 0100 0110 = 46H. Count = ১৬ − ১ = 000FH. Master clear নয় (তাতে অন্য channel-ও মুছে যায়); শুধু ch2-এর single mask বিট: set = 06H, clear = 02H.

            ORG 2000H
    START:  MVI A,06H       ; single mask: set, ch2
            OUT 7AH
            MVI A,46H       ; mode ch2: single, write, +1
            OUT 7BH
            OUT 7CH         ; clear byte pointer flip-flop
            XRA A           ; address 2100H: low byte first
            OUT 74H
            MVI A,21H
            OUT 74H
            MVI A,0FH       ; count = 16 - 1
            OUT 75H
            XRA A
            OUT 75H
            MVI A,02H       ; single mask: clear, ch2
            OUT 7AH
            HLT

    সত্যিকারের run: ১৬টি নির্দেশ, ১২৮ T; OUT-লগ 7AH<-06H, 7BH<-46H, 7CH<-46H, 74H<-00H, 74H<-21H, 75H<-0FH, 75H<-00H, 7AH<-02H. লগটি model-এ দিলে ch2 = 2100H, count 000FH, mask খোলা; তারপর ১৬টি single transfer-এ (১৬বার HRQ) ঠিকানা 2110H, count FFFFH, status 04H, আর ch2-এর mask বিট আবার set. সাজানোর অংশকে আরও নিরাপদ করতে আগে-পরে DI/EI দেওয়া যায় (ভাবনার প্রশ্ন ৩)।

  2. ভুল খুঁজুন — ঠিকানা উল্টে গেল: একটি program আগে debug-এর জন্য একবার IN 74H দিয়ে ch2-এর ঠিকানার নিচের byte পড়েছিল। তারপর লেখা হলো: XRA A / OUT 74H / MVI A,21H / OUT 74H / MVI A,10H / OUT 75H / XRA A / OUT 75H, ১৬ byte 2100H-এ আনার জন্য। Program-এ OUT 7CH নেই। দুটি ভুল খুঁজুন আর প্রতিটির ফল বলুন।

    ভুল ১, flip-flop: IN 74H flip-flop-কে 1 করে রেখেছে। তাই প্রথম OUT 74H (00H) যায় ওপরের byte-এ, দ্বিতীয়টি (21H) নিচের byte-এ: ঠিকানা 0021H. Count-এর লেখাও একইভাবে উল্টে 10H যায় ওপরে: count 1000H = ৪০৯৬, অর্থাৎ ৪০৯৭টি transfer. DMA 0021H থেকে ৪ KB-এর বেশি memory-তে লিখবে, যা এই নকশায় ROM বা program-এর এলাকা। Model-এ ঠিক এই ক্রমে চালিয়ে ফল: ঠিকানা 0021H, count 1000H. সমাধান: ঠিকানা লেখার আগে OUT 7CH.

    ভুল ২, N − 1: flip-flop ঠিক থাকলেও count 0010H মানে ১৭টি transfer; সঠিক 000FH. বাড়তি byte-টি 2110H-এ পড়ত, buffer-এর ঠিক পরের ঘরে, যা প্রায়ই অন্য কোনো variable. দুই ভুলের কোনোটিই assembler বা simulator ধরে না: OUT-লগে byte আর port দুটোই “ঠিক” দেখায়। ধরা যায় শুধু datasheet-এর নিয়ম মিলিয়ে, বা register পড়ে।

  3. হিসাব — ৯৬০০ baud আর লাইনের সময়: একই 3 MHz থেকে timer দিয়ে TxC বানিয়ে scale-কে ৯৬০০ baud-এ চালাতে চান। ×16 আর ×64 mode-এ timer-এর count কত, আসল baud আর ত্রুটি % কত? ×1 mode-এ? তারপর ১৫ অক্ষরের দামের লাইন 8N1-এ পাঠাতে ৯৩৭৫ baud-এ কত ms, আর ২৪০৩.৮৫ baud-এ কত? 8E2 (৮ বিট, even parity, ২ stop) হলে?
    1. ×16: 3,000,000 ÷ (9600 × 16) = 19.531 → ২০; baud = 3,000,000 ÷ 20 ÷ 16 = 9375.00, ত্রুটি −2.34%.
    2. ×64: 3,000,000 ÷ (9600 × 64) = 4.883 → ৫; baud = 9375.00, একই −2.34%.
    3. ×1: 3,000,000 ÷ 9600 = 312.5 → ৩১২; baud = 9615.38, +0.16%; কিন্তু ×1-এ গ্রাহক বিটের মাঝখান খোঁজে না, তাই async-এ সাধারণত ব্যবহার হয় না (ভাবনার প্রশ্ন ৫)।
    4. 8N1 = ১০ বিট: ১৫ × ১০ ÷ ৯৩৭৫ = 16.0 ms; ২৪০৩.৮৫ baud-এ 62.4 ms (ওপরের lab-run-এর শেষ stop বিট 62.45 ms-এ, প্রথম অক্ষর ১৩৬ T দেরিতে শুরু বলে)।
    5. 8E2 = ১ + ৮ + ১ + ২ = ১২ বিট: ৯৩৭৫ baud-এ 19.2 ms, ২৪০৩.৮৫ baud-এ 74.88 ms. Mode word: 11 1 1 11 10 = 0FEH.

    সংখ্যাগুলো লেখকের lab-এ Python দিয়ে হিসাব করা। ×16 আর ×64-এ ত্রুটি এক, কারণ দুটিতেই ভাগফল একই অনুপাতে গোল হয়েছে (২০ × ১৬ = ৫ × ৬৪ = ৩২০)।

  4. আগে বলুন, তারপর চালান — status byte-এর ধারা: 8251A-এ mode 4EH, তারপর command 37H. DSR̅ উঁচু (DSR বিট 0). এরপর ঘটনার ক্রম: CPU 'p' লেখে; CPU 'r' লেখে; গ্রাহকে 'T' আসে; CPU পড়ার আগেই 'A' আসে; CPU data পড়ে; প্রথম frame শেষ হয়; CPU আবার 37H লেখে; দ্বিতীয় frame শেষ হয়। প্রতিটি ধাপের পরে status (hex) কত? CPU কোন অক্ষর পায়?

    Model-এর ফল (D0 TxRDY, D1 RxRDY, D2 TxEMPTY, D4 OE):

    1. mode আর command-এর পরে: 05H (TxRDY, TxEMPTY).
    2. 'p': 01H. Byte সঙ্গে সঙ্গে shifter-এ, buffer খালি, কিন্তু transmitter আর খালি নয়।
    3. 'r': 00H. Buffer ভরা, অপেক্ষায়।
    4. 'T': 02H. RxRDY.
    5. 'A': 12H. RxRDY আর OE: 'T' হারিয়ে গেছে, তার জায়গায় 'A'.
    6. CPU পড়ে 'A' (41H); status 10H: OE পড়ায় মোছে না।
    7. প্রথম frame শেষ: 'r' shifter-এ গেল, buffer খালি: 11H.
    8. 37H (ER = 1): OE মুছল, 01H.
    9. দ্বিতীয় frame শেষ: 05H, আবার সব খালি।

    শিক্ষা: error flag থেকে যায় যতক্ষণ না command-এর ER দিয়ে মোছা হয়, আর overrun-এ হারায় পুরোনো অক্ষর। TxEMPTY পড়ে CPU জানতে পারে শেষ বিটও তারে চলে গেছে, যেমন half-duplex লাইনে দিক বদলানোর আগে।

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

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

ক্রম8085 আর 8237A-এর একটি single-mode DMA transfer-এর ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. যন্ত্র DREQ উঁচু করে
  2. 8237A HRQ দিয়ে CPU-র HOLD উঁচু করে
  3. CPU চলতি machine cycle শেষ করে bus ছাড়ে আর HLDA দেয়
  4. 8237A ঠিকানা দেয়, DACK দেয়, আর একসঙ্গে IOR̅ ও MEMW̅ চালায়
  5. Address বাড়ে, count কমে, আর 8237A HRQ নামায়
  6. CPU HLDA নামিয়ে আবার bus নেয়

8251A-কে async, ×16, ৭টি data বিট, even parity, ১টি stop বিটে চালাতে mode word কত?

  • 4EH
  • 7AH
  • 5AH
  • 7BH

8251A-এ C/D̅ = 1, RD̅ = 0, WR̅ = 1, CS̅ = 0 হলে কী ঘটে?

  • পাওয়া অক্ষরটি data bus-এ আসে
  • Data bus থেকে একটি command লেখা হয়
  • Status byte data bus-এ আসে
  • Data bus ভাসমান থাকে

8251A-এ command word-এ TxEN = 0, transmit buffer খালি, CTS̅ = 0. Status-এর TxRDY বিট আর TxRDY pin কী দেখায়?

  • Status বিট 1, pin 0
  • দুটোই 1
  • দুটোই 0
  • Status বিট 0, pin 1

8237A-এর একটি channel দিয়ে ঠিক ২৫৬টি byte সরাতে word count register-এ কোন মান লিখবেন?

  • 0100H
  • 0000H
  • FFFFH
  • 00FFH

8237A-এর কোন mode-এ প্রতিটি byte-এর পরে bus CPU-কে ফেরত যায়, DREQ চালু থাকলেও?

  • Block
  • Single
  • Demand
  • Cascade

8237A-এর memory-to-memory transfer সম্পর্কে কোন কথাটি ঠিক?

  • যেকোনো দুটি channel ব্যবহার করা যায়
  • Byte সরাসরি flyby-তে যায়, 8237A-এর ভেতর দিয়ে নয়
  • Channel 0 উৎস, channel 1 গন্তব্য; প্রতি byte ৮টি state
  • কাজ শেষ হয় channel 0-এর count FFFFH হলে

শব্দকোষ

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

মনে রাখুন

  1. 8251A: C/D̅ = 1 control/status, 0 data; reset → mode → (sync অক্ষর) → command; power-up-এ 00H ×৩ আর 40H. TxRDY বিট = buffer খালি, pin = তার সঙ্গে CTS̅ = 0 আর TxEN.
  2. Mode আর command: stop · EP · PEN · দৈর্ঘ্য − ৫ · factor; 4EH = 8N1 ×16, 7AH = 7E1 ×16. 37H = TxEN, DTR, RxE, ER, RTS; status D0–D5 = TxRDY, RxRDY, TxEMPTY, PE, OE, FE.
  3. Frame আর baud: start 0, data ছোট বিট আগে, parity, stop 1; baud = TxC ÷ factor; 3 MHz ÷ 78 ÷ 16 = 2403.85 baud, এক বিট 1248 T. গ্রাহক বিটের মাঝখানে নমুনা নেয়; stop-এ 0 = FE.
  4. 8237A: চারটি channel, ১৬ বিটের address ও count, আগে নিচের byte (তার আগে clear byte pointer); count = N − 1, 0000H → FFFFH-এ TC আর EOP̅. Mode = mode · ±১ · autoinit · type · channel; write = I/O → memory.
  5. Bus: DREQ → HRQ/HOLD → HLDA → DACK আর transfer; single প্রতি byte-এ bus ফেরত, block TC পর্যন্ত, demand DREQ পর্যন্ত, cascade চেইন। Memory-to-memory: ch0 → temp → ch1, প্রতি byte ৮ clock; ছোট কাজে সাজানোর খরচই বড়।

পরের পর্বে: পর্ব ২৮ (Microcontroller-এর পরিবার — AVR, PIC, ARM Cortex-M, ESP32 আর RISC-V MCU). এতক্ষণ যে chip-গুলো আলাদা বসিয়ে bus দিয়ে জুড়লেন, UART, timer, DMA, interrupt controller, সেগুলো এখন একটি chip-এর ভেতরে; কোন পরিবার কী নিয়ে আসে আর বাজারঘরের device-এর জন্য কোনটি কেন।

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

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