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

I/O interfacing — memory-mapped বনাম isolated I/O আর polling

I/O Interfacing: Memory-Mapped vs Isolated I/O and Polling

Taught in Bangla, this lesson explains why input needs a tri-state buffer (74LS244) and output a latch (74LS373 or 74LS374). It compares isolated I/O with 8085 IN and OUT against memory-mapped ports, with T-state costs, and runs both in the course's 8085 simulator. In-page Python computes the LED series resistor from sink and source currents, builds common-anode 7-segment codes and models a handshake, alongside polling and interrupt timing.

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

  • Input port-এ কেন tri-state buffer আর output port-এ কেন latch লাগে, আর decoder, RD, WR মিলিয়ে enable সংকেত বানানো
  • Isolated (port-mapped) আর memory-mapped I/O-র পার্থক্য: নির্দেশ, ঠিকানার আকার, T-state, সুবিধা আর অসুবিধা
  • OUT 01H আর memory-mapped STA 8000H-এর machine cycle ধরে কোন chip কখন সাড়া দেয় তা বলা
  • Switch-এর pull-up, LED-এর current-limiting resistor আর 7-segment-এর code হিসাব করা, datasheet-এর সংখ্যা দিয়ে
  • Polling loop, interrupt-ভিত্তিক I/O আর handshake তুলনা করা, polling-এর দেরি আর হারানো data হিসাব করা

১ · CPU আর বাইরের জগৎ — I/O interfacing কেন লাগে

আগের পর্বগুলোতে 8085 আর 8086 শুধু register আর memory নিয়ে কাজ করেছে। কিন্তু একটি দাঁড়িপাল্লা, একটি বোতাম, একটি বাতি বা একটি display ছাড়া কোনো যন্ত্র কাজের নয়। CPU-কে বাইরের এসব যন্ত্রের সঙ্গে জোড়ার কাজকে বলে I/O interfacing. এই পর্বে আমরা ঠিক hardware-এর স্তরে দেখব: কোন chip বসাতে হয়, কোন সংকেত দিয়ে সেটি চালু হয়, আর program কোন নির্দেশে তার সঙ্গে কথা বলে।

সমস্যাটি সময়ের। পর্ব ০৮-এ (8085-এর pin, machine cycle আর timing diagram) দেখেছেন, data bus-এ একটি byte থাকে একটি machine cycle-এর মাত্র দুই-তিনটি T-state, অর্থাৎ ৩ MHz clock-এ এক µs-এরও কম। একটি LED-কে কিন্তু কয়েক সেকেন্ড জ্বলে থাকতে হবে। তাই output-এর জন্য এমন কিছু লাগে, যা bus থেকে byte-টি তুলে নিয়ে ধরে রাখে: একটি latch. উল্টো দিকে, একটি switch সারাক্ষণ তার ভোল্টেজ দিচ্ছে। তাকে সরাসরি data bus-এ জুড়ে দিলে সে memory-র পড়ার সময়ও bus-এ নিজের মান চাপাবে। তাই input-এর জন্য এমন একটি দরজা লাগে, যা শুধু CPU যখন এই যন্ত্রটিকেই পড়ছে, তখন খোলে: একটি tri-state buffer.

উপমা — দারোয়ানের গেট আর নোটিশ বোর্ড: একটি অফিসের ভেতরে একটিমাত্র সরু করিডোর (data bus). বাইরে অনেক দর্শনার্থী দাঁড়িয়ে। দারোয়ান (buffer) গেট খোলে শুধু তখন, যখন ভেতর থেকে নাম ধরে ডাকা হয়; বাকিরা বাইরে অপেক্ষা করে, করিডোরে ভিড় হয় না। আবার ভেতর থেকে মাইকে একটি ঘোষণা মাত্র কয়েক সেকেন্ড শোনা যায়, তাই কেউ সেটি নোটিশ বোর্ডে লিখে রাখে (latch); ঘোষণা শেষ হলেও বোর্ডে লেখা থাকে, যতক্ষণ না নতুন ঘোষণা আসে। ঠিক কাকে ডাকা হলো, তা বোঝায় নামের তালিকা (address decoder).

লেখার নিয়ম শুরুতেই বলি: এই পর্বে সব ঠিকানা আর data Intel-এর ধরনে, শেষে H (01H, 8000H); বিটের ধারা দরকার হলে টেবিলে b দিয়ে। Active-low সংকেতের নামের ওপরে দাগ থাকে, যেমন RD; stepper আর টেবিলে জায়গা বাঁচাতে দাগ ছাড়া RD, WR, IO/M লেখা হবে, মানে একই: 0 হলে সক্রিয়। প্রতিটি I/O interface-এ চারটি অংশ থাকে:

  1. Address decoder: ঠিকানা দেখে ঠিক করে কোন port-কে ডাকা হলো, আর সেই port-এর chip select সক্রিয় করে। ঠিকানা থেকে chip select বানানোর পুরো কৌশল (74LS138, absolute আর partial decoding) পর্ব ২২ (Memory interfacing আর address decoding)-এর বিষয়; এখানে শুধু ফলটি ব্যবহার হবে।
  2. নিয়ন্ত্রণ-যুক্তি: chip select-কে RD বা WR আর IO/M-এর সঙ্গে মিলিয়ে ঠিক মুহূর্তে buffer খোলা বা latch চালু করা।
  3. Buffer বা latch: input-এ buffer, output-এ latch.
  4. যন্ত্র নিজে: switch, LED, 7-segment, keypad, sensor-এর ADC. যন্ত্রের ভোল্টেজ আর current CPU-র logic-এর সঙ্গে মেলাতে বাড়তি অংশ (resistor, transistor) লাগে।

ছবি ২৩.১ — এই পর্বের নকশা: দুটি port, তিনটি chip

Port 01H-এ সুইচের buffer (পড়া) আর LED-এর latch (লেখা); port 02H-এ 7-segment-এর latch

8085-এর সঙ্গে দুটি I/O port-এর নকশা 8085 + ALE latch data bus D7–D0 A7–A0 · IO/M · RD · WR 74LS138 decoder Y1 Y2 Y1+RD NOR(Y1,WR) NOR(Y2,WR) 74LS244 74LS373 74LS373 buffer · 01H latch · 01H latch · 02H ৮টি সুইচ 10 kΩ pull-up ৮টি LED 270 Ω · sink common anode IN 01H OUT 01H OUT 02H
ছবি ২৩.১ — 74LS138-এর G1-এ IO/M যায়, তাই decoder শুধু I/O cycle-এ জাগে; A7–A3 = 0 হলে A2 A1 A0 দিয়ে Y0–Y7-এর একটি 0 হয় (decoder-এর তত্ত্ব Computer Architecture পর্ব ১২-এ)। Buffer-এর তীর ওপরে, data bus-এ ওঠে; দুটি latch-এর তীর নিচে, bus থেকে নামে। একই ঠিকানা 01H দুটি chip-এ গেলেও কখনো দুজন একসঙ্গে চালু হয় না: একজন শুধু RD-তে, অন্যজন শুধু WR-এ। ডানের display-এ জ্বলছে অঙ্ক 5.

এই নকশাটি সারা পর্বে চলবে। ভাবুন বাজারঘরের দোকানে ৮০-র দশকের একটি 8085-ভিত্তিক কাউন্টার: আটটি switch-এর একটি TARE বোতাম (S0), কয়েকটি অবস্থা-বাতি (LED), আর দাম দেখানোর 7-segment. আগের পর্বগুলোতে port 01H কখনো ওজনের byte, কখনো keypad হিসেবে এসেছে; প্রতিটি পর্বের নকশা আলাদা, তাই port নম্বরের মানে সবসময় সেই নকশার টেবিল থেকে পড়তে হয়, অনুমান থেকে নয়।

২ · Isolated I/O — IN, OUT আর ৮ বিটের port

8085-এর memory-র ঠিকানা ১৬ বিট (৬৪ KB), আর এর পাশাপাশি আলাদা একটি ছোট ঠিকানা-জগৎ আছে শুধু I/O-র জন্য: ২৫৬টি input port আর ২৫৬টি output port. এই ব্যবস্থার নাম isolated বা port-mapped I/O. দুই জগৎকে আলাদা করে IO/M pin: memory-র cycle-এ 0, I/O-র cycle-এ 1. তাই ঠিকানা 0001H-এর memory আর port 01H একই জিনিস নয়, যদিও bus-এ ঠিকানার বিট একই রকম দেখায়।

নির্দেশ মাত্র দুটি, দুটিই ২ byte আর ১০ T-state (Spec decision 2):

  • IN port: port থেকে একটি byte এনে A-তে রাখে। Machine cycle: opcode fetch (৪ T) + port নম্বর পড়া (memory read, ৩ T) + I/O read (৩ T).
  • OUT port: A-র byte port-এ পাঠায়। Opcode fetch + memory read + I/O write.

দুটি সীমাবদ্ধতা মনে রাখার মতো: data সবসময় accumulator দিয়ে যায় (OUT-এর আগে মানটি A-তে আনতে হয়), আর port নম্বর নির্দেশের ভেতরে স্থির, তাই চলার সময় হিসাব করে port বদলানো যায় না। I/O cycle-এ 8085 port-এর ৮ বিটের নম্বরটি ঠিকানার দুই অর্ধেকেই রাখে: A15–A8 আর AD7–AD0 দুই জায়গায় 01H, অর্থাৎ ঠিকানা bus-এ 0101H. ফলে decoder চাইলে latch করা A7–A0 না নিয়ে সরাসরি A15–A8 থেকেই port চিনতে পারে। IO/M, S1, S0 আর RD, WR-এর timing diagram পর্ব ০৮-এ বিস্তারিত; এখানে আমরা দেখব সেই সংকেতে বাইরের chip কী করে।

প্রথম program: switch পড়ে একই নকশার LED-এ দেখানো। TARE (S0) আর S2 চাপা; চাপা switch পড়ে 0 (কেন, তা অংশ ৪-এ), তাই port 01H-এর মান 1111 1010b = 0FAH. Simulator-এ port-এর মান ;@in pragma দিয়ে বসানো (Spec decision 10); আসল switch নেই। সত্যিকারের run (কোর্সের reference lab-এর sim8085.py, Python 3.13.5; ফাইল লেখকের lab-এ):

~/lab$ python -B sim8085.py asm mirror.asm
2000               4          ORG 2000H
2000  DB 01        5  START:  IN 01H          ; 74LS244 buffer
2002  D3 01        6          OUT 01H         ; 74LS373 latch
2004  76           7          HLT

~/lab$ python -B sim8085.py run mirror.asm
A=FA B=00 C=00 D=00 E=00 H=00 L=00 SP=0000 PC=2005
Flags: S=0 Z=0 AC=0 P=0 CY=0   (F=00H)
OUT port 01H <- FAH  (at T=20)
Instructions: 3   T-states: 25

Listing-এ দেখুন: IN 01H-এর byte DB 01, OUT 01H-এর D3 01; দ্বিতীয় byte-টি port নম্বর। Simulator-এর OUT log বলছে port 01H-এ FAH গেছে T = ২০-এ, অর্থাৎ OUT শেষ হওয়ার মুহূর্তে (১০ + ১০)। মোট ২৫ T = 8.33 µs. এবার একই OUT 01H-কে bus আর বাইরের chip-এর চোখে দেখা যাক। প্রতিটি ধাপে কোন সংকেত কী, আর latch কখন byte ধরে রাখে, লক্ষ করুন। (Latch-এর আচরণ datasheet-এর নিয়ম থেকে লেখকের মডেল; simulator শুধু OUT log দেয়।)

