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

8255 PPI — port, mode আর control word

The 8255 PPI — Ports, Modes and the Control Word

Taught in Bangla, this lesson covers the 8255 PPI: ports A, B and C, the A1 and A0 address map, and building the mode set control word (83H for the scale design). It explains BSR mode for single port C bits, uses mode 0 to drive a 7-segment price display and read a key, and follows the mode 1 strobe handshake with IBF, INTE and INTR. Initialisation code runs in the course's 8085 simulator, and in-page Python builds control words and models the strobe sequence.

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

  • 8255-এর block, pin আর A1 A0 দিয়ে চারটি ঠিকানা বেছে নেওয়া ব্যাখ্যা করা
  • যেকোনো প্রয়োজন থেকে mode set word বিট ধরে বানানো, আর একটি byte দেখে তার অর্থ বলা
  • BSR দিয়ে port C-এর একটি বিট বদলানো, আর পুরো port লেখার ফাঁদ চেনা
  • Mode 0-তে 7-segment display আর key জোড়া, আর mode 1-এর STB, IBF, INTR, INTE handshake ধাপে ধাপে মেলানো
  • Mode 2, mode-এর মিশ্রণ আর বাস্তব নকশার নিয়ম, AI-এর উত্তর যাচাইসহ

১ · 8255 কেন — ২৪টি লাইন, একটি খাতা

বাজারঘরের smart scale-কে 8085 যুগে বানাতে চাইলে কী কী যন্ত্র CPU-র সঙ্গে জুড়তে হবে, একবার গুনে দেখুন। দামের জন্য চার অঙ্কের 7-segment display: প্রতিটি অঙ্কে সাতটি দাগ আর একটি দশমিক বিন্দু, অর্থাৎ ৮টি লাইন। Tare আর অন্য কয়েকটি বোতাম। একটি OVERLOAD বাতি আর একটি beeper. ওজন মাপার converter-এর “কাজ শেষ” সংকেত। সব মিলিয়ে দুই ডজনের মতো তার, কিছু output, কিছু input.

পর্ব ০৯-এ দেখেছেন, 8085-এ যন্ত্রের সঙ্গে কথা বলার দুটি নির্দেশ আছে: OUT port A-র byte বাইরে পাঠায়, IN port বাইরে থেকে একটি byte A-তে আনে। Port-এর ঠিকানা ৮ বিটের, আর যন্ত্রগুলো মেমরি থেকে আলাদা একটি ঠিকানা-জগতে থাকে; একে বলে port-mapped I/O. সবচেয়ে সরল output port একটি latch chip, যা OUT-এর মুহূর্তে byte ধরে রাখে; সবচেয়ে সরল input port একটি tri-state buffer, যা IN-এর মুহূর্তে বাইরের লাইনগুলো data bus-এ দেয়। এই দুই ধরনের port আর তার ঠিকানা-নকশা, polling আর memory-mapped I/O-এর তুলনা পর্ব ২৩-এর বিষয়। সমস্যা হলো, প্রতিটি port-এর জন্য আলাদা chip, আর কোনটি input কোনটি output তা circuit বানানোর সময়েই স্থির হয়ে যায়।

Intel-এর 8255 PPI (programmable peripheral interface) এই সমস্যার উত্তর। এক chip-এ তিনটি ৮ বিটের port, মোট ২৪টি লাইন, আর কোন লাইন input কোনটি output তা ঠিক হয় software দিয়ে: CPU একটি byte লেখে chip-এর ভেতরের control register-এ। Intel-এর নিজের datasheet chip-টিকে ডাকে “general purpose programmable I/O device”. 8080 আর 8085 পরিবারের সহায়ক chip হিসেবে ১৯৭০-এর দশকের মাঝামাঝি এটি এসেছিল (উৎসভেদে সাল একটু আলাদা), পরে 8086-এর সঙ্গেও একইভাবে চলেছে।

উপমা — আড়তের তিন গেট আর দারোয়ানের খাতা: কারওয়ান বাজারের একটি আড়তে তিনটি গেট: A, B আর C. কোন গেট দিয়ে মাল ঢুকবে আর কোনটি দিয়ে বেরোবে, তা লেখা থাকে দারোয়ানের খাতায়। মালিক সকালে খাতায় এক লাইন লিখে দেন (control word), সারাদিন দারোয়ান সেই নিয়মে গেট চালান। C গেটটি আবার দুই ভাগে ভাগ করা যায়, এক ভাগে ঢোকা, আরেক ভাগে বেরোনো। আর বিশেষ দিনে মালিক বলতে পারেন, “শুধু C গেটের পাঁচ নম্বর দরজাটা খুলে দিন”, বাকিগুলোয় হাত না দিয়ে। সেটিই BSR.

লেখার নিয়ম আগের পর্বগুলোর মতো: সংখ্যা Intel-এর ধরনে, শেষে H (83H, 0B3H; অক্ষর দিয়ে শুরু হলে সামনে 0); বিটের নকশা টেবিলে 1000 0011b. CPU-র clock 3 MHz (6 MHz crystal), এক T-state = 0.333 µs. 8085-এর প্রতিটি program কোর্সের reference lab-এর sim8085.py-তে চালানো (lab-এর পরিচয় পর্ব ০৬-এ)। কিন্তু lab 8255 chip-টি emulate করে না। তাই এই পর্বের জন্য Intel-এর 82C55A datasheet (order number 231256-004) থেকে একটি ছোট model লেখা হয়েছে, ppi8255.py: control word, BSR, mode 0, mode 1-এর handshake আর mode 2-এর বিট-বিন্যাস। লেখকের lab-এ datasheet-এর টেবিল আর ছবির সঙ্গে মিলিয়ে এর ১০টি পরীক্ষা পাস করেছে। নিচের ব্লকগুলোতে CPU-র অংশ চালায় reference-এর simulator-এর হুবহু কপি, আর 8255-এর প্রতিক্রিয়া আসে এই model থেকে; দুটি আলাদা রাখা হয়েছে, যাতে কোনটি কার কাজ, স্পষ্ট থাকে।

২ · ভেতরের গঠন, pin আর চারটি ঠিকানা

8255 একটি ৪০ pin-এর chip. হিসাবটি সহজ: ২৪টি port লাইন, ৮টি data লাইন (D7–D0), ছয়টি নিয়ন্ত্রণ-input (RD̅, WR̅, A1, A0, CS̅, RESET) আর দুটি power pin. ভেতরে চারটি অংশ। Data bus buffer CPU-র data bus-এর সঙ্গে দুই দিকে byte আদান-প্রদান করে। Read/write control logic ঠিক করে এখন কী হচ্ছে। Group A control চালায় port A আর port C-এর ওপরের অর্ধেক (PC7–PC4); group B control চালায় port B আর নিচের অর্ধেক (PC3–PC0). নিচের ছবিতে এর সঙ্গে বাজারঘরের scale-এর যন্ত্রগুলোও বসানো হলো; এই নকশাই পুরো পর্বে চলবে।

ছবি ২৪.১ — 8255-এর ভেতরের block আর বাজারঘরের scale-এর সংযোগ

বাঁয়ে 8085-এর bus, মাঝে 8255 (ঠিকানা 80H–83H), ডানে scale-এর যন্ত্র

8255-এর block diagram আর scale-এর সংযোগ 80858255 · 80H–83Hscale D7–D0RDWRA1A0CSRST data busbuffer group Acontrol read/writecontrol group Bcontrol port A৮ বিট PC7–4৪ বিট PC3–0৪ বিট port B৮ বিট 7-segsegment beeper,বাতি,অঙ্ক EOC(PC0) TARE,key ভেতরের ৮ বিটের bus
ছবি ২৪.১ — Group A মানে port A আর C-এর ওপরের চার বিট, group B মানে port B আর নিচের চার বিট। Port C-এর ভাগ হওয়ার কারণ mode 1-এ পরিষ্কার হবে: প্রতিটি group তার handshake লাইন নেয় port C থেকেই। Block-এর ভাগ Intel-এর 82C55A datasheet-এর Figure 1 আর 3 অনুসারে; ডানের scale-নকশাটি এই কোর্সের নিজের, কাল্পনিক: PC4 beeper, PC5 OVERLOAD বাতি, PC6–PC7 একটি 74LS139 দিয়ে চারটি অঙ্কের একটি বাছাই, PC0-তে converter-এর EOC, PB0-তে TARE.

CPU কোন register-এর সঙ্গে কথা বলছে, তা ঠিক করে দুটি ঠিকানা-লাইন A1 আর A0, সঙ্গে RD̅ বা WR̅. CS̅ (chip select) উঁচু থাকলে chip কিছুই শোনে না, data bus ছেড়ে দেয়। Datasheet-এর টেবিলটি সংক্ষেপে:

A1 A0লেখা (WR̅ = 0)পড়া (RD̅ = 0)scale-এ ঠিকানা
00port A-তেport A থেকে80H
01port B-তেport B থেকে81H
10port C-তেport C থেকে82H
11control register-এNMOS 8255A-তে নিষিদ্ধ; CMOS 82C55A-তে control word ফেরত83H

8085-এর A1 আর A0 সরাসরি 8255-এর A1 আর A0-তে যায়। বাকি ছয়টি লাইন A7–A2 দেখে একটি address decoding circuit CS̅ নামায়: এখানে শর্ত A7 = 1 আর A6–A2 সব 0, তাই chip সাড়া দেয় ঠিক 80H–83H-এ। Decoder আর পূর্ণ বনাম আংশিক decoding-এর পুরো নকশা পর্ব ২২-এর বিষয়; I/O-তে নিয়ম একই, শুধু ঠিকানা ৮ বিটের। 8086-এর সঙ্গে প্রচলিত নকশায় 8255 বসে data bus-এর নিচের byte-এ, তাই তার A1 A0 যায় CPU-র A2 A1-এ, আর চারটি ঠিকানা হয় জোড় সংখ্যা, যেমন 80H, 82H, 84H, 86H.

Bus-এ একটি OUT 83H দেখতে কেমন? পর্ব ০৮-এর ভাষায় এটি তিনটি machine cycle, মোট ১০ T: opcode fetch (৪ T), port-এর ঠিকানার byte পড়া (৩ T), আর I/O write (৩ T). শেষ cycle-এ IO/M̅ = 1, port-এর ৮ বিটের ঠিকানা A15–A8 আর AD7–AD0 দুই জায়গাতেই থাকে, data bus-এ A-র byte, আর WR̅ নিচে নামে। 8255 byte-টি নেয় WR̅-এর ওঠার মুহূর্তে। IN-এর শেষ cycle-এ একইভাবে RD̅ নামে, আর 8255 তখন data bus-এ byte দেয়। এই দুই মুহূর্ত, WR̅ আর RD̅-এর ধার, mode 1-এর handshake-এও গুরুত্বপূর্ণ হবে।

