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

8253/8254 programmable timer — counter mode আর হিসাব

8253/8254 Programmable Interval Timer — Counter Modes and Calculations

Taught in Bangla, this lesson explains the 8253/8254 programmable interval timer: three 16-bit down counters, four ports, and the SC, RW, M and BCD fields of the control word (0B6H for a buzzer square wave). It walks through all six modes, GATE behaviour, count latching and read-back, and calculates N = fin ÷ fout with cascaded counters for a 1 s tick. A delay loop and timer setup run in the course's 8085 simulator, and in-page Python models the six modes.

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

  • Software delay loop আর hardware timer-এর পার্থক্য সংখ্যা দিয়ে বলা
  • প্রয়োজন থেকে 8254-এর control word বানানো আর একটি অচেনা byte ভেঙে পড়া
  • ছয়টি mode-এ প্রতিটি CLK pulse-এ count আর OUT কী হয়, GATE-সহ, ধাপে ধাপে মেলানো
  • কোনো frequency বা delay-এর জন্য count, সীমা আর দুই counter-এর cascade হিসাব করা
  • 8085 আর 8086 থেকে timer চালু করার program লিখে simulator-এ যাচাই করা

১ · সময় মাপার দুই পথ — delay loop বনাম আলাদা timer chip

বাজারঘরের cold-storage monitor-কে প্রতি সেকেন্ডে একবার তাপমাত্রা পড়তে হয়, আর alarm বাজলে একটি buzzer-এ টানা সুর দিতে হয়। দুটি কাজই আসলে সময় মাপার কাজ। পর্ব ১২-এ আমরা প্রথম পথটি দেখেছি: একটি delay loop, যেখানে CPU একটি সংখ্যা কমাতে কমাতে সময় পার করে। 8085-এর 3 MHz clock-এ এক T-state = 0.333 µs, আর ১৬-বিটের loop নেয় 24N + 7 T-state. 10 ms অপেক্ষার জন্য N = 1250, মোট 30007 T, অর্থাৎ 10.0023 ms. পুরো সময়টা CPU আর কিছুই করতে পারে না।

Reference lab-এর simulator-এ সেই loop, সত্যিকারের run (delay10ms.asm: LXI B,1250 আর পর্ব ১২-এর ১৬-বিট loop):

~/lab$ python -B sim8085.py run delay10ms.asm
A=00 B=00 C=00 D=00 E=00 H=00 L=00 SP=0000 PC=200A
Flags: S=0 Z=1 AC=0 P=1 CY=0   (F=44H)
Instructions: 5002   T-states: 30012

৫০০২টি নির্দেশ, 30007 + 5 (HLT) = 30012 T. এক সেকেন্ডের জন্য লাগবে প্রায় তিন লাখ নির্দেশ। এই পথের তিনটি দুর্বলতা আছে। এক, CPU পুরোপুরি আটকে থাকে। দুই, মাঝখানে একটি interrupt এলে তার ISR-এর সময়টুকু হিসাবের বাইরে যোগ হয়ে যায়, তাই সময় লম্বা হয়ে যায়। তিন, crystal বদলালে বা program অন্য CPU-তে নিলে সব সংখ্যা নতুন করে গুনতে হয়।

উপমা — স্কুলের ঘণ্টাওয়ালা: প্রধান শিক্ষক নিজে ঘড়ির দিকে তাকিয়ে প্রতি পিরিয়ড শেষে ঘণ্টা বাজালে তাঁর আর কোনো কাজ হয় না (delay loop). তাই স্কুলে একজন দপ্তরি থাকেন: শিক্ষক একবার বলে দেন “৪০ মিনিট পরপর ঘণ্টা”, দপ্তরি নিজে গোনেন আর সময় হলে ঘণ্টা বাজান। শিক্ষক শুধু ঘণ্টা শুনলে সাড়া দেন। 8253/8254 সেই দপ্তরি, তিনজন একসাথে: তিনটি counter, প্রত্যেকের নিজের ঘড়ি আর নিজের ঘণ্টা।

দ্বিতীয় পথ তাই একটি আলাদা chip: programmable interval timer. Intel-এর 8253 (১৯৮০-র component catalog-এ পাওয়া যায়) আর তার উন্নত রূপ 8254 (১৯৮২-র catalog-এ “preliminary” datasheet হিসেবে) এই কাজের ক্লাসিক chip. Datasheet-এর নিজের ভাষায় 8254 হলো 8253-এর একটি superset. CPU একবার নির্দেশ লিখে দেয়; তারপর chip নিজের clock pin-এর প্রতিটি pulse-এ একটি down counter এক কমায়, আর শেষ হলে OUT pin-এর অবস্থা বদলায়। সেই OUT জোড়া যায় CPU-র interrupt pin-এ, একটি buzzer-এ, বা আরেকটি counter-এর clock-এ।

লেখার নিয়ম আগের পর্বগুলোর মতো: সংখ্যা Intel-এর ধরনে শেষে H দিয়ে (43H, 0B6H), আর অক্ষর দিয়ে শুরু হওয়া hex-এর আগে একটি 0. 8085-এর program শুরু 2000H-এ। এখানে প্রতিটি 8085 program কোর্সের reference lab-এর sim8085.py চালিয়ে পাওয়া (lab-এর পরিচয় পর্ব ০৬-এ)। তবে একটি সতর্কতা গুরুত্বপূর্ণ: lab-এ 8253/8254-এর কোনো emulator নেই। Simulator দেখায় CPU কোন port-এ কোন byte কখন পাঠাল; timer সেই byte পেয়ে কী করে, তা এই পর্বের জন্য লেখা একটি ছোট Python মডেল থেকে, যা Intel-এর 8254 datasheet (order number 231164-005) অনুযায়ী বানানো। মডেলটি datasheet-এর Figure 15 থেকে 20-এর আঠারোটি timing diagram-এর count আর OUT হুবহু মিলিয়ে পরীক্ষা করা হয়েছে, লেখকের lab-এ ১৮টির ১৮টিতেই মিলেছে।

২ · 8254-এর ভেতরে — তিনটি counter, চারটি port আর তিনটি pin

8254 একটি ২৪-pin chip. CPU-র দিক থেকে এটি চারটি I/O port-এর একটি সারি: A1 আর A0 pin ঠিক করে কোনটির সঙ্গে কথা হচ্ছে, আর chip select (CS̄) নিচু না হলে chip সাড়াই দেয় না। এই পর্বের নকশায় একটি address decoder CS̄ নিচু করে যখন port ঠিকানা 0100 00xx, অর্থাৎ 40H থেকে 43H; আর 8085-এর A1, A0 সরাসরি chip-এর A1, A0-তে। 8085 এখানে IN/OUT দিয়ে কথা বলে, মানে port-mapped I/O; Address decoder কীভাবে বানাতে হয়, তা পর্ব ২২-এ, আর I/O interfacing-এর পুরো আলোচনা পর্ব ২৩-এ।

A1 A0এই নকশায় portলিখলেপড়লে
0040Hcounter 0-এর countcounter 0-এর count বা status
0141Hcounter 1-এর countcounter 1-এর count বা status
1042Hcounter 2-এর countcounter 2-এর count বা status
1143Hcontrol word বা commandকিছু না (8254-এ এটি no-operation)

প্রতিটি counter-এর বাইরের জগতের সঙ্গে তিনটি pin: CLK (যে pulse গোনা হবে), GATE (গোনা চলবে কি না, বা কখন শুরু হবে) আর OUT (ফল)। Datasheet-এর pin নম্বর: CLK0 ৯, OUT0 ১০, GATE0 ১১, OUT1 ১৩, GATE1 ১৪, CLK1 ১৫, GATE2 ১৬, OUT2 ১৭, CLK2 ১৮; D7–D0 pin ১ থেকে ৮, A0 ১৯, A1 ২০, CS̄ ২১, RD̄ ২২, WR̄ ২৩, আর +5 V ও ground ২৪ আর ১২-তে।

Counter-এর ভেতরে তিনটি অংশের নাম মনে রাখা দরকার, কারণ timing-এর সব সূক্ষ্মতা এখান থেকে আসে। CR (count register): CPU যে count লেখে, তা আগে এখানে বসে। CE (counting element): আসল ১৬-বিটের নিচে-গোনা counter; CPU একে সরাসরি লিখতে বা পড়তে পারে না। OL (output latch): CE-এর মানের একটি কপি, যা CPU পড়ে। CR থেকে CE-তে count যায় একটি CLK pulse-এ; এই “load”-এর pulse-টিতে কোনো কমানো হয় না। পরীক্ষার “N + 1” উত্তরগুলোর জন্ম এখানেই।

একটি clock pulse মানে datasheet-এর ভাষায় একটি উঠন্ত ধার আর তারপর একটি নামন্ত ধার। GATE দেখা হয় উঠন্ত ধারে; count load হয় বা কমে নামন্ত ধারে। বাজারঘরের cold room-এর timer-নকশা নিচের ছবিতে, যা পুরো পর্বে ব্যবহার হবে।

ছবি ২৫.১ — বাজারঘরের cold room-এ 8085 আর 8254

Counter 0 আর 1 মিলে প্রতি 1 s-এ RST 7.5, counter 2 buzzer-এর 1 kHz সুর

বাজারঘরের cold room-এ 8085 আর 8254-এর সংযোগ 8085 8254 · 40H–43H buzzer GATE2 ← port 01H-এর bit 0 D0–D7A1 A0RD WRRST 7.5 2 MHz OUT1 Counter 0 · mode 2N = 20000 → 100 HzCLK0 = 2 MHz Counter 1 · mode 2N = 100 → 1 HzCLK1 = OUT0 Counter 2 · mode 3N = 2000 → 1 kHzGATE2 = alarm 1 kHz
ছবি ২৫.১ — একটি আলাদা 2 MHz clock উৎস counter 0-কে চালায়; OUT0 counter 1-এর clock হয়, তাই দুটি counter মিলে 2 MHz-কে 2 000 000 দিয়ে ভাগ করে (পর্বের অংশ ৭-এ হিসাব)। GATE0 আর GATE1 +5 V-এ বাঁধা ধরা হয়েছে। Pin-এর স্থান প্রতীকী, chip-এর আসল pin-বিন্যাস নয়।

2 MHz কেন আলাদা উৎস থেকে? 8085-এর CLK OUT pin দেয় 3 MHz, কিন্তু 8253-এর CLK-এর সীমা datasheet অনুযায়ী DC থেকে 2.6 MHz. 8254 নেয় 8 MHz পর্যন্ত, আর 8254-2 নেয় 10 MHz. তাই একই নকশা যেন দুটি chip-এই চলে, আমরা 2 MHz নিয়েছি। 8254 ব্যবহার করলে 3 MHz সরাসরিও দেওয়া যেত; তখন সব count দেড় গুণ হতো।