12000 IN 01H   ; buffer22002 OUT 01H  ; latch32004 HLT
এই ধাপে bus আর chip
ঠিকানা
AD7–AD0
IO/M S1 S0
RD · WR
Y1 · latch G
LED-এর byte
  1. M1, opcode fetch (৪ T). PC = 2002H. IO/M = 0, S1 S0 = 1 1: memory থেকে opcode D3H আসে। Decoder-এর G1-এ IO/M = 0, তাই Y1 = 1, port-এর কোনো chip জাগে না। T4-এ CPU বোঝে: এটি OUT, আরও এক byte লাগবে।
  2. M2, memory read (৩ T). ঠিকানা 2003H থেকে port নম্বর 01H আসে; Intel-এর বিবরণ অনুযায়ী এই byte ভেতরের দুটি অস্থায়ী register-এ যায়, তাই পরের cycle-এ ঠিকানার দুই অর্ধেকেই 01H. এখনো memory cycle, port নিরব।
  3. M3-এর T1: I/O write শুরু. IO/M = 1, S1 S0 = 0 1. ঠিকানা bus-এ 0101H, ALE ঠিকানা latch করে। Decoder এখন জাগে: A7–A3 = 0, A2–A0 = 001, তাই Y1 = 0. কিন্তু WR এখনো 1, তাই latch-এর G = NOR(0, 1) = 0; LED আগের মতোই।
  4. T2–T3: WR = 0. CPU AD bus-এ A-র মান FAH রাখে। এখন G = NOR(0, 0) = 1: 74LS373 স্বচ্ছ, Q = D, LED-গুলো সঙ্গে সঙ্গে নতুন মান দেখায়। Input buffer-এর enable = Y1 OR RD = 0 OR 1 = 1, তাই সে বন্ধ: bus-এ একমাত্র চালক CPU.
  5. WR আবার 1. G নেমে 0: latch শেষ মান FAH ধরে রাখে, এর পরে AD bus ভাসমান হলেও বা অন্য cycle চললেও LED বদলায় না। S0 আর S2-এর LED জ্বলে (বিট 0, তাই sink-এ জ্বলে, অংশ ৫)। OUT মোট ১০ T, program-এ মোট ২০ T, simulator-এর OUT log-এর সঙ্গে মেলে।

8086-এ isolated I/O একই ধারণার বড় রূপ। Intel-এর 8086 manual অনুযায়ী IN/OUT-এর দুই রকম লেখা আছে: port নম্বর সরাসরি নির্দেশে (৮ বিট, 00H–0FFH), অথবা DX register-এ (১৬ বিট, 0000H–0FFFFH); data যায় AL (byte) বা AX (word) দিয়ে। তাই 8086-এ ৬৫,৫৩৬টি পর্যন্ত ৮ বিটের port. আর DX ব্যবহার করলে port নম্বর চলার সময় হিসাব করা যায়, যা 8085-এ যায় না। সাবধান: 8086-এর minimum mode-এ pin-এর নাম M/IO, memory-তে 1; 8088-এ আবার IO/M, 8085-এর মতো। এই pin আর bus cycle পর্ব ২১ (8086-এর minimum আর maximum mode, bus cycle আর 8088)-এর বিষয়।

৩ · Memory-mapped I/O — memory-র ঠিকানায় port

বিকল্প পথ: port-কে আলাদা জগতে না রেখে memory-র ঠিকানার ভেতরেই বসানো। একে বলে memory-mapped I/O. CPU তখন জানেই না সে memory-তে লিখছে না port-এ; decoder ঠিকানা দেখে ঠিক করে, RAM সাড়া দেবে না port-এর chip. আমাদের দ্বিতীয় নকশায় (নকশা খ) একই দুটি chip বসানো হলো memory-র এলাকায়: LED-এর latch 8000H-এ (লেখা), switch-এর buffer 8001H-এ (পড়া)। শর্ত: A15 = 1 আর IO/M = 0, তারপর A0 দিয়ে বাছাই। এখানে A14–A1 দেখা হয় না, তাই 8002H, 8004H … সবই একই latch-এর ছায়া-ঠিকানা; এই foldback-এর কারণ আর দাম পর্ব ২২-এ।

Program-টি এখন সাধারণ memory নির্দেশে। সত্যিকারের run (sim8085.py; একটি সতর্কতা: simulator-এর কাছে 8001H সাধারণ RAM, তাই switch-এর মান ;@set দিয়ে আগে থেকে বসানো। আসল board-এ 8001H-এ লিখলে কিছুই ধরা থাকে না, কারণ সেখানে শুধু একটি buffer):

~/lab$ python -B sim8085.py asm mmio.asm
2000               5          ORG 2000H
2000  3A 01 80     6  START:  LDA 8001H       ; সুইচ
2003  32 00 80     7          STA 8000H       ; LED
2006  76           8          HLT

~/lab$ python -B sim8085.py run mmio.asm
A=FA B=00 C=00 D=00 E=00 H=00 L=00 SP=0000 PC=2007
Flags: S=0 Z=0 AC=0 P=0 CY=0   (F=00H)
Memory 8000H..8001H:
  8000H: FA FA
Instructions: 3   T-states: 31

ফল একই, 8000H-এ FAH, কিন্তু মোট ৩১ T, আগের ২৫-এর জায়গায়: LDA আর STA প্রতিটি ১৩ T, কারণ ১৬ বিটের ঠিকানার দুটি byte পড়তে হয়। নিচের stepper-এ STA 8000H-এর চারটি machine cycle; লক্ষ করুন IO/M পুরো সময় 0, আর latch-কে চেনে শুধু ঠিকানা।

12000 LDA 8001H ; buffer22003 STA 8000H ; latch32006 HLT
এই machine cycle-এ
cycle
ঠিকানা
data
IO/M S1 S0
A15 · latch G
মোট T
  1. Opcode fetch. LDA শেষ হয়েছে T = ১৩-এ; এখন PC = 2003H থেকে 32H আসে। মোট ১৭ T. Decoder-এর শর্ত A15 = 1 মেলে না (ঠিকানা 2003H), তাই latch-এর G = 0.
  2. প্রথম memory read. 2004H থেকে 00H, ঠিকানার নিচের byte (little-endian, পর্ব ০৫)। এখনো সাধারণ memory-র কাজ, port কিছু টের পায় না। মোট ২০ T.
  3. দ্বিতীয় memory read. 2005H থেকে 80H. CPU-র ভেতরে এখন পুরো ঠিকানা 8000H তৈরি। মোট ২৩ T.
  4. Memory write, কিন্তু যায় latch-এ. ঠিকানা bus-এ 8000H, IO/M = 0, S1 S0 = 0 1, WR = 0, AD-তে FAH. A15 = 1, A0 = 0, তাই G = 1, আর RAM-এর chip select-এ A15 = 0-এর শর্ত থাকায় RAM চুপ। WR উঠলে latch FAH ধরে রাখে। মোট ২৬ T.
  5. তুলনা. OUT 01H-এ একই কাজ ১০ T আর IO/M = 1; এখানে ১৩ T আর IO/M = 0. বাইরের latch-এর কাছে দুটো একই: একটি G pulse আর bus-এ একটি byte. পার্থক্য শুধু decoder কোন সংকেত দেখে চেনে।

দুই পদ্ধতির তুলনা, পরীক্ষায় প্রায়ই টেবিল আকারে চাওয়া হয়:

বিষয়Isolated (port-mapped) I/OMemory-mapped I/O
ঠিকানা৮ বিট (8085): ২৫৬ input + ২৫৬ output১৬ বিট: memory-র জায়গা থেকে কেটে নেওয়া
নির্দেশশুধু IN, OUT, শুধু A দিয়েসব memory নির্দেশ: LDA, STA, MOV r,M, MVI M, ANA M, INR M
সময় (8085)১০ TLDA/STA ১৩ T, MOV A,M ৭ T (HL আগে থেকে ঠিক থাকলে)
Decoder দেখেIO/M = 1 আর ৮ বিটের portIO/M = 0 আর ১৬ বিটের ঠিকানা
Memory-র ক্ষতিনেই, পুরো ৬৪ KB memory-র জন্যport-এর এলাকা memory হিসেবে আর ব্যবহার হয় না
ভুলের ঝুঁকিকম: port-এ যাওয়া নির্দেশ দেখেই বোঝা যায়একটি ভুল pointer port-এ লিখে যন্ত্র চালু করে দিতে পারে
কোথায় দেখা যায়8085, 8086/x86প্রায় সব microcontroller: ARM Cortex-M, AVR-এর বেশিরভাগ register, RISC-V

Memory-mapped I/O-র আসল শক্তি নির্দেশের স্বাধীনতা। ধরুন port-এর একটি বিট পরীক্ষা করতে হবে: HL-এ 8001H রেখে MOV A,M, বা সরাসরি ANA M (৭ T); A-তে আগে কিছু রাখার ঝামেলা নেই। একটি স্থির মান লিখতে MVI M,0FEH, A না ছুঁয়ে। দুটি port পরপর থাকলে INX H দিয়ে পরেরটিতে যাওয়া যায়, একটি loop-এ অনেক port. Isolated I/O-তে প্রতিটি port-এর জন্য আলাদা IN/OUT লিখতে হয়, কারণ port নম্বর নির্দেশে খোদাই করা।

আধুনিক microcontroller প্রায় পুরোপুরি memory-mapped. কোর্সের ভার্চুয়াল বাজারঘর board (আসল কোনো পণ্য নয়, Cortex-M3 chip-এর আদলে বানানো মডেল) README-র memory map অনুযায়ী GPIOA-কে রাখে 0x40010800-এ, আর তার output register ODR 0x0C দূরে। সেখানে LED জ্বালানো মানে একটি সাধারণ store নির্দেশ, ঠিক আমাদের STA 8000H-এর মতো; C-তে একটি pointer দিয়ে। সেই আধুনিক রূপ (direction, pull-up, open-drain) পর্ব ৪১ (GPIO)-এ, আর C-তে register-এর pointer পর্ব ৩৬-এ। এখানে মূল কথা: ধারণাটি নতুন নয়, 8085-এর STA-তেই এর বীজ।

আরও গভীরে — “memory” হলেও memory নয়: Memory-mapped port-এ পড়া বা লেখার একটি পার্শ্বফল থাকতে পারে (একটি status বিট মুছে যাওয়া, একটি byte পাঠানো শুরু হওয়া)। তাই CPU বা compiler যেন পড়া-লেখা বাদ না দেয়, জোড়া না লাগায় বা আগেভাগে না করে। ARMv7-M Architecture Reference Manual-এর মানচিত্রে 0x40000000–0x5FFFFFFF এলাকা “Peripheral”, ডিফল্টে Device ধরনের memory, যেখানে এ ধরনের অনুমানভিত্তিক বা জোড়া লাগানো access নিষেধ; আর C-তে একই কারণে register-এর pointer volatile হয় (পর্ব ৩৪)। 8085-এর মতো সরল CPU-তে এ সমস্যা ছিল না, কারণ প্রতিটি নির্দেশ ঠিক যা লেখা তাই করত; cache আর optimizing compiler আসার পরে এই নিয়ম জরুরি হয়েছে।

৪ · Input port — 74LS244 buffer আর switch

Texas Instruments-এর SN74LS244 datasheet (SDLS144D) এটিকে বলে octal buffer আর line driver, 3-state output-সহ। ভেতরে আটটি buffer, চার-চারটির দুই দল; প্রতিটি দলের একটি active-low output enable: 1G (pin ১) আর 2G (pin ১৯), দুটোই নামের ওপরে দাগসহ। Enable = 0 হলে Y = A (উল্টায় না); enable = 1 হলে output tri-state, অর্থাৎ তার থেকে বিচ্ছিন্ন। Port হিসেবে ব্যবহারে দুটি enable একসঙ্গে জোড়া হয়, তাই আটটি বিট একসঙ্গে bus-এ ওঠে বা নামে।