RESET pin উঁচু হলে control register মুছে যায় আর ২৪টি লাইনই input হয়ে যায়। কারণটি নিরাপত্তা: power চালুর মুহূর্তে কোনো লাইন নিজে থেকে output হয়ে কোনো motor বা relay চালু করে দেবে না। পুরোনো NMOS 8255A-তে reset-এর পরে লাইনগুলো ভাসমান (high impedance), আর CMOS 82C55A-তে ভেতরের ছোট “bus hold” circuit সেগুলোকে 1-এর কাছে ধরে রাখে। দুই ক্ষেত্রেই বাইরের circuit-কে ধরে নিতে হবে যে program control word না লেখা পর্যন্ত কোনো output চালু নেই।

৩ · Control word — একটি byte-এ পুরো নকশা

Port 83H-এ যে byte লেখা হয়, তার D7 ঠিক করে byte-টি কোন ধরনের। D7 = 1 হলে এটি mode set word: পুরো chip-এর mode আর দিক বদলায়। D7 = 0 হলে এটি BSR word, পরের অংশের বিষয়। Mode set word-এর আট বিট, Intel-এর Figure 6 অনুসারে:

বিটD7D6 D5D4D3D2D1D0
কারflaggroup Agroup B
অর্থ1 = mode set00 = mode 0, 01 = mode 1, 1x = mode 2port APC7–PC40 = mode 0, 1 = mode 1port BPC3–PC0
মান1mode1 = input, 0 = outputmode1 = input, 0 = output

মনে রাখার কৌশল: “১ = input” মনে রাখুন I দেখতে ১-এর মতো, আর O দেখতে ০-এর মতো। Group B-র mode একটি মাত্র বিট, কারণ mode 2 শুধু port A-র। এবার scale-এর প্রয়োজন থেকে byte-টি বানানো যাক: port A দিয়ে segment-এ output, port B দিয়ে key পড়া, PC7–PC4 দিয়ে বাতি, beeper আর অঙ্ক বাছাই (output), PC3–PC0 দিয়ে converter-এর EOC পড়া (input); সবই সরল mode 0.

1D7: mode set2D6 D5: group A mode 03D4: port A out4D3: PC7–PC4 out5D2: group B mode 06D1: port B in7D0: PC3–PC0 in8MVI A,83H9OUT 83H
Control word তৈরি হচ্ছে
D7 D6 D5 D4
D3 D2 D1 D0
hex
  1. D7 = 1. আমরা mode আর দিক ঠিক করছি, port C-এর একটি বিট নয়; তাই flag বিট 1.
  2. D6 D5 = 00. Group A-তে কোনো handshake লাগবে না: segment-এ byte লিখলেই হলো। তাই mode 0.
  3. D4 = 0. Port A output, কারণ CPU segment-এ লিখবে। “O দেখতে ০-এর মতো।”
  4. D3 = 0. PC7–PC4 output: PC4 beeper, PC5 OVERLOAD বাতি, PC6–PC7 অঙ্কের নম্বর। চারটি বিট একসাথে একই দিকে, আলাদা করা যায় না।
  5. D2 = 0. Group B-ও mode 0. এর একটিই বিট, কারণ port B-র mode 2 নেই।
  6. D1 = 1. Port B input: PB0-তে TARE, বাকিগুলোয় অন্য key.
  7. D0 = 1. PC3–PC0 input: PC0-তে converter-এর EOC (end of conversion). পুরো byte 1000 0011 = 83H.
  8. দুটি নির্দেশ. MVI A,83H (3E 83, ৭ T) আর OUT 83H (D3 83, ১০ T). সত্যিকারের run-এ OUT-এর লগ: OUT port 83H <- 83H (at T=17). এখন থেকে port A আর C-এর ওপরের অর্ধেক output, সব output 0.

নিচের ব্লকে model-এর দুটি ফাংশন: encode() প্রয়োজন থেকে byte বানায়, decode() byte থেকে অর্থ বলে। সাধারণ কয়েকটি নকশা আর কয়েকটি BSR byte একসাথে দেখুন; নিজের একটি প্রয়োজন যোগ করে চালিয়ে দেখুন।

# 8255-এর control word বানানো আর পড়া (ppi8255 = এই পর্বের model, Intel-এর datasheet থেকে)
from ppi8255 import encode, decode, bsr

need = [
    ("সব port output, mode 0", dict()),
    ("সব input (RESET-এর পরের মতো)", dict(a_in=1, cu_in=1, b_in=1, cl_in=1)),
    ("scale: A out, B in, C upper out, C lower in", dict(b_in=1, cl_in=1)),
    ("A mode 1 input, B mode 0 input", dict(a_mode=1, a_in=1, b_in=1, cl_in=1)),
    ("A mode 2, B mode 0 output", dict(a_mode=2)),
]
for text, kw in need:
    cw = encode(**kw)
    print(f"{cw:02X}H = {cw:08b}b  {text}")

print()
for bit, value in [(5, 1), (5, 0), (4, 1), (7, 1)]:
    cw = bsr(bit, value)
    print(f"BSR PC{bit}={value}: {cw:02X}H = {cw:08b}b")

print()
for cw in (0x82, 0x9B, 0xB3, 0x0B, 0x7B):
    print(f"{cw:02X}H -> {decode(cw)}")

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

80H = 10000000b  সব port output, mode 0
9BH = 10011011b  সব input (RESET-এর পরের মতো)
83H = 10000011b  scale: A out, B in, C upper out, C lower in
B3H = 10110011b  A mode 1 input, B mode 0 input
C0H = 11000000b  A mode 2, B mode 0 output

BSR PC5=1: 0BH = 00001011b
BSR PC5=0: 0AH = 00001010b
BSR PC4=1: 09H = 00001001b
BSR PC7=1: 0FH = 00001111b

82H -> mode set: A mode 0 out, C upper out, B mode 0 in, C lower out
9BH -> mode set: A mode 0 in, C upper in, B mode 0 in, C lower in
B3H -> mode set: A mode 1 in, C upper out, B mode 0 in, C lower in
0BH -> BSR: PC5 = 1
7BH -> BSR: PC5 = 1

তিনটি জিনিস লক্ষ করুন। এক, 9BH = সব input, ঠিক RESET-এর পরের অবস্থা; mode 0-এর ১৬টি নকশা 80H থেকে 9BH-এর মধ্যে, শুধু D4, D3, D1, D0 বদলায়। দুই, B3H-এ group A mode 1, কিন্তু “C upper out” তখন শুধু বাকি দুটি লাইন PC6–PC7-এর কথা; PC3, PC4, PC5 চলে যায় handshake-এ (অংশ ৬)। তিন, 0BH আর 7BH একই BSR আদেশ: D6–D4-এর মান কেউ দেখে না। তবু প্রচলিত নিয়ম এগুলো 0 রাখা, যাতে byte পড়ে অর্থ সহজে বোঝা যায়।

একই init কোড reference lab-এর simulator-এ, সত্যিকারের run (python -B sim8085.py asm scale7.asm, Python 3.13.5; ওপরের দুটি লাইন):

~/lab$ python -B sim8085.py asm scale7.asm
2000  3E 83        5  START:  MVI A,83H       ; A out, C upper out, B in, C lower in
2002  D3 83        6          OUT 83H         ; control register
...
নিয়ম

Mode set word = 1 · group A mode (২ বিট) · A · Cupper · group B mode (১ বিট) · B · Clower; প্রতিটি দিক-বিটে 1 = input. Byte যায় control register-এ, scale-এ 83H; port C-এর ঠিকানায় (82H) নয়।

৪ · BSR — port C-এর একটি বিট, বাকিগুলো অক্ষত

Scale-এর OVERLOAD বাতি PC5-এ। ওজন ৫০০০ g ছাড়ালে বাতি জ্বালাতে হবে, কিন্তু একই port-এর PC6–PC7 তখন কোনো একটি অঙ্ক বাছাই করে রেখেছে, আর PC4-এ beeper. Port C-তে পুরো byte লিখলে সব চারটি বিটই নতুন মান পায়। পুরোনো মান মনে রেখে, একটি বিট বদলে, আবার লেখা যায়, কিন্তু তাতে কয়েকটি নির্দেশ লাগে, আর মাঝপথে একটি interrupt একই port ছুঁলে গোলমাল হয়। 8255-এর সমাধান BSR (bit set/reset): control register-এ D7 = 0 দিয়ে একটি byte লিখলে port C-এর ঠিক একটি বিট বদলায়।

বিটD7D6 D5 D4D3 D2 D1D0
অর্থ0 = BSRব্যবহার নেই (0 রাখা হয়)বিটের নম্বর 0–7 (PC0–PC7)1 = set, 0 = reset
PC5 = 100001011 → 0BH
PC5 = 000001010 → 0AH

সূত্রটি এক লাইনের: BSR byte = বিটের নম্বর × 2 + মান। PC4 = 1 → 09H, PC7 = 0 → 0EH. খেয়াল করুন, BSR byte যায় control register-এ (83H), port C-তে (82H) নয়; আর BSR mode বদলায় না, তাই mode set-এর মতো অন্য output মুছেও দেয় না। নিচের stepper-এ scale-এর ছয়টি OUT; পঞ্চমটিতে ইচ্ছা করে একটি ভুল রাখা হয়েছে।

1MVI A,83H / OUT 83H2MVI A,0BH / OUT 83H3MVI A,09H / OUT 83H4MVI A,08H / OUT 83H5MVI A,40H / OUT 82H6MVI A,0BH / OUT 83H7IN 82H
Port C-এর pin (model)
PC7 PC6 · PC5 · PC4
PC3–PC0 (input)
OUT-এর T
  1. Mode set 83H. PC7–PC4 output হলো, আর mode set সব output latch 0 করে। PC3–PC0 input; PC0-তে EOC = 1 (converter তৈরি), তাই pin-এ 0001.
  2. BSR 0BH = 0000 1011. D3–D1 = 101 = 5, D0 = 1: শুধু PC5 = 1. OVERLOAD বাতি জ্বলল, বাকি বিট যেমন ছিল।
  3. BSR 09H. 100 = 4, D0 = 1: PC4 = 1, beeper বাজছে। PC5 অক্ষত, বাতি জ্বলছেই।
  4. BSR 08H. PC4 = 0, beeper থামল। একটি OUT = ১৭ T (৭ + ১০), অর্থাৎ প্রায় 5.67 µs-এ একটি বিট।
  5. ফাঁদ: OUT 82H দিয়ে 40H. উদ্দেশ্য ছিল অঙ্ক ১ বাছাই (PC7 PC6 = 01). কিন্তু পুরো port লেখায় PC5 আর PC4-ও নতুন মান পেল: 0. বাতি নিভে গেল, অথচ ওজন এখনো ৫০০০ g-এর বেশি। PC3–PC0 input, তাই সেগুলোয় লেখার কোনো প্রভাব নেই।
  6. আবার BSR 0BH. বাতি ফিরে এল, অঙ্কের বিট অক্ষত। শেষে IN 82H ফেরত দেয় 61H = 0110 0001: ওপরের অর্ধেক latch-এর মান, নিচের অর্ধেক pin-এর মান। মোট ১১৭ T.

