Latch আর flip-flop — SR, D, JK, T আর edge-triggering

১ · Combinational থেকে sequential — যখন circuit-কে মনে রাখতে হয়

মডিউল ২-এ যত circuit বানিয়েছেন — adder, multiplexer, decoder, ALU — সবগুলোর একটি মিল আছে: output নির্ভর করে শুধু এই মুহূর্তের input-এর ওপর। এদের বলে combinational circuit. Input সরিয়ে নিলে output-ও হারিয়ে যায়; circuit-টি কিছুই মনে রাখে না।

কিন্তু একটি কম্পিউটারের অর্ধেক কাজই মনে রাখা। Program counter মনে রাখে পরের instruction কোথায়, register মনে রাখে হিসাবের ফল, মেমরি মনে রাখে আপনার ফাইল। যে circuit-এর output এই মুহূর্তের input আর অতীতের ইতিহাস — দুটির ওপর নির্ভর করে, তাকে বলে sequential circuit. অতীতের যে সারাংশটুকু circuit ধরে রাখে, তার নাম state (অবস্থা)।

বেশিরভাগ ডিজিটাল নকশা synchronous: সব স্মৃতি-উপাদান একটি সাধারণ clock সংকেতের ছন্দে একসাথে নতুন মান নেয়, ঠিক যেন রেলস্টেশনের ঘণ্টা বাজলে সব ট্রেন একসাথে ছাড়ে। Clock ছাড়া, যেকোনো সময় বদলাতে পারা নকশাকে বলে asynchronous. এই পর্বে দুটিই দেখবেন: latch-গুলো মূলত clock ছাড়া (বা clock-এর স্তর দেখে) চলে, আর flip-flop চলে clock-এর ধার দেখে।

২ · Feedback আর দুই স্থির অবস্থা — দুটি inverter-এর লুপ

স্মৃতি বানানোর সবচেয়ে ছোট উপায়টি দেখতে প্রায় হাস্যকর রকম সরল। দুটি inverter নিন। প্রথমটির output দ্বিতীয়টির input-এ দিন, আর দ্বিতীয়টির output আবার প্রথমটির input-এ ফিরিয়ে দিন। বাইরে থেকে কোনো input নেই — শুধু একটি লুপ। একে বলে feedback.

এখন হিসাব করুন। ধরুন প্রথম inverter-এর output (নাম দিই Q) = 1. তাহলে দ্বিতীয়টির input 1, output 0. সেই 0 প্রথমটির input, তাই প্রথমটির output 1 — যা দিয়ে শুরু করেছিলাম! লুপটি নিজেকে নিজে সমর্থন করছে। আবার Q = 0 ধরলে দ্বিতীয়টির output 1, প্রথমটির output 0 — এটিও নিজেকে সমর্থন করে। অর্থাৎ এই circuit-এর ঠিক দুটি স্থির অবস্থা আছে: (Q, Q′) = (1, 0) অথবা (0, 1). দুই স্থির অবস্থার এমন circuit-কে বলে bistable, আর যেকোনোটিতে একবার পড়লে সে সেখানেই থাকে, যতক্ষণ বিদ্যুৎ আছে। একটি বিট মনে রাখার জন্য এর চেয়ে বেশি কিছু লাগে না।

এই “মাঝখানে রাখলে” কথাটি গুরুত্বপূর্ণ। দুটি স্থির বিন্দুর মাঝে একটি অস্থির ভারসাম্য-বিন্দুও আছে, যেখানে দুটি output-ই প্রায় অর্ধেক ভোল্টেজে — পাহাড়ের চূড়ায় বসানো একটি বলের মতো। বাস্তবে সামান্য noise-এ বলটি কোনো এক দিকে গড়িয়ে পড়ে, কিন্তু কতক্ষণে পড়বে তার নিশ্চয়তা নেই। এই অবস্থার নাম metastability — পর্ব ১৮-এ এর ঝুঁকি আর প্রতিকার বিস্তারিত দেখবেন।

শুধু দুটি inverter দিয়ে একটি সমস্যা: মান বদলানোর কোনো দরজা নেই। লুপটি যে অবস্থায় চালু হয়েছে, সেখানেই থাকবে। দরজা বানাতে হলে inverter-এর জায়গায় এমন gate লাগবে যার একটি অতিরিক্ত input বাইরে থেকে লুপকে জোর করে একদিকে ঠেলতে পারে। NOR আর NAND ঠিক এই কাজের — পরের অংশে।

আধুনিক chip-এর সবচেয়ে প্রচলিত দ্রুত মেমরি — cache-এর SRAM cell — আসলে ঠিক এই cross-coupled inverter-এর জোড়া, সাথে পড়া-লেখার জন্য দুটি “দরজা” transistor (মোট ছয়টি transistor). পর্ব ৪৯-এ SRAM আর DRAM-এর তুলনায় সেটি দেখবেন।

৩ · SR latch — NOR দিয়ে, আর NAND দিয়ে S′R′