৩ · Control word — আট বিটে একটি counter-এর পুরো নির্দেশ

প্রতিটি counter ব্যবহারের আগে port 43H-এ একটি control word লিখতে হয়। Power-on-এর পরে datasheet অনুযায়ী mode, count আর OUT সবই অনির্ধারিত; প্রোগ্রাম না করা counter-কে কাজে লাগানো যায় না, আর অব্যবহৃত counter-কে প্রোগ্রাম করার দরকারও নেই।

বিটD7 D6D5 D4D3 D2 D1D0
নামSC1 SC0RW1 RW0M2 M1 M0BCD
অর্থ00 counter 0
01 counter 1
10 counter 2
11 read-back (শুধু 8254)
00 counter latch command
01 শুধু LSB
10 শুধু MSB
11 আগে LSB, পরে MSB
000 mode 0
001 mode 1
X10 mode 2
X11 mode 3
100 mode 4
101 mode 5
0 ১৬-বিট binary
1 BCD, চার অঙ্ক

তিনটি জিনিস লক্ষ করুন। প্রথমত, control word নিজেই বলে দেয় কোন counter-এর জন্য, তাই তিনটি counter-এর control word একই port 43H-এ যায়। দ্বিতীয়ত, mode 2 আর 3-এর M2 বিট “X”: 110 আর 111 যথাক্রমে mode 2 আর 3-ই। Intel বলেছে X-কে 0 রাখতে, ভবিষ্যতের সঙ্গে মিল রাখার জন্য। তৃতীয়ত, RW = 00 আসলে কোনো mode লেখে না; এটি একটি আলাদা command, যা চলমান count-কে আটকে পড়ার সুযোগ দেয় (অংশ ৬)। BCD = 1 হলে counter চার দশমিক অঙ্কে গোনে, 9999 থেকে 0000, আর count-এর byte-গুলোও BCD-তে লিখতে হয়।

Count লেখার নিয়ম datasheet-এ দুটি: প্রতিটি counter-এর জন্য আগে control word, পরে count; আর count-কে control word-এর RW-এ বলা ধরন মানতে হবে। RW = 11 হলে counter-এর ঠিকানায় প্রথম byte যায় LSB হিসেবে, দ্বিতীয়টি MSB. Count 0 মানে সবচেয়ে বড় count: binary-তে 216 = 65536, BCD-তে 104 = 10000. নিচের ব্লকটি বিট জুড়ে control word বানায়, আবার একটি অচেনা byte ভেঙে অর্থ বলে।

# 8254-এর control word: বিট জুড়ে বানানো আর ভেঙে পড়া (Intel datasheet, Figure 7)
SC = ["counter 0", "counter 1", "counter 2", "read-back"]
RW = ["latch command", "LSB only", "MSB only", "LSB then MSB"]
def encode(sc, rw, mode, bcd=0):
    return sc << 6 | rw << 4 | mode << 1 | bcd
def decode(cw):
    sc, rw, m, bcd = cw >> 6, cw >> 4 & 3, cw >> 1 & 7, cw & 1
    if sc == 3:
        return "read-back command (8254 only)"
    if rw == 0:
        return "counter latch command for " + SC[sc]
    mode = m & 3 if m > 5 else m              # 110 = mode 2, 111 = mode 3
    return f"{SC[sc]}, {RW[rw]}, mode {mode}, {'BCD' if bcd else 'binary'}"
jobs = [(0, 3, 2), (1, 1, 2), (2, 3, 3), (2, 3, 3, 1), (0, 3, 0)]
for job in jobs:
    cw = encode(*job)
    print(f"{cw:02X}H = {cw:08b} -> {decode(cw)}")
print("--- unknown bytes ---")
for cw in (0x7E, 0x80, 0xE8, 0x5A):
    print(f"{cw:02X}H = {cw:08b} -> {decode(cw)}")

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

34H = 00110100 -> counter 0, LSB then MSB, mode 2, binary
54H = 01010100 -> counter 1, LSB only, mode 2, binary
B6H = 10110110 -> counter 2, LSB then MSB, mode 3, binary
B7H = 10110111 -> counter 2, LSB then MSB, mode 3, BCD
30H = 00110000 -> counter 0, LSB then MSB, mode 0, binary
--- unknown bytes ---
7EH = 01111110 -> counter 1, LSB then MSB, mode 3, binary
80H = 10000000 -> counter latch command for counter 2
E8H = 11101000 -> read-back command (8254 only)
5AH = 01011010 -> counter 1, LSB only, mode 5, binary

প্রথম তিনটি বাজারঘরের নকশার তিনটি control word: 34H, 54H, 0B6H. 0B6H আর 0B7H-এর পার্থক্য শুধু D0, binary বনাম BCD. 7EH-এ M = 111, তবু mode 3, কারণ M2 এখানে “X”. 80H কোনো mode লেখে না, counter 2-এর count আটকায়; আর 0E8H শুধু 8254 বোঝে, 8253-এ SC = 11 অবৈধ।

নিয়ম

Control word লেখামাত্র সেই counter-এর ভেতরের নিয়ন্ত্রণ-logic reset হয় আর OUT একটি জানা অবস্থায় যায়, কোনো CLK লাগে না: mode 0-এ নিচু, বাকি পাঁচ mode-এ উঁচু। Count না লেখা পর্যন্ত গোনা শুরু হয় না।

৪ · ছয়টি mode — OUT-এর ছয় রকম আচরণ

Mode ঠিক করে count শেষ হলে OUT কী করবে, গোনা নিজে আবার শুরু হবে কি না, আর GATE-এর ভূমিকা কী। প্রথমে ছবিতে সবগুলো একসাথে দেখুন। ছবিটি হাতে আঁকা নয়: এই পর্বের মডেলকে প্রতিটি mode-এ বারোটি CLK pulse চালিয়ে যে OUT পাওয়া গেছে, সরাসরি তা থেকে আঁকা।

ছবি ২৫.২ — ছয়টি mode-এ OUT-এর তরঙ্গ

Control word আর count লেখা হয়েছে CLK-এর ১ নম্বর pulse-এর ঠিক আগে; OUT বদলায় pulse-এর নামন্ত ধারে

8254-এর ছয়টি mode-এ OUT-এর তরঙ্গ CLK (count লেখা ১-এর আগে) 1 2 3 4 5 6 7 8 9 10 11 12 Mode 0 · N = 4 · TC-তে interrupt Mode 1 · N = 3 · one-shot GATE↑ Mode 2 · N = 4 · rate generator Mode 3 · N = 4 · square wave Mode 4 · N = 4 · software strobe Mode 5 · N = 3 · hardware strobe GATE↑
ছবি ২৫.২ — Mode 0-এ OUT নিচু থেকে N + 1 pulse পরে উঁচু হয়ে থাকে। Mode 1 আর 5 অপেক্ষা করে GATE-এর উঠন্ত ধারের (কমলা তীর) জন্য। Mode 2 প্রতি N pulse-এ একবার এক pulse নিচু হয়, mode 3 অর্ধেক সময় উঁচু আর অর্ধেক নিচু। Mode 4 আর 5 একবার এক pulse-এর জন্য নিচু হয় (strobe). মডেলটি Intel 8254 datasheet-এর Figure 15–20-এর সঙ্গে মিলিয়ে পরীক্ষিত।
Modeনামশুরু হয়OUTপুনরাবৃত্তিসর্বনিম্ন N
0interrupt on terminal countcount লিখলেনিচু, N + 1 pulse পরে উঁচু হয়ে থাকেনা1
1hardware retriggerable one-shotGATE-এর উঠন্ত ধারেtrigger-এর পরের pulse-এ নিচু, ঠিক N pulseআবার trigger দিলে1
2rate generatorcount লিখলে বা trigger-এউঁচু; প্রতি N pulse-এ এক pulse নিচুহ্যাঁ, নিজে2
3square wavecount লিখলে বা trigger-এN জোড় হলে N/2 উঁচু, N/2 নিচুহ্যাঁ, নিজে2
4software triggered strobecount লিখলেউঁচু; N + 1 pulse পরে এক pulse নিচুনা1
5hardware triggered strobeGATE-এর উঠন্ত ধারেউঁচু; trigger-এর N + 1 pulse পরে এক pulse নিচুআবার trigger দিলে1

প্রতিটি mode-এর একটি স্বাভাবিক কাজ আছে, datasheet নিজেই যা বলে দেয়। Mode 0 ঘটনা গোনা বা একবারের delay: N লিখুন, OUT-কে interrupt pin-এ জুড়ুন, N + 1 pulse পরে interrupt. Mode 1 একটি নির্দিষ্ট দৈর্ঘ্যের pulse: একটি sensor-এর সংকেত এলে ঠিক N clock ধরে একটি relay চালু রাখা; আবার সংকেত এলে সময় আবার গোড়া থেকে। Mode 2 একটি timer interrupt-এর নিয়মিত উৎস, মানে real-time clock. Mode 3 একটি নিয়মিত তরঙ্গ, যেমন buzzer-এর সুর বা baud rate clock (datasheet-এর ভাষায় mode 3 “typically used for Baud rate generation”). Mode 4 আর 5 একটি সরু strobe pulse, যা অন্য একটি chip-কে একটি নির্দিষ্ট মুহূর্তে data ধরতে বলে; mode 4-এ মুহূর্ত ঠিক করে software, mode 5-এ বাইরের একটি সংকেত।

বাজারঘরের দুটি device-এ প্রতিটি mode-এর একটি করে স্বাভাবিক জায়গা কল্পনা করা যায়; এগুলো নকশার উদাহরণ, কোর্সের lab-এর অংশ নয়। Smart scale প্রতি 100 ms-এ ওজন মাপে (README-র সংখ্যা): 2 MHz-এ সেটি 200 000 pulse, এক counter-এ ধরে না, কিন্তু 100 Hz-এর OUT0-কে clock ধরলে mode 2-এ N = 10. প্রতিটি মাপ শুরু করতে ADC-কে একটি সরু start pulse দেওয়া যায় mode 4-এ, software যখন চায়। Tare বোতাম চাপার পরে display-এর আলো 5 s জ্বলে থাকবে, আর আবার চাপলে সময় আবার গোড়া থেকে: এটি mode 1, 100 Hz clock-এ N = 500. দরজা কতবার খোলা হলো গুনে নির্দিষ্ট সংখ্যায় interrupt দেওয়া mode 0-এর কাজ, যা পরের অংশের প্রথম stepper-এ আছে।

নিচের ব্লক একই মডেল দিয়ে প্রতিটি pulse-এর পরে CE-এর নিচের byte আর OUT ছাপে, ঠিক datasheet-এর ছবির নিচের সংখ্যার সারির মতো। OUT-এর প্রথম অঙ্কটি count লেখার পরে, কোনো pulse-এর আগের অবস্থা; -- মানে CE-তে এখনো কিছু load হয়নি। মডেলটি পাতার নিচে pit8254.py নামে রাখা।