একই program-এর সত্যিকারের run (python -B sim8085.py run bsr.asm). Simulator 8255 চেনে না, তাই সে শুধু দেখায় CPU কোন port-এ কোন byte কখন পাঠাল; port C-এর pin-এর মান model থেকে:

~/lab$ python -B sim8085.py run bsr.asm
A=00 B=00 C=00 D=00 E=00 H=00 L=00 SP=0000 PC=201B
Flags: S=0 Z=0 AC=0 P=0 CY=0   (F=00H)
OUT port 83H <- 83H  (at T=17)
OUT port 83H <- 0BH  (at T=34)
OUT port 83H <- 09H  (at T=51)
OUT port 83H <- 08H  (at T=68)
OUT port 82H <- 40H  (at T=85)
OUT port 83H <- 0BH  (at T=102)
Instructions: 14   T-states: 117

Simulator-এ IN-এর জন্য কোনো মান দেওয়া হয়নি বলে শেষে A = 00. নিচের ব্লকে একই program আবার চলে, এবার IN আর OUT যায় model-এ, আর প্রতিটি OUT-এর পরে PC7..PC0 ছাপা হয়।

# BSR দিয়ে port C-এর একটি বিট, আর পুরো port লেখার ফাঁদ (sim85 = lab-এর sim8085.py)
from sim85 import assemble
from ppi8255 import PPI, run_ppi, decode
SRC = """ ORG 2000H
 MVI A,83H
 OUT 83H
 MVI A,0BH
 OUT 83H
 MVI A,09H
 OUT 83H
 MVI A,08H
 OUT 83H
 MVI A,40H
 OUT 82H
 MVI A,0BH
 OUT 83H
 IN 82H
 HLT"""
ppi = PPI()
ppi.ext["C"] = 0x01                    # PC0 = ADC-এর EOC (1), PC1-PC3 = 0
def watch(cpu, pc, op, cost):
    if op == 0xD3:
        t, port, v = cpu.out_log[-1]
        what = "port C-তে পুরো byte" if port == 0x82 else decode(v).split(",")[0]
        print(f"OUT {port:02X}H <- {v:02X}H  PC7..0 = {ppi.pins('C'):08b}  {what}")
cpu = run_ppi(assemble(SRC), ppi, trace=watch)
print(f"IN 82H -> A = {cpu.A:02X}H = {cpu.A:08b}b, T-states = {cpu.tstates}")

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

OUT 83H <- 83H  PC7..0 = 00000001  mode set: A mode 0 out
OUT 83H <- 0BH  PC7..0 = 00100001  BSR: PC5 = 1
OUT 83H <- 09H  PC7..0 = 00110001  BSR: PC4 = 1
OUT 83H <- 08H  PC7..0 = 00100001  BSR: PC4 = 0
OUT 82H <- 40H  PC7..0 = 01000001  port C-তে পুরো byte
OUT 83H <- 0BH  PC7..0 = 01100001  BSR: PC5 = 1
IN 82H -> A = 61H = 01100001b, T-states = 117

মোট ১১৭ T ওপরের simulator-run-এর সঙ্গে হুবহু এক, কারণ CPU-র অংশ একই কোড। পঞ্চম লাইনে 01000001: PC5 নিভে গেছে। শেষ লাইনে IN 82H = 61H, যেখানে simulator একা 00H দিত। Model-এ port C পড়ার নিয়ম datasheet অনুসারে: output বিটে latch-এর মান, input বিটে pin-এর মান।

দুটি সাধারণ ভুল: (১) BSR byte port C-এর ঠিকানায় লেখা: MVI A,0BH আর OUT 82H PC5 জ্বালায় না, বরং পুরো ওপরের অর্ধেককে 0000 করে দেয়। (২) চালু অবস্থায় mode set আবার লেখা, “নিশ্চিত হওয়ার জন্য”: datasheet-এর ভাষায় “All of the output registers, including the status flip-flops, will be reset whenever the mode is changed.” Beeper আর বাতি মুহূর্তের জন্য নিভে যাবে, আর relay হলে খটখট করবে।

৫ · Mode 0 কাজে — scale-এর দাম 7-segment-এ, TARE key-তে

Mode 0 মানে সরল input/output: কোনো handshake নেই, CPU লিখলে output latch-এ থাকে, CPU পড়লে সেই মুহূর্তের pin-এর মান আসে (input latch হয় না)। Datasheet অনুসারে দুটি ৮ বিটের port আর দুটি ৪ বিটের port, প্রতিটি আলাদাভাবে input বা output, মোট ১৬ রকম নকশা। Scale-এর পুরো কাজ এই mode-এই চলে।

Segment code. Common-cathode display-এ যে segment-এর লাইন 1, সেটি জ্বলে। Port A-র বিট সাজানো PA0 = a, PA1 = b … PA6 = g, PA7 = dp (দশমিক বিন্দু)। তাহলে “8” = সাতটি segment = 7FH, “1” = শুধু b আর c = 06H, আর “1.” = 06H + বিন্দু 80H = 86H. পর্ব ২৩-এ common-anode display-এর code দেখেছেন, যেখানে 0 দিলে segment জ্বলে; সেখানকার code এখানকার code-এর ঠিক উল্টো (প্রতিটি বিট NOT), যেমন “8” = 80H, তাই কোন ধরনের display, তা আগে দেখে নিতে হয়।

অঙ্ক0123456789
code3F065B4F666D7D077F6F

চারটি অঙ্ক, একটি port. চার অঙ্কের জন্য ৩২টি segment-লাইন লাগত। তার বদলে চারটি অঙ্কের একই নামের segment একসাথে জোড়া হয়, আর একবারে মাত্র একটি অঙ্ক চালু রাখা হয়: অঙ্ক ০-তে তার code, তারপর অঙ্ক ১-এ, এভাবে ঘুরে ঘুরে, দ্রুত। একে বলে display multiplexing. চোখ দ্রুত নিভে-জ্বলা আলাদা করতে পারে না, তাই চারটিকেই একসাথে জ্বলন্ত মনে হয়। Scale-এ PC7 PC6 দুটি বিটে অঙ্কের নম্বর (00–11) যায় একটি 74LS139 decoder-এ, যা চারটির একটিকে চালু করে; এভাবে ৪টির জায়গায় মাত্র ২টি লাইন খরচ হয়, আর PC4–PC5 থাকে beeper আর বাতির জন্য।

উপমা — স্কুলের রোল কল: শিক্ষক একবারে একজনের নাম ডাকেন, একজনই সাড়া দেয়, তবু পুরো ক্লাসের উপস্থিতি এক মিনিটে হয়ে যায়। Multiplexing-এও প্রতি মুহূর্তে একটি অঙ্ক “সাড়া দেয়”, কিন্তু ঘোরা এত দ্রুত যে চোখে চারটিই একসাথে।

Net ১২৫০ g-এ দাম ৮১.৮৮ টাকা (reference README-র হিসাব: 1250 × 6550 / 1000 = 8187.5 → ৮১৮৮ পয়সা)। নিচের program এই দাম চার অঙ্কে একবার দেখায়, তারপর PB0 পড়ে TARE চাপা কি না দেখে। প্রতিটি অঙ্কে আগে segment বন্ধ, তারপর অঙ্ক বাছাই, তারপর নতুন code: নইলে অঙ্ক বদলানোর মুহূর্তে আগের code নতুন অঙ্কে এক ঝলক দেখা যায় (ghosting). সত্যিকারের run:

~/lab$ python -B sim8085.py run scale7.asm
A=00 B=00 C=00 D=00 E=00 H=20 L=54 SP=0000 PC=2022
Flags: S=0 Z=1 AC=1 P=1 CY=0   (F=54H)
Memory 2060H..2060H:
  2060H: 00
OUT port 83H <- 83H  (at T=17)
OUT port 80H <- 00H  (at T=48)
OUT port 82H <- 00H  (at T=62)
OUT port 80H <- 7FH  (at T=79)
OUT port 80H <- 00H  (at T=124)
OUT port 82H <- 40H  (at T=138)
OUT port 80H <- 86H  (at T=155)
...
OUT port 82H <- C0H  (at T=290)
OUT port 80H <- 7FH  (at T=307)
Instructions: 52   T-states: 370

Source-এ ;@in 81H 0FEH লাইনটি port B-তে 1111 1110 দেয়: PB0 = 0, অর্থাৎ TARE চাপা (key-গুলো pull-up-সহ, চাপলে 0). তাই 2060H = 00. Loop-এর শেষে ADI 40H: C0H + 40H = 100H, CY = 1, তাই চারটি অঙ্ক শেষে JNC আর ফেরে না। নিচের ব্লকে একই program, এবার OUT যায় 8255-এর model-এ, আর প্রতিবার segment জ্বললে কোন অঙ্কে কী দেখা যাচ্ছে তা ছাপা হয়।

# বাজারঘরের scale: 8085-এর OUT 8255-এর model-এ, 7-segment-এ দাম 81.88 (sim85 = lab-এর sim8085.py)
from sim85 import assemble
from ppi8255 import PPI, run_ppi
SRC = """        ORG 2000H
START:  MVI A,83H
        OUT 83H
        LXI H,2050H
        MVI B,00H
NEXT:   XRA A
        OUT 80H
        MOV A,B
        OUT 82H
        MOV A,M
        OUT 80H
        INX H
        MOV A,B
        ADI 40H
        MOV B,A
        JNC NEXT
        IN 81H
        ANI 01H
        STA 2060H
        HLT
        ORG 2050H
        DB 7FH,86H,7FH,7FH"""
FONT = dict(zip([0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F], "0123456789"))
ppi, shown = PPI(), {}
ppi.ext["B"] = 0xFE                    # TARE চাপা: PB0 = 0
def watch(cpu, pc, op, cost):
    if op == 0xD3 and ppi.pins("A"):   # OUT, আর কোনো segment জ্বলছে
        seg, digit = ppi.pins("A"), ppi.pins("C") >> 6
        shown[digit] = FONT[seg & 0x7F] + ("." if seg & 0x80 else "")
        print(f"T={cpu.out_log[-1][0]:<4} PA={seg:08b}  digit {digit} -> {shown[digit]}")