Enable কখন 0 হবে? শুধু তখন, যখন decoder এই port-কে বাছাই করেছে (Y1 = 0) আর CPU পড়ছে (RD = 0). দুটি active-low শর্তের “দুটোই সক্রিয়” মানে OR gate: G = Y1 + RD. AND gate দিলে ভুল হবে, কারণ তখন যেকোনো একটি 0 হলেই buffer খুলবে। IO/M-কে আলাদা করে দেখার দরকার নেই, কারণ decoder-এর G1-এ IO/M আগেই আছে। Datasheet-এর সময়ও মেলাতে হয়: enable থেকে output চালু হতে (tPZL) সর্বোচ্চ 30 ns, data input থেকে output (tPLH) সর্বোচ্চ 18 ns; ৩ MHz-এর 8085-এ পড়ার জানালা কয়েকশো ns, তাই এই chip যথেষ্ট দ্রুত।

এখন switch. একটি switch শুধু দুটি তার জোড়ে বা ছাড়ে; সে নিজে 1 তৈরি করতে পারে না। তাই প্রতিটি input একটি pull-up resistor দিয়ে +5 V-এ বাঁধা, আর switch অন্য দিকে GND-তে। খোলা থাকলে resistor input-কে 1-এ টেনে রাখে; চাপলে switch সরাসরি GND-তে জোড়ে, input 0. ফল: চাপা = 0, তাই এমন switch-কে active-low বলা হয়। ১০ kΩ-এর হিসাব datasheet দিয়ে যাচাই করা যায়:

  1. চাপা অবস্থায় resistor দিয়ে current = 5 V ÷ 10 kΩ = 0.5 mA, switch-এর জন্য খুব সামান্য, আর power-ও কম।
  2. খোলা অবস্থায় 74LS244-এর input current (IIH) সর্বোচ্চ 20 µA; resistor-এ ভোল্টেজ পড়ে 20 µA × 10 kΩ = 0.2 V, তাই input ≈ 4.8 V, যা 1-এর ন্যূনতম সীমা VIH = 2 V-এর অনেক ওপরে।
  3. চাপা অবস্থায় input 0 V, যা 0-এর সর্বোচ্চ সীমা VIL = 0.8 V-এর নিচে, নিরাপদ।

ছবি ২৩.২ — একটি switch আর একটি LED-এর circuit

বাঁয়ে: pull-up দিয়ে switch (চাপা = 0). ডানে: LED latch-এর output-এ sink হিসেবে (Q = 0 হলে জ্বলে)

Switch আর LED-এর circuit +5 V +5 V 10 kΩ 270 Ω S0 244-এ 373: 1Q খোলা = 1, চাপা = 0 Q = 0 → LED জ্বলে Q = 1 → নিভে থাকে
ছবি ২৩.২ — Switch-এর দিকে resistor ছাড়া শুধু switch দিলে খোলা অবস্থায় input ভাসমান থাকত, আর TTL-এর ভাসমান input সাধারণত 1-এর মতো আচরণ করলেও শব্দ-গোলমালে বদলে যেতে পারে; তাই pull-up বাধ্যতামূলক ধরুন। LED-এর দিকে resistor current সীমিত রাখে (অংশ ৫-এর হিসাব)।

যান্ত্রিক switch চাপার মুহূর্তে কয়েক ms ধরে লাফায় (bounce): 0 আর 1 কয়েকবার বদলায়। 8085-এর একটি polling loop প্রতি ৯ µs-এ পড়লে একটি চাপকে কয়েকটি চাপ ভাবতে পারে। এর প্রতিকার, অর্থাৎ debouncing, software আর hardware দুই ভাবে, পর্ব ৪২ (Button debouncing)-এর বিষয়; এই পর্বে ধরে নিচ্ছি switch পরিষ্কার।

এখন সবচেয়ে গুরুত্বপূর্ণ ভুলটি নিজে চালিয়ে দেখুন। নিচের মডেল ছবি ২৩.১-এর decoder আর enable-যুক্তিকে চারটি bus cycle-এ চালায়, আর প্রতিটি cycle-এ কে কে data bus চালাচ্ছে গোনে। দুজন চালালে সেটি bus contention. দ্বিতীয় অংশে buffer-এর enable থেকে RD বাদ দেওয়া হয়েছে, একটি বাস্তব নকশা-ভুল।

# নকশা: port 01H = সুইচের 74LS244 (IN) আর LED-এর 74LS373 (OUT); port 02H = 7-segment latch
# active-low: 0 = সক্রিয়। 74LS138: G1 = IO/M, A7–A3 = 0 হলে চালু, A2 A1 A0 বাছে Y0–Y7
def y138(io_m, a):
    return [0 if (io_m == 1 and a & 0xF8 == 0 and a & 7 == k) else 1 for k in range(8)]

def bus_cycle(kind, addr, data, st, buggy=False):
    io_m = 1 if kind in ("IOR", "IOW") else 0
    rd, wr = (0 if kind in ("MR", "IOR") else 1), (0 if kind in ("MW", "IOW") else 1)
    y = y138(io_m, addr & 0xFF)               # 8085 port ঠিকানা A7–A0-তেও থাকে
    buf_oe = y[1] if buggy else (y[1] | rd)    # 244-এর 1G̅,2G̅ = Y1̅ OR RD̅
    led_g = 1 - (y[1] | wr)                    # 373-এর G = NOR(Y1̅, WR̅)
    seg_g = 1 - (y[2] | wr)
    drivers = (["CPU"] if wr == 0 else []) + (["244"] if buf_oe == 0 else [])
    if kind == "MR": drivers.append("RAM")
    if led_g: st["led"] = data                 # latch স্বচ্ছ, WR̅ উঠলে ধরে রাখে
    if seg_g: st["seg"] = data
    bus = "সংঘাত!" if len(drivers) > 1 else "+".join(drivers)
    print(f"{kind:3} {addr:04X}H {io_m}{rd}{wr}  {y[1]}{y[2]}  {'on ' if buf_oe == 0 else 'off'} {led_g}"
          f"   {bus:6} {st['led']:02X}H {st['seg']:02X}H")

for buggy in (False, True):
    print("--- ভুল নকশা: 244 শুধু Y1 দিয়ে চালু ---" if buggy else "--- সঠিক নকশা ---")
    st = {"led": 0xFF, "seg": 0xFF}
    print("cycle ঠিকানা IO/M,RD,WR Y1Y2 244 G373 চালক  LED 7seg")
    bus_cycle("IOR", 0x0101, 0xFA, st, buggy)   # IN 01H
    bus_cycle("IOW", 0x0101, 0xFA, st, buggy)   # OUT 01H
    bus_cycle("IOW", 0x0202, 0x92, st, buggy)   # OUT 02H
    bus_cycle("MW", 0x0101, 0x55, st, buggy)    # STA 0101H — memory, port নয়

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

--- সঠিক নকশা ---
cycle ঠিকানা IO/M,RD,WR Y1Y2 244 G373 চালক  LED 7seg
IOR 0101H 101  01  on  0   244    FFH FFH
IOW 0101H 110  01  off 1   CPU    FAH FFH
IOW 0202H 110  10  off 0   CPU    FAH 92H
MW  0101H 010  11  off 0   CPU    FAH 92H
--- ভুল নকশা: 244 শুধু Y1 দিয়ে চালু ---
cycle ঠিকানা IO/M,RD,WR Y1Y2 244 G373 চালক  LED 7seg
IOR 0101H 101  01  on  0   244    FFH FFH
IOW 0101H 110  01  on  1   সংঘাত! FAH FFH
IOW 0202H 110  10  off 0   CPU    FAH 92H
MW  0101H 010  11  off 0   CPU    FAH 92H

তিন অঙ্কের কলাম IO/M, RD, WR; তারপর decoder-এর Y1 Y2. সঠিক নকশায় প্রতিটি সারিতে চালক একজন: IN 01H-এ 244, বাকিগুলোতে CPU. OUT 01H-এ LED-এর latch FAH নিল, OUT 02H-এ 7-segment-এর latch 92H, আর শেষ সারির STA 0101H (ঠিকানা একই রকম দেখতে) কোনো port ছোঁয়নি, কারণ IO/M = 0 হওয়ায় decoder ঘুমিয়ে ছিল (Y1 Y2 = 11). ভুল নকশায় OUT 01H-এর সারিতে 244 আর CPU দুজনেই bus চালাচ্ছে: CPU দিচ্ছে FAH, switch দিচ্ছে নিজের মান। মডেলে latch তবু FAH দেখাচ্ছে, কিন্তু বাস্তবে যে বিটে দুজনের মান উল্টো, সেখানে একজনের output 1 আর অন্যজনের 0 চালাতে গিয়ে বড় current যায়: মান অনিশ্চিত, chip গরম হয়, আর দীর্ঘদিনে নষ্টও হতে পারে। মডেলটি লেখকের, TI-র datasheet-এর function table আর এই পর্বের নকশা মেনে; লেখকের lab-এ একই কোড চালিয়ে এই আউটপুট মিলিয়ে দেখা হয়েছে।

৫ · Output port — 74LS373 latch, 74LS374 আর LED

Output-এর জন্য জনপ্রিয় দুটি chip একই datasheet-এ আছে (TI, SDLS165B): 74LS373, আটটি স্বচ্ছ D-latch, আর 74LS374, আটটি edge-triggered D flip-flop. Datasheet-এর ভাষায়, 373-এর enable C (অনেকে LE বা G বলেন) উঁচু থাকা পর্যন্ত Q-গুলো D-কে অনুসরণ করে, আর C নামলে শেষ মানটি ধরে রাখে; 374 শুধু clock-এর উঠন্ত কিনারায় D নেয়। দুটিরই active-low output control (OC): 1 হলে output tri-state, তবে datasheet জোর দিয়ে বলে, তখনও ভেতরের latch নতুন data নিতে বা পুরোনো রাখতে পারে। Port হিসেবে OC সাধারণত সবসময় 0, কারণ LED-কে সারাক্ষণ মান দেখতে হবে।

বিষয়74LS373 (latch)74LS374 (flip-flop)
কখন data নেয়C = 1 থাকা পুরো সময় (স্বচ্ছ)CLK-এর উঠন্ত কিনারায়, এক মুহূর্তে
port-এ সংযোগC = NOR(Y1, WR); WR উঠলে C নামে, মান ধরাCLK = Y1 + WR; WR উঠলে CLK ওঠে, মান ধরা
setup · hold (datasheet, ন্যূনতম)5 ns · 20 ns20 ns · 0 ns
ব্যবহার8085-এর ALE latch, সরল output portclock-এর সঙ্গে মেলানো register, output port

দুই ক্ষেত্রেই আসল মুহূর্ত WR-এর উঠন্ত কিনারা। তখন bus-এর data আরও কিছুক্ষণ স্থির থাকতে হয় (hold time); 8085AH-এর datasheet WR ওঠার পরে data কতক্ষণ থাকবে তার একটি ন্যূনতম সময় দেয় (tWD), যা latch-এর hold-এর চেয়ে বড় হতে হবে। নকশার নিয়ম পর্ব ০৮-এর মতোই: CPU যে সময় দেয়, প্রতিটি chip-এর প্রয়োজন তার চেয়ে কম হতে হবে।