# ছয়টি mode, প্রতিটি CLK pulse-এ CE আর OUT (pit8254 = datasheet-এর মডেল)
from pit8254 import Counter
def trace(mode, n, trig=None, pulses=10):
    c = Counter()
    if trig: c.set_gate(0); c.trig = False      # mode 1, 5: GATE নিচে অপেক্ষা
    c.control(0x10 | mode << 1)                 # counter 0, LSB only, binary
    c.write(n)
    ce, out = [], [str(c.out)]
    for i in range(1, pulses + 1):
        if i == trig: c.set_gate(1)             # GATE-এর উঠন্ত ধার = trigger
        c.clk()
        s = c.show(); ce.append(s[2:] if s != "--" else "--")  # নিচের byte
        out.append(str(c.out))
    print(f"mode {mode} N={n}: CE " + " ".join(ce))
    print(f"            OUT {out[0]}|" + "".join(out[1:]))
trace(0, 4)
trace(1, 3, trig=3)
trace(2, 4)
trace(3, 4)
trace(3, 5)
trace(4, 4)
trace(5, 3, trig=3)

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

mode 0 N=4: CE 04 03 02 01 00 FF FE FD FC FB
            OUT 0|0000111111
mode 1 N=3: CE -- -- 03 02 01 00 FF FE FD FC
            OUT 1|1100011111
mode 2 N=4: CE 04 03 02 01 04 03 02 01 04 03
            OUT 1|1110111011
mode 3 N=4: CE 04 02 04 02 04 02 04 02 04 02
            OUT 1|1100110011
mode 3 N=5: CE 04 02 00 04 02 04 02 00 04 02
            OUT 1|1110011100
mode 4 N=4: CE 04 03 02 01 00 FF FE FD FC FB
            OUT 1|1111011111
mode 5 N=3: CE -- -- 03 02 01 00 FF FE FD FC
            OUT 1|1111101111

চারটি জিনিস মিলিয়ে নিন। এক, mode 0-এ প্রথম pulse-এ CE = 04, কমানো নয়, load; OUT উঁচু হয় ৫ নম্বর pulse-এ, মানে N + 1. তারপর counter থামে না, FF, FE ধরে ঘুরে চলে, কিন্তু OUT উঁচুই থাকে। দুই, mode 2-এ count কখনো 0 দেখায় না: 1-এ OUT নিচু, পরের pulse-এ আবার 04. তিন, mode 3-এ count দুই করে কমে। চার, mode 1 আর 5-এ trigger আসে ৩ নম্বর pulse-এর আগে; mode 1-এ OUT ঠিক তিন pulse নিচু (৩, ৪, ৫), mode 5-এ strobe আসে ৬ নম্বরে, trigger-এর পরে চতুর্থ pulse-এ, মানে N + 1.

৫ · Mode 0 আর mode 3 ধাপে ধাপে

পরীক্ষায় আর বাস্তবে সবচেয়ে বেশি আসে এই দুটি mode. প্রথমটি দিয়ে একবারের interrupt: ধরুন বাজারঘরের দরজার একটি sensor প্রতিবার দরজা খোলায় একটি pulse দেয়, সেটি CLK0-তে; চারবার খোলা হলে OUT0 উঁচু হয়ে RST 7.5-এ interrupt দেবে। Counter 0, শুধু LSB, mode 0, binary: 00 01 000 0 = 10H. Stepper-টি এক pulse করে এগিয়ে দেখুন।

1MVI A,10H2OUT 43H   ; CW3MVI A,04H4OUT 40H   ; N5CLK0 pulse ↓
Counter 0-এর অবস্থা
pulse
CR · CE
OUT0
NULL count
  1. Control word 10H. লেখামাত্র OUT0 = 0, কোনো CLK লাগে না। CR আর CE-তে কী আছে জানা নেই। NULL count = 1, অর্থাৎ নতুন count এখনো CE-তে পৌঁছায়নি।
  2. Count 04H. RW = 01, তাই একটি byte-ই পুরো count; CR = 0004. CE এখনো বদলায়নি, কারণ load হয় পরের CLK pulse-এ। (সত্যিকারের run-এ এই দুটি OUT নির্দেশের প্রতিটি ১০ T.)
  3. Pulse ১: load. CR থেকে CE-তে 0004; NULL = 0. এই pulse-এ কিছু কমে না। এটিই সেই বাড়তি এক pulse.
  4. Pulse ২. CE = 0003. GATE0 উঁচু, তাই গোনা চলছে; GATE নিচু হলে CE এখানেই থেমে থাকত, কিন্তু OUT বদলাত না।
  5. Pulse ৩. CE = 0002.
  6. Pulse ৪. CE = 0001. OUT এখনো নিচু।
  7. Pulse ৫: terminal count. CE = 0000, OUT0 উঁচু হয়। এই উঠন্ত ধার RST 7.5-এর latch-এ ধরা পড়ে, আর CPU ISR-এ যায় (পর্ব ১৩)। Count লেখা থেকে মোট N + 1 = ৫ pulse.
  8. Pulse ৬. CE ঘুরে FFFF হয় আর কমতেই থাকে, কিন্তু OUT উঁচু থাকে যতক্ষণ না নতুন count বা নতুন mode 0 control word লেখা হয়। আবার চারটি গুনতে ISR-কে নতুন করে 04H লিখতে হবে।

এবার mode 3. দুটি বিষয় এখানে বিশেষ: count দুই করে কমে, আর N বিজোড় হলে উঁচু অংশ এক pulse বেশি। Datasheet-এর বর্ণনা অনুযায়ী জোড় N-এ CE-তে N load হয়, প্রতি pulse-এ দুই কমে, শূন্যে পৌঁছালে OUT উল্টায় আর আবার N load হয়। বিজোড় N-এ load হয় N − 1, আর OUT উঁচু থাকা অবস্থায় শূন্যে পৌঁছালে এক pulse পরে OUT নিচু হয়। ফল: উঁচু (N + 1)/2, নিচু (N − 1)/2. N = 5 নিয়ে দেখুন, control word 16H (counter 0, শুধু LSB, mode 3).

Counter 0, mode 3, N = 5
pulse
CE
OUT0
উঁচু · নিচু গোনা
  1. প্রস্তুতি. Control word 16H লেখামাত্র OUT0 = 1. তারপর count 05H.
  2. Pulse ১: load. N বিজোড়, তাই CE-তে যায় N − 1 = 4. OUT উঁচু, উঁচু অংশের প্রথম pulse.
  3. Pulse ২. CE = 4 − 2 = 2.
  4. Pulse ৩. CE = 0, count শেষ। কিন্তু N বিজোড় আর OUT উঁচু, তাই OUT এখনই বদলায় না; এক pulse অপেক্ষা। উঁচু অংশ তিন pulse ছুঁয়েছে।
  5. Pulse ৪: OUT নিচু. এক pulse পরে OUT = 0, আর CE-তে আবার N − 1 = 4.
  6. Pulse ৫. CE = 2. নিচু অংশের দ্বিতীয় pulse.
  7. Pulse ৬: OUT উঁচু. CE শূন্যে পৌঁছায়, আর OUT নিচু ছিল বলে এবার কোনো অপেক্ষা নেই: সঙ্গে সঙ্গে OUT = 1 আর CE = 4. তাই নিচু অংশ মাত্র দুই pulse = (N − 1)/2.
  8. Pulse ৭. CE = 2. নতুন উঁচু অংশ।
  9. Pulse ৮. CE = 0, আবার এক pulse-এর অপেক্ষা।
  10. Pulse ৯. OUT নিচু, CE = 4. পূর্ণ এক পর্যায় (৪ থেকে ৯) = ৫ pulse = N.
  11. Pulse ১০. CE = 2. ক্রম চলতেই থাকে: উঁচু ৩, নিচু ২, period ৫. Count-এর সারি 4 2 0 4 2 4 2 0 4 2, ঠিক datasheet-এর Figure 18-এর মাঝের ছবির মতো।

জোড় N-এ ছবিটি সরল: N = 4 হলে সারি 4 2 4 2 …, দুই pulse উঁচু, দুই pulse নিচু। বড় N-এ একই নিয়ম। লেখকের lab-এ মডেলের দীর্ঘ পরীক্ষা: N = 2000-এ OUT নিচু হয় ১০০১ নম্বর pulse-এ, আবার উঁচু ২০০১-এ, period ২০০০; N = 2001-এ উঁচু ১০০১, নিচু ১০০০; N = 7-এ উঁচু ৪, নিচু ৩. বিজোড় N-এর duty cycle তাই পুরো ৫০ শতাংশ নয়, তবে বড় N-এ পার্থক্য নগণ্য।

৬ · GATE, count পড়া আর read-back

GATE pin-এর কাজ mode অনুযায়ী তিন রকম, আর পরীক্ষায় এর সারণিটি প্রায়ই চাওয়া হয়। Datasheet-এর “Gate Pin Operations Summary”:

ModeGATE নিচু বা নামছেGATE উঠছে (trigger)GATE উঁচু
0গোনা থামায়—গোনা চালায়
1—গোনা শুরু; পরের pulse-এ OUT নিচু—
2গোনা থামায়; OUT সঙ্গে সঙ্গে উঁচুগোনা নতুন করে শুরুগোনা চালায়
3গোনা থামায়; OUT সঙ্গে সঙ্গে উঁচুগোনা নতুন করে শুরুগোনা চালায়
4গোনা থামায়—গোনা চালায়
5—গোনা শুরু—

Mode 0, 2, 3, 4-এ GATE-এর level গুরুত্বপূর্ণ; mode 1, 2, 3, 5-এ উঠন্ত ধার। ধারটি একটি ভেতরের flip-flop-এ জমা হয়, যা পরের CLK-এর উঠন্ত ধারে দেখা হয়; তাই খুব ছোট trigger pulse-ও হারায় না। Mode 2 আর 3-এ দুটোই কাজ করে। বাজারঘরের buzzer এই নিয়মের সুবিধা নেয়: counter 2 সবসময় mode 3-এ 1 kHz-এ প্রস্তুত, আর alarm চালু-বন্ধ হয় শুধু GATE2 দিয়ে। GATE2 = 0 হলে OUT2 স্থির উঁচু, তাই একটি passive piezo buzzer-এ কোনো সুর নেই; GATE2 = 1 হলে পরের pulse-এ গোনা নতুন করে শুরু, সুর বাজে। CPU-কে বারবার timer প্রোগ্রাম করতে হয় না, একটি output port-এর একটি বিট বদলালেই হয়; সেই বিট আসতে পারে পর্ব ২৩-এর মতো একটি latch থেকে, বা পর্ব ২৪-এর 8255-এর port C-এর একটি বিট থেকে।