cpu = run_ppi(assemble(SRC), ppi, trace=watch)
print(f"display: {''.join(shown.values())} টাকা; TARE (2060H) = {cpu.mem[0x2060]}, T = {cpu.tstates}")

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

T=79   PA=01111111  digit 0 -> 8
T=155  PA=10000110  digit 1 -> 1.
T=231  PA=01111111  digit 2 -> 8
T=307  PA=01111111  digit 3 -> 8
display: 81.88 টাকা; TARE (2060H) = 0, T = 370

চারটি সময় (৭৯, ১৫৫, ২৩১, ৩০৭ T) simulator-এর OUT port 80H-এর সময়ের সঙ্গে মেলে; প্রতি অঙ্কে loop-এর খরচ ৭৬ T, প্রায় 25.3 µs. দ্বিতীয় অঙ্কে 10000110: PA7 (dp) জ্বলছে, তাই “1.”. Display: 81.88, ঠিক README-র ৮১.৮৮ টাকা। এই গতিতে ঘুরলে অঙ্কগুলো খুব কম সময় জ্বলে আর আলো ক্ষীণ হয়; বাস্তবে প্রতিটি অঙ্কের পরে একটি delay বসে, যার হিসাব অনুশীলন ৩-এ।

Key আর keypad. PB0–PB7-এ প্রতিটি key একটি pull-up resistor দিয়ে 1-এ টানা, চাপলে লাইন মাটিতে, তাই 0. Key বেশি হলে লাইন বাঁচাতে matrix keypad: ১৬টি key চারটি সারি আর চারটি কলামে, মাত্র ৮টি লাইনে। Program একবারে একটি সারি 0 করে আর কলামগুলো পড়ে; কোনো কলাম 0 হলে সেই সারি-কলামের key চাপা। 8255-এ এর স্বাভাবিক জায়গা port C: ওপরের অর্ধেক output (সারি), নিচের অর্ধেক input (কলাম), ঠিক 83H-এর নকশা। পুরো program অনুশীলন ১-এ। যান্ত্রিক key চাপার মুহূর্তে কয়েক মিলিসেকেন্ড লাফায় (bounce), তাই একবার পড়ে সিদ্ধান্ত না নিয়ে কয়েক ms পরে আবার পড়ে মেলানো হয়; এর পুরো আলোচনা পর্ব ৪২ (button debouncing)-এ।

৬ · Mode 1 — strobe আর handshake

Mode 0-এর input-এ একটি দুর্বলতা আছে: CPU যখন পড়ে, তখনকার pin-এর মানই আসে। যন্ত্র যদি এক মুহূর্তের জন্য data দেয়, আর CPU তখন অন্য কাজে, data হারায়। Mode 1 এর সমাধান: যন্ত্র data দিয়ে একটি ছোট নিম্নমুখী pulse পাঠায়, strobe (STB̅); সেই মুহূর্তে 8255 data নিজের input latch-এ ধরে রাখে আর একটি পতাকা তোলে, “buffer ভরা”। CPU পরে সময়মতো পড়ে নেয়। এই আদান-প্রদানকে বলে handshake. প্রতিটি group-এর handshake-এর তিনটি লাইন আসে port C থেকে:

Mode 1Port A inputPort A outputPort B inputPort B output
যন্ত্র → 8255PC4 = STB̅APC6 = ACK̅APC2 = STB̅BPC2 = ACK̅B
8255 → যন্ত্রPC5 = IBFAPC7 = OBF̅APC1 = IBFBPC1 = OBF̅B
8255 → CPUPC3 = INTRAPC3 = INTRAPC0 = INTRBPC0 = INTRB
INTE-এর BSR বিটPC4PC6PC2PC2
বাকি I/OPC6, PC7PC4, PC5নেই (PC0–PC2 সব handshake)

Input-এর নিয়ম, Intel-এর ভাষায় সংক্ষেপে: STB̅ নিচে নামলে data latch-এ যায়, আর IBF (input buffer full) = 1. STB̅ আবার উঠলে, যদি IBF = 1 আর INTE = 1, তবে INTR = 1. CPU port পড়লে RD̅-এর নামার ধারে INTR = 0, আর ওঠার ধারে IBF = 0. INTE (interrupt enable) একটি ভেতরের flip-flop, যার কোনো pin নেই; তাকে খোলা-বন্ধ করা হয় BSR দিয়ে, ঠিক STB̅-এর বিট-নম্বরে। Port A input-এ INTE A = PC4, তাই BSR 09H. PC4 নিজে তখন input pin (STB̅), তাই BSR সেই pin-এ কিছু লেখে না, শুধু INTE বদলায়।

ছবি ২৪.২ — Mode 1 strobed input-এর timing

যন্ত্র STB̅ দেয়, 8255 IBF আর INTR তোলে, CPU-র RD̅ দুটিকে নামায়

Mode 1 strobed input-এর timing STBIBFINTRRD ১২৩৪
ছবি ২৪.২ — Intel-এর 82C55A datasheet-এর Figure 9 (MODE 1 Strobed Input)-এর সরল রূপ; প্রকৃত ns-এর সময় (tST, tSIB, tRIB ইত্যাদি) datasheet-এর AC টেবিলে, এখানে দেখানো হয়নি। INTR ওঠে STB̅-এর ওঠার পরে, নামার সময় নয়। ১: data latch, IBF ওঠে; ২: STB̅ ওঠে, INTE থাকলে INTR ওঠে; ৩: CPU পড়া শুরু, RD̅ নামতেই INTR নামে; ৪: RD̅ ওঠে, IBF নামে।

বাজারঘরের উদাহরণ: দোকানদার একটি ছোট keypad-encoder-এ পণ্যের code টাইপ করেন (আলু = 07H). Encoder প্রতিটি code-এর সঙ্গে একটি STB̅ pulse দেয়। Port A mode 1 input, INTRA (PC3) জোড়া 8085-এর RST 5.5-এ (level-triggered, পর্ব ১৩), PC6–PC7 output, port B আর PC0–PC2 mode 0 input: control word 1011 0011 = B3H. CPU HLT-এ ঘুমিয়ে থাকে; code এলেই জাগে।

1MVI A,0B3H / OUT 83H2MVI A,09H / OUT 83H3SIM / EI / HLT4002CH: PUSH PSW5IN 80H6MOV M,A7POP PSW / EI / RET
Handshake-এর লাইন (model)
STB̅ · IBF · INTR
INTE A
port C status
A · 2060H
মোট T
  1. Mode set B3H. PC3 = INTRA, PC4 = STB̅A, PC5 = IBFA. Mode set সব status flip-flop আর INTE 0 করে। Port C পড়লে 07H: D2–D0 = PC2–PC0-এর pin (এখানে 1), D5 IBF = 0, D4 INTE = 0, D3 INTR = 0.
  2. BSR 09H: INTE A = 1. Status 17H: D4 = 1. Pin PC4 বদলায়নি, কারণ সেটি input. তারপর SIM (0EH: শুধু RST 5.5 খোলা), EI, HLT: CPU T = 74 থেকে ঘুমিয়ে।
  3. T = 100: STB̅ = 0. Encoder 07H দিয়ে strobe নামাল। 8255 byte-টি latch করল আর IBF = 1 (PC5 উঁচু, encoder বোঝে “নিয়েছি”)। INTR এখনো 0. Status 37H.
  4. T = 106: STB̅ = 1. এখন IBF = 1, INTE = 1, STB̅ = 1: INTR = 1. PC3 উঁচু, আর সেটিই RST 5.5-এর line. Status 3FH.
  5. Acknowledge. CPU জেগে RST 5.5 নেয়: IE = 0, ফেরার ঠিকানা stack-এ, PC = 002CH, ১২ T, মোট ১১৮. ISR-এর PUSH PSW শেষ T = 130-এ। INTR তখনো 1, কিন্তু IE = 0 বলে আবার ঢোকে না।
  6. IN 80H, RD̅ নামল. I/O read machine cycle-এ RD̅ নিচে নামতেই INTR = 0: RST 5.5-এর line নেমে গেল। (Status-এর 37H এখানে ধারণাগত: এই মুহূর্তে CPU port A পড়ছে, port C নয়।)
  7. RD̅ উঠল. Byte 07H A-তে, আর RD̅-এর ওঠার ধারে IBF = 0. Encoder এখন পরের code পাঠাতে পারে। IN শেষ T = 140-এ।
  8. জমা আর ফেরা. MOV M,A code-টি 2060H-এ রাখে, POP PSW, EI, RET, তারপর দ্বিতীয় HLT. মোট ১৭৬ T, 2060H = 07H.

CPU-র অংশের সত্যিকারের trace (python -B sim8085.py trace mode1.asm; লাইন ছোট করা হয়েছে, register-এর মাঝের অংশ বাদ). Simulator-এ 8255 নেই, তাই source-এ ;@irq 106 RST5.5 দিয়ে INTR-এর মুহূর্ত আর ;@in 80H 07H দিয়ে latch-এর byte হাতে দেওয়া:

~/lab$ python -B sim8085.py trace mode1.asm
...
2012  76        HLT            ... T=5  total=74
---- interrupt RST5.5 acknowledged -> vector 002CH (12 T)  total=118
002C  F5        PUSH PSW       ... T=12 total=130
002D  DB 80     IN 80H         ... T=10 total=140
002F  77        MOV M,A        ... T=7  total=147
0030  F1        POP PSW        ... T=10 total=157
0031  FB        EI             ... T=4  total=161
0032  C9        RET            ... T=10 total=171
2013  76        HLT            ... T=5  total=176
...
Memory 2060H..2060H:
  2060H: 07
Instructions: 17   T-states: 176

নিচের ব্লকে CPU আর model জোড়া: STB̅-এর দুটি ঘটনা model-এ যায়, model-এর INTRA সরাসরি RST 5.5-এর level হয়, আর IN 80H model-এর latch পড়ে। কেউ হাতে interrupt-এর সময় বলে দেয়নি।

# Mode 1 strobed input: keypad encoder -> port A, INTRA (PC3) -> RST 5.5 (sim85 + ppi8255)
from sim85 import assemble
from ppi8255 import PPI, run_ppi
SRC = """ ORG 2000H
 LXI SP,2800H
 MVI A,0B3H
 OUT 83H
 MVI A,09H
 OUT 83H
 MVI A,0EH
 SIM
 LXI H,2060H
 EI
 HLT
 HLT
 ORG 002CH
 PUSH PSW
 IN 80H
 MOV M,A
 POP PSW
 EI
 RET"""