এখন LED. একটি LED-এ সরাসরি 5 V দিলে প্রায় সীমাহীন current চায়, তাই সবসময় একটি current-limiting resistor. প্রশ্ন দুটি: LED-কে latch-এর output থেকে current দেব (source, output 1 হলে জ্বলবে) না টানব (sink, output 0 হলে জ্বলবে)? আর resistor কত? Datasheet-এর recommended operating conditions-এ উত্তর: 74LS373-এর IOH সর্বোচ্চ −2.6 mA, কিন্তু IOL সর্বোচ্চ 24 mA. LS ধরনের TTL output 1-এ খুব দুর্বল, 0-এ শক্ত। তাই LED-এর anode resistor দিয়ে +5 V-এ, cathode latch-এর output-এ: sink. নিচের ব্লক হিসাবটি করে।

# 74LS373-এর output দিয়ে LED: resistor কত? (TI SN74LS373 datasheet SDLS165B)
VCC = 5.0            # V
VF = 2.0             # V, ধরে নেওয়া লাল LED (আপনার LED-এর datasheet দেখুন)
VOL = 0.4            # V, output 0-তে সর্বোচ্চ (IOL = 12 mA শর্তে)
IOL_MAX, IOH_MAX = 24.0, 2.6     # mA, recommended operating conditions
I_WANT = 10.0        # mA
E12 = [100, 120, 150, 180, 220, 270, 330, 390, 470, 560, 680, 820, 1000]

r_exact = (VCC - VF - VOL) / (I_WANT / 1000)
r = min(x for x in E12 if x >= r_exact)          # বড়টি নিলে current কম, নিরাপদ
i = (VCC - VF - VOL) / r * 1000
print(f"sink (LED-এর cathode latch-এ): R = (5 - {VF} - {VOL}) / {I_WANT} mA = {r_exact:.0f} Ω")
print(f"  E12 মান {r} Ω -> I = {i:.2f} mA (সীমা {IOL_MAX:.0f} mA), "
      f"resistor-এ {i * i * r / 1e6 * 1000:.1f} mW")
print(f"  VOL typical 0.25 V হলে I = {(VCC - VF - 0.25) / r * 1000:.2f} mA")
print(f"  ৮টি LED একসঙ্গে: {8 * i:.1f} mA GND pin দিয়ে")
print(f"source (output 1-এ LED জ্বলবে): IOH সর্বোচ্চ {IOH_MAX} mA, "
      f"চাই {I_WANT:.0f} mA -> {'চলবে' if I_WANT <= IOH_MAX else 'চলবে না'}")
for name, vf in [("সবুজ (ধরা)", 2.2), ("নীল (ধরা)", 3.0)]:
    print(f"{name:11} Vf={vf} V -> R ≥ {(VCC - vf - VOL) / (I_WANT / 1000):.0f} Ω")

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

sink (LED-এর cathode latch-এ): R = (5 - 2.0 - 0.4) / 10.0 mA = 260 Ω
  E12 মান 270 Ω -> I = 9.63 mA (সীমা 24 mA), resistor-এ 25.0 mW
  VOL typical 0.25 V হলে I = 10.19 mA
  ৮টি LED একসঙ্গে: 77.0 mA GND pin দিয়ে
source (output 1-এ LED জ্বলবে): IOH সর্বোচ্চ 2.6 mA, চাই 10 mA -> চলবে না
সবুজ (ধরা)  Vf=2.2 V -> R ≥ 240 Ω
নীল (ধরা)   Vf=3.0 V -> R ≥ 160 Ω

ধাপগুলো: (১) resistor-এর ওপর ভোল্টেজ = 5 − 2.0 − 0.4 = 2.6 V; (২) R = 2.6 V ÷ 10 mA = 260 Ω; (৩) বাজারের E12 সারিতে 260 নেই, বড়টি 270 Ω নিলে current একটু কমে, 9.63 mA, নিরাপদ দিকে; (৪) VOL-এর typical মান 0.25 V হলে current ১০.১৯ mA, তবু ২৪ mA-র অনেক নিচে; (৫) resistor-এ মাত্র ২৫ mW, সাধারণ ¼ W resistor যথেষ্ট। Source-এর লাইনটি মূল শিক্ষা: ১০ mA চাইলে 2.6 mA-র সীমা ভাঙে, তাই 1-এ জ্বলা নকশা এখানে চলে না। ধরুন LED-এর VF 2.0 V; এটি একটি অনুমান, আপনার LED-এর datasheet থেকে আসল মান নিন। নীল LED-এ VF বেশি, তাই R কম (১৬০ Ω), কিন্তু সূত্র একই।

নিরাপত্তা আর নির্ভরযোগ্যতা: resistor ছাড়া LED কখনো latch-এ জুড়বেন না; LED বা output pin, যেকোনোটি নষ্ট হতে পারে। আটটি LED একসঙ্গে জ্বললে প্রায় ৭৭ mA একটি chip-এর GND pin দিয়ে যায়; datasheet প্রতিটি output-এর সীমা দেয়, তাই বড় load, relay বা motor-এর জন্য latch-এর পরে আলাদা transistor বা ULN2803-এর মতো driver array আর inductive load-এ flyback diode লাগে (motor পর্ব ৬৭-এ)। Mains (২২০ V) চালানো যন্ত্র কখনো সরাসরি নয়; সেখানে প্রশিক্ষিত মানুষের নকশা করা isolated module লাগে, আর এই কোর্স mains-এর তারে কাজ শেখায় না।

৬ · 7-segment display — অঙ্ক থেকে segment code

একটি 7-segment display-এ সাতটি লম্বা LED (a ওপরে, তারপর ঘড়ির কাঁটার দিকে b, c, d, e, f, আর মাঝে g), সঙ্গে একটি বিন্দু dp. ভেতরে সব LED-এর একটি প্রান্ত একসঙ্গে জোড়া: সব anode এক হলে common anode (+5 V-এ বাঁধা, segment জ্বলে তার cathode 0 হলে), সব cathode এক হলে common cathode (GND-এ, segment জ্বলে 1 হলে)। আগের অংশের হিসাবে 74LS373 sink-এ ভালো, তাই আমাদের নকশায় common anode, প্রতিটি segment-এর জন্য আলাদা resistor. একটি resistor common pin-এ বসালে যত বেশি segment জ্বলে, প্রতিটি তত ম্লান হয়: “1” উজ্জ্বল আর “8” ঝাপসা।

কোন বিট কোন segment, তা নকশাকারীর পছন্দ, কোনো সর্বজনীন নিয়ম নয়। এখানে প্রচলিত একটি ধারা: D0 = a, D1 = b … D6 = g, D7 = dp. নিচের ব্লক এই ধারায় দুই ধরনের code বানায় আর display-এর চোখে আঁকে।

# 7-segment code: bit 0 = a … bit 6 = g, bit 7 = dp (একটি প্রচলিত wiring)
SEGS = {0: "abcdef", 1: "bc", 2: "abdeg", 3: "abcdg", 4: "bcfg",
        5: "acdfg", 6: "acdefg", 7: "abc", 8: "abcdefg", 9: "abcdfg"}

def cc_code(d):                      # common cathode: 1 = segment জ্বলে
    return sum(1 << "abcdefg".index(s) for s in SEGS[d])

cc = [cc_code(d) for d in range(10)]
ca = [c ^ 0xFF for c in cc]          # common anode: 0 = জ্বলে (dp-ও নেভা = 1)
print("অঙ্ক  CC    CA")
for d in range(10):
    print(f"  {d}   {cc[d]:02X}H  {ca[d]:02X}H")

def draw(code, anode=True):          # code থেকে ছবি, যেন display-এর চোখে
    on = lambda s: ((code >> "abcdefg".index(s)) & 1) == (0 if anode else 1)
    h = lambda s: " __ " if on(s) else "    "
    v = lambda l, m, r: ("|" if on(l) else " ") + ("__" if on(m) else "  ") + ("|" if on(r) else " ")
    return [h("a"), v("f", "g", "b"), v("e", "d", "c")]

rows = [draw(c) for c in (0x99, 0x92, 0xF8)]   # CA-তে 4, 5, 7
for line in range(3):
    print("  ".join(r[line] for r in rows))
print("ভুল: CA display-এ CC code 66H পাঠালে:")
print("\n".join(draw(0x66)))

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

অঙ্ক  CC    CA
  0   3FH  C0H
  1   06H  F9H
  2   5BH  A4H
  3   4FH  B0H
  4   66H  99H
  5   6DH  92H
  6   7DH  82H
  7   07H  F8H
  8   7FH  80H
  9   6FH  90H
       __    __ 
|__|  |__      |
   |   __|     |
ভুল: CA display-এ CC code 66H পাঠালে:
 __ 
    
|__ 

Common cathode-এর 3FH (0), 06H (1) … 6FH (9) পরীক্ষায় বহুল প্রচলিত তালিকা; common anode-এর code ঠিক তার উল্টো (XOR 0FFH), dp-ও নেভা থাকে বলে বিট 7 = 1: C0H, F9H … 90H. আঁকা তিনটি অঙ্ক 4, 5, 7 common-anode code থেকে। শেষ ছবি একটি সাধারণ ভুল: common-anode display-এ common-cathode-এর code 66H (অঙ্ক 4) পাঠালে যে segment-গুলোর বিট 0, অর্থাৎ a, d, e জ্বলে (বিট 7 = 0 বলে dp-ও, যা ছবিতে আঁকা নেই), আর একটি অর্থহীন আকার দেখা যায়। Display কাজ না করলে প্রথমে দেখুন code-এর ধরন display-এর ধরনের সঙ্গে মেলে কি না।

এবার 8085-এ। Switch-এর নিচের চার বিট একটি অঙ্ক (চাপা = 1 বানাতে আগে CMA), আর একটি lookup table থেকে code নিয়ে port 02H-এ। Table রাখা 2050H-এ, ঠিক ব্লকের CA কলামের মান। সত্যিকারের run (sim8085.py, port-এর মান ;@in 01H 0FAH, আগের মতো S0 আর S2 চাপা):

~/lab$ python -B sim8085.py trace seg7.asm
2000  DB 01     IN 01H         A=FA … PC=2002 … Z=0  T=10 total=10
2002  2F        CMA            A=05 … PC=2003 … Z=0  T=4  total=14
2003  E6 0F     ANI 0FH        A=05 … PC=2005 … Z=0  T=7  total=21
2005  21 50 20  LXI H,2050H    A=05 … PC=2008 … Z=0  T=10 total=31
2008  5F        MOV E,A        A=05 … PC=2009 … Z=0  T=4  total=35
2009  16 00     MVI D,00H      A=05 … PC=200B … Z=0  T=7  total=42
200B  19        DAD D          A=05 … PC=200C … Z=0  T=10 total=52
200C  7E        MOV A,M        A=92 … PC=200D … Z=0  T=7  total=59
200D  D3 02     OUT 02H        A=92 … PC=200F … Z=0  T=10 total=69
200F  76        HLT            A=92 … PC=2010 … Z=0  T=5  total=74
OUT port 02H <- 92H  (at T=69)
Instructions: 10   T-states: 74

(Trace-এর লাইন ছোট করা: …-এর জায়গায় বাকি register, SP আর বাকি flag.) প্রতিটি লাইন একটি ধাপ: IN দেয় FAH, CMA করে 05H (চাপা দুটি switch এখন 1, অর্থাৎ বিট 0 আর 2: 4 + 1 = 5), ANI 0FH নিচের চার বিট রাখে, DAD D HL-কে 2055H-এ নেয়, MOV A,M আনে 92H, আর OUT 02H সেটি T = ৬৯-এ display-এর latch-এ পাঠায়। অঙ্ক 5-এর common-anode code 92H, ব্লকের টেবিলের সঙ্গে মেলে। মোট ১০টি নির্দেশ, ৭৪ T = 24.67 µs.