NOR gate-এর নিয়ম মনে করুন (পর্ব ০৮): যেকোনো input 1 হলে output 0; সব input 0 হলেই কেবল output 1. লক্ষ করুন, একটি input 0 রাখলে NOR ঠিক inverter-এর মতো আচরণ করে (output = অন্য input-এর উল্টো)। তাই দুটি NOR-কে cross-couple করে তাদের বাড়তি input দুটি 0 রাখলে আগের অংশের দুই-inverter লুপই পাই। আর বাড়তি input 1 করলে সেই gate-এর output জোর করে 0 — লুপকে একদিকে ঠেলার দরজা পেয়ে গেলাম। এই circuit-টিই SR latch: S (set) আর R (reset) দুটি input, Q আর Q′ দুটি output.

খেয়াল করুন, R ঢোকে Q-এর gate-এ: R = 1 হলে Q = 0 জোর করে — অর্থাৎ reset. আর S ঢোকে Q′-এর gate-এ: S = 1 হলে Q′ = 0, তারপর ওপরের gate-এর দুটি input-ই 0 বলে Q = 1 — set. চারটি input-সংমিশ্রণ মিলিয়ে টেবিলটি এমন:

এবার ধাপে ধাপে একটি input-ক্রম চালিয়ে দেখুন। প্রতিটি ধাপে দুটি gate কীভাবে একে অপরকে ঠেলে স্থির হয়, সেটিই আসল শিক্ষা:

নিচের simulator ঠিক এই মডেলটি চালায়: প্রতিটি gate-এর delay এক একক, আর প্রতি এককে দুটি gate-ই পুরোনো মান দেখে একসাথে নতুন মান বসায়। Output না বদলানো পর্যন্ত (বা ৬ একক পর্যন্ত) চলে, তারপর জানায় স্থির হলো কি না:

// NOR SR latch, gate level: Q = NOR(R, Qn), Qn = NOR(S, Q).
// Unit delay: both gates look at the OLD outputs, then update together.
const NOR = (a, b) => (a | b) ? 0 : 1;
let Q = 0, Qn = 1;                       // start in the "reset" state
function apply(S, R, label) {
  const trace = [`${Q}${Qn}`];
  for (let t = 1; t <= 6; t++) {
    const q = NOR(R, Qn), qn = NOR(S, Q); // both computed from old values
    if (q === Q && qn === Qn) break;      // nothing changed: stable
    Q = q; Qn = qn; trace.push(`${Q}${Qn}`);
  }
  const stable = NOR(R, Qn) === Q && NOR(S, Q) === Qn;
  const note = !stable ? "OSCILLATES (never settles)"
             : Q === Qn ? "stable, but Q = Q' (not complements!)"
             : "stable";
  console.log(`S=${S} R=${R}  ${label.padEnd(10)} QQ': ${trace.join(" -> ").padEnd(28)} ${note}`);
}
apply(0, 0, "hold");
apply(1, 0, "set");
apply(0, 0, "hold");
apply(0, 1, "reset");
apply(0, 0, "hold");
apply(1, 1, "forbidden");
apply(0, 0, "release");                  // S and R drop at the SAME instant
Q = 0; Qn = 0;                           // back to the forbidden outputs
apply(1, 0, "R first");                  // R drops first, S a moment later
apply(0, 0, "then S");

S=0 R=0  hold       QQ': 01                           stable
S=1 R=0  set        QQ': 01 -> 00 -> 10               stable
S=0 R=0  hold       QQ': 10                           stable
S=0 R=1  reset      QQ': 10 -> 00 -> 01               stable
S=0 R=0  hold       QQ': 01                           stable
S=1 R=1  forbidden  QQ': 01 -> 00                     stable, but Q = Q' (not complements!)
S=0 R=0  release    QQ': 00 -> 11 -> 00 -> 11 -> 00 -> 11 -> 00 OSCILLATES (never settles)
S=1 R=0  R first    QQ': 00 -> 10                     stable
S=0 R=0  then S     QQ': 10                           stable

NAND দিয়ে S′R′ latch — active-low সংস্করণ

NAND gate-এর কোনো input 0 হলে output জোর করে 1. তাই দুটি NAND cross-couple করলে input-গুলো 0 হলে সক্রিয় হয় — একে বলে active-low input, নাম লেখা হয় S′ আর R′ (বা S̄, R̄). গঠন: Q = NAND(S′, Q′), Q′ = NAND(R′, Q). এখানে S′ ঢোকে Q-এর gate-এ (NOR-এর উল্টো ছবি), কারণ NAND-এর 0 input তার output-কে 1 করে।

SR latch-এর একটি খুব বাস্তব ব্যবহার আছে: যান্ত্রিক সুইচের contact bounce দূর করা। একটি বোতাম চাপলে ধাতব পাত কয়েক millisecond ধরে কয়েকবার লাফিয়ে ওঠে-নামে, ফলে 0-1-0-1-এর ঝাঁক আসে। দুই-দিকের (SPDT) সুইচের দুই প্রান্ত একটি S′R′ latch-এর S′ আর R′-তে দিলে প্রথম ছোঁয়াতেই latch set হয়ে যায়, পরের লাফগুলোতে input “hold”-এ (11) ফেরে বলে output আর নড়ে না। পুরোনো ল্যাবের ট্রেনার বোর্ডের “debounced” বোতামের ভেতরে প্রায়ই এটাই থাকে।