ppi = PPI()
def show(t, what):
    c = ppi.read(2)                    # status: D5 IBF, D4 INTE A, D3 INTR A
    print(f"T={t:<4} {what:22} IBF={c >> 5 & 1} INTE={c >> 4 & 1} INTR={c >> 3 & 1}")
def press(p): p.ext["A"] = 0x07; p.strobe("A", 0); show(100, "code 07H, STB low")
def release(p): p.strobe("A", 1); show(106, "STB high")
def trace(cpu, pc, op, cost):
    if pc is None: show(cpu.tstates, f"{op} -> {cost:04X}H")
    elif op in (0xD3, 0xDB):
        show(cpu.tstates, f"{pc:04X} {'OUT' if op == 0xD3 else 'IN'}, A = {cpu.A:02X}H")
cpu = run_ppi(assemble(SRC), ppi, events=[(100, press), (106, release)],
              line="RST5.5", trace=trace)
print(f"2060H = {cpu.mem[0x2060]:02X}H, T-states = {cpu.tstates}")

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

T=27   2005 OUT, A = B3H      IBF=0 INTE=0 INTR=0
T=44   2009 OUT, A = 09H      IBF=0 INTE=1 INTR=0
T=100  code 07H, STB low      IBF=1 INTE=1 INTR=0
T=106  STB high               IBF=1 INTE=1 INTR=1
T=118  RST5.5 -> 002CH        IBF=1 INTE=1 INTR=1
T=140  002D IN, A = 07H       IBF=0 INTE=1 INTR=0
2060H = 07H, T-states = 176

INTR = 1 হয়েছে ঠিক STB̅ ওঠার সময় (T = 106), আর CPU নিয়েছে T = 118-এ, simulator-এর ;@irq 106-এর run-এর সঙ্গে হুবহু এক; মোট ১৭৬ T-ও এক। ISR-এর IN-এর পরে IBF আর INTR দুটোই 0. INTE = 0 থাকলে (BSR 08H) STB̅-এ IBF তবু উঠত, কিন্তু INTR নয়: তখন CPU port C-এর D5 (IBF) বারবার পড়ে polling করতে পারত।

Interrupt ছাড়া একই কাজ polling-এ: INTE বন্ধ রেখে port C-এর D5 (IBFA) বারবার পড়া, যতক্ষণ না 1 হয়।

        MVI A,0B3H      ; A mode 1 input, INTE stays 0
        OUT 83H
WAIT:   IN 82H          ; port C status
        ANI 20H         ; D5 = IBF A
        JZ WAIT
        IN 80H          ; read the latched code, IBF -> 0
        STA 2060H
        HLT

প্রতি পাকে ২৭ T (IN ১০ + ANI ৭ + JZ ১০). লেখকের lab-এ একই strobe (T = 100 আর 106) দিয়ে model-জোড়া run: status পড়া হয়েছে পাঁচবার, 2060H = 07H, মোট ১৭৭ T, শেষে IBF = 0 আর INTR = 0. Simulator একা চালালে (;@in 82H 20H, অর্থাৎ IBF শুরু থেকেই 1) প্রথম পাকেই বেরোয়: ৮টি নির্দেশ, ৬৯ T. Latch-এর সুবিধা দুই পথেই আছে; পার্থক্য শুধু অপেক্ষার সময়ে CPU কী করে।

Mode 1 output. উল্টো দিকে দুটি লাইন: OBF̅ (output buffer full) আর ACK̅. CPU port-এ লিখলে WR̅-এর নামায় INTR = 0, আর WR̅-এর ওঠায় OBF̅ = 0: যন্ত্রকে জানানো “নতুন byte আছে”। যন্ত্র byte নিয়ে ACK̅ নামালে OBF̅ = 1, আর ACK̅ উঠলে INTE থাকলে INTR = 1: “পরেরটি দিন”। একটি সূক্ষ্ম ফল: buffer খালি থাকা অবস্থায় INTE খুললেই INTR = 1 হয়, কারণ শর্ত (OBF̅ = 1, ACK̅ = 1, INTE = 1) তখনই পূর্ণ। অনুশীলন ৪-এ রসিদ-printer দিয়ে এটি দেখবেন।

Status word. Mode 1-এ port C পড়লে handshake-এর অবস্থা আসে, কোনো আলাদা নির্দেশ লাগে না। STB̅ আর ACK̅-এর বিটের জায়গায় pin-এর মান নয়, INTE-এর মান দেখা যায়:

নকশাD7D6D5D4D3D2D1D0
inputI/OI/OIBFAINTEAINTRAINTEBIBFBINTRB
outputOBF̅AINTEAI/OI/OINTRAINTEBOBF̅BINTRB

৭ · Mode 2, mode-এর মিশ্রণ আর বাস্তব নকশার নিয়ম

Mode 2 শুধু port A-র: একই ৮টি লাইনে দুই দিকেই strobed আদান-প্রদান, অর্থাৎ bidirectional bus. Handshake-এর পাঁচটি লাইন লাগে: PC3 INTRA, PC4 STB̅A, PC5 IBFA, PC6 ACK̅A, PC7 OBF̅A. INTE দুটি: INTE 1 (output দিক, BSR PC6) আর INTE 2 (input দিক, BSR PC4). Port A-র output buffer তখনই লাইনে byte দেয় যখন যন্ত্র ACK̅ নামায়; বাকি সময় লাইন ছেড়ে রাখে, যাতে যন্ত্রও লাইনে byte দিতে পারে। এভাবে দুটি processor-এর মধ্যে, বা একটি CPU আর একটি নিজস্ব-বুদ্ধির যন্ত্রের মধ্যে, আট লাইনেই দুই দিকের কথা চলে। Group B তখন mode 0 বা 1, PC0–PC2 সেই অনুযায়ী।

Modeকোন portHandshake লাইনInput latchসাধারণ ব্যবহার
0A, B, C (দুই অর্ধেক)নেইনাLED, key, display, relay
1A আর Bপ্রতি port-এ ৩টি (port C থেকে)হ্যাঁkeypad encoder, printer, ADC
2শুধু A৫টি (PC3–PC7)হ্যাঁদুই দিকের bus, দুটি CPU-র যোগাযোগ
BSRশুধু C——একটি বিট, INTE খোলা-বন্ধ

Datasheet-এর নিজের উদাহরণ অনুসারে mode মিশিয়ে ব্যবহার করা যায়: group B mode 0-তে সাধারণ switch পড়ছে বা ফল দেখাচ্ছে, আর group A mode 1-এ interrupt দিয়ে একটি keyboard চালাচ্ছে। বাস্তব নকশায় কয়েকটি নিয়ম মনে রাখুন:

  • Mode একবার, শুরুতে. Mode set সব output আর flag মোছে। চলার সময় বদলাতে হলে BSR বা data port.
  • Port C লেখা শুধু mode 0-এর output-এ কাজ করে. Datasheet: “only the Port C pins programmed as outputs in a Mode 0 group can be written”. Mode 1 group-এর বাকি I/O লাইন আর INTE বদলাতে BSR লাগে।
  • Control word পড়া যায় কি না, chip দেখে. NMOS 8255A-তে A1 A0 = 11 পড়া নিষিদ্ধ; CMOS 82C55A control word ফেরত দেয় (D7 সবসময় 1). Program নিজের লেখা মান একটি RAM-এর ঘরে রাখলে দুই chip-এই নিরাপদ।
  • Output-এর জোর সীমিত. 82C55A-র datasheet: যেকোনো output 2.5 mA দিতে বা নিতে পারে, Darlington driver চালানোর জন্য। একটি LED resistor দিয়ে চলে, কিন্তু multiplexed display-এর অঙ্কের common লাইন, beeper বা relay চালাতে transistor বা driver chip লাগে।
  • Input-এ pull-up. খোলা switch-এর লাইন ভাসমান থাকলে মান অনিশ্চিত; প্রতিটি key-লাইনে pull-up resistor.

আরও গভীরে: 8255 শুধু প্রশিক্ষণ kit-এর chip ছিল না: Wikipedia-র তথ্য অনুযায়ী আসল IBM PC, PC/XT আর অনেক home computer (যেমন MSX)-এ এটি ব্যবহৃত হয়েছে; প্রচলিত বিবরণে IBM PC-তে এটি I/O ঠিকানা 60H–63H-এ বসে keyboard-এর code পড়া আর speaker চালু-বন্ধের কাজ করত। আজকের microcontroller-এ 8255-এর ধারণা ভেতরে ঢুকে গেছে: প্রতিটি GPIO port-এর একটি দিক-register আছে (mode set-এর কাজ), আর STM32 ধাঁচের chip-এ BSRR register একটি লেখাতেই নির্দিষ্ট বিট set বা reset করে, ঠিক BSR-এর মতো, read-modify-write ছাড়াই। কোর্সের ভার্চুয়াল বাজারঘর board-এও GPIOA-র BSRR আছে (offset 0x10); GPIO-র register পর্ব ৪১-এর বিষয়। CMOS 82C55A এখনো কিছু নির্মাতা বানায়, মূলত microcontroller-এর I/O বাড়ানোর জন্য।

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

  • “Port A input, B output, C ওপরের অর্ধেক output, নিচের অর্ধেক input, mode 0: control word?” → 1001 0001 = 91H.
  • “PC7 reset করার BSR word?” → বিট 111, D0 = 0: 0EH, control register-এ।
  • “Mode 1 input-এ INTR কখন ওঠে, কখন নামে?” → STB̅ ওঠার পরে, IBF = 1 আর INTE = 1 হলে; RD̅-এর নামায় নামে।
  • “Mode 2 কোন port-এ?” → শুধু port A; handshake PC3–PC7.
  • “8255-এর ঠিকানা 80H হলে control register কোথায়?” → A1 A0 = 11: 83H (8086-এ প্রচলিত জোড়-ঠিকানা নকশায় 86H).

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

8255-এর প্রশ্নে AI assistant-এর ভুল ছোট কিন্তু বিপজ্জনক: একটি বিট উল্টে গেলে পুরো port উল্টো দিকে চলে, আর output-এ বাইরের যন্ত্রের সঙ্গে দুই দিক থেকে টানাটানিতে chip গরম হতে পারে। সাধারণ ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
দিক-বিটের অর্থ উল্টায় (1 = output বলে)Intel-এর Figure 6: 1 = input. 9BH = সব input মনে রাখুন
BSR byte port C-র ঠিকানায় পাঠায়BSR আর mode set দুটোই control register-এ (A1 A0 = 11)
D7 ভুলে যায়, যেমন mode-এর জন্য 03HD7 = 0 হলে সেটি BSR; decode করে দেখুন
Mode 1-এর লাইন ভুল বলে, যেমন port A input-এ INTE = PC6Input-এ PC4, output-এ PC6, port B-তে PC2
Port B-তে mode 2 বা 8086-এ বিজোড় ঠিকানা দেয়Mode 2 শুধু A; 8086-এর নকশা দেখে A1 A0 কোন CPU লাইনে
8085 code-এ 8086-এর OUT DX,AL বা MOV AL মেশায়কোর্সের 8085 simulator-এ assemble করুন

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