বাজারঘরের smart scale-এর দাম, যেমন ১৫০ g আলুর 9.83 টাকা (README-র হিসাব), দেখাতে লাগে অন্তত তিনটি অঙ্ক। প্রতিটি অঙ্কের জন্য আলাদা latch আর আটটি resistor দিলে chip আর তার বাড়ে। প্রচলিত সমাধান multiplexing: সব অঙ্কের segment-এর তার এক, আর প্রতিবার একটিমাত্র অঙ্কের common pin চালু, দ্রুত পালা করে; চোখ সবকটি একসঙ্গে জ্বলা দেখে। এর জন্য একটি port-এ segment, আরেকটিতে অঙ্ক বাছাই, আর নিয়মিত সময় লাগে; 8255-এর port দিয়ে এই কাজ পর্ব ২৪ (8255 PPI)-এ, আর নিয়মিত সময় তৈরির timer পর্ব ২৫-এ।

৭ · Polling, interrupt আর handshake — কখন পড়বেন

এতক্ষণ ধরে নিয়েছি যন্ত্র সবসময় প্রস্তুত: switch পড়লেই মান, LED-এ লিখলেই জ্বলে। একে বলে সরল বা শর্তহীন I/O. কিন্তু বোতাম কখন চাপা হবে, ADC কখন রূপান্তর শেষ করবে, printer কখন পরের অক্ষর নিতে পারবে, CPU আগে থেকে জানে না। তখন তিনটি পথ:

  1. Polling: CPU একটি loop-এ বারবার যন্ত্রের অবস্থা পড়ে, প্রস্তুত হলে কাজ করে।
  2. Interrupt: যন্ত্র নিজে CPU-র interrupt pin-এ সংকেত দেয়; CPU অন্য কাজ করতে থাকে। 8085-এর পাঁচটি interrupt line, mask আর ISR পর্ব ১৩-এ (8085-এর interrupt) বিস্তারিত, সেখানে বাজারঘরের TARE বোতামই RST 7.5-এ চালানো হয়েছে।
  3. DMA: খুব দ্রুত ধারার data-য় CPU-কে বাদ দিয়ে যন্ত্র নিজেই memory-তে লেখে (8237, পর্ব ২৭)।

Polling-এর সবচেয়ে ছোট রূপ: TARE বোতাম (S0, port 01H-এর বিট 0) চাপা না হওয়া পর্যন্ত ঘোরা, তারপর LED0 জ্বালানো। Simulator-এর ;@in একটি স্থির মান দেয়, তাই সময়ের সঙ্গে বদলানো বোতামের জন্য লেখকের lab-এ একটি ছোট wrapper (poll_run.py) লেখা হয়েছে: সেটি reference lab-এর sim8085.py-কে বিন্দুমাত্র না বদলে import করে, আর port 01H-এর মান মোট T-state ১০০ ছোঁয়ার আগে 0FFH, পরে 0FEH দেয়। একটি সীমা: simulator IN-এর মান নেয় নির্দেশ শুরুর মুহূর্তে, আসল chip নেয় I/O read cycle-এর ভেতরে, কয়েক T পরে। সত্যিকারের run (trace-এর লাইন আগের মতো ছোট করা):

~/lab$ python -B poll_run.py 100
2000  3E FF     MVI A,0FFH     A=FF … PC=2002 … Z=0  T=7  total=7
2002  D3 01     OUT 01H        A=FF … PC=2004 … Z=0  T=10 total=17
2004  DB 01     IN 01H         A=FF … PC=2006 … Z=0  T=10 total=27
2006  E6 01     ANI 01H        A=01 … PC=2008 … Z=0  T=7  total=34
2008  C2 04 20  JNZ 2004H      A=01 … PC=2004 … Z=0  T=10 total=44
2004  DB 01     IN 01H         A=FF … PC=2006 … Z=0  T=10 total=54
2006  E6 01     ANI 01H        A=01 … PC=2008 … Z=0  T=7  total=61
2008  C2 04 20  JNZ 2004H      A=01 … PC=2004 … Z=0  T=10 total=71
2004  DB 01     IN 01H         A=FF … PC=2006 … Z=0  T=10 total=81
2006  E6 01     ANI 01H        A=01 … PC=2008 … Z=0  T=7  total=88
2008  C2 04 20  JNZ 2004H      A=01 … PC=2004 … Z=0  T=10 total=98
2004  DB 01     IN 01H         A=FF … PC=2006 … Z=0  T=10 total=108
2006  E6 01     ANI 01H        A=01 … PC=2008 … Z=0  T=7  total=115
2008  C2 04 20  JNZ 2004H      A=01 … PC=2004 … Z=0  T=10 total=125
2004  DB 01     IN 01H         A=FE … PC=2006 … Z=0  T=10 total=135
2006  E6 01     ANI 01H        A=00 … PC=2008 … Z=1  T=7  total=142
2008  C2 04 20  JNZ 2004H      A=00 … PC=200B … Z=1  T=7  total=149
200B  3E FE     MVI A,0FEH     A=FE … PC=200D … Z=1  T=7  total=156
200D  D3 01     OUT 01H        A=FE … PC=200F … Z=1  T=10 total=166
200F  76        HLT            A=FE … PC=2010 … Z=1  T=5  total=171
OUT port 01H <- FFH  (at T=17)
OUT port 01H <- FEH  (at T=166)
button pressed at T=100; Instructions: 20   T-states: 171
1MVI A,0FFH2OUT 01H   ; সব নেভা3POLL: IN 01H4ANI 01H   ; বিট 05JNZ POLL6MVI A,0FEH7OUT 01H   ; LED08HLT
Register, port আর সময়
পাক
port 01H
A · Z
LED latch
মোট T
  1. শুরু. MVI A,0FFH (৭ T) আর OUT 01H (১০ T): সব বিট 1, তাই sink-এ বাঁধা সব LED নেভা। মোট ১৭ T, OUT log-এ FFH.
  2. প্রথম পাক. IN 01H দেয় FFH (বোতাম চাপা নয়), ANI 01H রাখে শুধু বিট 0: A = 01H, Z = 0. JNZ শর্ত মেলায় লাফায়, ১০ T. এক পাক = ১০ + ৭ + ১০ = ২৭ T = 9 µs. মোট ৪৪ T.
  3. দ্বিতীয় থেকে চতুর্থ পাক. একই ফল। বোতাম চাপা হলো T = ১০০-এ, কিন্তু চতুর্থ পাকের IN শুরু হয়েছিল T = ৯৮-এ, মান তখনই নেওয়া। তাই চতুর্থ পাক চাপ টের পায় না; T = ১২৫-এ শেষ।
  4. পঞ্চম পাক. IN (T = ১২৫-এ শুরু) দেয় FEH, ANI 01H করে 00H, Z = 1. এবার JNZ লাফায় না, শুধু ৭ T (শর্ত না মিললে দ্বিতীয় ঠিকানা-byte পড়ে না, পর্ব ০৮)। মোট ১৪৯ T.
  5. সাড়া. MVI A,0FEH, OUT 01H: LED0 জ্বলে T = ১৬৬-এ, HLT-সহ মোট ১৭১ T. চাপ থেকে সাড়া ৬৬ T = 22 µs, যার মধ্যে ২৫ T শুধু পরের IN-এর অপেক্ষা। পুরো সময় CPU আর কোনো কাজ করতে পারেনি।

Polling-এর দুটি দাম পরিষ্কার হলো। প্রথম, দেরি: ঘটনা যেকোনো মুহূর্তে আসতে পারে, তাই পরের পড়া পর্যন্ত অপেক্ষা ০ থেকে প্রায় এক পাক। দ্বিতীয়, অপচয়: অপেক্ষার পুরো সময় CPU ব্যস্ত, একে busy-wait বলে। Interrupt দুটোই কমায়, কিন্তু নিজের একটি স্থির খরচ আনে: পর্ব ১৩-এর হিসাবে acknowledge, vector, PUSH/POP আর ফেরা মিলিয়ে প্রায় ৫৮ T. তাই বিরল ঘটনায় (বোতাম) interrupt, খুব ঘন আর নিয়মিত ঘটনায় polling বা DMA.

Handshake: একটি যন্ত্র যখন একের পর এক byte দেয় (যেমন একটি ADC বা আরেকটি কম্পিউটার), তখন শুধু “প্রস্তুত কি না” জানা যথেষ্ট নয়; জানতে হয় নতুন byte এলো কি না, আর CPU আগেরটি নিয়েছে কি না। সবচেয়ে প্রচলিত সমাধান: যন্ত্র data রেখে একটি strobe pulse দেয় (STB, active-low), যা একটি flip-flop-কে 1 করে: “data ready” flag. CPU একটি status port-এ এই flag পড়ে (polling), 1 পেলে data port পড়ে, আর data port পড়ার সংকেতই flag মুছে দেয়। Output-এর দিকেও উল্টো জোড়া: CPU লিখলে “output full” flag, যন্ত্র নিলে ACK pulse দিয়ে মোছে। এই দুই তারের অনুরোধ-স্বীকৃতিই handshake; 8255-এর mode 1 এই flip-flop আর সংকেতগুলো chip-এর ভেতরেই রাখে (পর্ব ২৪)।

Flag 1 থাকা অবস্থায় আরেকটি byte এলে আগেরটি মুছে যায়: overrun. নিচের মডেল দেখায়, polling loop কত ধীর হলে byte হারায়। Device প্রতি ১২০ T-এ (৩ MHz-এ 40 µs) একটি byte দেয়; loop-এর এক পাক ২৭ T; প্রতিটি byte পাওয়ার পরে কাজ (data port পড়া আর memory-তে রাখা) কখনো ৪০ T, কখনো ১৫০ T.

# Handshake-সহ input: device data দিয়ে STB pulse দেয় -> "ready" flip-flop = 1.
# CPU status port-এর bit পড়ে (polling), data port পড়লে flag মুছে যায়।
# Flag 1 থাকা অবস্থায় নতুন byte এলে আগেরটি হারায় (overrun). ৩ MHz: 1 T = 1/3 µs
def run(period, loop_t, work_t, n=8):
    ready, data, got, lost, t = 0, None, [], 0, 0
    arrivals = [(k + 1) * period for k in range(n)]   # byte k আসে এই T-তে
    i = 0
    while t < arrivals[-1] + 3 * period:
        while i < n and arrivals[i] <= t:              # এই সময়ের মধ্যে আসা byte
            if ready: lost += 1                        # আগেরটি কেউ পড়েনি
            ready, data = 1, i
            i += 1
        if ready:                                      # status bit = 1
            got.append(data); ready = 0                # data port পড়া, flag মুছল
            t += work_t                                # byte নিয়ে কাজ (যেমন memory-তে রাখা)
        t += loop_t                                    # IN + ANI + JZ = এক পাক
    return got, lost

for work in (40, 150):
    got, lost = run(period=120, loop_t=27, work_t=work)
    print(f"byte আসে প্রতি 120 T (40 µs), প্রতিটির কাজ {work:3} T: পেল {got}, হারাল {lost}")

# polling latency: বোতাম চাপার মুহূর্ত বদলে, পরের IN পর্যন্ত কত দেরি?
LOOP = 27
d = [(LOOP - (p % LOOP)) % LOOP for p in range(0, 270)]
print(f"loop {LOOP} T: অপেক্ষা সর্বনিম্ন {min(d)} T, সর্বোচ্চ {max(d)} T "
      f"({max(d) / 3:.1f} µs), গড় {sum(d) / len(d):.1f} T")

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

byte আসে প্রতি 120 T (40 µs), প্রতিটির কাজ  40 T: পেল [0, 1, 2, 3, 4, 5, 6, 7], হারাল 0
byte আসে প্রতি 120 T (40 µs), প্রতিটির কাজ 150 T: পেল [0, 1, 3, 4, 6, 7], হারাল 2
loop 27 T: অপেক্ষা সর্বনিম্ন 0 T, সর্বোচ্চ 26 T (8.7 µs), গড় 13.0 T