৪ · Gated SR latch আর D latch — দরজাওয়ালা স্মৃতি

সাধারণ SR latch যেকোনো মুহূর্তে S বা R-এ সাড়া দেয়। কিন্তু বড় নকশায় আমরা চাই, স্মৃতি-উপাদান শুধু নির্দিষ্ট সময়ে নতুন মান নিক — যখন আগের combinational হিসাব শেষ হয়ে মান স্থির হয়েছে। এজন্য S আর R-এর সামনে দুটি AND gate বসিয়ে তাদের অন্য input-এ একটি enable সংকেত (EN, অনেক বইয়ে C বা clock) দেওয়া হয়। EN = 0 হলে দুটি AND-এর output 0, তাই latch-এর কাছে S = R = 0 — hold, বাইরে যা-ই ঘটুক। EN = 1 হলে S আর R পার হয়ে যায়। এটি gated SR latch. NAND দিয়ে বানালে চারটি NAND লাগে: সামনের দুটি NAND(S, EN) আর NAND(R, EN) সরাসরি S′R′ latch-এর active-low input দেয়।

কিন্তু নিষিদ্ধ অবস্থাটি এখনো আছে: EN = 1 অবস্থায় S = R = 1 হলে সেই একই সমস্যা, আর তারপর EN নামলে আবার race. সমাধানটি চমৎকার রকম সরল — S আর R-কে আলাদা input রাখবেন না। একটি মাত্র data input D নিন, আর দিন S = D, R = D′ (একটি inverter দিয়ে)। তাহলে S আর R কখনো একসাথে 1 হতে পারে না; নিষিদ্ধ অবস্থা গঠনগতভাবেই অসম্ভব। এই circuit-ই D latch.

সূত্রটি চেনা লাগছে? এটি ঠিক একটি 2:1 multiplexer-এর সূত্র (পর্ব ১২): EN হলো select, EN = 1-এ নতুন D, EN = 0-এ পুরোনো Q. সত্যিই, অনেক CMOS standard-cell latch ভেতরে একটি mux আর feedback-এর লুপ — mux-এর একটি input বাইরের D, আরেকটি নিজের output.

EN = 1 থাকার পুরো সময় latch-টি একটি স্বচ্ছ কাচের জানালার মতো: D বদলালে Q-ও সঙ্গে সঙ্গে (একটু delay-তে) বদলায়। এজন্য একে transparent latch বলে। EN নামার মুহূর্তে জানালা বন্ধ হয়, আর তখন D-এর যে মান ছিল সেটিই ভেতরে আটকে থাকে। পর্ব ১৪-এর latch-এর ফাঁদে অসম্পূর্ণ if (en) q = d; লিখে ঠিক এই উপাদানটিই অনিচ্ছায় পেয়েছিলেন — একটি inferred latch.

৫ · Level-sensitive বনাম edge-triggered — master–slave D flip-flop

D latch সাড়া দেয় EN-এর স্তর দেখে — EN = 1 থাকার পুরো সময়। একে বলে level-sensitive. ছোট নকশায় এটি সমস্যা নয়, কিন্তু CPU-র মতো synchronous pipeline-এ এটি বিপজ্জনক। কারণটা বুঝতে একটি register-এর শিকল ভাবুন: latch A-এর output যায় কিছু combinational logic হয়ে latch B-তে, B থেকে আবার logic হয়ে C-তে, আর সবার EN একই clock. Clock = 1 হওয়া মাত্র A খুলে যায়, তার নতুন মান logic পেরিয়ে B-তে পৌঁছায় — আর B-ও তো খোলা! মানটি B পার হয়ে C-র দিকে ছুটতে থাকে। Clock-এর high অংশ যথেষ্ট লম্বা হলে একটি মান এক টিকে একাধিক ধাপ পেরিয়ে যায়। একে বলে race-through: আমরা চেয়েছিলাম প্রতি টিকে ঠিক এক ধাপ, পেলাম “যত দূর দৌড়াতে পারে”। ফলাফল তখন নির্ভর করে gate-এর delay আর clock-এর pulse-এর দৈর্ঘ্যের ওপর — যা তাপমাত্রা আর ভোল্টেজে বদলায়।

সমাধান: এমন স্মৃতি-উপাদান, যা clock-এর একটি মুহূর্তে — ধারে — একবার মান নেয়, আর বাকি পুরো সময় input-কে উপেক্ষা করে। একে বলে edge-triggered উপাদান, আর এটিই flip-flop. Clock 0 থেকে 1-এ ওঠার মুহূর্ত rising edge (positive edge), 1 থেকে 0-তে নামার মুহূর্ত falling edge (negative edge).

দুটি latch দিয়ে একটি flip-flop