চলমান counter পড়ার তিনটি উপায় datasheet দেয়। প্রথম, সরাসরি পড়া; কিন্তু তখন GATE বা বাইরের logic দিয়ে CLK থামাতে হয়, নইলে পড়ার মাঝে count বদলে যেতে পারে। দ্বিতীয়, counter latch command: port 43H-এ SC আর RW = 00 লিখলে সেই মুহূর্তের count OL-এ আটকে যায়, গোনা থামে না; তারপর counter-এর port থেকে দুটি byte পড়া। তৃতীয়, শুধু 8254-এর read-back command: 11 COUNT̄ STATUS̄ CNT2 CNT1 CNT0 0. একটি command-এ একাধিক counter-এর count আর status একসাথে আটকানো যায়। Status byte-এর বিট: D7 OUT pin-এর অবস্থা, D6 NULL count, আর D5–D0 সেই counter-এর শেষ control word-এর নিচের ছয় বিট হুবহু।

# GATE দিয়ে buzzer চালু-বন্ধ, আর read-back-এর status byte (pit8254 = মডেল)
from pit8254 import Counter
buz = Counter()
buz.control(0xB6)                     # counter 2, LSB+MSB, mode 3, binary
print(f"status after CW   : {buz.status():02X}H")
buz.write(0x04); buz.write(0x00)      # ছোট N = 4, যাতে লাইন ছোট থাকে
print(f"status after count: {buz.status():02X}H  (NULL = 1)")
gate = {8: 0, 12: 1}                  # pulse 8-এর আগে GATE2 = 0, 12-এর আগে 1
line = ""
for i in range(1, 17):
    if i in gate: buz.set_gate(gate[i]); line += "|"
    buz.clk(); line += str(buz.out)
    if i == 1: print(f"status after load : {buz.status():02X}H  (NULL = 0)")
print("OUT2:", line)
def decode(st):
    m = (st >> 1) & 7
    return (f"OUT={st >> 7} NULL={(st >> 6) & 1} RW={(st >> 4) & 3:02b} "
            f"mode={m & 3 if m > 5 else m} BCD={st & 1}")
for st in (0xF6, 0xB6, 0x14, 0x94):
    print(f"{st:02X}H -> {decode(st)}")

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

status after CW   : F6H
status after count: F6H  (NULL = 1)
status after load : B6H  (NULL = 0)
OUT2: 1100110|1111|11001
F6H -> OUT=1 NULL=1 RW=11 mode=3 BCD=0
B6H -> OUT=1 NULL=0 RW=11 mode=3 BCD=0
14H -> OUT=0 NULL=0 RW=01 mode=2 BCD=0
94H -> OUT=1 NULL=0 RW=01 mode=2 BCD=0

0F6H = 1111 0110: OUT = 1, NULL = 1 (count লেখা হয়েছে কিন্তু এখনো CE-তে যায়নি), আর নিচের ছয় বিট 36H, অর্থাৎ control word 0B6H-এর নিচের ছয় বিট। প্রথম pulse-এ load হতেই NULL = 0, status 0B6H. OUT2-এর সারিতে প্রথম |-এর আগে সুর চলছে (১১০০১১০), সপ্তম pulse-এ OUT নিচু ছিল; GATE2 নামতেই OUT উঁচু হয়ে স্থির (১১১১), কোনো CLK লাগেনি। GATE2 উঠলে পরের pulse-এ নতুন করে load, আবার সুর। শেষ দুটি status একই mode 2 counter-এর: 14H-এ OUT নিচু, মানে ঠিক সেই এক pulse-এর মুহূর্ত; 94H-এ উঁচু।

সাবধান — দুই byte-এর ফাঁদ: RW = 11 হলে counter-এর ভেতরে একটি “এবার LSB না MSB” অবস্থা থাকে। Main program LSB লিখে ফেলেছে, এমন সময় একটি ISR একই counter-এ লিখলে বা পড়লে ক্রম গুলিয়ে যায়; datasheet স্পষ্ট বলে, প্রথম আর দ্বিতীয় byte-এর মাঝে একই counter ছোঁয় এমন routine-এ নিয়ন্ত্রণ দেওয়া চলবে না। সমাধান: দুই byte লেখার আগে DI, পরে EI, অথবা counter-টিকে শুধু একটি জায়গা থেকে ব্যবহার করা।

৭ · হিসাব — count, cascade আর বাজারঘরের timer

প্রায় সব timer-হিসাব একটি সূত্রে দাঁড়ায়। Input clock fin, এক pulse-এর সময় Tclk = 1 ÷ fin. Mode 2 বা 3-এ output-এর frequency fout = fin ÷ N, তাই N = fin ÷ fout. Mode 0-এ delay = (N + 1) × Tclk, আর mode 1-এ pulse-এর দৈর্ঘ্য N × Tclk. তারপর তিনটি পরীক্ষা: N পূর্ণসংখ্যা কি না, mode-এর সর্বনিম্ন (mode 2, 3-এ 2) থেকে বড় কি না, আর 65536 (BCD-তে 10000)-এর মধ্যে কি না। Buzzer-এর হিসাবটি stepper-এ:

1N = 2 000 000 ÷ 100022 ≤ N ≤ 65536 ?32000 = 07D0H4CW = 10 11 011 05MVI A,0B6H / OUT 43H6MVI A,0D0H / OUT 42H7MVI A,07H  / OUT 42H8OUT2 → buzzer
হিসাবের অবস্থা
N
CW
LSB · MSB
OUT log
  1. Count. N = fin ÷ fout = 2 000 000 Hz ÷ 1000 Hz = 2000. একক মিলিয়ে নিন: Hz ÷ Hz, তাই N একটি খাঁটি সংখ্যা।
  2. সীমা. Mode 3-এ N ≥ 2, আর ১৬-বিটে N ≤ 65536. 2000 আরামে ভেতরে; জোড় বলে duty cycle ঠিক ৫০ শতাংশ।
  3. Byte-এ ভাঙা. 2000 = 07D0H: LSB 0D0H, MSB 07H. BCD বেছে নিলে লিখতে হতো 00H আর 20H, কারণ BCD-তে 2000 = 2000H.
  4. Control word. SC = 10 (counter 2), RW = 11 (LSB তারপর MSB), M = 011 (mode 3), BCD = 0: 1011 0110 = 0B6H.
  5. Control port-এ লেখা. MVI A,0B6H, OUT 43H. বাজারঘরের পুরো init program-এ এটি পঞ্চম OUT, simulator-এর হিসাবে T = 102-এ শেষ।
  6. Count লেখা. Counter 2-এর port 42H-এ আগে 0D0H, পরে 07H, T = 119 আর 136-এ। ক্রম উল্টালে count হয়ে যায় 0D007H (অনুশীলন ২)।
  7. ফল. পরের CLK pulse-এ load; তারপর ১০০০ pulse উঁচু, ১০০০ pulse নিচু। প্রতিটি pulse 0.5 µs, তাই উঁচু 500 µs, নিচু 500 µs, period 1 ms = 1 kHz. মডেলে OUT2 নিচু হয় ১০০১ নম্বর pulse-এ, উঁচু ২০০১-এ।

এবার 1 s-এর tick. N = 2 000 000 ÷ 1 = 2 000 000, যা 65536-এর অনেক ওপরে। একটি counter-এ 2 MHz থেকে সবচেয়ে ধীর output হলো 2 000 000 ÷ 65536 ≈ 30.5 Hz, অর্থাৎ সর্বোচ্চ period 65536 × 0.5 µs = 32.768 ms. সমাধান cascaded counters: OUT0-কে CLK1-এ জোড়া, যাতে দুটি N গুণ হয়। আমাদের বাছাই N0 = 20000 (প্রতি 10 ms) আর N1 = 100: 20000 × 100 = 2 000 000. Counter 0 mode 2-এ, কারণ পরের counter-এর clock হিসেবে প্রতি period-এ ঠিক একটি পরিষ্কার pulse দরকার; counter 1-ও mode 2-এ, যার OUT1 প্রতি সেকেন্ডে একবার এক pulse (10 ms) নিচু হয়, আর সেই pulse শেষের উঠন্ত ধার RST 7.5-এর edge-triggered interrupt. Counter 1-এর count 100 এক byte-এ ধরে, তাই RW = 01: control word 54H. লেখকের lab-এ মডেলে দুই counter একসাথে চার মিলিয়ন pulse চালানো হয়েছে: OUT1 নিচু হয় ২০ লাখতম pulse-এ (1.000 s), উঠে যায় ২০ লাখ ২০ হাজারতম-এ (1.010 s), আবার নিচু ৪০ লাখতম-এ; period ঠিক 1 s.

পুরো init program, reference lab-এর simulator-এ সত্যিকারের run (pit_init.asm, Python 3.13.5; listing-এর মন্তব্যের লাইন বাদ):

~/lab$ python -B sim8085.py asm pit_init.asm
      = 0043       5  CW      EQU 43H
2000               6          ORG 2000H
2000  3E 34        7  START:  MVI A,34H
2002  D3 43        8          OUT CW
2004  3E 20        9          MVI A,20H
2006  D3 40       10          OUT 40H
2008  3E 4E       11          MVI A,4EH
200A  D3 40       12          OUT 40H
200C  3E 54       13          MVI A,54H
200E  D3 43       14          OUT CW
2010  3E 64       15          MVI A,64H
2012  D3 41       16          OUT 41H
2014  3E B6       17          MVI A,0B6H
2016  D3 43       18          OUT CW
2018  3E D0       19          MVI A,0D0H
201A  D3 42       20          OUT 42H
201C  3E 07       21          MVI A,07H
201E  D3 42       22          OUT 42H
2020  76          23          HLT
~/lab$ python -B sim8085.py run pit_init.asm
A=07 B=00 C=00 D=00 E=00 H=00 L=00 SP=0000 PC=2021
Flags: S=0 Z=0 AC=0 P=0 CY=0   (F=00H)
OUT port 43H <- 34H  (at T=17)
OUT port 40H <- 20H  (at T=34)
OUT port 40H <- 4EH  (at T=51)
OUT port 43H <- 54H  (at T=68)
OUT port 41H <- 64H  (at T=85)
OUT port 43H <- B6H  (at T=102)
OUT port 42H <- D0H  (at T=119)
OUT port 42H <- 07H  (at T=136)
Instructions: 17   T-states: 141

OUT-এর opcode D3, তার পরে port-এর এক byte; প্রতিটি MVI ৭ T আর OUT ১০ T (Spec decision 2), তাই প্রতি জোড়া ১৭ T. পুরো timer চালু করতে CPU-র খরচ ১৪১ T = 47 µs, একবারই। তুলনায় অংশ ১-এর software loop শুধু 10 ms-এর জন্য 30012 T নিয়েছিল। নিচের ব্লক একই program পাতার ভেতরের 8085 simulator-এ (sim85.py, reference-এর sim8085.py-র কপি, শুধু command line অংশ বাদ) চালায়, তারপর OUT log-এর প্রতিটি byte port অনুযায়ী তিনটি counter-মডেলে পাঠায়: A1 A0 = port-এর নিচের দুই বিট।