কাজ ৪০ T হলে প্রতিটি byte পরের byte আসার আগেই নেওয়া হয়, আটটিই পৌঁছায়। কাজ ১৫০ T হলে, যা byte আসার ব্যবধান ১২০ T-এর চেয়ে বেশি, CPU যখন কাজ শেষ করে ফিরে আসে তখন মাঝে মাঝে দুটি byte এসে গেছে: byte 2 আর 5 হারাল, flag ঠিকই বলেছিল নতুন data আছে, কিন্তু আগেরটি কেউ নেয়নি। নিয়মটি সরল: প্রতিটি byte-এর মোট খরচ (কাজ + বড়জোর এক পাক) byte-এর ব্যবধানের চেয়ে কম হতে হবে। শেষ লাইন polling-এর দেরি: বোতাম চাপার মুহূর্ত ০ থেকে ২৬৯ T পর্যন্ত বদলে দেখা গেল পরের IN পর্যন্ত অপেক্ষা ০ থেকে ২৬ T, গড়ে ১৩ T, অর্থাৎ ২৭ T-এর loop-এ সর্বোচ্চ প্রায় 8.7 µs. Stepper-এর ২৫ T অপেক্ষা এই সীমার ভেতরেই। মডেলটি লেখকের, simulator-এর T-state (২৭ T-এর পাক) দিয়ে।

বিষয়PollingInterrupt
Hardwareশুধু একটি status বিটInterrupt line, দরকারে priority (8259, পর্ব ২৬)
দেরি০ থেকে এক পাক, আর loop কত কাজ করে তার ওপরচলতি নির্দেশ শেষ + acknowledge + ISR-এর শুরু
CPU-র সময়অপেক্ষার পুরো সময় ব্যস্তঘটনা ছাড়া মুক্ত, প্রতিটিতে স্থির খরচ
পূর্বানুমানখুব ভালো: প্রতিটি পাকের T জানাঘটনার মুহূর্তের ওপর নির্ভর, পরীক্ষা কঠিন
উপযুক্তঘন, নিয়মিত ঘটনা; CPU-র আর কাজ নেইবিরল, অনিশ্চিত ঘটনা; বাকি কাজ চালু রাখতে হবে

পরীক্ষা ও ইন্টারভিউতে — সাধারণ প্রশ্ন আর এক লাইনের উত্তর:

  • 8085-এ কয়টি I/O port? ৮ বিটের port নম্বর, তাই ২৫৬টি input আর ২৫৬টি output; IO/M = 1 দিয়ে memory থেকে আলাদা।
  • Input port-এ latch, output port-এ buffer দিলে কী হয়? Input-এ tri-state ছাড়া chip bus-এ সারাক্ষণ মান চাপায় (contention); output-এ buffer মান ধরে রাখে না, LED এক µs-এর কম জ্বলে নিভে যায়।
  • Memory-mapped I/O-র দুটি সুবিধা আর একটি অসুবিধা? যেকোনো memory নির্দেশ আর addressing mode চলে, ঠিকানা বেশি; কিন্তু memory-র জায়গা খায় আর 8085-এ নির্দেশ লম্বা (১৩ T বনাম ১০ T).
  • Common anode-এ “0”-এর code (D0 = a … D6 = g, dp নেভা)? C0H; common cathode-এ 3FH.
  • LED কেন sink-এ? 74LS373-এর IOL 24 mA কিন্তু IOH মাত্র 2.6 mA, তাই 0-তে জ্বালানো নিরাপদ আর উজ্জ্বল।

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

“8085-এ একটি LED আর switch জোড়ার circuit আর program দিন” লিখলে AI assistant কয়েক সেকেন্ডে সুন্দর উত্তর দেয়। এই বিষয়ে তার ভুলগুলো থাকে ঠিক সেখানে, যেখানে সংকেতের polarity, datasheet-এর সংখ্যা বা নির্দেশের নিয়ম লাগে:

AI প্রায়ই যা করেকীভাবে ধরবেন
8085-এ IN AL,DX বা OUT DX,AL লেখা (8086-এর রূপ), বা OUT 01H,B (8085-এ শুধু A)কোর্সের 8085 simulator-এ assemble করা; ভুল হলে assembler থামে
Active-low enable-এ AND gate বসানো, বা buffer-এর enable থেকে RD বাদ দেওয়াপ্রতিটি cycle-এর truth table নিজে লেখা; এই পর্বের ports.py-র মতো মডেলে contention গোনা
LED latch থেকে source করে ১০–২০ mA ধরা, বা resistor-এর মান আন্দাজেChip-এর datasheet-এ IOH, IOL, VOL; সূত্রে হাতে হিসাব
Common anode আর common cathode-এর code গুলিয়ে ফেলা, বা বিট-ধারা না বলেই টেবিল দেওয়াবিট-ধারা ঠিক করে নিজে code বানানো; এক অঙ্ক আঁকিয়ে দেখা
Memory-mapped আর isolated I/O-র T-state ভুল বলা (যেমন OUT ১৩ T)Simulator-এর trace: IN/OUT ১০ T, LDA/STA ১৩ T
আধুনিক MCU-র জন্য register-এর নাম আর ঠিকানা বানিয়ে বলাসেই chip-এর reference manual-এর memory map; কোর্সের board-এ README-র টেবিল

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

আমি Intel 8085 (৩ MHz clock) দিয়ে isolated I/O নকশা করছি। Port 01H-এ 74LS244 buffer-এ আটটি switch (10 kΩ pull-up, চাপা = 0), আর একই port 01H-এ 74LS373 latch-এ আটটি LED (sink, চাপা switch-এর LED জ্বলবে)। ১. 74LS138 decoder-এর output Y1 থেকে 244-এর enable আর 373-এর G-এর logic দাও, প্রতিটি gate-এর কারণসহ। IN 01H, OUT 01H আর একটি memory write-এর জন্য truth table দাও। ২. Program লেখো: switch পড়ে LED-এ দেখাও। প্রতিটি নির্দেশের T-state দাও। শুধু 8085-এর নির্দেশ, 8086 বা Z80-এর নয়। ৩. LED-এর resistor হিসাব করো: VF 2.0 V ধরো, 74LS373-এর IOL আর VOL কোন datasheet থেকে নিলে বলো। ৪. যেখানে নিশ্চিত নও, অনুমান না করে বলো।

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

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

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

প্র ০১Intel কেন 8080/8085-এ আলাদা I/O ঠিকানা-জগৎ রাখল, অথচ Motorola-র 6800 আর আজকের ARM শুধু memory-mapped I/O-তে চলে? কোন পথ “ঠিক”?

১৯৭৪ সালের 8080 আর তার উত্তরসূরি 8085-এর ঠিকানা মাত্র ১৬ বিট, অর্থাৎ ৬৪ KB. তখন memory দামি আর ৬৪ KB-ই বড় ব্যাপার, তাই প্রতিটি ঠিকানা মূল্যবান। আলাদা I/O জগৎ রাখলে port-এর জন্য memory থেকে কিছুই কাটতে হয় না। আরেকটি লাভ hardware-এর সরলতা: port নম্বর মাত্র ৮ বিট, তাই decoder ছোট; আর IO/M-এর মতো একটি pin দেখেই বোঝা যায় এটি I/O. 8080-এর পূর্বসূরি 8008-এরও আলাদা input-output নির্দেশ ছিল, আর Intel সেই ধারা রেখেছে; 8086 আর আজকের x86-এও IN/OUT টিকে আছে, পুরোনো software চালানোর বাধ্যবাধকতায়।

অন্যদিকে প্রায় একই সময়ের Motorola 6800 কোনো আলাদা I/O নির্দেশ রাখেনি। তার যুক্তি: নির্দেশের সংখ্যা কম, শেখা সহজ, আর memory-র সব addressing mode আর ALU নির্দেশ port-এর ওপরও চলে। এই পর্বের তুলনা-টেবিলে দেখেছেন, 8085-এ memory-mapped port-এ ANA M বা MVI M সরাসরি চলে, যা IN/OUT দিয়ে সম্ভব নয়। দাম memory-র কিছু জায়গা আর ১৬ বিটের decoding.

৩২ বিটের যুগে প্রথম যুক্তিটি প্রায় হারিয়ে গেছে: ৪ GB-এর ঠিকানা-জগতে peripheral-এর জন্য কয়েক MB আলাদা রাখা কোনো ক্ষতিই নয়। তাই ARM Cortex-M, RISC-V আর অনেক আধুনিক নকশায় আলাদা I/O নির্দেশই নেই; peripheral-এর register-ও সাধারণ load-store দিয়ে, যেমন কোর্সের ভার্চুয়াল board-এর GPIO 0x40010800-এ। বাকি থাকে দ্বিতীয় যুক্তি, নির্দেশের নিরাপত্তা: আলাদা নির্দেশ থাকলে একটি ভুল pointer হঠাৎ port-এ লিখতে পারে না, আর x86-এ অপারেটিং সিস্টেম IN/OUT-কে সাধারণ program-এর জন্য বন্ধ রাখতে পারে। Memory-mapped জগতে একই সুরক্ষা আসে MPU বা MMU দিয়ে, ঠিকানার এলাকা ধরে অনুমতি দিয়ে।

তাই কোনো পথ চিরকালের জন্য “ঠিক” নয়; প্রতিটি তার সময়ের সীমাবদ্ধতার উত্তর। পরীক্ষায় তুলনা লিখতে গেলে শুধু সুবিধা-অসুবিধার তালিকা নয়, এই প্রেক্ষাপটও এক লাইনে বলা ভালো।

মূল উপলব্ধি: আলাদা I/O জগৎ ছিল ছোট ঠিকানা-জগতের যুগের সাশ্রয়; বড় ঠিকানা-জগতে memory-mapped I/O-র নমনীয়তা জিতেছে, আর সুরক্ষা এসেছে অন্য পথে।

প্র ০২Tri-state output না থাকলে একটি shared bus কি আদৌ সম্ভব? Bus contention কেন এত বিপজ্জনক, আর open-drain বা open-collector আরেকটি পথ কীভাবে?

সাধারণ TTL বা CMOS output দুটি অবস্থার যেকোনো একটিতে সবসময় জোর দিয়ে থাকে: 1-এ সে তারকে supply-এর দিকে টানে, 0-এ ground-এর দিকে। একই তারে দুটি এমন output জুড়লে আর তারা উল্টো মান চাইলে একজনের ওপরের transistor আর অন্যজনের নিচের transistor মিলে supply থেকে ground-এ একটি প্রায় সরাসরি পথ তৈরি হয়। 74LS373-এর datasheet-এ short-circuit output current (IOS) সর্বোচ্চ ১৩০ mA পর্যন্ত লেখা, আর সতর্কবাণী: একসঙ্গে একটির বেশি output short করা যাবে না, আর এক সেকেন্ডের বেশি নয়। আটটি বিটে এমন সংঘাত মানে মোটা current, chip গরম, ভোল্টেজের মাঝামাঝি একটি মান যা কেউ 0 বা 1 নিশ্চিত পড়তে পারে না, আর power supply-তে শব্দ, যা অন্য chip-কেও বিভ্রান্ত করে।