আমি Intel 8085-এর সঙ্গে একটি 8255 PPI জুড়ছি; ঠিকানা 80H (port A) থেকে 83H (control register), I/O-mapped. Intel-এর mnemonic আর 2050H ধরনের hex চাই। ১. Port A mode 1 input (একটি keypad encoder, INTR A যাবে RST 5.5-এ), port B mode 0 output, PC6–PC7 output — control word বিট ধরে বানাও, প্রতিটি বিটের অর্থ লেখো। ২. INTE A চালু করার BSR word দাও, আর বলো কেন সেটি port C-তে নয়, control register-এ যায়। ৩. ISR লেখো যা latch করা code 2060H-এ রাখে; কোন মুহূর্তে IBF আর INTR নামে, বলো। ৪. 8086 বা Z80-এর নির্দেশ ব্যবহার করবে না। কোনো pin বা বিট নিয়ে নিশ্চিত না হলে অনুমান না করে বলো।

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

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

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

প্র ০১Port C কেন দুই অর্ধেকে ভাগ, আর আলাদা BSR ব্যবস্থার দরকার কেন পড়ল? আজকের chip-এ এর উত্তরসূরি কী?

দুটি কারণ একসাথে কাজ করেছে। প্রথম কারণ pin-এর হিসাব। ৪০ pin-এর package-এ ২৪টি I/O লাইনের বেশি জায়গা ছিল না, আর mode 1-এ প্রতিটি port-এর তিনটি handshake লাইন লাগে। আলাদা pin দেওয়ার উপায় নেই, তাই Intel port C-কেই দুই ভাগ করল: ওপরের অর্ধেক group A-র (port A-র handshake), নিচের অর্ধেক group B-র। Mode 0-তে এই লাইনগুলো সাধারণ I/O, mode 1 বা 2-এ সেগুলো handshake-এর কাজে চলে যায়। Datasheet-এর ভাষায় নকশাটি “maximum use of the available pins”. প্রতিটি অর্ধেকের দিক আলাদা বিটে (D3, D0), যাতে একই port-এর এক অংশে input আর অন্য অংশে output চলে, যেমন keypad-এর সারি আর কলাম।

দ্বিতীয় কারণ নিয়ন্ত্রণের কাজের ধরন। Port C-এর লাইনগুলো প্রায়ই আলাদা আলাদা যন্ত্র চালায়: একটি বাতি, একটি beeper, একটি relay. একটি বদলাতে পুরো byte লিখতে হলে program-কে বাকি সাতটির মান মনে রাখতে হয় (একটি shadow copy), তারপর read-modify-write: পড়া, একটি বিট বদলানো, লেখা। এতে কয়েকটি নির্দেশ লাগে, আর মাঝপথে একটি ISR একই port বদলালে সেই পরিবর্তন মুছে যায়, কারণ main তার পুরোনো copy লিখে দেয়। এই পর্বের stepper-এ OUT 82H বাতি নিভিয়ে দিয়েছিল ঠিক এই কারণেই। BSR এক লেখাতেই একটি বিট বদলায়, অন্যগুলো ছোঁয় না, তাই দুই কাজের মধ্যে কোনো ফাঁক থাকে না। সঙ্গে আরেকটি সুবিধা: mode 1-এর INTE flip-flop-এর কোনো pin নেই, আর BSR-ই তাদের খোলা-বন্ধের পথ।

আজকের microcontroller-এ সমস্যাটি আরও বড়, কারণ একটি port-এ ১৬টি pin, আর interrupt ও RTOS-এর অনেক task একসাথে pin বদলায়। STM32-এর মতো chip-এ তাই BSRR register: ওপরের ১৬ বিটে 1 লিখলে সংশ্লিষ্ট pin reset, নিচের ১৬ বিটে 1 লিখলে set, আর 0-এর কোনো প্রভাব নেই। কোর্সের ভার্চুয়াল board-এর GPIOA-তেও BSRR আর BRR আছে। ARM Cortex-M3-এর bit-banding-ও একই সমস্যার আরেক উত্তর। C-তে এই কাজের বিট-অপারেশন C প্রোগ্রামিং পর্ব ০৯-এ, আর microcontroller-এর register-এ তার ব্যবহার পর্ব ৩৫-এ।

মূল উপলব্ধি: Port C-এর ভাগ pin বাঁচানোর নকশা, আর BSR একটি বিট নিরাপদে বদলানোর নকশা; একটি লেখাতে একটি বিট, এই ধারণা আজকের প্রতিটি GPIO-তে টিকে আছে।

প্র ০২নতুন mode set word লিখলে সব output কেন মুছে যায়? এর বাস্তব বিপদ কী, আর ভালো firmware কীভাবে তা এড়ায়?

Mode set word শুধু দিক বদলায় না, প্রতিটি port-এর ভেতরের কাঠামোই নতুন করে সাজায়: কোন লাইন handshake, কোন flip-flop কার, কোন buffer চালু। Intel বেছে নিয়েছে সবচেয়ে নিরাপদ নিয়ম: mode বদলালে সব output latch আর status flip-flop 0, আর INTE-ও reset. এর যুক্তি সহজ। ধরুন port A এতক্ষণ input ছিল আর latch-এ কোনো পুরোনো মান পড়ে আছে। Output করার মুহূর্তে সেই অজানা মান লাইনে চলে গেলে বাইরের যন্ত্র একটি অর্থহীন আদেশ পেত। সবকিছু 0 থেকে শুরু হলে অন্তত জানা থাকে কী বেরোচ্ছে, আর একটি পুরোনো IBF বা INTR থেকে হঠাৎ interrupt আসে না।

কিন্তু একই নিয়ম চলমান ব্যবস্থায় বিপদ আনে। Scale-এ OVERLOAD বাতি জ্বলছে, display ঘুরছে, এমন সময় একটি subroutine “নিশ্চিত হওয়ার জন্য” আবার MVI A,83H আর OUT 83H লিখল। দিক একই থাকলেও PC4–PC7 মুহূর্তের জন্য 0: বাতি নিভে আবার জ্বলবে (যদি কেউ আবার জ্বালায়), display এক ঝলক ফাঁকা। Relay বা motor-এর driver থাকলে আরও খারাপ: relay ছেড়ে দিয়ে আবার ধরবে, contact-এর আয়ু কমবে, আর conveyor belt হলে ঝাঁকুনি দেবে। Mode 1-এ ব্যাপারটা আরও সূক্ষ্ম: INTE 0 হয়ে যায়, তাই পরের key code-এ আর interrupt আসবে না, আর program নিঃশব্দে “বধির” হয়ে যাবে।

ভালো firmware তিনটি নিয়ম মানে। এক, mode set একবারই, reset-এর পরে init routine-এ, আর তার ঠিক পরেই সব output-এর নিরাপদ শুরু-মান আর দরকারি INTE BSR দিয়ে। দুই, বাকি সব জায়গায় শুধু data port বা BSR. তিন, hardware-এর দিকেও সুরক্ষা: reset-এর পরে লাইনগুলো input (8255A-তে ভাসমান, 82C55A-তে প্রায় 1), তাই প্রতিটি গুরুত্বপূর্ণ output-এ একটি pull-up বা pull-down resistor বসানো হয়, যাতে program চলার আগের কয়েক মিলিসেকেন্ডেও relay বা motor নিজের নিরাপদ অবস্থায় থাকে। আজকের microcontroller-এর ক্ষেত্রেও একই পরামর্শ: GPIO-কে output করার আগে তার output register-এ মান লিখে রাখা, তারপর দিক বদলানো। এর পুরো আলোচনা পর্ব ৪১-এ।

মূল উপলব্ধি: Mode set একটি “পুরো chip নতুন করে শুরু” আদেশ; নিরাপদ শুরুর জন্য তা দরকারি, কিন্তু চলার মাঝে তা ব্যবহার করলে output-এ ঝাঁকুনি আর হারানো interrupt.

প্র ০৩Mode 1-এর handshake ছাড়া, mode 0 আর polling দিয়েও কি একই কাজ করা যেত? Latch আর IBF আসলে কী সমস্যা মেটায়?

কিছু ক্ষেত্রে যেত, কিন্তু তিনটি সমস্যা থেকে যেত। প্রথম সমস্যা data কখন বৈধ। Keypad encoder বা একটি converter-এর output লাইন বদলানোর সময় কয়েক মুহূর্ত মাঝামাঝি অবস্থায় থাকে: কিছু বিট নতুন, কিছু পুরোনো। Mode 0-তে CPU ঠিক তখন পড়লে একটি ভুল byte পায়। Mode 1-এ যন্ত্র নিজেই বলে দেয় “এখন বৈধ” (STB̅), আর সেই মুহূর্তের byte latch-এ জমে যায়। CPU পরে যখনই পড়ুক, সেই বৈধ byte-ই পাবে।

দ্বিতীয় সমস্যা হারানো আর দ্বিগুণ পড়া। Mode 0-তে CPU-কে নিজেই বুঝতে হয় নতুন data এসেছে কি না, সাধারণত আগের মানের সঙ্গে তুলনা করে। একই key দুবার চাপলে কিছু বদলায় না, তাই দ্বিতীয় চাপ হারায়; আবার CPU দ্রুত পড়লে একই data দুবার গোনে। IBF এই দুটোই মেটায়: STB̅ এলে 1, CPU পড়লে 0. তাই প্রতিটি ঘটনা ঠিক একবার গোনা হয়। আর IBF যন্ত্রের দিকেও একটি pin: যতক্ষণ 1, যন্ত্র বোঝে CPU আগের byte এখনো নেয়নি, পরেরটি পাঠানো উচিত নয়। এটিই flow control, ধীর আর দ্রুত দুই পক্ষ নিজের গতিতে চলতে পারে।

তৃতীয় সমস্যা CPU-র সময়। Polling-এ CPU বারবার পড়ে, ঘটনা না এলেও। Mode 1-এ INTR আর INTE থাকায় CPU HLT-এ ঘুমিয়ে থাকতে পারে, বা অন্য কাজ করতে পারে; এই পর্বের run-এ code এসেছে T = 100-এ, আর CPU কোনো কাজ ছাড়াই অপেক্ষা করেছে। তবে polling-এর পথও খোলা: INTE বন্ধ রেখে port C-এর IBF বিট পড়া যায়, latch-এর সুবিধা অক্ষত রেখে। দুটির মধ্যে বাছাইয়ের হিসাব পর্ব ১৩-এর ভাবনার প্রশ্নে আছে: ঘটনা বিরল হলে interrupt, খুব ঘন হলে polling বা DMA (পর্ব ২৭)।