# 8085-এর program -> OUT log -> 8254-এর তিনটি counter (sim85 = sim8085.py, pit8254 = মডেল)
from sim85 import assemble, run
from pit8254 import Counter
# (byte, port) জোড়া, ঠিক pit_init.asm-এর ক্রমে: প্রতিটি থেকে MVI A আর OUT
PAIRS = [(0x34, 0x43), (0x20, 0x40), (0x4E, 0x40),    # counter 0: mode 2, 4E20H
         (0x54, 0x43), (0x64, 0x41),                  # counter 1: mode 2, 64H
         (0xB6, 0x43), (0xD0, 0x42), (0x07, 0x42)]    # counter 2: mode 3, 07D0H
SRC = "ORG 2000H\n" + "".join(f"MVI A,0{v:02X}H\nOUT {p:02X}H\n" for v, p in PAIRS) + "HLT"
cpu = run(assemble(SRC))
pit = [Counter(), Counter(), Counter()]
for t, port, v in cpu.out_log:                  # port 40H-43H: A1 A0 = port & 3
    sel = port & 3
    if sel == 3: pit[v >> 6].control(v)
    else: pit[sel].write(v)
    print(f"T={t:3}  OUT {port:02X}H <- {v:02X}H")
print("instructions", cpu.steps, " T-states", cpu.tstates)
def edges(c, pulses):                           # pulse numbers where OUT changes
    e, prev = [], c.out
    for i in range(1, pulses + 1):
        c.clk()
        if c.out != prev: e.append(i); prev = c.out
    return e
print("counter 0 N =", pit[0].n(), " OUT edges:", edges(pit[0], 40001))
print("counter 1 N =", pit[1].n(), " OUT edges:", edges(pit[1], 201))
print("counter 2 N =", pit[2].n(), " OUT edges:", edges(pit[2], 4001))
f = 2_000_000
print(f"tick = {f / 20000 / 100} Hz, buzzer = {f / 2000:.0f} Hz")

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

T= 17  OUT 43H <- 34H
T= 34  OUT 40H <- 20H
T= 51  OUT 40H <- 4EH
T= 68  OUT 43H <- 54H
T= 85  OUT 41H <- 64H
T=102  OUT 43H <- B6H
T=119  OUT 42H <- D0H
T=136  OUT 42H <- 07H
instructions 17  T-states 141
counter 0 N = 20000  OUT edges: [20000, 20001, 40000, 40001]
counter 1 N = 100  OUT edges: [100, 101, 200, 201]
counter 2 N = 2000  OUT edges: [1001, 2001, 3001, 4001]
tick = 1.0 Hz, buzzer = 1000 Hz

OUT log আর মোট ১৪১ T ওপরের lab run-এর সঙ্গে অক্ষরে অক্ষরে এক। Counter 0 নিচু হয় ঠিক ২০০০০তম pulse-এ (mode 2: count লেখার N pulse পরে) আর এক pulse পরেই উঁচু: প্রতি 10 ms-এ একটি সরু pulse. Counter 1-কে এখানে আলাদা করে ২০১টি pulse দেওয়া হয়েছে, যেন প্রতিটি OUT0-এর একটি pulse; তার নিচু অংশ ১০০ আর ২০০ নম্বরে, অর্থাৎ প্রতি ১০০ × 10 ms = 1 s. তৃতীয় সারি stepper-এর ১০০১ আর ২০০১. মনে রাখুন: OUT log সত্যিকারের simulator-এর, counter-এর সাড়া এই পর্বের মডেলের।

এবার tick-এর অন্য প্রান্ত: CPU. OUT1-এর প্রতিটি উঠন্ত ধার RST 7.5 দেয়; ISR cold room-এর sensor-এর একটি byte পড়ে (এখানে সরলীকৃত একটি input port 02H, যা দেয় 70H), আর একটি গণক দিয়ে দশটি tick গুনে telemetry-র গণক বাড়ায়: README-র নির্দিষ্ট সংখ্যা, প্রতি 1 s-এ এক reading আর প্রতি 10 s-এ telemetry. Main program শুধু HLT-এ ঘুমায়। Simulator-এ বারোটি RST 7.5 দেওয়া হয়েছে ঠিক সেই মুহূর্তে, যখন মডেলে OUT1 ওঠে: 1.010 s, 2.010 s, …, যা 3 MHz-এ T = 3 030 000, 6 030 000, …; CPU থেমে থাকলে simulator-এর ঘড়ি সরাসরি পরের ঘটনায় লাফ দেয় (Spec decision 8). সত্যিকারের run (tick.asm; trace থেকে দুটি tick, register অংশ ছাঁটা):

~/lab$ python -B sim8085.py run tick.asm
A=0B B=00 C=00 D=00 E=00 H=00 L=00 SP=2800 PC=2008
Flags: S=0 Z=0 AC=0 P=0 CY=0   (F=00H)
Memory 2060H..2063H:
  2060H: 02 00 01 70
Instructions: 177   T-states: 36030143
~/lab$ python -B sim8085.py trace tick.asm
...
---- interrupt RST7.5 acknowledged -> vector 003CH (12 T)  total=3030012
003C  C3 0B 20  JMP 200BH      ...  total=3030022
200B  F5        PUSH PSW       ...  total=3030034
200C  DB 02     IN 02H         ...  total=3030044
 ... (STA, LDA, INR, CPI 0AH, JNZ, STA, POP PSW, EI)
2027  C9        RET            ...  total=3030128
2008  C3 07 20  JMP 2007H      ...  total=3030138
2007  76        HLT            ...  total=3030143
...
---- interrupt RST7.5 acknowledged -> vector 003CH (12 T)  total=30030012
 ... (দশম tick: JNZ পড়ে না, telemetry-র গণক 2062H বাড়ে, XRA A)
2027  C9        RET            ...  total=30030159

সাধারণ একটি tick-এ ঘটনা থেকে RET পর্যন্ত ১২৮ T, দশম tick-এ ১৫৯ T; সঙ্গে JMP WAIT আর HLT-এর ১৫ T. অর্থাৎ প্রতি সেকেন্ডের 3 000 000 T-এর মধ্যে CPU কাজ করে ১৫০-এর মতো T, বাকি সময় ঘুমিয়ে। বারো সেকেন্ডে মোট ১৭৭টি নির্দেশ; শেষে 2060H = 02 (দশের পরে আরও দুটি tick), 2062H = 01 (একবার telemetry), আর 2063H-এ শেষ reading 70H জমা আছে। অংশ ১-এর loop শুধু 10 ms-এর জন্য ৫০০২টি নির্দেশ চালিয়েছিল। ISR-এর গঠন, PUSH PSW থেকে EI আর RET পর্যন্ত, পর্ব ১৩-এর নিয়মেই।

কোর্সের ভার্চুয়াল বাজারঘর board-এ, যা বাস্তব Cortex-M chip-এর আদলে বানানো একটি শিক্ষণ-মডেল, একই কাজ করে SysTick: LOAD = 79 999, period = LOAD + 1 = 80 000 cycle = 10 ms at 8 MHz, আর ১০০ tick-এ 1 s (Spec decision 22). পার্থক্যটি লক্ষ করুন: SysTick-এ period LOAD + 1, 8254-এর mode 2-এ period ঠিক N. দুই chip-এর সূত্র গুলিয়ে ফেলা খুব সাধারণ ভুল।

8086 থেকে একই buzzer চালু করার কোড আরও ছোট, কারণ AX-এ পুরো ১৬-বিট count একবারে রাখা যায়। Reference lab-এর run8086.py-তে সত্যিকারের run (NASM 3.02, Unicorn 2.1.4; trace-এর register অংশ ছাঁটা):

~/lab$ python -B run8086.py pit86.asm --bin
bytes (14): B0 B6 E6 43 B8 D0 07 E6 42 88 E0 E6 42 C3
~/lab$ python -B run8086.py pit86.asm --trace
1000:0100  B0B6     mov al,0xb6         AX=00B6
1000:0102  E643     out byte 0x43,al    AX=00B6
1000:0104  B8D007   mov ax,0x7d0        AX=07D0
1000:0107  E642     out byte 0x42,al    AX=07D0
1000:0109  88E0     mov al,ah           AX=0707
1000:010B  E642     out byte 0x42,al    AX=0707
1000:010D  C3       ret                 AX=0707

Source-এ নির্দেশগুলো mov al,0B6h, out 43h,al, mov ax,2000, out 42h,al, mov al,ah, out 42h,al. প্রথম out-এ AL = 0B6H, দ্বিতীয়তে 0D0H, তৃতীয়তে 07H: 8085-এর মতোই তিনটি byte, একই ক্রমে। run8086.py-তে কোনো I/O যন্ত্র নেই, তাই out-এর byte কোথাও যায় না; trace থেকে AL দেখে মেলাতে হয়। 8086-এর পুরো interrupt-ব্যবস্থা পর্ব ২০-এ।

৮ · 8253 বনাম 8254, আর আজকের microcontroller timer

বিষয়82538254
Counter, mode, pin৩টি ১৬-বিট, mode 0–5, ২৪ pinএকই, একই pin-বিন্যাস
সর্বোচ্চ CLK2.6 MHz8 MHz (8254), 10 MHz (8254-2)
Read-back commandনেই (SC = 11 অবৈধ)আছে: count আর status একসাথে
Status byte (OUT, NULL count)নেইআছে
প্রযুক্তিNMOSHMOS (datasheet অনুযায়ী)

সবচেয়ে বিখ্যাত ব্যবহার ১৯৮১-র IBM PC: সেখানে 8253-এর তিনটি counter-এর clock ছিল প্রায় 1.19318 MHz (একটি 14.31818 MHz crystal-কে ১২ দিয়ে ভাগ), port 40h–43h. Counter 0 দিত system timer-এর IRQ 0, count 0 অর্থাৎ 65536-এ প্রায় 18.2 Hz; counter 1 DRAM refresh-এর সংকেত; আর counter 2 PC speaker-এর সুর, যার জন্য BIOS যে control word লিখত, তা আমাদের buzzer-এর মতোই 0B6H. আজকের PC-তে আলাদা 8254 chip নেই, কিন্তু অনেক chipset একই port-এ এর সামঞ্জস্যপূর্ণ রূপ রেখে দেয়, পুরোনো software-এর জন্য। Intel-এর বর্তমান processor datasheet-এও “8254 Timers” নামে একটি অংশ পাওয়া যায়।