Tri-state সমাধান: তৃতীয় একটি অবস্থা, যেখানে দুটি transistor-ই বন্ধ আর output তার থেকে প্রায় বিচ্ছিন্ন (datasheet-এ off-state current মাত্র ২০ µA-এর ঘরে)। তখন নিয়ম হয়, একটি মুহূর্তে মাত্র একজন চালক, বাকিরা বিচ্ছিন্ন। এই নিয়ম রক্ষা করে decoder আর enable-যুক্তি; এই পর্বের ports.py-র ভুল নকশা দেখিয়েছে, একটি RD বাদ পড়লেই নিয়ম ভাঙে। 8085 নিজেও HOLD-এ তার bus tri-state করে, যাতে DMA controller চালক হতে পারে (পর্ব ০৮, পর্ব ২৭)।

দ্বিতীয় পথ open-collector (TTL) বা open-drain (CMOS): output শুধু 0-এ টানতে পারে, 1-এর জন্য বাইরে একটি pull-up resistor. তখন একাধিক output একই তারে নিরাপদ: কেউ 0 টানলে তার 0, কেউ না টানলে resistor-এর 1; সংঘাত হয় না, ফলটা একধরনের AND (wired-AND). দাম গতি: resistor দিয়ে তার 1-এ ওঠে ধীরে। I2C bus ঠিক এভাবেই চলে, যাতে অনেক device একই দুটি তার ভাগ করতে পারে আর ACK, clock stretching সম্ভব হয় (পর্ব ৫১); microcontroller-এর GPIO-তে open-drain mode পর্ব ৪১-এ আসবে। 8085-এর interrupt-এর জন্যও অনেক নকশায় একাধিক যন্ত্রের open-collector output এক তারে জোড়া হতো।

মূল উপলব্ধি: Shared bus-এর মূল নিয়ম “এক মুহূর্তে এক চালক”; tri-state সেটি decoder দিয়ে রক্ষা করে, open-drain সেটিকে নকশাতেই নিরাপদ করে, গতির দামে।

প্র ০৩8085-এর port-এ আসা একটি switch-এর মান আর আধুনিক microcontroller-এর GPIO input register-এর মধ্যে কী মিল, কী অমিল? ৪০ বছরে কী বদলাল?

মিল মৌলিক জায়গায়। আধুনিক chip-এর GPIO-র input data register পড়া মানে, ঠিক 74LS244-এর মতো, একটি মুহূর্তে pin-গুলোর অবস্থা bus-এ তুলে আনা; output data register লেখা মানে 74LS373-এর মতো একটি latch-এ মান রাখা, যা pin-গুলো ধরে রাখে। কোর্সের ভার্চুয়াল board-এর README-তে GPIOA-র IDR (পড়া) আর ODR (লেখা) ঠিক এই দুই ভূমিকা। Pull-up resistor, active-low বোতাম, sink-এ LED, সবই একই পদার্থবিদ্যা।

বদল তিন জায়গায়। এক, সবকিছু chip-এর ভেতরে: buffer, latch, decoder, এমনকি pull-up resistor-ও (চাইলে register-এ একটি বিট দিয়ে চালু), তাই বাইরে শুধু LED আর তার resistor থাকে। দুই, প্রতিটি pin-এর দিক বদলানো যায়: একই pin কখনো input, কখনো output, একটি direction register দিয়ে; 8085-এর যুগে দিক বদলাতে আলাদা chip লাগত, যা পরে 8255-এর মতো programmable chip সহজ করেছিল (পর্ব ২৪)। তিন, পরমাণু-স্তরের সুবিধা: অনেক chip-এ একটি set/reset register থাকে (কোর্সের board-এ BSRR আর BRR), যাতে একটি বিট বদলাতে পুরো byte পড়ে-বদলে-লেখার দরকার না হয়, interrupt-এর মাঝখানে ভুলের ঝুঁকিও থাকে না।

আরেকটি পার্থক্য মাত্রায়। 8085-এর পড়ার জানালা কয়েকশো ns, আর আধুনিক chip-এ input-এর পথে একটি synchroniser থাকে, যা বাইরের অসমলয় সংকেতকে CPU-র clock-এর সঙ্গে মেলায়, যাতে একটি পরিবর্তনশীল pin পড়ার মুহূর্তে অনিশ্চিত অবস্থা (metastability) CPU-তে না ঢোকে। এর ফলে input বদলের পরে register-এ দেখা দিতে কয়েক clock লাগতে পারে; নির্দিষ্ট সংখ্যা প্রতিটি chip-এর reference manual-এ। আর output-এ drive-এর শক্তি আর গতি register দিয়ে বাছা যায়, যাতে অপ্রয়োজনীয় দ্রুত কিনারা শব্দ না ছড়ায়।

মূল উপলব্ধি: GPIO হলো 74LS244 আর 74LS373-এর chip-এর ভেতরে চলে যাওয়া রূপ, সঙ্গে দিক বদল, ভেতরের pull-up আর পরমাণু-স্তরের বিট-লেখার সুবিধা; ধারণা একই, সুবিধা বেশি।

প্র ০৪Handshake ছাড়া দুটি ভিন্ন গতির যন্ত্র কি নির্ভরযোগ্যভাবে data দিতে-নিতে পারে? Centronics printer port থেকে আজকের serial bus পর্যন্ত এই ধারণা কীভাবে টিকে আছে?

পারে, কিন্তু শুধু একটি শর্তে: দুজনের গতি আগে থেকে নিশ্চিত জানা আর সবসময় মেনে চলা। উদাহরণ UART: দুই প্রান্ত একই baud rate-এ একমত, তাই প্রতিটি বিট কখন আসবে জানা (পর্ব ৪৯)। কিন্তু একপক্ষ ধীর হয়ে গেলে, যেমন receiver অন্য কাজে ব্যস্ত, তখন data হারায়: এই পর্বের handshake.py-র মডেলে কাজ ১৫০ T হতেই আটটির মধ্যে দুটি byte গেল। যে যন্ত্রের গতি কাজভেদে বদলায়, তার জন্য অপেক্ষার নিয়ম দরকার: “আমি দিলাম” আর “আমি নিলাম”-এর দুটি সংকেত।

১৯৭০-এর দশক থেকে PC-র printer-এ ব্যবহৃত Centronics parallel interface এর একটি পরিচিত উদাহরণ: কম্পিউটার আটটি data লাইনে অক্ষর রাখে আর একটি STROBE pulse দেয়; printer অক্ষর নিলে ACK pulse পাঠায়, আর ব্যস্ত থাকলে BUSY লাইন উঁচু রাখে। ধীর যান্ত্রিক printer আর দ্রুত কম্পিউটার এভাবে কোনো অক্ষর না হারিয়ে কথা বলত। এর বিস্তারিত সংকেত-নাম আর timing প্রস্তুতকারক ভেদে কিছুটা আলাদা ছিল, পরে IEEE 1284 মান সেগুলো গুছিয়েছে; মূল ধারণাটি এই পর্বের strobe আর flag. 8255-এর mode 1 (পর্ব ২৪) এই ধরনের handshake chip-এর ভেতরে এনে দেয়: STB, IBF, ACK, OBF আর INTR সংকেত।

আজকের serial bus-এও একই ধারণা ভিন্ন রূপে। I2C-তে প্রতিটি byte-এর পরে receiver একটি ACK বিট দেয়, আর ধীর slave clock লাইন নিচু ধরে master-কে থামাতে পারে (clock stretching, পর্ব ৫১)। UART-এর hardware flow control-এ RTS/CTS তার দিয়ে “এখন পাঠাবেন না” জানানো হয়। আর নেটওয়ার্কে TCP-এর acknowledgement আর window পুরো ধারণাটিকে software-এ নিয়ে গেছে। এমনকি 8085-এর READY pin, যা ধীর memory-কে wait state ঢোকাতে দেয় (পর্ব ০৮), একধরনের handshake.

মূল উপলব্ধি: দুই পক্ষের গতি নিশ্চিত না হলে handshake ছাড়া data হারানো সময়ের ব্যাপার; strobe আর acknowledge-এর এই সরল জোড়া printer port থেকে I2C আর TCP পর্যন্ত টিকে আছে।

প্র ০৫কোর্সের 8085 simulator কি I/O interfacing-এর নকশা যাচাই করতে পারে? এই পর্বের কোন সংখ্যা simulator থেকে, কোনটি মডেল থেকে, আর কোনটি শুধু datasheet থেকে?

Simulator I/O-কে খুব সরল ভাবে দেখে, Spec decision 10 অনুযায়ী: IN একটি port-এর আগে থেকে বসানো মান পড়ে (না বসালে 00H), আর OUT একটি log-এ লেখে কোন port-এ কোন মান কোন T-state-এ গেল। এতে program-এর যুক্তি আর সময় নিখুঁত যাচাই হয়: কোন byte কোথায় গেল, flag কী হলো, কত T লাগল। এই পর্বের FAH, 92H, OUT-এর T = ২০, ৬৯, ১৬৬, আর সব T-state-এর সংখ্যা সেখান থেকে। Simulator যা জানে না: decoder, buffer, latch, pull-up, LED, current, bus contention. তার কাছে 8001H নিছক RAM; সেখানে লিখলে মান থেকে যায়, যা আসল buffer-এ কখনো হতো না।

তাই এই পর্বের সংখ্যাগুলো তিন উৎসের। প্রথম, simulator: program-এর ফল আর T-state. দ্বিতীয়, লেখকের ছোট মডেল (ports.py, seg7.py, handshake.py, আর polling-এর wrapper): datasheet-এর function table আর এই পর্বের নকশা থেকে বানানো, লেখকের lab-এ চালিয়ে মেলানো। মডেল শুধু ততটুকু সত্য, যতটুকু তাতে লেখা হয়েছে; যেমন ports.py contention গোনে, কিন্তু কত current বইবে বলে না। তৃতীয়, শুধু datasheet: 74LS373-এর 24 mA আর 2.6 mA, 74LS244-এর 30 ns, setup আর hold. এগুলো কোনো run-এ আসেনি; এসেছে TI-র নথি থেকে, আর resistor-এর হিসাব সেই সংখ্যার ওপর।

বাস্তব নকশায় পরের ধাপ hardware-স্তরের simulation (যেমন একটি SPICE বা logic simulator) আর তারপর আসল board-এ logic analyzer দিয়ে মাপা। এই কোর্সে কোনো আসল board বা logic analyzer চালানো হয়নি। পরীক্ষায় বা কাজে যা প্রায়ই ভুল হয় তা হলো এই স্তরগুলো গুলিয়ে ফেলা: simulator-এ program ঠিক চলেছে মানে circuit ঠিক, এমন নয়। Polling-এর wrapper নিজেই একটি উদাহরণ: সেখানে IN-এর মান নির্দেশ শুরুর মুহূর্তে নেওয়া, আসল chip-এ কয়েক T পরে; একটি সীমান্তের ঘটনায় এই পার্থক্য ফল বদলাতে পারে।

মূল উপলব্ধি: প্রতিটি tool একটি স্তরের সত্য দেখায়; program-এর সত্যের জন্য simulator, logic-এর জন্য মডেল আর truth table, বিদ্যুতের জন্য datasheet, আর শেষ কথা আসল hardware-এ মাপা সংকেত।