সবচেয়ে প্রচলিত গঠনটি হলো master–slave flip-flop: দুটি D latch পরপর, কিন্তু তাদের enable উল্টো। প্রথমটি (master) খোলা থাকে clock = 0-তে (EN = clk′), দ্বিতীয়টি (slave) খোলা থাকে clock = 1-এ (EN = clk). যেকোনো মুহূর্তে ঠিক একটি latch খোলা — তাই D থেকে Q পর্যন্ত কখনো সরাসরি স্বচ্ছ পথ থাকে না।

একটি পূর্ণ clock period ধরে দেখুন কোন latch কখন খোলা, আর Q কখন বদলায়:

Enable দুটি অদলবদল করলে (master খোলা clk = 1-এ, slave clk = 0-তে) পাওয়া যায় negative-edge-triggered flip-flop — সেটি falling edge-এ মান নেয়। Circuit-এর প্রতীকে clock input-এর পাশে একটি ছোট ত্রিভুজ (>) মানে edge-triggered; ত্রিভুজের আগে একটি ছোট বৃত্ত (bubble) থাকলে falling edge. ত্রিভুজ না থাকলে সেটি latch — level-sensitive.

এবার একটি দীর্ঘ waveform-এ একটি D latch (clk = 1-এ খোলা) আর একটি rising-edge D flip-flop পাশাপাশি চালিয়ে দেখি। প্রতিটি অক্ষর এক একক সময়; দুটিই শুরু করে Q = 0 থেকে:

// D latch (transparent while clk = 1) vs rising-edge D flip-flop.
// One character = one time unit. Both start with Q = 0.
const clk = "0001111000011110000111100001111";
const D   = "0011100000001100110000000111111";
let qL = 0, qF = 0, latch = "", ff = "", diff = "";
for (let t = 0; t < clk.length; t++) {
  const c = +clk[t], d = +D[t];
  if (c === 1) qL = d;                          // latch: Q follows D while open
  const rising = t > 0 && clk[t - 1] === "0" && c === 1;
  if (rising) qF = d;                           // FF: sample D only at 0 -> 1
  latch += qL; ff += qF;
  diff += qL !== qF ? "^" : " ";
}
const wave = s => [...s].map(b => (b === "1" ? "‾" : "_")).join("");
const edges = [...clk].map((b, t) => (t > 0 && clk[t - 1] === "0" && b === "1" ? "|" : " ")).join("");
console.log("edge    " + edges);
console.log("clk     " + wave(clk));
console.log("D       " + wave(D));
console.log("Q latch " + wave(latch));
console.log("Q FF    " + wave(ff));
console.log("differ  " + diff);
console.log("Q latch = " + latch);
console.log("Q FF    = " + ff);
let n = 0; for (const ch of diff) if (ch === "^") n++;
console.log(`they differ in ${n} of ${clk.length} time units`);

edge       |       |       |       |   
clk     ___‾‾‾‾____‾‾‾‾____‾‾‾‾____‾‾‾‾
D       __‾‾‾_______‾‾__‾‾_______‾‾‾‾‾‾
Q latch ___‾‾_______‾‾_____________‾‾‾‾
Q FF    ___‾‾‾‾‾‾‾‾________________‾‾‾‾
differ       ^^^^^^ ^^                 
Q latch = 0001100000001100000000000001111
Q FF    = 0001111111100000000000000001111
they differ in 8 of 31 time units

৬ · চার রকম flip-flop — characteristic table আর equation

Edge-triggering-এর কৌশল একবার পেলে ধারে কী মান নেবে, সেই নিয়ম বদলে চার রকম flip-flop বানানো যায়। প্রতিটির আচরণ বর্ণনার দুটি মানক উপায়: characteristic table (input আর বর্তমান Q থেকে Q⁺-এর টেবিল) আর characteristic equation (সেই টেবিলের Boolean সূত্র)।

সূত্র বের করা — SR আর JK-এর K-map

Characteristic equation মুখস্থ করার দরকার নেই, পর্ব ০৯-এর K-map দিয়ে এক মিনিটে বের হয়। SR-এর জন্য তিন চলক S, R, Q নিয়ে Q⁺-এর টেবিল: SRQ = 000 → 0, 001 → 1, 010 → 0, 011 → 0, 100 → 1, 101 → 1, আর 110, 111 নিষিদ্ধ, তাই don't care (x). 1-গুলো আছে 001, 100, 101-এ। চারটি S = 1-এর ঘর (100, 101 আর দুটি x) মিলে একটি চারের দল: S. বাকি 001 আর 101 জোড়া (দুটির মিল R = 0, Q = 1): R′Q. তাই Q⁺ = S + R′Q. Don't care ছাড়া এটি হতো SR′ + R′Q — x দুটিই সূত্রকে ছোট করেছে, আর বিনিময়ে শর্ত দিয়েছে SR = 0.

JK-তে নিষিদ্ধ ঘর নেই; JKQ = 110 → 1 আর 111 → 0 (toggle). 1-গুলো: 001, 100, 101, 110. জোড়া ১: 100 আর 110 (J = 1, Q = 0) → JQ′. জোড়া ২: 001 আর 101 (K = 0, Q = 1) → K′Q. Q⁺ = JQ′ + K′Q. সূত্রটি পড়ুন এভাবে: “Q এখন 0 হলে J ঠিক করে উঠবে কি না; Q এখন 1 হলে K ঠিক করে নামবে কি না।” এভাবে পড়ার অভ্যাস excitation table বুঝতেও সাহায্য করবে।