আধুনিক microcontroller-এর timer এই ধারণাগুলোরই বড় রূপ। একটি prescaler আগে input clock ভাগ করে, যাতে ১৬-বিটেও দীর্ঘ সময় মাপা যায়; এটি আমাদের দুই-counter cascade-এর কাজ একটি chip-এর ভেতরে করে। Auto-reload বা update event mode 2-এর মতো নিয়মিত interrupt দেয়, compare-এ pin toggle mode 3-এর মতো square wave, আর one-pulse mode হলো mode 1-এর উত্তরসূরি। সঙ্গে নতুন দুটি কাজ: input capture (একটি ঘটনার মুহূর্তের count ধরে রাখা) আর PWM. এগুলোর পুরো আলোচনা মডিউল ৭-এর পর্ব ৪৪ (Timer আর counter — prescaler, overflow, input capture আর output compare) আর পর্ব ৪৫ (PWM)-এ। Counter আর flip-flop-এর gate-স্তরের নকশা দেখতে Computer Architecture পর্ব ১৬.

আরও গভীরে: Datasheet-এর একটি সূক্ষ্ম সতর্কতা: mode 2 আর 3-এ terminal count-এর ঠিক এক CLK আগে GATE বদলানো উচিত নয়, কারণ তখন reload আর trigger একই মুহূর্তে লড়ে। আরেকটি: mode 1 আর 5-এ trigger প্রতিটি CLK-এর উঠন্ত ধারে দেখা হয়, আর সেই ধারের 120 ns-এর (8254-2-এ 70 ns) মধ্যে দ্বিতীয় trigger এলে তা ধরা না-ও পড়তে পারে। Count পড়ার সমস্যাটি আজও আছে: একটি ৩২-বিট timer-কে দুই ধাপে পড়া বা ভিন্ন clock domain থেকে পড়া হলে একই “ছেঁড়া মান” ঝুঁকি, তাই আধুনিক chip-এও latch বা “দুবার পড়ে মেলানো” কৌশল লাগে। Wikipedia-র 8253 নিবন্ধ জানায় যে 8253-এ পড়া আর লেখার LSB/MSB ক্রম একটিই ভেতরের বিটে চলত, 8254-এ দুটি আলাদা; এটি আমরা Intel-এর মূল 8253 datasheet থেকে মিলিয়ে দেখতে পারিনি, তাই সতর্কভাবে উল্লেখ করছি।

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

  • Counter 1, LSB তারপর MSB, mode 3, binary-র control word? 01 11 011 0 = 76H.
  • CLK 1.5 MHz, 1 kHz square wave-এর count? 1 500 000 ÷ 1000 = 1500 = 05DCH.
  • 2 MHz-এ এক counter-এর সর্বোচ্চ delay? 65536 × 0.5 µs = 32.768 ms; এর বেশি হলে cascade.
  • Mode 2 আর mode 3-এর পার্থক্য? দুটিই period N; mode 2-এ প্রতি period-এ এক pulse নিচু, mode 3-এ প্রায় অর্ধেক নিচু।
  • 8254-এ কিন্তু 8253-এ নেই? Read-back command আর status byte, আর বেশি clock (8/10 MHz বনাম 2.6 MHz).

৯ · AI-এর যুগে 8253/8254-এর হিসাব যাচাই

Timer-এর প্রশ্নে AI assistant-এর উত্তর প্রায়ই আত্মবিশ্বাসী আর প্রায় ঠিক, যা সবচেয়ে বিপজ্জনক। কারণ সে বহু chip-এর timer একসাথে শিখেছে: SysTick-এর LOAD = N − 1, AVR-এর prescaler, PC-র 8254, সবকিছু মিশে যায়। কয়েকটি পরিচিত ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
Control word-এর বিটের ক্রম উল্টায় বা RW আর M-এর জায়গা বদলায়বিট ধরে নিজে লিখে decoder-এ মেলান; 0B6H = counter 2, mode 3
MSB আগে লেখে, বা RW = 11 দিয়ে একটিই byte লেখেSimulator-এর OUT log-এ byte-এর ক্রম আর সংখ্যা গুনুন
SysTick-এর অভ্যাসে N − 1 লেখে, বা mode 0-এর N + 1 ভুলে যায়Datasheet-এর mode-বর্ণনা; মডেলে pulse গুনে দেখুন
65536-এর বেশি count এক counter-এ বসায়, বা mode 3-এ N = 1 দেয়সীমা: 2 ≤ N ≤ 65536 (mode 2, 3); count 0 = 65536
8253-এ read-back বা 8 MHz clock দাবি করে8253: 2.6 MHz, read-back নেই; 8254-এর datasheet দেখুন
Control word পাঠায় counter-এর port-এ, বা 8085-এ OUT DX-এর মতো 8086-এর রূপ লেখেA1 A0 = 11 শুধু control; 8085-এ শুধু OUT port, simulator-এ assemble করুন

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

আমি Intel 8085 assembly লিখছি, সঙ্গে Intel 8254 timer, port 40H–43H (43H control). CLK0 = 2 MHz. ১. Counter 0-কে 5 kHz square wave-এ চালাও। N কত, control word-এর প্রতিটি বিট (SC, RW, M, BCD) আলাদা করে ব্যাখ্যা করো। ২. পুরো program লেখো, Intel mnemonic আর 2050H ধরনের সংখ্যায়; LSB আগে না MSB আগে, কেন, বলো। ৩. OUT কতগুলো CLK pulse উঁচু আর কতগুলো নিচু থাকবে, হিসাব দেখাও। ৪. 8253 আর 8254-এর মধ্যে কোনো পার্থক্য এখানে গুরুত্বপূর্ণ হলে বলো। কোনো সংখ্যা নিয়ে নিশ্চিত না হলে অনুমান কোরো না, বলো।

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

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

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

প্র ০১Software delay loop তো বিনা খরচে পাওয়া যায়। তাহলে 1970-80-এর দশকের নকশাকারীরা আলাদা একটি timer chip বসাতেন কেন? আজ কখন loop-ই যথেষ্ট?

Delay loop-এর আসল খরচ টাকায় নয়, CPU-র সময়ে আর নির্ভরযোগ্যতায়। অংশ ১-এর সংখ্যাগুলো আবার দেখুন: 10 ms অপেক্ষায় ৫০০২টি নির্দেশ, 30012 T-state. এই সময়ে CPU একটি key-ও পড়তে পারে না, display-ও হালনাগাদ করতে পারে না। তার চেয়েও বড় সমস্যা হলো সময়ের সঠিকতা। Loop-এর হিসাব ধরে নেয় যে প্রতিটি নির্দেশ ঠিক নির্দিষ্ট T-state নেবে আর মাঝে কিছু ঘটবে না। একটি interrupt এলেই ISR-এর সময় loop-এর সময়ে যোগ হয়; DMA bus নিলে CPU দাঁড়িয়ে থাকে; আর memory ধীর হলে wait state যোগ হয়। ফলে একটি “এক সেকেন্ডের” loop দিনে কয়েক মিনিট পিছিয়ে যেতে পারে, অথচ বাজারঘরের cold room-এর মতো কাজে প্রতি সেকেন্ডের reading আর প্রতি দশ সেকেন্ডের telemetry ঠিক সময়ে চাই।

Timer chip এই দুটি সমস্যা একসাথে মেটায়। গোনা চলে একটি স্বাধীন crystal-চালিত clock-এ, CPU-র ব্যস্ততার ওপর নির্ভর না করে; ISR দেরিতে চললেও পরের tick ঠিক সময়েই আসে, কারণ mode 2 নিজে থেকে reload হয়। আর CPU-র খরচ শুধু একবার ১৪১ T-state-এর প্রোগ্রামিং, তারপর প্রতি tick-এ একটি ছোট ISR. একটি chip-এ তিনটি counter থাকায় একই board-এ real-time clock, একটি baud rate আর একটি সুর একসাথে চলে। IBM PC ঠিক এই তিনটি কাজই একটি 8253 দিয়ে করত: system timer, DRAM refresh আর speaker.

তবু loop আজও টিকে আছে, যেখানে সময় খুব ছোট আর একবারের। একটি LCD-কে command দেওয়ার পরে কয়েক মাইক্রোসেকেন্ড অপেক্ষা, বা একটি sensor-এর reset-এর পরে ছোট বিরতি: এখানে timer প্রোগ্রাম করার খরচই অপেক্ষার চেয়ে বেশি। কিন্তু নিয়ম স্পষ্ট: সময় দীর্ঘ হলে, বারবার হলে, বা সঠিকতা জরুরি হলে hardware timer; আর loop-এর সময় নির্ভর করে clock আর compiler-এর ওপর, তাই আধুনিক C firmware-এ loop-এর সংখ্যা প্রায়ই optimizer বদলে দেয়।

মূল উপলব্ধি: সময় মাপার দায়িত্ব CPU থেকে একটি স্বাধীন counter-এ সরালে CPU মুক্ত হয় আর সময় নির্ভুল হয়; loop শুধু ছোট, একবারের অপেক্ষার জন্য।

প্র ০২Mode 3-এ counter দুই করে কমে, আর বিজোড় N-এ উঁচু অংশ এক pulse বেশি। Intel এমন জটিল নকশা কেন বেছে নিল? এর ফল baud rate বা সুরের ওপর কী?

Square wave-এর লক্ষ্য হলো N pulse-এর period-এর প্রায় অর্ধেক উঁচু আর অর্ধেক নিচু রাখা। সবচেয়ে সরল চিন্তা হতো দুটি আলাদা count রাখা: N/2 উঁচু, N/2 নিচু। কিন্তু তাতে chip-এর ভেতরে আরেকটি ১৬-বিট register বা একটি ভাগের circuit লাগত, আর বিজোড় N-এ N/2 পূর্ণসংখ্যাই নয়। Intel-এর সমাধান মার্জিত: একই counter, একই N, শুধু প্রতি pulse-এ এক না কমিয়ে দুই কমানো। তাহলে N থেকে শূন্যে পৌঁছাতে লাগে N/2 pulse, অর্থাৎ ঠিক অর্ধেক period; শূন্যে OUT উল্টে আবার N load করলে বাকি অর্ধেক। কোনো বাড়তি register নেই, শুধু কমানোর ধাপ বদল।

বিজোড় N-এ সমস্যা হলো দুই করে কমিয়ে বিজোড় সংখ্যা থেকে শূন্যে পৌঁছানো যায় না। তাই chip load করে N − 1 (জোড়), আর একটি অংশে এক pulse বাড়তি অপেক্ষা যোগ করে: OUT উঁচু থাকা অবস্থায় count শেষ হলে এক pulse পরে OUT নামে। ফল উঁচু (N + 1)/2, নিচু (N − 1)/2, মোট ঠিক N. এই পর্বের stepper-এ N = 5-এ ৩ আর ২ দেখা গেছে, আর মডেলে N = 2001-এ ১০০১ আর ১০০০. Period সবসময় নিখুঁত N, শুধু duty cycle সামান্য অসম।