অনুশীলন

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

  1. নকশা — গ্রাহক-বোতাম আর display: ছবি ২৩.১-এর নকশায় একটি নতুন input port 04H যোগ করুন: একটি 74LS244-এর বিট 7-এ “গ্রাহক এসেছেন” বোতাম (pull-up, চাপা = 0). (ক) এই buffer-এর enable কোন সংকেত থেকে আসবে? (খ) একটি 8085 program লিখুন, যা বোতাম চাপা না হওয়া পর্যন্ত অপেক্ষা করে, তারপর port 02H-এর common-anode display-এ অঙ্ক 1 দেখায়। বোতাম আগে থেকেই চাপা থাকলে মোট কত T-state?

    (ক) 74LS138-এর A2 A1 A0 = 100 হলে Y4 = 0, তাই enable = Y4 + RD (OR gate), ঠিক port 01H-এর মতো। (খ) Program আর সত্যিকারের run (;@in 04H 7FH, অর্থাৎ বিট 7 = 0):

    ~/lab$ python -B sim8085.py asm wait4.asm
    2000               3          ORG 2000H
    2000  DB 04        4  WAIT:   IN 04H
    2002  E6 80        5          ANI 80H
    2004  C2 00 20     6          JNZ WAIT
    2007  3E F9        7          MVI A,0F9H
    2009  D3 02        8          OUT 02H
    200B  76           9          HLT
    
    ~/lab$ python -B sim8085.py run wait4.asm
    A=F9 B=00 C=00 D=00 E=00 H=00 L=00 SP=0000 PC=200C
    Flags: S=0 Z=1 AC=1 P=1 CY=0   (F=54H)
    OUT port 02H <- F9H  (at T=41)
    Instructions: 6   T-states: 46

    ANI 80H শুধু বিট 7 রাখে; চাপা হলে ফল 0, Z = 1, JNZ লাফায় না। অঙ্ক 1-এর CA code F9H (b আর c জ্বলে)। মোট: IN ১০ + ANI ৭ + JNZ (না লাফিয়ে) ৭ + MVI ৭ + OUT ১০ + HLT ৫ = ৪৬ T, simulator-এর সঙ্গে মেলে; OUT হয় T = ৪১-এ।

  2. ভুল খুঁজুন — একটি সস্তা নকশা: একজন chip বাঁচাতে লিখলেন: “switch-গুলোর জন্যও একটি 74LS373 নিলাম, OC সবসময় 0, G-তে Y1 + RD. আর LED-গুলো latch-এর Q থেকে 100 Ω দিয়ে GND-তে, Q = 1 হলে জ্বলবে; LED-এর VF 2.0 V.” কয়টি সমস্যা? সংখ্যা দিয়ে ব্যাখ্যা করুন।

    তিনটি। (১) Input-এ 373-এর OC সবসময় 0 মানে তার output সবসময় data bus চালাচ্ছে: প্রতিটি opcode fetch, memory read আর OUT-এ CPU বা memory-র সঙ্গে সংঘাত, ports.py-র ভুল নকশার চেয়েও খারাপ। Input port-এ enable-টি tri-state control-এ যেতে হয়, latch-এর G-তে নয়; সঠিক chip 74LS244. (২) G-তে Y1 + RD-ও উল্টো: G active-high, তাই সেখানে 1 আসে যখন port বাছাই হয়নি। (৩) LED source-এ: 74LS373-এর typical VOH 3.4 V ধরলে current = (3.4 − 2.0) ÷ 100 Ω = 14 mA, কিন্তু datasheet-এর IOH সর্বোচ্চ 2.6 mA; output-এর ভোল্টেজ নেমে যাবে, আর ন্যূনতম VOH 2.4 V-এ current মাত্র (2.4 − 2.0) ÷ 100 = 4 mA, তবু সীমার বাইরে। ঠিক নকশা: sink, 270 Ω, Q = 0-তে জ্বলে। সংখ্যাগুলো লেখকের lab-এ হিসাব করা (14.0 আর 4.0 mA).

  3. আগে বলুন, তারপর চালান — lookup-এর সীমানা: অংশ ৬-এর seg7.asm program-এ port 01H-এর মান (ক) 0F6H আর (খ) 0F0H হলে port 02H-এ কী যাবে, আর display-এ কী দেখা যাবে? দুই ক্ষেত্রে মোট T-state কি বদলাবে?

    (ক) CMA: 0F6H → 09H, অঙ্ক 9, HL = 2059H, code 90H: display-এ 9. (খ) 0F0H → 0FH = ১৫, যা table-এর বাইরে: HL = 205FH, সেখানে table নেই, simulator-এর memory 00H. CA display-এ 00H মানে সব segment আর dp জ্বলে: “8.”, একটি বিভ্রান্তিকর অঙ্ক। আসল board-এ সেখানে যা থাকে তাই যাবে, আরও অনিশ্চিত। সত্যিকারের run (--in দিয়ে port-এর মান বদলে):

    ~/lab$ python -B sim8085.py run seg7.asm --in 01H=0F6H
    A=90 B=00 C=00 D=00 E=09 H=20 L=59 SP=0000 PC=2010
    OUT port 02H <- 90H  (at T=69)
    Instructions: 10   T-states: 74
    ~/lab$ python -B sim8085.py run seg7.asm --in 01H=0F0H
    A=00 B=00 C=00 D=00 E=0F H=20 L=5F SP=0000 PC=2010
    OUT port 02H <- 00H  (at T=69)
    Instructions: 10   T-states: 74

    দুই ক্ষেত্রেই মোট ৭৪ T: শাখা না থাকায় সময় data-র ওপর নির্ভর করে না। প্রতিকার: ANI 0FH-এর পরে CPI 0AH আর JNC দিয়ে ১০ বা বেশি হলে একটি “ভুল” চিহ্ন (যেমন শুধু g, CA code 0BFH) দেখানো। Lookup table-এর সূচক সবসময় সীমানা-পরীক্ষা চায়।

  4. হিসাব — polling কি পারবে? একটি ADC handshake দিয়ে প্রতি 50 µs-এ একটি byte দেয় (৩ MHz-এ ১৫০ T). Polling loop-এর এক পাক ২৭ T, আর প্রতিটি byte পাওয়ার পরে কাজ ৬০ T. (ক) কোনো byte হারাবে? (খ) byte আসে প্রতি 20 µs-এ (৬০ T) হলে? (গ) প্রথম ক্ষেত্রে CPU-র সময়ের কত অংশ শুধু অপেক্ষায় যায়?

    নিয়ম: প্রতিটি byte-এর সবচেয়ে খারাপ খরচ = বড়জোর এক পাকের অপেক্ষা + কাজ = ২৭ + ৬০ = ৮৭ T. (ক) ৮৭ < ১৫০, তাই কোনো byte হারায় না। (খ) ৮৭ > ৬০, তাই হারাবে: CPU একটি byte-এর কাজ শেষ করার আগেই পরেরটি এসে যায়, মাঝে মাঝে তার পরেরটিও। (গ) প্রতি ১৫০ T-এ কাজ ৬০ T, বাকি ৯০ T, অর্থাৎ ৬০%, loop ঘুরে অপেক্ষায় যায়। লেখকের lab-এ handshake.py-র run() ২০টি byte দিয়ে চালানো হয়েছে: ১৫০ T-এ ২০টিই পৌঁছেছে, হারিয়েছে ০; ৬০ T-এ পৌঁছেছে ১৪টি, হারিয়েছে ৬টি। দ্বিতীয় ক্ষেত্রে polling-এর পরিবর্তে DMA (পর্ব ২৭) বা কাজ ছোট করা, আর অপচয় কমাতে প্রথম ক্ষেত্রে interrupt বিবেচনা করা যায়: পর্ব ১৩-এর প্রায় ৫৮ T-এর স্থির খরচ যোগ করলেও ১৫০ T-এর মধ্যে আসে।

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

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

ক্রম8085-এর OUT 01H চলার সময় একটি latch-ভিত্তিক output port-এ ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Opcode fetch-এ CPU D3H আনে আর decode করে
  2. Memory read-এ নির্দেশের দ্বিতীয় byte, port নম্বর 01H, আসে
  3. I/O write cycle শুরু: IO/M = 1, ঠিকানা bus-এ 0101H, decoder-এর Y1 = 0
  4. WR = 0 হয়, A-র মান data bus-এ আসে আর latch স্বচ্ছ হয়
  5. WR আবার 1 হয়, latch মানটি ধরে রাখে আর LED তা দেখায়

Intel 8085-এ isolated I/O-র জন্য সর্বোচ্চ কয়টি input port ঠিকানা দেওয়া যায়?

  • ১৬টি
  • ২৫৬টি
  • ৬৫,৫৩৬টি
  • ৬৪K, memory-র সমান

8085-এর একটি system-এ আটটি switch-কে input port হিসেবে data bus-এ জোড়া হবে। Switch আর bus-এর মাঝে কোনটি সঠিক পছন্দ, আর কেন?

  • 74LS244-এর মতো tri-state buffer, যা শুধু পড়ার মুহূর্তে bus চালায়
  • OC সবসময় 0 রাখা একটি 74LS373 latch
  • কিছু না, switch সরাসরি data bus-এ
  • শুধু একটি 74LS138 decoder

8085-এ isolated I/O-র তুলনায় memory-mapped I/O সম্পর্কে কোন কথাটি সঠিক?

  • এটি সবসময় দ্রুত, কারণ নির্দেশ ছোট
  • এতে port-এ যাওয়ার সময় IO/M = 1 হয়
  • এতে data শুধু accumulator দিয়ে যেতে পারে
  • যেকোনো memory নির্দেশ port-এ চলে, কিন্তু memory-র কিছু ঠিকানা খরচ হয়

একটি common-anode 7-segment display-এর segment a থেকে g যথাক্রমে D0 থেকে D6-এ, D7-এ dp (নেভা রাখতে হবে)। অঙ্ক 0 দেখাতে কোন byte পাঠাতে হবে?

  • 3FH
  • C0H
  • 40H
  • 00H

৩ MHz clock-এর 8085-এ একটি polling loop: POLL: IN 01H, ANI 01H, JNZ POLL. বিট এখনো 1 থাকলে loop-এর এক পাকে কত সময় লাগে?

  • 8 µs
  • 4.5 µs
  • 9 µs
  • 11 µs

74LS373-এর datasheet-এ IOL সর্বোচ্চ 24 mA আর IOH সর্বোচ্চ −2.6 mA. একটি LED-কে ১০ mA-তে চালাতে কোন সংযোগ ঠিক?

  • LED-এর anode resistor দিয়ে +5 V-এ, cathode output-এ; output 0 হলে জ্বলে
  • LED output থেকে resistor দিয়ে GND-তে; output 1 হলে জ্বলে
  • LED সরাসরি output আর GND-এর মাঝে, resistor ছাড়া
  • LED-কে OC pin-এ জোড়া

শব্দকোষ

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

মনে রাখুন

  1. Buffer আর latch: input-এ tri-state buffer (74LS244, enable = Y + RD), output-এ latch (74LS373, G = NOR(Y, WR)) বা flip-flop (74LS374); এক মুহূর্তে data bus-এ একজনই চালক।
  2. Isolated I/O: IN/OUT, ৮ বিটের port, শুধু A, ১০ T; IO/M = 1; port নম্বর A15–A8 আর A7–A0 দুই জায়গায়।
  3. Memory-mapped I/O: port memory-র ঠিকানায়, সব memory নির্দেশ চলে, LDA/STA ১৩ T, memory-র জায়গা খরচ; আধুনিক MCU-র নিয়ম।
  4. LED আর 7-segment: sink, R = (5 − VF − VOL) ÷ I = 260 Ω → 270 Ω; CA code = CC code-এর উল্টো, অঙ্ক 5 = 92H, 0 = C0H.
  5. কখন পড়বেন: polling (২৭ T-এর পাক, দেরি ০–২৬ T, CPU ব্যস্ত), interrupt (পর্ব ১৩), handshake-এর ready flag আর overrun-এর নিয়ম: কাজ + এক পাক < byte-এর ব্যবধান।

পরের পর্বে: পর্ব ২৪ (8255 PPI — port, mode আর control word). এই পর্বে buffer, latch আর handshake আলাদা chip দিয়ে বানালেন; পরের পর্বে একটিমাত্র programmable chip এই সবকিছু করে, তিনটি port আর একটি control word দিয়ে।

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

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