JK — SR-এর নিষিদ্ধ ঘরের সদ্ব্যবহার

JK flip-flop হলো SR, যেখানে নিষিদ্ধ 11-কে একটি কাজের অর্থ দেওয়া হয়েছে: toggle, অর্থাৎ মান উল্টে দেওয়া। এজন্য ভেতরে output দুটি ফিরিয়ে এনে input gate-এ দেওয়া হয়: S = JQ′, R = KQ. তাহলে Q = 0 হলে শুধু J কাজ করে, Q = 1 হলে শুধু K — S আর R কখনো একসাথে 1 হয় না। J = K = 1-এ প্রতিটি সক্রিয় ধারে Q উল্টায়।

কিন্তু এই feedback-ই পুরোনো, level-triggered JK-তে একটি বিখ্যাত সমস্যা তৈরি করে: race-around condition. ধরুন JK-টি gated latch-এর মতো clock = 1 থাকার পুরো সময় সাড়া দেয়, আর J = K = 1. Q উল্টাল; নতুন Q feedback হয়ে input gate-এ ফিরল; clock তখনো 1, তাই আবার উল্টাল… clock pulse যতক্ষণ high, ততক্ষণ Q দোল খায়, আর pulse শেষে কোন মানে থামবে তা নির্ভর করে pulse-এর দৈর্ঘ্য আর gate delay-এর অনুপাতের ওপর। প্রতিকার তিনটি: (১) clock pulse-কে flip-flop-এর propagation delay-এর চেয়ে ছোট রাখা — অনির্ভরযোগ্য; (২) master–slave গঠন — master যখন খোলা, slave বন্ধ, তাই feedback লুপ কখনো এক pulse-এ সম্পূর্ণ হয় না; (৩) সত্যিকারের edge-triggered গঠন। আধুনিক সব JK এই শেষ দুটির একটি।

T flip-flop হলো JK-এর J আর K একসাথে বাঁধা রূপ: T = 0 হলে hold, T = 1 হলে toggle. Counter আর frequency divider-এ এটি স্বাভাবিক পছন্দ। বাজারে আলাদা T flip-flop-এর IC প্রায় পাওয়া যায় না; JK বা D দিয়েই বানানো হয় — পরের অংশে ঠিক কীভাবে, দেখবেন।

৭ · Excitation table আর এক flip-flop দিয়ে আরেকটি বানানো

Characteristic table প্রশ্ন করে: “এই input দিলে Q⁺ কী হবে?” নকশা করার সময় প্রশ্নটা উল্টো: “Q এখন 0, পরের edge-এ 1 চাই — কোন input দেব?” এর উত্তরের টেবিলই excitation table. পর্ব ১৬-এর counter আর পর্ব ১৭-এর FSM নকশায় এটিই প্রধান হাতিয়ার, আর বিশ্ববিদ্যালয় ও চাকরির পরীক্ষায় বারবার আসা টেবিলও এটি।