এর ব্যবহারিক ফল কম, কারণ যারা mode 3 ব্যবহার করে তারা প্রায় সবসময় তরঙ্গের ধার বা frequency ব্যবহার করে। একটি USART (যেমন পর্ব ২৭-এর 8251) baud clock-এর ধার গুনে বিট-এর মাঝখান খোঁজে; তার কাছে period গুরুত্বপূর্ণ, duty নয়। Buzzer-এর সুরের উচ্চতাও ঠিক করে frequency; ৫০.০৫ শতাংশ duty কানে ধরা পড়ে না। ছোট N-এ পার্থক্য বড়: N = 3-এ উঁচু ২, নিচু ১, মানে duty প্রায় ৬৭ শতাংশ। তাই বিশেষ নিখুঁত duty চাইলে নকশাকারী জোড় N বেছে নেন, যেমন আমরা buzzer-এ 2000 নিয়েছি।

মূল উপলব্ধি: দুই করে কমানো একটি register বাঁচানোর কৌশল; period সবসময় N থাকে, আর বিজোড় N-এর এক pulse-এর অসমতা বেশিরভাগ ব্যবহারে অপ্রাসঙ্গিক।

প্র ০৩একটি চলমান ১৬-বিট counter-কে ৮-বিটের bus দিয়ে পড়া কেন বিপজ্জনক? 8253-এর counter latch আর 8254-এর read-back কীভাবে সমস্যাটি সামলায়?

ধরুন counter-এর মান এখন 0100H, আর প্রতি 0.5 µs-এ কমছে। CPU আগে LSB পড়ল: 00H. দুটি IN-এর মাঝখানে counter এক কমে 00FFH হলো; তারপর MSB পড়ল: 00H. CPU-র হাতে এল 0000H, যা কখনো একসাথে counter-এ ছিল না। উল্টো দিকেও হতে পারে, LSB FFH আর পুরোনো MSB মিলে একটি বিশাল ভুল মান। এই “ছেঁড়া পড়া” (torn read) প্রতিটি যন্ত্রে ঘটে যেখানে মানের প্রস্থ bus-এর প্রস্থের চেয়ে বড় আর মান পড়ার সময় বদলায়।

প্রথম সমাধান CLK থামানো: GATE দিয়ে (যে mode-এ GATE গোনা থামায়) বা বাইরের logic দিয়ে। তাতে মান স্থির থাকে, কিন্তু সময় মাপাই তো উদ্দেশ্য; থামালে সময় হারায়। দ্বিতীয় সমাধান counter latch command, যা 8253-তেও ছিল: control port-এ RW = 00 লিখলে সেই মুহূর্তের পুরো ১৬-বিট মান OL-এ একসাথে আটকে যায়, CE গুনতেই থাকে। CPU তারপর ধীরেসুস্থে দুটি byte পড়ে; দ্বিতীয় byte পড়া শেষ হলে latch নিজে খুলে যায়। Datasheet আরও বলে, পড়ার আগে আবার latch দিলে দ্বিতীয়টি উপেক্ষিত হয়, তাই প্রথম মুহূর্তের মানই আসে।

8254 আরও দুই ধাপ এগোয়। Read-back একটি command-এ একাধিক counter একসাথে আটকায়, তাই তিনটি counter-এর মান একই মুহূর্তের, যা দুটি ঘটনার সময়-পার্থক্য মাপতে জরুরি। আর status byte জানায় OUT এখন কী আর NULL count: নতুন লেখা count এখনো CE-তে যায়নি, এমন অবস্থায় পড়া মান পুরোনো। এই পর্বের ব্লকে 0F6H থেকে 0B6H-এ বদল ঠিক এটাই দেখিয়েছে। আজকের microcontroller-এ একই সমস্যা ৩২-বিট timer আর ৬৪-বিট time counter-এ ফিরে আসে; সমাধানও একই পরিবারের: hardware latch, বা উঁচু অংশ দুবার পড়ে মাঝের নিচু অংশ যাচাই।

মূল উপলব্ধি: বদলাতে থাকা মান কয়েক টুকরোয় পড়তে হলে আগে একটি মুহূর্তে পুরোটা আটকাতে হয়; counter latch আর read-back এই নীতির hardware রূপ।

প্র ০৪IBM PC-তে 8253-এর clock প্রায় 1.19318 MHz, আর system timer 18.2 Hz-এর মতো অদ্ভুত সংখ্যা। এই সংখ্যাগুলো কোথা থেকে এল, আর এর উত্তরাধিকার কী?

১৯৮১-র IBM PC-র সব clock একটি 14.31818 MHz crystal থেকে আসত। এই সংখ্যাটি NTSC রঙিন টেলিভিশনের color burst frequency (প্রায় 3.579545 MHz)-এর চার গুণ, কারণ তখন computer-কে সাধারণ টেলিভিশনেও ছবি দেখাতে হতো, আর এই crystal সস্তায় প্রচুর পাওয়া যেত। Crystal-কে ৩ দিয়ে ভাগ করে 4.77 MHz CPU clock, আর ১২ দিয়ে ভাগ করে প্রায় 1.19318 MHz timer clock; শেষেরটি 8253-এর 2.6 MHz সীমার ভেতরে আরামে বসে।

Counter 0-এ BIOS count 0 লিখত, অর্থাৎ সবচেয়ে বড় count 65536. তাহলে 1 193 182 ÷ 65536 ≈ 18.2 Hz, প্রতি প্রায় 54.9 ms-এ একটি interrupt. সংখ্যাটি গোল নয়, কারণ লক্ষ্য গোল সংখ্যা ছিল না, বরং সবচেয়ে কম interrupt-এ দিনের সময় রাখা; DOS এই tick গুনে ঘড়ি চালাত। Counter 1 প্রতি কয়েক মাইক্রোসেকেন্ডে DRAM refresh-এর অনুরোধ দিত (পর্ব ২৭-এর 8237 DMA-র মাধ্যমে), আর counter 2 mode 3-এ speaker-এর সুর; একটি port-এর বিট দিয়ে GATE2 আর speaker-এর সংযোগ নিয়ন্ত্রণ হতো, ঠিক আমাদের buzzer-এর GATE2-এর মতো ধারণা।

এই নকশার উত্তরাধিকার আশ্চর্য রকম দীর্ঘ। PC-সামঞ্জস্যপূর্ণ computer-এ বহু বছর ধরে port 40h–43h-এ একটি 8254-সামঞ্জস্যপূর্ণ timer রাখা হয়েছে, কারণ পুরোনো software সেখানে লিখত; আধুনিক operating system বেশিরভাগ সময় local APIC timer বা HPET-এর মতো নতুন timer ব্যবহার করে, কিন্তু PIT অনেক chipset-এ এখনো আছে, আর virtual machine-গুলো একে emulate করে। Intel-এর বর্তমান একটি processor datasheet-এও “8254 Timers” শিরোনামের অংশ পাওয়া যায়। একটি ১৯৮০-র chip-এর register-বিন্যাস আজও শেখা কাজের, এটি তার একটি বড় কারণ।

মূল উপলব্ধি: Timer-এর সংখ্যা আসে crystal থেকে ভাগের শৃঙ্খলে; আর একবার software একটি hardware interface-এ নির্ভর করলে সেই interface কয়েক দশক টিকে যায়।

প্র ০৫8254-এর ছয়টি mode আজকের microcontroller timer-এ কোথায় গেল? বাজারঘরের cold room যদি আজ একটি Cortex-M chip-এ বানাই, কী বদলাবে আর কী একই থাকবে?

Mode-গুলো হারায়নি, ভেঙে ছোট ছোট সুইচ হয়েছে। STM32-এর মতো chip-এর একটি সাধারণ timer-এ থাকে একটি prescaler, একটি counter যা ওপরে বা নিচে গোনে, একটি auto-reload register, আর কয়েকটি compare/capture channel. Auto-reload-এ পৌঁছালে update interrupt: এটি mode 2-এর নিয়মিত tick. Compare-এ pin toggle করলে square wave: mode 3. Compare-এর মান বদলে duty ঠিক করা: PWM, যা 8254-এ সরাসরি ছিল না। One-pulse mode আর trigger input মিলে mode 1 আর 5-এর কাজ। আর input capture একটি বাইরের ঘটনার মুহূর্তে count ধরে রাখে, অনেকটা read-back-এর latch-এর মতো, কিন্তু ঘটনাটিই latch চালায়।

যা একই থাকে তা হলো হিসাবের যুক্তি। fout = fin ÷ (prescaler × count), পূর্ণসংখ্যা হতে হবে, register-এর প্রস্থের সীমায় থাকতে হবে। আমাদের cascade 20000 × 100 আসলে একটি prescaler আর একটি counter-এর জোড়া। আর off-by-one-এর প্রশ্ন সবখানে: 8254-এর mode 2-এ period N, SysTick-এ LOAD + 1, অনেক MCU timer-এ (ARR + 1) × (PSC + 1). প্রতিটি chip-এর reference manual আলাদা করে পড়তে হয়, যা এই কোর্সের মডিউল ৭-এর পর্ব ৪৪-এর বিষয়।

বাজারঘরের cold room আজ বানালে ছবিটি সরল হয়। আলাদা timer chip নেই, address decoder নেই, OUT নির্দেশও নেই: core-এর SysTick 10 ms tick দেয় (কোর্সের ভার্চুয়াল board-এ LOAD = 79 999), একটি peripheral timer PWM দিয়ে buzzer বাজায়, আর tick গুনে firmware প্রতি সেকেন্ডে I2C sensor পড়ে। বড় পরিবর্তন শক্তিতে: CPU tick-এর মাঝে WFI দিয়ে ঘুমায়, আর timer-ই তাকে জাগায়, যা ব্যাটারিতে চলা device-এর জন্য জরুরি (পর্ব ৬০)। ধারণা একই: সময় গোনে একটি স্বাধীন counter, CPU শুধু ঘটনায় সাড়া দেয়।