এই ধরনের STROBE-ACK জোড় সেই যুগের printer-এর parallel interface-এও ছিল, আর আজও প্রায় প্রতিটি bus-এ কোনো না কোনো রূপে আছে: SPI-এর chip select, I2C-এর ACK বিট, বা USB-এর handshake packet. Handshake-এর সাধারণ তত্ত্ব আর bus-এর লেনদেন Computer Architecture পর্ব ৫১-এ।

মূল উপলব্ধি: Latch বলে “কোন byte”, IBF বলে “নতুন কি না”, INTR বলে “এখনই দেখুন”; তিনটি মিলে একটি ধীর যন্ত্র আর দ্রুত CPU-কে নিরাপদে জোড়ে।

প্র ০৪আজকের microcontroller-এ ডজন ডজন GPIO pin থাকতে আলাদা I/O chip-এর কি আর কোনো জায়গা আছে? 8255-এর গল্প থেকে কী শেখার আছে?

8255-এর যুগে CPU chip-এ শুধু CPU থাকত: 8085-এর ৪০ pin-এর প্রায় সবই address, data আর নিয়ন্ত্রণে খরচ, বাইরের যন্ত্রের জন্য সরাসরি লাইন বলতে শুধু SID আর SOD. তাই প্রতিটি computer-এ আলাদা I/O chip লাগত, আর 8255 এক chip-এ ২৪টি লাইন দিয়ে board-এর chip-সংখ্যা কমিয়েছিল। Microcontroller এই ধারণাকে CPU-র ভেতরেই ঢুকিয়ে দিল: আজকের একটি ছোট MCU-তে কয়েক ডজন GPIO, প্রতিটির দিক, pull-up আর output-এর ধরন register দিয়ে বাছা যায়। অর্থাৎ 8255-এর control word এখন প্রতিটি port-এর একটি mode register.

তবু আলাদা I/O chip হারিয়ে যায়নি, রূপ বদলেছে। প্রথমত, pin কম পড়লে: একটি ছোট MCU-তে display, keypad আর অনেক relay একসাথে চালাতে হলে I2C বা SPI-এর “I/O expander” chip (যেমন PCF8574 বা MCP23017 পরিবার) দুটি বা চারটি তারে আরও ৮ বা ১৬টি লাইন দেয়। এগুলো আসলে 8255-এর উত্তরসূরি: ভেতরে দিক-register, output latch আর input পড়ার register, অনেকগুলোর একটি interrupt output-ও, যা কোনো input বদলালে MCU-কে জানায়, যেন mode 1-এর INTR-এর আধুনিক রূপ। দ্বিতীয়ত, দূরত্ব আর বিচ্ছিন্নতা: কারখানার যন্ত্রে I/O-কে প্রায়ই মূল board থেকে দূরে, আলাদা power-এ রাখা হয়। তৃতীয়ত, পুরোনো যন্ত্রের রক্ষণাবেক্ষণ: Wikipedia অনুযায়ী CMOS 8255 এখনো তৈরি হয়, মূলত microcontroller-এর I/O বাড়াতে।

শেখার জিনিসটি chip-এর বাইরে। 8255 দেখিয়েছিল, hardware-এর আচরণ software দিয়ে বদলানোর সুবিধা কত বড়: একই board বিভিন্ন কাজে, শুধু init-এর একটি byte বদলে। দামও আছে: ভুল byte লিখলে hardware উল্টো আচরণ করে, যা এই পর্বের ফাঁদগুলোতে দেখেছেন। আধুনিক MCU-তে register অনেক বেশি, তাই ভুলের সুযোগও বেশি, আর datasheet ও reference manual পড়ার অভ্যাস আরও জরুরি। 8255-এর ৮ বিটের একটি control word দিয়ে সেই অভ্যাস শুরু করা সহজ। Microcontroller-এর পরিবারগুলো পর্ব ২৮-এ, আর GPIO register পর্ব ৪১-এ।

মূল উপলব্ধি: 8255-এর কাজ microcontroller-এর ভেতরে চলে গেছে, আর বাইরে থেকে গেছে I/O expander হিসেবে; কিন্তু “একটি byte লিখে hardware সাজানো” ধারণা আর তা যাচাইয়ের দায়িত্ব অপরিবর্তিত।

প্র ০৫চার অঙ্কের display একসাথে না জ্বালিয়ে multiplexing কেন? আলো, তড়িৎপ্রবাহ, refresh-এর হার আর ghosting-এর হিসাব কীভাবে মেলাবেন?

Static display-এ প্রতিটি segment-এর নিজের লাইন: চার অঙ্কে ৩২টি লাইন, অর্থাৎ ১.৩৩টি 8255, বা চারটি আলাদা latch chip. Multiplexing-এ ৮টি segment-লাইন আর অঙ্ক বাছাইয়ের কয়েকটি লাইন যথেষ্ট; scale-এ decoder দিয়ে মাত্র ২টি। লাইন বাঁচানো ছাড়াও মোট তড়িৎপ্রবাহ কমে, কারণ প্রতি মুহূর্তে একটি অঙ্কই জ্বলে। এই সুবিধার দাম তিনটি।

প্রথম দাম আলো। প্রতিটি অঙ্ক সময়ের এক-চতুর্থাংশ জ্বলে, তাই একই প্রবাহে চোখে কম উজ্জ্বল। তাই multiplexed display-এ প্রতিটি segment-এ সাধারণত বেশি প্রবাহ দেওয়া হয় (LED-এর datasheet-এর pulse-সীমার ভেতরে), আর অঙ্কের common লাইনে, যেখানে আটটি segment-এর প্রবাহ একসাথে আসে, একটি transistor বসে, কারণ 82C55A-র একটি output মাত্র 2.5 mA-র জন্য নির্ধারিত।

দ্বিতীয় দাম সময়ের হিসাব। চোখে ঝিকঝিক না দেখাতে প্রতিটি অঙ্ককে সেকেন্ডে অনেকবার জ্বালাতে হয়; প্রচলিত নকশায় কয়েক মিলিসেকেন্ড পরপর। অনুশীলন ৩-এর program-এ প্রতিটি অঙ্কে প্রায় 2 ms-এর delay দিয়ে সত্যিকারের run: এক অঙ্ক থেকে পরের অঙ্ক ৬০৮৩ T = 2027.67 µs, চার অঙ্কের এক পাক প্রায় 8.11 ms, অর্থাৎ প্রতিটি অঙ্ক সেকেন্ডে প্রায় ১২৩ বার। কিন্তু CPU পুরো সময় এই loop-এই আটকে থাকে; ওজন মাপার কাজ করতে হলে refresh-কে একটি timer interrupt-এ সরাতে হয়, যেখানে প্রতি tick-এ একটি অঙ্ক বদলায়। 8253/8254 timer দিয়ে ঠিক এই কাজ পরের পর্বে সম্ভব হবে। আর ISR-এ ঝামেলা হলে display থেমে যায়, একটি অঙ্ক অতিরিক্ত উজ্জ্বল হয়ে টিকে থাকে, তাই ISR ছোট রাখা জরুরি।

তৃতীয় দাম ghosting: অঙ্ক বদলানোর মুহূর্তে আগের অঙ্কের code নতুন অঙ্কে এক ঝলক জ্বলে, ফলে ফাঁকা segment-এ ক্ষীণ ছায়া। এই পর্বের program তাই প্রতিবার আগে segment বন্ধ (OUT 80H দিয়ে 00H), তারপর অঙ্ক বদলায়, তারপর নতুন code দেয়। একই সারি-কলাম কৌশল keypad-এও চলে, আর অনেক নকশায় display-এর অঙ্ক-বাছাইয়ের লাইনই keypad-এর সারি-লাইন হিসেবে ভাগ করা হয়, যাতে আরও লাইন বাঁচে।