JK-এর সারিগুলো যুক্তি দিয়ে বের করুন: 0 → 1 চাই। J = 1, K = 0 দিলে set হয়ে 1; J = 1, K = 1 দিলে toggle হয়েও 1. দুই ক্ষেত্রেই কাজ হয়, তাই K = x (don't care). একইভাবে 1 → 0-তে K = 1 দরকার, J যা-ই হোক (reset বা toggle). JK-এর excitation table-এ প্রতিটি সারিতে একটি x থাকে — এজন্যই counter নকশায় JK দিলে K-map-এ x বেশি, সূত্র ছোট। D-এর টেবিল সবচেয়ে সহজ: D = Q⁺. T-এর: T = Q ⊕ Q⁺ — বদলাতে চাইলে 1, না চাইলে 0.

রূপান্তরের পদ্ধতি — পাঁচ ধাপ

“আপনার কাছে শুধু D flip-flop আছে, একটি JK বানান” — এমন প্রশ্নের একটি নির্দিষ্ট পদ্ধতি আছে: (১) যে flip-flop বানাতে চান তার characteristic table লিখুন — input আর Q থেকে Q⁺; (২) প্রতিটি সারিতে Q → Q⁺ দেখুন; (৩) যে flip-flop হাতে আছে তার excitation table থেকে সেই রূপান্তরের input লিখুন; (৪) K-map দিয়ে সরল করুন; (৫) circuit এঁকে সব সারিতে simulate করে মিলিয়ে নিন।

কাজ করা উদাহরণ ১ — D flip-flop থেকে JK

D-এর কলামে 1 আছে JKQ = 001, 100, 101, 110-এ — হুবহু JK-এর characteristic equation-এর minterm. K-map-এ সরল করলে D = JQ′ + K′Q. Circuit: দুটি AND (একটিতে J আর Q′, অন্যটিতে K′ আর Q), একটি OR, আর তার output D flip-flop-এর D-তে; Q আর Q′ ফিরে আসে AND-গুলোতে। D flip-flop থেকে রূপান্তর সবসময় এমন সরল — D-এর কলাম মানেই কাঙ্ক্ষিত flip-flop-এর characteristic equation.

কাজ করা উদাহরণ ২ — JK flip-flop থেকে T

T-এর characteristic table: TQ = 00 → 0, 01 → 1, 10 → 1, 11 → 0. প্রতিটি সারিতে JK-এর excitation table থেকে input: 00-তে 0 → 0, তাই JK = 0x; 01-তে 1 → 1, JK = x0; 10-তে 0 → 1, JK = 1x; 11-তে 1 → 0, JK = x1. J-এর কলাম 0, x, 1, x — x-গুলো সুবিধামতো বসালে J = T. K-এর কলাম x, 0, x, 1 — K = T. অর্থাৎ J = K = T: JK-এর দুটি input একসাথে জুড়ে দিলেই T flip-flop.

হাতে করা এই রূপান্তর দুটি নিচের generator নিজে বের করে আর simulate করে মিলিয়ে নেয়। প্রথমে চার flip-flop-এর characteristic equation থেকে excitation table, তারপর রূপান্তরের “লাগবে” কলাম, আর শেষে প্রস্তাবিত সূত্রটি সব সারিতে চালিয়ে যাচাই — একটি ইচ্ছাকৃত ভুল সূত্রসহ:

// Characteristic equations -> excitation tables -> flip-flop conversion.
const FF = {   // Q+ from (inputs..., Q); null = input combination not allowed
  SR: { ins: "SR", next: (S, R, Q) => (S & R ? null : S | (!R & Q)) },
  JK: { ins: "JK", next: (J, K, Q) => (J & !Q) | (!K & Q) },
  D:  { ins: "D",  next: (D) => D },
  T:  { ins: "T",  next: (T, Q) => T ^ Q },
};
const combos = n => [...Array(1 << n)].map((_, v) => [...Array(n)].map((_, i) => (v >> (n - 1 - i)) & 1));
const nxt = (f, x, Q) => { const r = f.next(...x, Q); return r === null ? null : +r; };
function excite(f, q, qp) {          // inputs needed for Q -> Q+, "x" = don't care
  const ok = combos(f.ins.length).filter(x => nxt(f, x, q) === qp);
  return [...f.ins].map((_, i) => { const v = new Set(ok.map(x => x[i])); return v.size === 2 ? "x" : [...v][0]; }).join("");
}
for (const [name, f] of Object.entries(FF))
  console.log(`${name.padEnd(2)} ` + [[0, 0], [0, 1], [1, 0], [1, 1]].map(([q, p]) => `${q}->${p}:${excite(f, q, p)}`).join("  "));
// Build flip-flop `want` from flip-flop `have`: per row, read Q+ from want, inputs from have's excitation.
function convert(want, have, guess) {
  const W = FF[want], H = FF[have], cols = [...H.ins].map(() => []);
  let ok = 0, rows = 0;
  for (const x of combos(W.ins.length)) for (const Q of [0, 1]) {
    const need = excite(H, Q, nxt(W, x, Q)), g = guess(...x, Q).map(Number);
    need.split("").forEach((c, i) => cols[i].push(c));
    rows++; if (nxt(H, g, Q) === nxt(W, x, Q)) ok++;      // simulate the guess
  }
  console.log(`${want} from ${have}:`);
  console.log(`  ${(W.ins + "Q").padEnd(9)}: ` + combos(W.ins.length + 1).map(v => v.join("")).join(" "));
  cols.forEach((c, i) => console.log(`  ${(H.ins[i] + " needed").padEnd(9)}: ` + c.join(" ".repeat(W.ins.length + 1))));
  console.log(`  candidate simulated: ${ok}/${rows} rows give the right Q+`);
}
convert("JK", "D", (J, K, Q) => [(J & !Q) | (!K & Q)]);    // D = JQ' + K'Q
convert("T", "JK", (T) => [T, T]);                          // J = K = T
convert("JK", "D", (J, K, Q) => [J | (!K & Q)]);           // a wrong guess: D = J + K'Q

SR 0->0:0x  0->1:10  1->0:01  1->1:x0
JK 0->0:0x  0->1:1x  1->0:x1  1->1:x0
D  0->0:0  0->1:1  1->0:0  1->1:1
T  0->0:0  0->1:1  1->0:1  1->1:0
JK from D:
  JKQ      : 000 001 010 011 100 101 110 111
  D needed : 0   1   0   0   1   1   1   0
  candidate simulated: 8/8 rows give the right Q+
T from JK:
  TQ       : 00 01 10 11
  J needed : 0  x  1  x
  K needed : x  0  x  1
  candidate simulated: 4/4 rows give the right Q+
JK from D:
  JKQ      : 000 001 010 011 100 101 110 111
  D needed : 0   1   0   0   1   1   1   0
  candidate simulated: 7/8 rows give the right Q+

আরও কয়েকটি প্রচলিত রূপান্তর, একই পদ্ধতিতে বের করা (অনুশীলনে দুটি নিজে করবেন): D থেকে T — D = T ⊕ Q; JK থেকে D — J = D, K = D′; T থেকে JK — T = JQ′ + KQ; JK থেকে SR — J = S, K = R (শর্ত SR = 0).

৮ · বাস্তবের flip-flop — preset, clear, enable আর timing

Asynchronous preset আর clear

কম্পিউটার চালু হওয়ার মুহূর্তে প্রতিটি flip-flop-এ কী মান থাকবে? Power-on-এ cross-coupled লুপ এলোমেলোভাবে যেকোনো দিকে পড়ে। তাই বাস্তবের বেশিরভাগ flip-flop-এ দুটি বাড়তি input থাকে: preset (PRE, Q-কে জোর করে 1) আর clear (CLR, Q-কে জোর করে 0). এগুলো সাধারণত active-low (PRE′, CLR′), আর asynchronous — clock-এর অপেক্ষা না করে সঙ্গে সঙ্গে কাজ করে, আর সক্রিয় থাকাকালীন clock আর D-কে পুরোপুরি উপেক্ষা করা হয়। ভেতরে এরা সরাসরি শেষ ধাপের latch-এর NAND-এ ঢোকে।

খেয়াল করুন তৃতীয় সারি — NAND S′R′ latch-এর নিষিদ্ধ অবস্থার পুরোনো বন্ধু ফিরে এসেছে। Clock-এর সাথে বাঁধা আরেক রকম reset-ও আছে: synchronous reset, যা শুধু clock edge-এ কাজ করে (ভেতরে D-এর সামনে একটি AND). কোনটি কখন ভালো, তা FPGA আর ASIC-এ ভিন্ন; তবে একটি নিয়ম সবখানে খাটে — asynchronous reset ছাড়ার (নিষ্ক্রিয় হওয়ার) মুহূর্তটি clock-এর সাথে মিলিয়ে নিতে হয়, নইলে পর্ব ১৮-এর metastability-র ঝুঁকি।

Enable — mux দিয়ে feedback

প্রায়ই চাই, register প্রতি clock-এ নয়, শুধু “লেখার” সংকেত এলে নতুন মান নিক। সঠিক উপায় হলো flip-flop-এর সামনে একটি 2:1 mux (পর্ব ১২): D_in = EN ? d : Q. EN = 0 হলে flip-flop নিজের পুরোনো মানই আবার নেয় — বদল নেই। একে বলে clock enable. লোভনীয় কিন্তু বিপজ্জনক বিকল্প হলো clock-কেই একটি AND gate দিয়ে আটকে দেওয়া; সেই gate-এর delay আর glitch clock-এ ঢুকে timing নষ্ট করতে পারে। Chip-এ বিদ্যুৎ বাঁচাতে clock gating সত্যিই ব্যবহার হয়, তবে tool-এর দেওয়া বিশেষ latch-ভিত্তিক cell দিয়ে, হাতে বসানো AND দিয়ে নয়।

Timing-এর তিনটি সংখ্যা — প্রথম পরিচয়

“ধারের মুহূর্তের D নেয়” কথাটি আদর্শ রূপ। বাস্তবে flip-flop-এর ভেতরের latch-গুলো বন্ধ হতেও সময় লাগে, তাই তিনটি সংখ্যা মানতে হয়:

• Setup time (t_setup): clock edge-এর আগে অন্তত এতক্ষণ D স্থির থাকতে হবে — master latch-কে ঠিক মানটি ধরার সময় দিতে।
• Hold time (t_hold): edge-এর পরে অন্তত এতক্ষণ D বদলানো যাবে না — master পুরোপুরি বন্ধ হওয়া পর্যন্ত।
• Clock-to-Q delay (t_clk→Q বা t_pcq): edge-এর পর Q-তে নতুন মান আসতে যত সময় লাগে।

Setup বা hold ভাঙলে flip-flop ভুল মান নিতে পারে, অথবা অংশ ২-এর সেই পাহাড়-চূড়ায় কিছুক্ষণ আটকে থাকতে পারে — metastability. আধুনিক chip-এ এই সংখ্যাগুলো সাধারণত কয়েক দশ picosecond-এর ঘরে, পুরোনো TTL IC-তে কয়েক থেকে কয়েক দশ nanosecond — নির্দিষ্ট মান সবসময় datasheet বা cell library থেকে নিতে হয়। এরা কীভাবে সর্বোচ্চ clock speed ঠিক করে (t_clk→Q + logic-এর delay + t_setup ≤ clock period), critical path, clock skew আর synchronizer — সব পর্ব ১৮-এ।

প্রতিটি register-এর ভেতরে

এ পর্যন্ত যা দেখলেন, তা কোনো বিচ্ছিন্ন খেলনা নয়। RISC-V CPU-র ৩২-বিট program counter মানে ৩২টি D flip-flop, একই clock-এ চলা। ৩২টি ৩২-বিট general-purpose register (x0 সবসময় শূন্য, তাই আসলে ৩১টি) মানে প্রায় এক হাজার flip-flop. পর্ব ৩৫-এর পাঁচ ধাপের pipeline-এ প্রতিটি ধাপের মাঝে বসে একটি pipeline register — একসারি flip-flop, যা প্রতি clock-এ এক ধাপের ফল পরের ধাপে তুলে দেয়; এখানে race-through হলে একটি instruction এক cycle-এ দুই ধাপ পেরিয়ে যেত। পর্ব ১৭-এর FSM-এ state register মনে রাখে যন্ত্রটি এখন কোন অবস্থায়। Cache-এর SRAM cell অবশ্য flip-flop নয়, তবে একই cross-coupled লুপ (পর্ব ৪৯)।

৯ · Verilog-এ flip-flop — posedge, reset আর non-blocking <=

পর্ব ১৪-এর শেষে flip-flop-এর আগাম চেহারা দেখেছিলেন। এবার পূর্ণ রূপ — asynchronous active-low reset আর clock enable-সহ একটি D flip-flop, আর পাশে একটি D latch তুলনার জন্য (synthesizable Verilog-2001, চালানো যায় না — উদাহরণ):

module dff_r (input  wire clk, rst_n, en, d,
              output reg  q);
  always @(posedge clk or negedge rst_n)   // edge list = flip-flop
    if (!rst_n)   q <= 1'b0;               // async clear: wins over the clock
    else if (en)  q <= d;                  // enable: synthesis adds the mux
                                           // no else: q keeps its value
endmodule

module d_latch (input wire en, d, output reg q);
  always @(*)                              // level-sensitive
    if (en) q = d;                         // no else -> a latch, on purpose
endmodule

তিনটি বিষয় লক্ষ করুন। (১) Sensitivity list-এ posedge clk থাকলেই synthesis flip-flop বানায়; or negedge rst_n যোগ করলে reset asynchronous হয়, কারণ block-টি reset নামার মুহূর্তেও জাগে। Reset-কে if-এর প্রথম শাখায় রাখা বাধ্যতামূলক — এটাই “clock-এর ওপর অগ্রাধিকার”। (২) else if (en)-এর পরে else নেই, তবু এখানে latch হয় না — clock-চালিত block-এ “মান না দেওয়া” মানে flip-flop-এর enable mux, যা আমরা চাই। পর্ব ১৪-এর latch-এর ফাঁদ শুধু always @(*)-এ। (৩) Latch সত্যিই চাইলে (বিরল) সেটি always @(*)-এ অসম্পূর্ণ if দিয়ে লেখা হয়, আর synthesis report-এ “latch inferred” সতর্কবার্তা আসে।

কেন <= — অদলবদলের ক্লাসিক উদাহরণ

Hardware-এ একই clock edge-এ সব flip-flop একসাথে মান নেয়: প্রত্যেকে edge-এর ঠিক আগের মান দেখে। Non-blocking assignment (<=) ঠিক এটাই মডেল করে — একটি time step-এ সব ডান পাশ আগে পড়ে, তারপর সব বাঁ পাশ একসাথে বসায়। Blocking assignment (=) software-এর মতো লাইন ধরে ধরে চলে, পরের লাইন আগের লাইনের নতুন মান দেখে। দুটি register-এর মান অদলবদল করতে গেলে পার্থক্যটা চোখে পড়ে:

1// edge-এর আগে: a = 1, b = 02always @(posedge clk) begin3  a = b;     // blocking4  b = a;5end6always @(posedge clk) begin7  a <= b;    // non-blocking8  b <= a;9end

এই নিয়ম না মানলে আরও সূক্ষ্ম বিপদ আছে: দুটি আলাদা always @(posedge clk) block-এ = ব্যবহার করলে simulator কোন block আগে চালাবে তার ওপর ফল নির্ভর করে — এক simulator-এ ঠিক, আরেকটিতে ভুল, আর synthesis-এর hardware হয়তো তৃতীয় কিছু। <= এই ক্রম-নির্ভরতা দূর করে।

১০ · AI-এর যুগে — টেবিল AI দিয়ে, যাচাই simulation দিয়ে

Flip-flop-এর টেবিল আর রূপান্তর দেখতে যান্ত্রিক কাজ, তাই AI চ্যাটবট দ্রুত উত্তর দেয় — কিন্তু এখানে ছোট একটি উল্টোপাল্টা পুরো উত্তর নষ্ট করে, আর ভাষা মডেল টেবিলটি সত্যিই simulate করে না। এই বিষয়ে প্রায়ই দেখা ভুলগুলো:

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

• Latch NOR না NAND, input active-high না active-low — প্রশ্ন আর উত্তরে একই আছে, মিলিয়েছি
• Excitation table-এর প্রতিটি সারির input characteristic equation-এ বসিয়ে Q⁺ মিলিয়েছি
• রূপান্তরের সূত্র সব সারিতে simulate করেছি — শুধু দুই-একটি উদাহরণে নয়
• Waveform-এর উত্তরে প্রতিটি edge চিহ্নিত করে দেখেছি latch আর flip-flop কখন আলাদা হয়
• Verilog-এ clock-চালিত block-এ শুধু <=, reset sensitivity list-এ negedge rst_n, আর testbench-এ চালিয়ে দেখেছি