মূল উপলব্ধি: 8254-এর প্রতিটি mode আজকের timer-এর একটি সুইচ বা channel হয়ে বেঁচে আছে; তাই এর হিসাব আর off-by-one-এর সতর্কতা সরাসরি আধুনিক firmware-এ কাজে লাগে।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — দুই সুরের alarm: Cold room-এর HIGH alarm-এ buzzer 1 kHz, LOW alarm-এ 2 kHz বাজবে। 8254 আছে 40H–43H-এ, CLK2 = 2 MHz. একটি 8085 subroutine লিখুন, যা A-তে 01H পেলে 1 kHz আর 02H পেলে 2 kHz-এর জন্য counter 2 প্রোগ্রাম করে। প্রতিটি count আর control word দেখান, আর 2 kHz-এ OUT2-এর উঁচু ও নিচু অংশ কত µs বলুন।

    2 kHz: N = 2 000 000 ÷ 2000 = 1000 = 03E8H. 1 kHz: N = 2000 = 07D0H. দুটির control word একই 0B6H; শুধু count আলাদা। Count-গুলো একটি সারণিতে রাখলে program ছোট হয়:

            ORG 2000H
    START:  LXI SP,2800H
            MVI A,02H       ; পরীক্ষা: LOW alarm
            CALL TONE
            HLT
    TONE:   PUSH H
            LXI H,TABLE-2   ; A = 1 বা 2
            ADD A           ; ২ byte প্রতি সারি
            ADD L
            MOV L,A         ; সারণি একই page-এ
            MVI A,0B6H      ; counter 2, LSB+MSB, mode 3
            OUT 43H
            MOV A,M
            OUT 42H         ; LSB
            INX H
            MOV A,M
            OUT 42H         ; MSB
            POP H
            RET
    TABLE:  DW 2000, 1000

    সত্যিকারের run-এর OUT log: OUT port 43H <- B6H (at T=86), OUT port 42H <- E8H (at T=103), OUT port 42H <- 03H (at T=126); ১৮টি নির্দেশ, ১৫১ T, শেষে HL আগের মানে। DW little-endian, তাই সারণিতে আগে LSB, যা ঠিক যে ক্রমে 8254 চায়। মডেলে N = 1000-এ OUT2 নিচু হয় ৫০১ নম্বর pulse-এ, উঁচু ১০০১-এ: উঁচু ৫০০ pulse = 250 µs, নিচু 250 µs, period 500 µs. সারণির ঠিকানার যোগ শুধু L-এ, তাই সারণি একটি 256-byte page পেরোতে পারবে না; এখানে TABLE = 201DH, নিরাপদ।

  2. ভুল খুঁজুন — buzzer প্রায় নীরব: একজন buzzer-এর জন্য লিখলেন MVI A,0B6H / OUT 43H / MVI A,07H / OUT 42H / MVI A,0D0H / OUT 42H. CLK2 = 2 MHz. Buzzer 1 kHz-এর বদলে খুব নিচু একটি গুনগুন করে। কী ভুল, counter-এ আসলে কোন N বসল, আর frequency কত?

    RW = 11 মানে counter-এর port-এ প্রথম byte সবসময় LSB. এখানে আগে গেছে 07H (LSB হিসেবে), পরে 0D0H (MSB হিসেবে)। ফলে N = 0D007H = 53255.

    1. f = 2 000 000 ÷ 53255 ≈ 37.555 Hz, প্রায় 1 kHz-এর ২৭ ভাগের এক।
    2. N বিজোড়, তাই উঁচু (53255 + 1)/2 = 26628 pulse, নিচু 26627 pulse. মডেলে OUT2 নিচু হয় ২৬৬২৯ নম্বর pulse-এ, আবার উঁচু ৫৩২৫৬-এ, ঠিক এই হিসাব।
    3. সমাধান: দুটি MVI-এর জায়গা বদল, আগে 0D0H, পরে 07H.

    Simulator-এ এই ভুল ধরা পড়ে না: OUT log শুধু দেখায় 42H <- 07H তারপর 42H <- D0H, যা নিখুঁতভাবে “চলে”। তাই নিয়মটি মনে রাখা আর OUT log-এর ক্রম নিজে পড়া জরুরি।

  3. আগে বলুন, তারপর মিলিয়ে দেখুন — mode 1-এর retrigger: Counter 1-এ control word 52H আর count 04H. GATE1 প্রথমে নিচু; ২ নম্বর CLK pulse-এর আগে একটি trigger (GATE উঠল), আবার ৪ নম্বরের আগে দ্বিতীয় trigger. প্রথম দশটি pulse-এর পরে CE-এর নিচের byte আর OUT1 লিখুন। OUT1 মোট কয় pulse নিচু থাকে?

    52H = 01 01 001 0: counter 1, শুধু LSB, mode 1, binary. Trigger-এর পরের pulse-এ load আর OUT নিচু; প্রতিটি নতুন trigger count আবার 4 থেকে শুরু করে।

    pulse : 1  2  3  4  5  6  7  8  9  10
    CE    : -- 04 03 04 03 02 01 00 FF FE
    OUT1  : 1  0  0  0  0  0  0  1  1  1

    OUT1 নিচু ২ থেকে ৭ নম্বর pulse পর্যন্ত, মোট ৬ pulse: প্রথম trigger-এর ২ pulse আর দ্বিতীয় trigger থেকে পূর্ণ N = 4. এটিই “retriggerable”: শেষ trigger থেকে N pulse. এই সারি মডেলে চালিয়ে মেলানো। বাস্তব ব্যবহার: একটি গতির sensor যতক্ষণ বারবার সংকেত দেয়, একটি বাতি ততক্ষণ জ্বলে থাকে, আর শেষ সংকেতের N pulse পরে নেভে।

  4. হিসাব — আধা সেকেন্ডের tick আর একবারের delay: CLK0 = 2 MHz, OUT0 → CLK1. (ক) প্রতি 0.5 s-এ একটি interrupt-এর জন্য দুই counter-এর N, mode আর control word বলুন। (খ) একটি counter mode 0-এ 25 ms-এর একবারের delay দিতে পারবে কি? N কত, আর OUT ঠিক কখন উঁচু হবে? (গ) একই 0.5 s software loop-এ 3 MHz 8085-এ কত T-state?
    1. (ক) মোট ভাগ = 2 000 000 × 0.5 = 1 000 000 > 65536, তাই cascade. Counter 0: mode 2, N = 20000 (10 ms), control word 34H, count 20H, 4EH. Counter 1: mode 2, N = 50 = 32H, শুধু LSB, control word 54H. 20000 × 50 = 1 000 000 pulse = 0.5 s.
    2. (খ) 25 ms ÷ 0.5 µs = 50000 ≤ 65536, তাই এক counter-এই হয়। Mode 0-এ OUT উঁচু হয় N + 1 pulse পরে, তাই N = 50000 = 0C350H দিলে delay 50001 × 0.5 µs = 25.0005 ms; নিখুঁত 25 ms চাইলে N = 49999. Control word (counter 0, LSB+MSB, mode 0, binary) = 30H. মডেলে N = 50000-এ OUT উঁচু হয় ৫০০০১ নম্বর pulse-এ।
    3. (গ) 0.5 s × 3 000 000 T/s = 1 500 000 T; ১৬-বিট loop-এ 24N + 7 ≤ 24 × 65535 + 7 = 1 572 847, তাই প্রায় সীমায়, আর পুরো সময় CPU আটকে। Timer-এ CPU-র খরচ শুধু প্রোগ্রামিং আর প্রতি tick-এ একটি ছোট ISR.

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

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

ক্রম8254-এর counter 2-কে mode 3-এ চালু করে প্রথম কমানো পর্যন্ত কী কী ঘটে, সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. fin ÷ fout থেকে N হিসাব করে সীমা মেলানো হয়
  2. Control word (SC, RW, M, BCD) port 43H-এ লেখা হয়, OUT উঁচু হয়
  3. Counter 2-এর port-এ count-এর LSB লেখা হয়
  4. একই port-এ count-এর MSB লেখা হয়, CR-এ পুরো N
  5. পরের CLK pulse-এ CR থেকে CE-তে load হয়, কোনো কমানো ছাড়া
  6. পরের প্রতিটি CLK pulse-এর নামন্ত ধারে CE দুই করে কমে

8254-এর counter 2-কে LSB তারপর MSB, mode 3, binary-তে চালাতে control word কোনটি?

  • 36H
  • B6H
  • B7H
  • 96H

8254-এর CLK = 2 MHz. Mode 3-এ 1 kHz square wave পেতে count কত?

  • 1000
  • 1999
  • 2000 (07D0H)
  • 4000

8254-এর একটি counter mode 3-এ N = 5. OUT প্রতি period-এ কয়টি CLK pulse উঁচু আর কয়টি নিচু থাকে?

  • ৩টি উঁচু, ২টি নিচু
  • ২টি উঁচু, ৩টি নিচু
  • ৪টি উঁচু, ১টি নিচু
  • ২.৫টি উঁচু, ২.৫টি নিচু

8254-এর mode 0-এ GATE উঁচু রেখে count N লেখা হলো। OUT কখন উঁচু হবে?

  • ঠিক N pulse পরে
  • Count লেখার সঙ্গে সঙ্গে
  • N − 1 pulse পরে
  • N + 1 pulse পরে

নিচের কোন সুবিধা 8254-এ আছে কিন্তু 8253-এ নেই?

  • চলমান count আটকে পড়ার counter latch command
  • Read-back command আর status byte
  • Mode 5, hardware triggered strobe
  • BCD গোনা

8254-এর একটি counter mode 3-এ চলছে, OUT এই মুহূর্তে নিচু। GATE নিচু করলে কী হয়?

  • কিছুই না, গোনা চলতে থাকে
  • গোনা থামে, OUT নিচুই থাকে
  • গোনা থামে আর OUT সঙ্গে সঙ্গে উঁচু হয়
  • Counter-এর count মুছে শূন্য হয়

CLK = 2 MHz. একটি 8254 counter একা binary mode-এ সবচেয়ে দীর্ঘ কত সময় মাপতে পারে (mode 2-এর period)?

  • 32.768 ms
  • 32.7675 ms
  • 1 s
  • 5 ms

শব্দকোষ

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

মনে রাখুন

  1. গঠন: তিনটি স্বাধীন ১৬-বিট down counter, প্রতিটির CLK, GATE, OUT; A1 A0 = 11 control register, বাকি তিনটি counter.
  2. Control word: SC1 SC0 · RW1 RW0 · M2 M1 M0 · BCD; আগে control word, পরে count; RW = 11-এ আগে LSB.
  3. Mode: 0 TC-তে OUT উঁচু (N + 1), 1 one-shot (N), 2 rate generator (period N, এক pulse নিচু), 3 square wave (দুই করে কমে), 4 আর 5 strobe (N + 1).
  4. হিসাব: N = fin ÷ fout; 2 ≤ N ≤ 65536 (count 0 = 65536, BCD-তে 10000); বড় হলে cascade, যেমন 20000 × 100 = 1 s at 2 MHz.
  5. 8254-এর বাড়তি: read-back আর status (OUT, NULL count), 8/10 MHz; 8253 থামে 2.6 MHz-এ।

পরের পর্বে: পর্ব ২৬ (8259 PIC — interrupt priority, ICW আর OCW). এই পর্বের OUT1 সরাসরি RST 7.5-এ গিয়েছিল; যন্ত্র বাড়লে interrupt line কম পড়ে। 8259 আটটি অনুরোধের অগ্রাধিকার ঠিক করে CPU-কে একটি করে পাঠায়।

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

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