মূল উপলব্ধি: Multiplexing লাইন আর প্রবাহ বাঁচায় সময় দিয়ে; তার বদলে উজ্জ্বলতার জন্য বেশি pulse-প্রবাহ, refresh-এর জন্য নিয়মিত সময় আর ghosting এড়াতে লেখার সঠিক ক্রম দরকার।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — 4×4 keypad scan: একটি আলাদা 8255 বসেছে 84H–87H-এ। PC4–PC7 চারটি সারি (output), PC0–PC3 চারটি কলাম (input, pull-up সহ; চাপা key-র কলাম 0 পড়ে যখন তার সারি 0). Control word দিন, আর একটি 8085 program লিখুন যা একবারে একটি সারি 0 করে কলাম পড়ে, আর চাপা key-র code (সারি × 4 + কলাম) 2070H-এ রাখে; কোনো key না চাপলে 0FFH.

    Control word: A আর B এখানে ব্যবহার নেই (output রাখা নিরাপদ), C upper output, C lower input: 1000 0001 = 81H হলেও চলে; নিচের program scale-এর মতো 83H দেয় (B input), যা একই কাজ করে।

            ORG 2000H
            MVI A,83H       ; C upper out (rows), C lower in (columns)
            OUT 87H
            MVI B,0EFH      ; PC4 low first: 1110 1111
            MVI D,00H       ; row x 4
    ROW:    MOV A,B
            OUT 86H         ; drive one row low
            IN 86H
            ANI 0FH         ; columns: 1 = open (pull-up)
            CPI 0FH
            JNZ FOUND
            MOV A,B
            RLC             ; next row low
            MOV B,A
            MOV A,D
            ADI 04H
            MOV D,A
            CPI 10H
            JNZ ROW
            MVI A,0FFH      ; no key
            STA 2070H
            HLT
    FOUND:  MVI C,00H       ; column number
    COL:    RRC
            JNC DONE        ; first 0 = pressed column
            INR C
            JMP COL
    DONE:   MOV A,D
            ADD C           ; key = row x 4 + column
            STA 2070H
            HLT

    লেখকের lab-এ program-টি simulator-এ (৫৪ byte) আর একটি keypad-model জুড়ে চালানো, যেখানে চাপা key-র কলাম 0 হয় শুধু তার সারি 0 থাকলে। ফল: সারি ১ কলাম ১ → 05H (দুটি সারি লেখা: EF, DF; ২৪০ T); সারি ০ কলাম ০ → 00H (১২৬ T); সারি ৩ কলাম ২ → 0EH (৪৪৩ T); সারি ২ কলাম ৩ → 0BH (৩৭৯ T); কোনো key নয় → 0FFH (চারটি সারি, ৪০৯ T). শেষেরটি simulator একাই (;@in 86H 0FFH) একই ৪০৯ T দেখিয়েছে। লক্ষ করুন, OUT 86H পুরো port C লেখে, কিন্তু নিচের অর্ধেক input বলে সেখানে কোনো প্রভাব নেই; ওপরের অর্ধেকে শুধু সারির লাইন, তাই এখানে BSR-এর দরকার নেই। বাস্তবে key পাওয়ার পরে কয়েক ms অপেক্ষা করে আবার scan করে মেলাতে হবে (debounce).

  2. ভুল খুঁজুন — বাতি জ্বলে না: Scale-এর init আর OVERLOAD-এর কোড কেউ এভাবে লিখলেন: MVI A,8BH / OUT 83H, তারপর ওজন বেশি হলে MVI A,0BH / OUT 82H. বাতি কখনো জ্বলে না, আর display-ও অন্ধকার। দুটি ভুল খুঁজুন, প্রতিটির ফল বলুন, আর ঠিক কোড দিন।

    ভুল ১: 8BH = 1000 1011: D3 = 1, তাই PC7–PC4 input. বাতি, beeper আর অঙ্ক-বাছাইয়ের লাইন 8255 চালায়ই না; লাইনগুলো ভাসমান বা pull-up-এ, তাই display আর বাতি দুটোই অচল। Model-এ 8BH-এর পরে port C-এর আটটি লাইনই “in”. ঠিক byte 1000 0011 = 83H.

    ভুল ২: BSR byte গেছে port C-তে (82H), control register-এ নয়। এটি তখন সাধারণ data: 0BH = 0000 1011, অর্থাৎ PC7–PC4 = 0000. ঠিক control word থাকলেও এতে PC5 জ্বলত না, উল্টো সব ওপরের লাইন 0 হতো। Model-এ 83H আর BSR 0BH-এর পরে PC7..PC0 = 00100001; তারপর ভুল OUT 82H দিলে 00000001, বাতি নিভে গেল।

    ঠিক কোড: MVI A,83H / OUT 83H init-এ একবার, আর বাতির জন্য MVI A,0BH / OUT 83H, নেভাতে MVI A,0AH / OUT 83H. Simulator-এ দুই সংস্করণেরই OUT-এর লগ মিলিয়ে দেখা যায় কোন byte কোন port-এ গেল; byte-এর অর্থ যাচাই model-এর decode()-এ।

  3. হিসাব — display-এর refresh: Scale-এর display program-এ প্রতিটি অঙ্কে segment জ্বালানোর পরে একটি 16-বিটের delay বসানো হলো: LXI D,N / DLY: DCX D / MOV A,E / ORA D / JNZ DLY, যার খরচ 24N + 7 T. প্রায় 2 ms-এর জন্য N কত? তখন এক অঙ্ক থেকে পরের অঙ্ক কত T আর কত µs, চার অঙ্কের এক পাক কত ms, আর প্রতিটি অঙ্ক সেকেন্ডে কতবার জ্বলে? (Delay ছাড়া প্রতি অঙ্কে loop-এর খরচ ৭৬ T.)
    1. 2 ms = 2000 µs ÷ 0.333 µs = 6000 T. 24N + 7 = 6000 → N = 5993 ÷ 24 = 249.7, তাই N = 250.
    2. Delay = 24 × 250 + 7 = 6007 T = 2002.33 µs. (Reference-এর delay16.asm-এ N = 250 দিয়ে সত্যিকারের run: ৬০১২ T = ৬০০৭ + HLT-এর ৫.)
    3. এক অঙ্ক থেকে পরের অঙ্ক: 76 + 6007 = 6083 T = 2027.67 µs.
    4. চার অঙ্কের এক পাক: 4 × 6083 = 24332 T ≈ 8.11 ms; প্রতিটি অঙ্ক সেকেন্ডে প্রায় 1 ÷ 8.11 ms ≈ ১২৩ বার (loop-এ ফেরার কয়েকটি T বাদে)।

    সত্যিকারের run (scale7d.asm, delay-সহ): segment জ্বলেছে T = 79, 6162, 12245, 18328-এ, ঠিক 6083 T পরপর; মোট ৪০৫৩টি নির্দেশ, ২৪৩৬৮ T. অঙ্কটি জ্বলে থাকে পরের “segment বন্ধ” পর্যন্ত: 79 থেকে 6131, অর্থাৎ 6052 T ≈ 2017.33 µs. খেয়াল করুন, delay-তে B নয়, DE ব্যবহার হয়েছে, কারণ B-তে অঙ্কের নম্বর।

  4. আগে বলুন, তারপর চালান — রসিদ-printer, mode 1 output: বাজারঘরের রসিদ-printer port A-তে, mode 1 output: control word A0H (group B mode 0, সব বাকি লাইন output). তারপর BSR 0DH, তারপর OUT 80H-এ 41H (‘A’), তারপর printer ACK̅ নামায়, তারপর তোলে। প্রতিটি ধাপের পরে port C পড়লে কী আসবে (OBF̅A, INTEA, INTRA)? কোন ধাপে INTR প্রথম ওঠে, আর তা কেন অবাক করতে পারে?

    Output নকশায় status: D7 = OBF̅A, D6 = INTEA, D3 = INTRA; বাকি output latch 0. Model-এর ফল:

    1. Mode set A0H: 80H = 1000 0000. OBF̅ = 1 (buffer খালি), INTE = 0, INTR = 0.
    2. BSR 0DH (PC6 = 1 → INTE A): C8H = 1100 1000. INTR = 1 এখনই!
    3. OUT 80H, 41H: 40H = 0100 0000. WR̅-এর নামায় INTR = 0, ওঠায় OBF̅ = 0; port A-র লাইনে 41H.
    4. ACK̅ = 0: C0H. OBF̅ = 1, INTR এখনো 0.
    5. ACK̅ = 1: C8H. INTR = 1: “পরের অক্ষর দিন”।

    অবাক করার মতো ধাপটি ২: buffer খালি, ACK̅ = 1, INTE = 1, এই তিন শর্ত INTE খোলার মুহূর্তেই পূর্ণ, তাই printer কিছু না করলেও interrupt আসে। নকশা তাই দুই রকম: INTE খোলা হয় শুধু যখন পাঠানোর মতো লেখা আছে, আর প্রথম interrupt-এর ISR-ই প্রথম অক্ষর পাঠায়; লেখা শেষ হলে ISR BSR 0CH দিয়ে INTE বন্ধ করে। Datasheet-এর নিয়ম: “INTR is set when ACK is a one, OBF is a one and INTE is a one. It is reset by the falling edge of WR.”

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

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

ক্রম8255-এর port A mode 1 input-এ INTE A = 1 অবস্থায় একটি byte আসার ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. যন্ত্র port A-র লাইনে byte রেখে STB̅ নামায়
  2. 8255 byte-টি latch করে আর IBF = 1 করে
  3. STB̅ ওঠে, আর INTR = 1 হয়
  4. CPU interrupt নিয়ে ISR-এ port A পড়া শুরু করে, RD̅ নামতেই INTR = 0
  5. RD̅ ওঠে, byte CPU-তে পৌঁছায় আর IBF = 0 হয়

8255-এ port A input, port B output, port C-এর ওপরের অর্ধেক output, নিচের অর্ধেক input, সবই mode 0. Control word কত?

  • 91H
  • 89H
  • 19H
  • 98H

8255-এ PC7-কে 0 করার BSR word কোনটি, আর কোথায় লিখতে হবে? (ঠিকানা 80H–83H)

  • 0FH, port 83H-এ
  • 0EH, port 82H-এ
  • 0EH, port 83H-এ
  • 07H, port 83H-এ

8255 (ঠিকানা 80H–83H) control word 83H দিয়ে চালু আছে, আর PC5-এ একটি বাতি জ্বলছে। এখন MVI A,0BH আর OUT 82H চললে কী হয়?

  • PC5 = 1, বাকি বিট অক্ষত
  • PC7–PC4 সব 0 হয়, বাতি নেভে; নিচের input অপরিবর্তিত
  • 8255-এর mode বদলে যায়
  • এটি নিষিদ্ধ, chip কিছুই করে না

8255-এর mode 2 সম্পর্কে কোন কথাটি ঠিক?

  • Port A আর port B দুটোই mode 2-এ যেতে পারে
  • Handshake-এর লাইন PC0–PC4
  • Mode 2-এ কোনো handshake লাগে না
  • শুধু port A, আর PC3–PC7 handshake-এ যায়

8255-এর mode 1 input-এ INTR কোন ঘটনায় 0 হয়?

  • STB̅-এর নামার ধারে
  • IBF উঠলে
  • CPU-র RD̅-এর নামার ধারে, port পড়ার সময়
  • RD̅-এর ওঠার ধারে, পড়া শেষে

চালু অবস্থায় একটি 8255-এ একই mode set word আবার লেখা হলো (দিক একই)। কী ঘটে?

  • সব output latch, status flip-flop আর INTE 0 হয়ে যায়
  • কিছুই বদলায় না, কারণ byte একই
  • সব port input হয়ে যায়
  • INTR = 1 হয়ে CPU-তে interrupt যায়

শব্দকোষ

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

মনে রাখুন

  1. গঠন: port A, B (৮ বিট), C (৪ + ৪); group A = A + PC7–PC4, group B = B + PC3–PC0; A1 A0 = 00, 01, 10, 11 → A, B, C, control; RESET-এ সব input.
  2. Mode set: 1 · A-র mode (২ বিট) · A · Cupper · B-র mode · B · Clower; 1 = input. 80H সব output, 9BH সব input, scale = 83H.
  3. BSR: D7 = 0, byte = বিট × 2 + মান, control register-এ; PC5 = 1 → 0BH. Port C-তে পুরো byte লিখলে পাশের output বিটও বদলায়।
  4. Mode 1 input: STB̅↓ latch আর IBF = 1; STB̅↑ আর INTE = 1 → INTR = 1; RD̅↓ INTR = 0; RD̅↑ IBF = 0. INTE: A input PC4, A output PC6, B PC2.
  5. নিয়ম: mode set সব output আর flag মোছে, তাই একবার, শুরুতে; mode 2 শুধু port A (PC3–PC7); 82C55A-র output 2.5 mA, বড় load-এ driver.

পরের পর্বে: পর্ব ২৫ (8253/8254 programmable timer — counter mode আর হিসাব). তিনটি ১৬ বিটের counter, ছয়টি mode, আর একটি control word দিয়ে নির্দিষ্ট frequency-র square wave বা নির্দিষ্ট delay; scale-এর display refresh-কে loop থেকে মুক্ত করার পথ।

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

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