Register, shift register আর counter

১ · Register — একসাথে clock পাওয়া কয়েকটি flip-flop

পর্ব ১৫-এ (Latch আর flip-flop) আপনি এক বিটের স্মৃতি দেখেছেন: একটি D flip-flop clock-এর উঠন্ত ধারে (rising edge) D-এর মান নিয়ে পরের ধার পর্যন্ত Q-তে ধরে রাখে। কিন্তু CPU এক বিট নিয়ে কাজ করে না — একটি সংখ্যা ৮, ৩২ বা ৬৪ বিটের। সমাধান সোজা: n টি D flip-flop পাশাপাশি বসান, সবার clock-এ একই তার দিন। এই দলটিই একটি n-বিটের register.

এমন register-কে বলা হয় PIPO (parallel-in, parallel-out): n টি বিট একসাথে ঢোকে, n টি বিট একসাথে পড়া যায়। এই পর্বে লেখার রীতি: register-এর বিট Q₃Q₂Q₁Q₀ এভাবে লেখা হবে, বাঁয়ে MSB; কোনো চলকের উল্টো A′ (prime) দিয়ে, আর কোডে ~A বা কোডের output-এ A'. XOR লেখা হবে ⊕ দিয়ে। Q⁺ মানে পরের clock edge-এর পরের মান (next state).

Load enable — নতুন মান নেবে কি না

সাধারণ register প্রতিটি clock edge-এ D নেয়। কিন্তু CPU-র ৩২টি register-এর মধ্যে এক cycle-এ সাধারণত একটিতেই লেখা হয় — বাকিদের পুরোনো মান রাখতে হবে। তাই দরকার একটি load enable (LD বা EN) সংকেত: EN = 1 হলে নতুন মান, EN = 0 হলে পুরোনো মান থেকে যাবে। এর দুটি উপায় আছে:

দ্বিতীয় সমস্যাটি ভয়ংকর, কারণ flip-flop সেই ভুয়া ধারেও মান নিয়ে নেয়। পর্ব ১৮-এ (Timing আর clock) clock skew আর setup-hold নিয়ম দেখার পর এর আসল ঝুঁকি পরিষ্কার হবে। তবে বাস্তব chip-এ clock gating একেবারে নিষিদ্ধ নয় — বিদ্যুৎ বাঁচাতে এটি খুব প্রচলিত, কিন্তু তখন একটি latch আর AND মিলিয়ে বানানো বিশেষ “integrated clock gating” সেল ব্যবহার করা হয়, যাতে clock 0 থাকার সময়েই শুধু enable বদলাতে পারে। নিজে হাতে AND gate বসিয়ে clock আটকানো নতুনদের একটি প্রচলিত ভুল। FPGA-তে প্রতিটি flip-flop-এ সাধারণত একটি তৈরি clock enable pin থাকে — যা ভেতরে আসলে mux-এর কাজই করে।

Clear — synchronous না asynchronous

চালু হওয়ার মুহূর্তে flip-flop-এর মান অনির্দিষ্ট (0 বা 1 যা খুশি)। তাই প্রায় সব register-এ একটি clear বা reset থাকে, যা সব বিটকে 0 করে। দুই রকম:

• Synchronous reset: reset = 1 হলেও মান বদলায় পরের clock edge-এ। আসলে এটি D-র সামনে আরেকটি gate: D_i = reset′·(পরের মান)। Clock চলতে হবে, নইলে reset কাজ করে না। সুবিধা: সবকিছু clock-এর ছন্দে, তাই timing বিশ্লেষণ সহজ।
• Asynchronous reset: flip-flop-এর ভেতরের একটি আলাদা pin (প্রায়ই active-low, CLR′) — চাপলেই সঙ্গে সঙ্গে Q = 0, clock-এর অপেক্ষা নেই। Power-on বা জরুরি অবস্থায় সুবিধাজনক, clock না চললেও কাজ করে। ঝুঁকি: reset ছাড়ার মুহূর্তটি clock edge-এর খুব কাছে পড়লে বিভিন্ন flip-flop ভিন্ন cycle-এ জেগে উঠতে পারে — তাই বাস্তবে reset সাধারণত asynchronous-ভাবে চাপা হয় কিন্তু ছাড়া হয় clock-এর সাথে মিলিয়ে (reset synchronizer পর্ব ১৭-এ, তার পেছনের metastability পর্ব ১৮-এ)।

পরীক্ষায় প্রায়ই একটি ৪-বিট register-এর ছবি আঁকতে বলা হয়, যেখানে প্রতিটি flip-flop-এর আগে একটি 2:1 mux (load) আর তার আগে বা পরে clear-এর gate. মনে রাখার সূত্র: অগ্রাধিকার clear > load > hold — প্রায় সব বাণিজ্যিক IC-তে এবং অংশ ৮-এর Verilog-এ এই ক্রম।

২ · Shift register — প্রতি clock-এ এক ঘর সরে

এবার flip-flop-গুলোকে পাশাপাশি না বসিয়ে একটি শিকলে জুড়ুন: প্রথমটির Q যায় দ্বিতীয়টির D-তে, দ্বিতীয়টির Q তৃতীয়টির D-তে, এভাবে। সবার clock একই। প্রতিটি clock edge-এ প্রতিটি flip-flop তার বাঁ পাশের প্রতিবেশীর পুরোনো মান নেয় — ফলে পুরো বিটের সারি এক ঘর সরে যায়। এটিই shift register.

চার রকম — ডেটা কীভাবে ঢোকে আর বের হয়

PISO-তে প্রতিটি flip-flop-এর সামনে একটি 2:1 mux লাগে: load = 1 হলে বাইরের parallel বিট, load = 0 হলে প্রতিবেশীর বিট। নিচের stepper-এ একটি ৪-বিট SIPO register-এ serial লাইনে 1011 পাঠানো হচ্ছে — MSB আগে, প্রতি clock-এ বাঁয়ে সরানো (shift left), নতুন বিট ঢোকে Q₀-তে:

Universal shift register — এক chip, চার mode

একটি universal shift register প্রতিটি flip-flop-এর সামনে একটি 4:1 mux বসায়, আর দুটি mode বিট S₁S₀ ঠিক করে D-তে কী যাবে: নিজের মান (hold), বাঁ প্রতিবেশী (shift right), ডান প্রতিবেশী (shift left), নাকি বাইরের parallel বিট (load). ডিজিটাল লজিক ল্যাবের পরিচিত 74194 (৪-বিট bidirectional universal shift register) এমনই একটি chip; প্রচলিত datasheet অনুযায়ী এর mode 00 = hold, 01 = shift right, 10 = shift left, 11 = parallel load, আর সঙ্গে একটি asynchronous, active-low clear — তবে ল্যাবে বসানোর আগে নির্মাতার datasheet-এ pin আর mode মিলিয়ে নিন।

কোথায় লাগে

• Serial ↔ parallel: একটি তার দিয়ে বিট একটির পর একটি পাঠানো সস্তা; CPU-র ভেতরে কাজ হয় একসাথে ৮ বা ৩২ বিটে। UART-এর transmitter একটি PISO (UART সাধারণত LSB আগে পাঠায়), receiver একটি SIPO. SPI-তে দুই পাশে দুটি shift register মিলে একটি বড় আংটির মতো — প্রতি clock-এ এক বিট বেরোয়, এক বিট ঢোকে (বেশিরভাগ ক্ষেত্রে MSB আগে, তবে configurable). বিস্তারিত পর্ব ৫১-এ (I/O আর bus). দ্রুত লিংকের SerDes (serializer/deserializer) এই ধারণারই বহু-গিগাবিটের রূপ।
• Delay line: n-বিটের SISO একটি সংকেতকে ঠিক n clock দেরি করায় — digital filter-এ বা ডেটাকে অন্য পথের সাথে সময় মেলাতে।
• ২ দিয়ে গুণ-ভাগ: বাঁয়ে এক ঘর সরিয়ে 0 ঢোকালে unsigned সংখ্যা ২ গুণ (0110 = ৬ → 1100 = ১২), ডানে সরালে ২ দিয়ে ভাগ, ভাগশেষ বাদ (0110 → 0011 = ৩)। Signed সংখ্যার ডান shift-এ খালি ঘরে sign বিট বসাতে হয় — arithmetic shift (পর্ব ০৬); 0 বসালে logical shift. বাঁয়ে সরাতে গিয়ে MSB-র 1 হারালে overflow.

৩ · Ring আর Johnson counter — শিকলের শেষ মাথা শুরুতে

Shift register-এর শেষ output আবার প্রথম input-এ ফিরিয়ে দিলে বিটগুলো ঘুরতে থাকে, বাইরে থেকে কিছু দিতে হয় না। প্রতিটি clock-এ register একটি নির্দিষ্ট state থেকে পরের state-এ যায়, আর কয়েক clock পরে শুরুতে ফেরে — অর্থাৎ এটি একটি counter, যদিও binary-তে গোনে না। দুই রকম feedback:

• Ring counter: Q₀ সরাসরি ফেরে Q₃-এ (ডানে সরানো ধরে)। শুরুতে ঠিক একটি 1 বসিয়ে দিলে (1000) সেটি ঘুরতে থাকে: 1000 → 0100 → 0010 → 0001 → 1000. n টি flip-flop-এ n টি state, আর প্রতিটি state one-hot — decode করতে কোনো gate লাগে না, প্রতিটি Q নিজেই একটি “এখন আমার পালা” সংকেত। বিনিময়ে flip-flop বেশি লাগে: ১০টি state-এর জন্য ১০টি।
• Johnson counter (twisted-ring বা Möbius counter): Q₀-এর উল্টো Q₀′ ফেরে Q₃-এ। 0000 থেকে শুরু করলে বাঁ দিক থেকে 1 ভরতে থাকে, পুরো ভরে গেলে 0 ভরতে থাকে: n টি flip-flop-এ ২n টি state.

কেন মাত্র দুটি বিট দেখলেই Johnson state চেনা যায়? প্রতিটি বৈধ Johnson state-এ 1-গুলো একটি টানা দল, আর 0-গুলো আরেকটি টানা দল — অর্থাৎ সারিতে (শেষ মাথা আর শুরুকে পাশাপাশি ধরে, একটি বৃত্তের মতো) বড়জোর দুটি “সীমানা” থাকে। প্রতিটি state-কে চেনানো যায় তার একটি নির্দিষ্ট সীমানা দিয়ে: যেমন 1100-এ Q₂ = 1 আর Q₁ = 0 — এমন “1-এর পরেই 0” ঠিক এই জায়গায় আর কোনো বৈধ state-এ নেই। দুটি প্রান্তিক state (0000 আর 1111)-এ ভেতরে কোনো সীমানা নেই, তাই সেখানে প্রান্তের দুটি বিট Q₃ আর Q₀ দেখা হয়। ফলে n যত বড়ই হোক, প্রতিটি decode gate ২-input — binary counter-এ যেখানে n-input AND লাগত। দ্রুত আর glitch-কম decode-এর জন্যই Johnson counter জনপ্রিয় (যেমন বহু-ধাপের timing সংকেত বানাতে)।

নিচের simulator প্রথমে অংশ ২-এর SIPO/SISO, PISO আর দ্বিমুখী shift চালায়, তারপর ৪-বিট ring আর Johnson counter-এর পুরো sequence, প্রতিটি Johnson state-এর ২-input decode (নিজে খুঁজে বের করে), আর অব্যবহৃত state-এর চক্র দেখায়:

// 4-bit shift register (r[0] = Q3 ... r[3] = Q0), then ring and Johnson counters.
const s = (r) => r.join("");
const left = (r, sin) => [...r.slice(1), sin];        // Q3 <- Q2 <- Q1 <- Q0 <- sin
const right = (r, sin) => [sin, ...r.slice(0, 3)];    // sin -> Q3 -> Q2 -> Q1 -> Q0
let r = [0, 0, 0, 0], out = [];
console.log("SIPO/SISO: serial in 1,0,1,1 (MSB first) at Q0, shift left");
for (const b of [1, 0, 1, 1, 0, 0, 0, 0]) {           // 4 more clocks push it out (SISO)
  out.push(r[0]); r = left(r, b);
  console.log(`  in=${b}  Q3..Q0=${s(r)}  shifted out of Q3=${out.at(-1)}`);
}
r = [1, 0, 1, 1]; out = [];                           // PISO: parallel load, then shift
for (let c = 0; c < 4; c++) { out.push(r[0]); r = left(r, 0); }
console.log(`PISO: load 1011, 4 left shifts, serial out = ${out.join(",")}`);
r = [0, 1, 1, 0];
const steps = [["L", left], ["R", right], ["R", right]];
console.log(`bidirectional from 0110 (=6): ` + steps.map(([n, f]) =>
  { r = f(r, 0); return `${n}->${s(r)}(=${parseInt(s(r), 2)})`; }).join("  "));
const seq = (start, fb) => { let q = start, a = [];
  do { a.push(q); q = right(q, fb(q)); } while (s(q) !== s(start)); return a; };
const ring = seq([1, 0, 0, 0], (q) => q[3]);          // Q0 back to Q3
const john = seq([0, 0, 0, 0], (q) => 1 - q[3]);      // NOT Q0 back to Q3
console.log(`ring    (${ring.length} states): ${ring.map(s).join(" ")}`);
console.log(`Johnson (${john.length} states): ${john.map(s).join(" ")}`);
const pairs = [[0, 3], [0, 1], [1, 2], [2, 3]], nm = ["Q3", "Q2", "Q1", "Q0"];
for (const q of john) {                               // 2-input AND that is 1 only here
  const [i, j] = pairs.find(([i, j]) =>
    john.filter((o) => o[i] === q[i] && o[j] === q[j]).length === 1);
  const lit = (k) => nm[k] + (q[k] ? "" : "'");
  console.log(`  ${s(q)} decoded by ${lit(i)}.${lit(j)}`);
}
const used = new Set(john.map(s)), bad = [];
for (let v = 0; v < 16 && bad.length === 0; v++) { const q = v.toString(2).padStart(4, "0");
  if (!used.has(q)) bad.push(...seq([...q].map(Number), (x) => 1 - x[3])); }
console.log(`unused Johnson states form their own loop: ${bad.map(s).join(" ")}`);

SIPO/SISO: serial in 1,0,1,1 (MSB first) at Q0, shift left
  in=1  Q3..Q0=0001  shifted out of Q3=0
  in=0  Q3..Q0=0010  shifted out of Q3=0
  in=1  Q3..Q0=0101  shifted out of Q3=0
  in=1  Q3..Q0=1011  shifted out of Q3=0
  in=0  Q3..Q0=0110  shifted out of Q3=1
  in=0  Q3..Q0=1100  shifted out of Q3=0
  in=0  Q3..Q0=1000  shifted out of Q3=1
  in=0  Q3..Q0=0000  shifted out of Q3=1
PISO: load 1011, 4 left shifts, serial out = 1,0,1,1
bidirectional from 0110 (=6): L->1100(=12)  R->0110(=6)  R->0011(=3)
ring    (4 states): 1000 0100 0010 0001
Johnson (8 states): 0000 1000 1100 1110 1111 0111 0011 0001
  0000 decoded by Q3'.Q0'
  1000 decoded by Q3.Q2'
  1100 decoded by Q2.Q1'
  1110 decoded by Q1.Q0'
  1111 decoded by Q3.Q0
  0111 decoded by Q3'.Q2
  0011 decoded by Q2'.Q1
  0001 decoded by Q1'.Q0
unused Johnson states form their own loop: 0010 1001 0100 1010 1101 0110 1011 0101

৪ · LFSR — XOR-এর feedback আর ছদ্ম-এলোমেলো সংখ্যা

Ring counter-এ feedback ছিল একটি তার, Johnson-এ একটি NOT. এবার feedback-এ কয়েকটি নির্দিষ্ট ঘরের (যাদের বলে tap) XOR দিন। এই circuit-এর নাম LFSR — linear feedback shift register. “Linear” কারণ XOR হলো mod-2 যোগ, আর পুরো circuit-টি mod-2 গণিতে একটি রৈখিক (linear) রূপান্তর। এখানে যে রূপটি দেখব তাকে বলে Fibonacci LFSR: বাঁয়ে সরানো, আর নতুন Q₀ = tap-গুলোর XOR.

কোন ঘরে tap, তা লেখা হয় একটি feedback polynomial দিয়ে। এই পর্বের রীতি: ঘরগুলোর নম্বর ১ থেকে n, serial input-এর দিক থেকে (stage k = Q_k−1); xⁿ + x^k + 1 মানে stage n আর stage k-এর XOR. উদাহরণ: x⁴ + x³ + 1 → নতুন Q₀ = Q₃ ⊕ Q₂. (বই আর tool ভেদে ঘর গোনার দিক আর polynomial লেখার রীতি আলাদা হয় — কেউ উল্টো polynomial লেখেন; তুলনা করার আগে রীতি মিলিয়ে নিন।)

কাজ করা উদাহরণ — ৪-বিট, x⁴ + x³ + 1, seed 0001

প্রতিটি সারিতে নতুন state = আগের state বাঁয়ে সরিয়ে শেষে XOR-এর বিট: যেমন 0100 → (Q3 ⊕ Q2 = 0 ⊕ 1 = 1) → 1001. ১৫ clock পরে seed 0001-এ ফিরে এল, আর মাঝে 0000 বাদে ১৫টি ভিন্ন state-এর প্রতিটি ঠিক একবার এসেছে। এমন সর্বোচ্চ দৈর্ঘ্যের চক্রকে বলে maximal-length sequence (m-sequence), দৈর্ঘ্য ২ⁿ − ১.

কেন ২ⁿ − ১, আর কেন সব tap কাজ করে না

০-এর ফাঁদ: সব বিট 0 হলে যেকোনো XOR-ও 0, তাই 0000 থেকে পরের state আবার 0000 — চিরকাল আটকে থাকে। তাই LFSR কখনো 0 seed দিয়ে শুরু করা যায় না, আর সর্বোচ্চ চক্রে বাকি ২ⁿ − ১টি state থাকতে পারে, বেশি নয়।

চক্র কেন হয়ই: প্রতিটি state-এর পরের state নির্দিষ্ট, আর আগের state-ও একটিই (বাঁয়ে সরানোর সময় যে MSB হারাল, তা feedback বিট থেকে উল্টো হিসাব করে ফিরে পাওয়া যায়, কারণ stage n সবসময় tap-এ থাকে)। অর্থাৎ next-state function একটি এক-এক (one-to-one) ম্যাপ — তাই সব state কয়েকটি বন্ধ চক্রে ভাগ হয়ে যায়, কোনো “লেজ” থাকে না।

কোন tap-এ একটিই বড় চক্র: mod-2 বীজগণিতে দেখানো যায়, চক্রটি পুরো ২ⁿ − ১ দৈর্ঘ্যের হয় ঠিক তখন, যখন feedback polynomial একটি primitive polynomial — মোটামুটি বললে, এমন polynomial যা ছোট polynomial-এর গুণফল নয় এবং যার “ক্রম” সর্বোচ্চ। x⁴ + x³ + 1 আর x⁴ + x + 1 primitive; কিন্তু x⁴ + x² + 1 = (x² + x + 1)² (mod 2-এ) — ভাঙা যায় বলে এটি ১৫টি state-কে ৬, ৬ আর ৩ দৈর্ঘ্যের তিনটি চক্রে ভাগ করে। পূর্ণ প্রমাণ finite field (Galois field) তত্ত্বের বিষয়; পরীক্ষায় সাধারণত tap দিয়ে sequence লিখে period গুনতে বলা হয়, যা নিচের simulator করে:

// Fibonacci LFSR: shift left, new Q0 = XOR of the tapped stages.
// Stage k = Q(k-1); polynomial x^n + x^k + 1 taps stages n and k.
function run(n, taps, seed) {
  const states = [];
  let q = seed;
  do {
    states.push(q);
    let fb = 0;
    for (const k of taps) fb ^= (q >> (k - 1)) & 1;   // read stage k
    q = ((q << 1) | fb) & ((1 << n) - 1);              // shift left, feed back
  } while (q !== seed);
  return states;
}
const bin = (v, n) => v.toString(2).padStart(n, "0");
function report(n, taps, seed = 1) {
  const st = run(n, taps, seed), max = 2 ** n - 1;
  const poly = taps.map((k) => (k > 1 ? `x^${k}` : "x")).join(" + ") + " + 1";
  console.log(`${n}-bit, ${poly}: period ${st.length} ` +
    (st.length === max ? "= 2^n - 1, MAXIMAL" : `< ${max}, not maximal`));
  return st;
}
const s4 = report(4, [4, 3]);
console.log("  states: " + s4.map((v) => bin(v, 4)).join(" "));
console.log("  output bit Q3: " + s4.map((v) => (v >> 3) & 1).join(""));
const ones = s4.filter((v) => (v >> 3) & 1).length;  console.log(`  ones: ${ones}, zeros: ${15 - ones}`);
report(4, [4, 1]);
const s5 = report(5, [5, 3]);
console.log("  first 8 states: " + s5.slice(0, 8).map((v) => bin(v, 5)).join(" "));
report(4, [4, 2]);                                     // x^4 + x^2 + 1 = (x^2 + x + 1)^2
const seen = new Set(), loops = [];                    // split all 15 non-zero states
for (let v = 1; v < 16; v++) if (!seen.has(v)) {
  const c = run(4, [4, 2], v); c.forEach((x) => seen.add(x)); loops.push(c.length);
}
console.log(`  x^4 + x^2 + 1 splits the 15 non-zero states into loops of ${loops.join(", ")}`);
console.log(`  seed 0000 with any taps -> period ${run(4, [4, 3], 0).length} (stuck forever)`);

4-bit, x^4 + x^3 + 1: period 15 = 2^n - 1, MAXIMAL
  states: 0001 0010 0100 1001 0011 0110 1101 1010 0101 1011 0111 1111 1110 1100 1000
  output bit Q3: 000100110101111
  ones: 8, zeros: 7
4-bit, x^4 + x + 1: period 15 = 2^n - 1, MAXIMAL
5-bit, x^5 + x^3 + 1: period 31 = 2^n - 1, MAXIMAL
  first 8 states: 00001 00010 00100 01001 10010 00101 01011 10110
4-bit, x^4 + x^2 + 1: period 6 < 15, not maximal
  x^4 + x^2 + 1 splits the 15 non-zero states into loops of 6, 6, 3
  seed 0000 with any taps -> period 1 (stuck forever)

LFSR কোথায় কাজে লাগে

৫ · Asynchronous (ripple) counter — সস্তা, কিন্তু delay জমে

এবার সত্যিকারের binary counter. সবচেয়ে সরল নকশাটি পর্ব ১৫-এর T flip-flop দিয়ে: T = 1 রাখলে প্রতিটি সক্রিয় clock edge-এ Q উল্টে যায় (toggle). ধরুন flip-flop-গুলো নামন্ত ধারে (falling edge, 1 → 0) সক্রিয়। প্রথমটির clock-এ আসল clock, আর প্রতিটি পরের flip-flop-এর clock-এ আগেরটির Q. তাহলে Q₁ উল্টায় যখনই Q₀ 1 থেকে 0-তে নামে — ঠিক যেমন binary যোগে নিচের ঘর 1 থেকে 0 হলে carry যায় ওপরের ঘরে। T flip-flop না থাকলে J = K = 1 রাখা JK flip-flop একই কাজ করে।

এখানে flip-flop-গুলো একই clock পায় না — প্রতিটি আগেরটির output দেখে চলে, তাই এটি asynchronous, আর বদল ঢেউয়ের মতো এক ঘর থেকে পরের ঘরে ছড়ায় বলে নাম ripple counter. Delay উপেক্ষা করলে ৩-বিটের waveform এমন (প্রতিটি “↓” clock-এর নামন্ত ধার):

count    0   1   2   3   4   5   6   7   0
CLK    __‾‾__‾‾__‾‾__‾‾__‾‾__‾‾__‾‾__‾‾__
           ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
Q0     ____‾‾‾‾____‾‾‾‾____‾‾‾‾____‾‾‾‾__   f/2
Q1     ________‾‾‾‾‾‾‾‾________‾‾‾‾‾‾‾‾__   f/4
Q2     ________________‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾__   f/8

দুটি জিনিস চোখে পড়ে। প্রথমত, প্রতিটি Q নিচেরটির অর্ধেক হারে ওঠানামা করে — Q₀-এর frequency clock-এর অর্ধেক, Q₁-এর এক-চতুর্থাংশ। অর্থাৎ n টি stage-এর ripple counter একটি f/২ⁿ frequency divider, আর প্রতিটি output-এর duty cycle ঠিক ৫০% (অর্ধেক সময় 1). দ্বিতীয়ত, Q₂Q₁Q₀ একসাথে পড়লে 0, 1, 2 … 7 — binary-তে গোনা। Down counter বানাতে প্রতিটি পরের stage-এর clock-এ Q-এর বদলে Q′ দিন (অথবা উঠন্ত-ধারের flip-flop-এ Q দিন): তখন নিচের বিট 0 থেকে 1-এ উঠলে ওপরেরটি উল্টায় — ঠিক বিয়োগের borrow.

সমস্যা — delay জমে, আর মাঝপথে ভুল মান

বাস্তবে প্রতিটি flip-flop clock পাওয়ার পর Q বদলাতে কিছু সময় নেয় — তার propagation delay t_pd. Ripple counter-এ দ্বিতীয় flip-flop জানতেই পারে না যে তাকে উল্টাতে হবে, যতক্ষণ না প্রথমটি উল্টে যায়। সবচেয়ে খারাপ ক্ষেত্রে (যেমন 011 → 100 বা 111 → 000) সবগুলো stage একের পর এক উল্টায়, তাই চূড়ান্ত মান স্থির হতে লাগে n × t_pd. এর মাঝের সময়ে counter কিছু সত্যিকারের কিন্তু ভুল মান দেখায় — নিচের stepper-এ t_pd = ১০ ns ধরে দেখুন:

এই হিসাব থেকেই পরীক্ষার প্রচলিত সূত্র: counter-এর মান প্রতি cycle-এ অন্তত একবার স্থির হয়ে পড়ার মতো থাকতে হলে clock period T ≥ n·t_pd (আর output decode করলে তার সাথে decoder gate-এর delay). তাই

যেমন ৪-বিট, t_pd = ১০ ns, decode না করলে: ১ / ৪০ ns = ২৫ MHz. শুধু frequency ভাগ করতে চাইলে (প্রতিটি Q আলাদাভাবে ব্যবহার) এই সীমা খাটে না — প্রথম flip-flop যত দ্রুত toggle করতে পারে, ততটাই যথেষ্ট; তখন delay শুধু output-গুলোর মধ্যে সময়ের গরমিল (skew) বানায়। নিচের C program পুরো ৮টি গোনার প্রতিটি বদল সময়সহ ছাপে, ক্ষণস্থায়ী মানগুলো চিহ্নিত করে, আর “count = 6” decoder কতবার ভুল pulse দিল গোনে:

#include <stdio.h>
/* 3-bit ripple (asynchronous) up counter. Stage 0 toggles TPD ns after
   each clock edge; stage i+1 toggles TPD ns after stage i falls 1 -> 0. */
#define N   3
#define TPD 10                       /* flip-flop delay in ns */

int main(void) {
    unsigned q = 0, false6 = 0;      /* q = Q2 Q1 Q0 */
    printf("time(ns)  Q2Q1Q0  value\n");
    for (int clk = 1; clk <= 8; clk++) {
        int t = clk * 100;           /* one active clock edge every 100 ns */
        unsigned target = (q + 1) % (1u << N);
        for (int stage = 0; stage < N; stage++) {
            unsigned old = (q >> stage) & 1u;
            t += TPD;
            q ^= 1u << stage;        /* this flip-flop toggles now */
            printf("%6d     %u%u%u    %u%s\n", t, (q >> 2) & 1u, (q >> 1) & 1u,
                   q & 1u, q, q == target ? "" : "   <- transient");
            if (q == 6 && target != 6) false6++;
            if (old == 0) break;     /* 0 -> 1: no falling edge, ripple stops */
        }
    }
    printf("decoder for 6 (Q2.Q1.Q0') gave %u false pulse(s)\n", false6);
    printf("worst settle = %d x %d = %d ns -> f_max about %d MHz\n",
           N, TPD, N * TPD, 1000 / (N * TPD));
    return 0;
}

time(ns)  Q2Q1Q0  value
   110     001    1
   210     000    0   <- transient
   220     010    2
   310     011    3
   410     010    2   <- transient
   420     000    0   <- transient
   430     100    4
   510     101    5
   610     100    4   <- transient
   620     110    6
   710     111    7
   810     110    6   <- transient
   820     100    4   <- transient
   830     000    0
decoder for 6 (Q2.Q1.Q0') gave 1 false pulse(s)
worst settle = 3 x 10 = 30 ns -> f_max about 33 MHz

৬ · Synchronous counter নকশা — excitation table থেকে সমীকরণ

সমাধানটি নীতিগত: সব flip-flop একই clock পাবে (synchronous counter), আর কোন flip-flop এই edge-এ উল্টাবে বা কী মান নেবে, তা ঠিক করবে একটি combinational circuit — present state থেকে। তখন সব বিট একই মুহূর্তে (একটি t_pd পরে) বদলায়, মাঝপথের ভুল মান প্রায় থাকে না, আর ইচ্ছেমতো যেকোনো sequence বানানো যায় — শুধু 0, 1, 2… নয়।

Excitation table — এক লাইনের স্মরণ

পর্ব ১৫-এর excitation table উল্টো প্রশ্নের উত্তর দেয়: Q থেকে Q⁺-এ যেতে input কী হতে হবে? এখানে শুধু সারাংশ:

অর্থাৎ D = Q⁺, T = Q ⊕ Q⁺, আর JK-তে দুটি x (don't care) — যেমন 0 → 1-এ J = 1 দিলেই হয়, K = 0 (set) বা 1 (toggle) দুটোতেই Q⁺ = 1. এই বাড়তি x-গুলোর জন্যই JK নকশায় সমীকরণ প্রায়ই সবচেয়ে ছোট হয়।

নকশার রেসিপি

1. State আর flip-flop: M টি state-এর জন্য n = ⌈log₂ M⌉ টি flip-flop (mod-6-এ ৩টি)।
2. State table: প্রতিটি present state-এর পাশে next state. অব্যবহৃত state-এর next state = don't care (আপাতত)।
3. Flip-flop input-এর কলাম: প্রতিটি বিটের Q → Q⁺ দেখে excitation table থেকে D, T বা J, K লিখুন।
4. K-map: প্রতিটি input-এর জন্য একটি K-map (পর্ব ০৯), অব্যবহৃত state আর JK-র x সব don't care; সরল SOP বের করুন।
5. যাচাই: সমীকরণে প্রতিটি অব্যবহৃত state বসিয়ে দেখুন সে কোথায় যায় — কয়েক clock-এর মধ্যে মূল চক্রে ফিরলে counter self-starting; না ফিরলে lock-out, নকশা ঠিক করতে হবে।

কাজ করা উদাহরণ ১ — ৩-বিট synchronous binary up counter

0 → 1 → … → 7 → 0. Binary যোগ মনে করুন: বিট i উল্টায় ঠিক তখন, যখন তার নিচের সব বিট 1 (carry আসছে)। তাই T flip-flop দিয়ে K-map ছাড়াই উত্তর: T₀ = 1, T₁ = Q₀, T₂ = Q₁Q₀, আর সাধারণভাবে T_i = Q_i−1···Q₀. JK দিয়ে একই: J_i = K_i = T_i. নিচের designer K-map পদ্ধতিতেও ঠিক এটিই পায়।

গতির হিসাব: এখন clock period-এর সীমা হলো একটি flip-flop-এর delay + AND gate-এর delay + পরের flip-flop-এর setup time (পর্ব ১৮): T ≥ t_pd,FF + t_AND + t_setup. ধরুন ১০ + ৫ + ৫ = ২০ ns → ৫০ MHz, n যত বড়ই হোক (যতক্ষণ প্রতিটি AND একটি স্তরে বানানো যায়)। একই flip-flop-এ ৪-বিট ripple counter-এর মান পড়তে লাগত ৪০ ns (২৫ MHz). খুব চওড়া counter-এ (যেমন ৬৪ বিট) AND gate-এর fan-in অনেক বড় হয়, তখন adder-এর carry-lookahead-এর মতো (পর্ব ১১) কৌশলে AND-গুলো ভাগে ভাগে বানানো হয়।

কাজ করা উদাহরণ ২ — mod-6 counter, D flip-flop দিয়ে

0 → 1 → 2 → 3 → 4 → 5 → 0; state 6 (110) আর 7 (111) অব্যবহৃত। D = Q⁺, তাই next state-এর বিটগুলোই D-র কলাম:

K-map-এ don't care ব্যবহার করে: D₀ = 1 সারি ০, ২, ৪-এ → D₀ = Q₀′. D₁ = 1 সারি ১, ২-এ: m2-কে m6 (x)-এর সাথে জুড়ে Q₁Q₀′, আর m1-এর কোনো 1 বা x প্রতিবেশী নেই (m0, m3, m5 সবই 0) → D₁ = Q₁Q₀′ + Q₂′Q₁′Q₀. D₂ = 1 সারি ৩, ৪-এ: m3 + m7 → Q₁Q₀, m4 + m6 → Q₂Q₀′ → D₂ = Q₁Q₀ + Q₂Q₀′.

Self-starting যাচাই: 110-এ D₂ = 0 + 1 = 1, D₁ = 1 + 0 = 1, D₀ = 1 → 111. আবার 111-এ D₂ = 1 + 0 = 1, D₁ = 0 + 0 = 0, D₀ = 0 → 100 = ৪, যা মূল চক্রে। তাই 6 → 7 → 4 — দুই clock-এর মধ্যে counter নিজেই ঠিক হয়ে যায়: self-starting. এবার একই counter JK দিয়ে, শুধু Q₂-এর input-গুলো ধাপে ধাপে:

হাতের এই পদ্ধতিটি যন্ত্রে চালানো যায়। নিচের designer যেকোনো ৩-বিট sequence আর flip-flop-এর ধরন (D, T বা JK) নেয়, excitation table থেকে প্রতিটি input-এর 1 আর don't care বের করে, প্রতিটি সম্ভাব্য prime implicant-এর সমষ্টি খুঁজে সবচেয়ে ছোট SOP বাছে (brute force — ৩ চলকে মুহূর্তে হয়), তারপর circuit-টি simulate করে sequence নিশ্চিত করে, আর প্রতিটি অব্যবহৃত state কোথায় যায় তা দেখায়:

// Synchronous counter designer: state sequence + flip-flop type -> minimal SOP inputs.
const N = 3, NAME = ["Q2", "Q1", "Q0"], ALL = [...Array(2 ** N).keys()];
const EXC = { D: (q, n) => [n], T: (q, n) => [q ^ n],                 // excitation tables
  JK: (q, n) => (q === 0 ? [n, "x"] : ["x", 1 - n]) };
const FF = { D: (q, i) => i[0], T: (q, i) => q ^ i[0], JK: (q, i) => (q ? 1 - i[1] : i[0]) };
const hit = (c, s) => (s & c.m) === c.v, bit = (x, k) => (x >> (N - 1 - k)) & 1;
const text = (c) => NAME.map((nm, k) => (bit(c.m, k) ? nm + (bit(c.v, k) ? "" : "'") : "")).join("") || "1";
function minimise(on, dc) { const imp = []; // brute force over prime implicants; cube {m: bits used, v: values}
  for (let m = 0; m < 2 ** N; m++) for (let v = 0; v < 2 ** N; v++)
    if ((v & ~m) === 0 && ALL.every((s) => !hit({ m, v }, s) || on.has(s) || dc.has(s))) imp.push({ m, v });
  const pr = imp.filter((a) => !imp.some((b) => b !== a && (b.m & a.m) === b.m && (a.v & b.m) === b.v));
  let best = { pick: [], cost: Infinity };
  for (let set = 0; set < 2 ** pr.length; set++) {
    const pick = pr.filter((_, k) => (set >> k) & 1);
    const cost = pick.reduce((t, c) => t + 10 + NAME.filter((_, k) => bit(c.m, k)).length, 0);
    if ([...on].every((s) => pick.some((c) => hit(c, s))) && cost < best.cost) best = { pick, cost };
  }
  return best.pick;
}
function design(seq, type) {
  const next = new Map(seq.map((s, i) => [s, seq[(i + 1) % seq.length]])), eq = [];
  for (let k = 0; k < N; k++) for (let p = 0; p < (type === "JK" ? 2 : 1); p++) {
    const on = new Set(), dc = new Set(); for (const s of ALL) { const x = next.has(s) ? EXC[type](bit(s, k), bit(next.get(s), k))[p] : "x";
      if (x === "x") dc.add(s); else if (x) on.add(s); }
    eq.push({ k, cubes: minimise(on, dc), name: (type === "JK" ? "JK"[p] : type) + (N - 1 - k) });
  }
  const step = (s) => ALL.slice(0, N).reduce((t, _, k) => t | FF[type](bit(s, k),
    eq.filter((e) => e.k === k).map((e) => +e.cubes.some((c) => hit(c, s)))) << (N - 1 - k), 0);
  console.log(`${seq.join("->")}->${seq[0]}, ${type}: ` + eq.map((e) => `${e.name} = ${e.cubes.map(text).join(" + ") || "0"}`).join(", "));
  const un = ALL.filter((s) => !next.has(s)).map((s) => { const path = [s];
    while (!next.has(path.at(-1)) && path.indexOf(step(path.at(-1))) < 0) path.push(step(path.at(-1)));
    return path.join("->") + (next.has(path.at(-1)) ? " ok" : `->${step(path.at(-1))} LOCK-OUT`); });
  console.log(`  sequence ${seq.every((s, i) => step(s) === next.get(s)) ? "confirmed" : "WRONG"}; unused: ${un.join(", ") || "none"}`);
}
for (const [q, t] of [[[0, 1, 2, 3, 4, 5, 6, 7], "T"], [[0, 1, 2, 3, 4, 5], "D"], [[0, 1, 2, 3, 4, 5], "JK"], [[0, 3, 5, 6], "JK"], [[0, 3, 5, 6], "D"]]) design(q, t);

0->1->2->3->4->5->6->7->0, T: T2 = Q1Q0, T1 = Q0, T0 = 1
  sequence confirmed; unused: none
0->1->2->3->4->5->0, D: D2 = Q1Q0 + Q2Q0', D1 = Q1Q0' + Q2'Q1'Q0, D0 = Q0'
  sequence confirmed; unused: 6->7->4 ok, 7->4 ok
0->1->2->3->4->5->0, JK: J2 = Q1Q0, K2 = Q0, J1 = Q2'Q0, K1 = Q0, J0 = 1, K0 = 1
  sequence confirmed; unused: 6->7->0 ok, 7->0 ok
0->3->5->6->0, JK: J2 = Q0, K2 = Q0', J1 = 1, K1 = 1, J0 = Q1', K0 = Q1'
  sequence confirmed; unused: 1->6 ok, 2->0 ok, 4->3 ok, 7->5 ok
0->3->5->6->0, D: D2 = Q0, D1 = Q1', D0 = Q2'
  sequence confirmed; unused: 1->7->4->2->1 LOCK-OUT, 2->1->7->4->2 LOCK-OUT, 4->2->1->7->4 LOCK-OUT, 7->4->2->1->7 LOCK-OUT

BCD (mod-10) counter: ৪টি flip-flop, state ০ থেকে ৯, আর ১০ থেকে ১৫ অব্যবহৃত। একই রেসিপিতে T flip-flop দিয়ে পাওয়া যায় T₀ = 1, T₁ = Q₃′Q₀, T₂ = Q₁Q₀, T₃ = Q₃Q₀ + Q₂Q₁Q₀ — অনুশীলন ১-এ পুরো সমাধান আর self-starting যাচাই। এমন counter দিয়ে ঘড়ি, ক্যালকুলেটর বা মিটারে দশমিক অঙ্ক গোনা হয়, আর প্রতিটি অঙ্কের output সরাসরি 7-segment decoder-এ (পর্ব ১২) যায়।

৭ · আরও counter, আর বাস্তবে কোথায় গুনছে

Up/down counter — একটি mode input

একটি mode বিট M যোগ করুন: M = 0 হলে ওপরে, M = 1 হলে নিচে গোনা। Up-এ বিট i উল্টায় যখন নিচের সব বিট 1; down-এ যখন নিচের সব বিট 0 (borrow). তাই ৩-বিটে up/down counter-এর T-সমীকরণ:

যাচাই (script দিয়ে): M = 0-তে 0, 1, 2, … 7, 0; M = 1-এ 0, 7, 6, … 1, 0. লিফটের তলার সূচক বা ক্রিকেট স্কোরবোর্ডের “বল বাকি” — দুই দিকেই গোনা লাগে এমন যেকোনো জায়গায় এই নকশা।

Parallel load আর mod-N — 74163-এর কৌশল

বাস্তব counter IC-তে register-এর মতোই parallel load থাকে: LOAD সক্রিয় হলে counter বাইরের একটি সংখ্যা নিয়ে নেয়, তারপর সেখান থেকে গোনে। ল্যাবের পরিচিত 74163 (৪-বিট synchronous binary counter) প্রচলিত datasheet অনুযায়ী synchronous clear, synchronous load, দুটি count-enable (ENP, ENT) আর একটি ripple carry output (RCO, count 1111 আর ENT = 1 হলে 1) দেয়; RCO পরের chip-এর ENT-তে দিয়ে ৮, ১২ বা ১৬ বিট জোড়া যায়। এর জুড়ি 74161-এ clear asynchronous — নকশায় এই পার্থক্যটাই আসল (pin আর সক্রিয়-নিম্ন সংকেত datasheet-এ মিলিয়ে নিন)।

পরীক্ষার প্রিয় প্রশ্ন — mod-10 বানান: synchronous clear (74163)-এ count ৯ (1001) চিনে clear দিন: পরের edge-এ 0000, তাই ০–৯. Asynchronous clear (74161)-এ ৯ চিনলে counter ৯-এই সঙ্গে সঙ্গে মুছে যেত — তাই চিনতে হয় ১০ (1010), যা কয়েক ns-এর জন্য দেখা দিয়ে মিলিয়ে যায় (আবার সেই glitch-ধাঁচের ক্ষণস্থায়ী state). এজন্য synchronous clear বা load দিয়ে mod-N বানানো বেশি নিরাপদ।

Gray-code counter

পর্ব ০৪-এর (সংখ্যা পদ্ধতি) Gray code-এ পরপর দুটি মানে ঠিক একটি বিট বদলায়: 000, 001, 011, 010, 110, 111, 101, 100. এই sequence-কে অংশ ৬-এর designer-এ দিলেই একটি Gray-code counter পাওয়া যায়। লাভ: প্রতি গোনায় একটিই flip-flop বদলায়, তাই বিদ্যুৎ কম আর ভিন্ন clock-এর অংশ থেকে counter পড়লেও বড় ভুল হয় না — পড়ার মুহূর্তে বড়জোর পুরোনো বা নতুন মান, মাঝের কোনো আজব মান নয়। Asynchronous FIFO-র pointer এভাবেই এক clock domain থেকে আরেকটিতে পাঠানো হয় (ভাবনার প্রশ্ন ০৫; পর্ব ১৮)।

Frequency divider — ঘড়ির ৩২,৭৬৮ Hz থেকে ১ Hz

হাতঘড়ি বা দেয়ালঘড়ির quartz crystal সাধারণত ৩২,৭৬৮ Hz-এ কাঁপে। সংখ্যাটি বেছে নেওয়ার কারণ: ৩২,৭৬৮ = ২^১৫. তাই ১৫টি T flip-flop-এর একটি ripple counter শেষ stage-এ ঠিক ১ Hz দেয় — প্রতি সেকেন্ডে এক টিক। এখানে ripple-এর delay কোনো সমস্যা নয়, কারণ কেউ পুরো count পড়ছে না, শুধু শেষ বিটটি ব্যবহার হচ্ছে; আর ripple counter-এ বেশিরভাগ flip-flop খুব কম বদলায় বলে বিদ্যুৎ খরচ নগণ্য — ব্যাটারির ঘড়ির জন্য আদর্শ। ২-এর ঘাত নয় এমন ভাগের জন্য (÷N) একটি mod-N counter লাগে; তখন output-এর duty cycle ৫০% না-ও হতে পারে।

CPU আর microcontroller-এর ভেতরে counter

• Program counter: একটি ৩২-বিট register, যার পরের মান প্রায় সবসময় PC + 4 (RV32I-এ প্রতিটি instruction ৪ byte; compressed extension থাকলে কখনো + 2), আর branch-jump-এ একটি নতুন ঠিকানা load. অর্থাৎ এটি “parallel load-সহ counter”, শুধু ১-এর বদলে ৪ যোগ — বাস্তবে একটি adder আর একটি mux দিয়ে। পুরো ছবি পর্ব ৩২-এ (Single-cycle datapath), যেখানে register file-ও আসবে।
• Timer আর watchdog: microcontroller-এর timer একটি prescaler (frequency divider) আর একটি counter, যা নির্দিষ্ট মানে পৌঁছালে interrupt দেয় — LED জ্বালানো-নেভানো থেকে motor-এর PWM পর্যন্ত। Watchdog একটি counter যা software-কে নিয়মিত reset করতে হয়; software আটকে গেলে counter শেষ সীমায় পৌঁছে পুরো chip reset করে দেয়। বিস্তারিত পর্ব ৫৬-এ।
• Performance counter: CPU-র ভেতরে cycle, instruction, cache miss গোনার ৬৪-বিট counter — RISC-V-তে যেমন mcycle আর minstret. পর্ব ০৩-এ CPI মাপার সময় আপনি এদের সংখ্যাই ব্যবহার করেছেন।

৮ · Verilog-এ counter আর shift register, আর ল্যাবের IC

পর্ব ১৪-এ (Verilog-এর পরিচয়) আপনি always @(posedge clk) আর non-blocking assignment (<=) দেখেছেন। এই পর্বের সব block এই দুটি দিয়েই কয়েক লাইনে লেখা যায়। নিচে synthesizable Verilog-2001 (চালানো যায় না — উদাহরণ): একটি ৪-বিট counter (asynchronous active-low reset, load, enable আর terminal count), একটি ৮-বিট shift register (synchronous reset, enable), আর একটি ৪-বিট LFSR:

// উদাহরণ — synthesizable Verilog-2001
module counter4 (
  input  wire       clk, rst_n,       // rst_n: asynchronous, active-low
  input  wire       load, en,         // priority: reset > load > count
  input  wire [3:0] d,
  output reg  [3:0] q,
  output wire       tc                // terminal count: q == 15 while enabled
);
  always @(posedge clk or negedge rst_n)
    if (!rst_n)     q <= 4'd0;
    else if (load)  q <= d;
    else if (en)    q <= q + 4'd1;    // no final else: q simply holds
  assign tc = en & (q == 4'd15);
endmodule

module shift8 (
  input  wire       clk, rst,         // rst: synchronous, active-high
  input  wire       en, sin,
  output reg  [7:0] q,                // parallel out (SIPO)
  output wire       sout              // serial out (SISO)
);
  always @(posedge clk)
    if (rst)      q <= 8'd0;
    else if (en)  q <= {q[6:0], sin};  // shift left, serial in at bit 0
  assign sout = q[7];
endmodule

module lfsr4 (input wire clk, rst, output reg [3:0] q);  // x^4 + x^3 + 1
  always @(posedge clk)
    if (rst) q <= 4'b0001;              // never seed with 0000
    else     q <= {q[2:0], q[3] ^ q[2]};
endmodule

তিনটি বিষয় খেয়াল করুন। (১) else if (en)-এর পরে কোনো else নেই, তবু এখানে অনিচ্ছাকৃত latch তৈরি হয় না — clock-চালিত block-এ “কিছু না বলা” মানে flip-flop আগের মান রাখবে, আর synthesis tool ঠিক অংশ ১-এর load-enable mux বানায় (অথবা flip-flop-এর clock-enable pin ব্যবহার করে)। Clock আটকানো হয় না। (২) Sensitivity list-এ negedge rst_n থাকলেই reset asynchronous; shift8-এর মতো শুধু posedge clk থাকলে synchronous. (৩) {q[6:0], sin}-এর concatenation-ই পুরো shift — আর non-blocking <=-এর কারণে সব বিট একসাথে পুরোনো মান পড়ে, ঠিক hardware-এর মতো। এখানে blocking = দিয়ে বিটগুলো একটি একটি লিখলে simulation আর hardware-এর আচরণ আলাদা হয়ে যেতে পারত।

ল্যাবের পরিচিত IC

বিশ্ববিদ্যালয়ের ল্যাবে প্রায়ই 74-series chip দিয়ে এই block-গুলো জোড়া হয়। নিচের বর্ণনা প্রচলিত datasheet অনুযায়ী; পরিবার (74LS, 74HC ইত্যাদি) আর নির্মাতাভেদে খুঁটিনাটি আলাদা হতে পারে, তাই বসানোর আগে datasheet মিলিয়ে নিন:

৯ · AI-এর যুগে — sequence নিজে simulate করে যাচাই

“JK flip-flop দিয়ে mod-6 counter নকশা করুন” লিখলে AI চ্যাটবট কয়েক সেকেন্ডে টেবিল আর সমীকরণ দেয় — প্রায়ই নিখুঁত দেখতে, কিন্তু একটি K-map দল ভুল, বা excitation table-এর x বসানো উল্টো। অব্যবহৃত state যাচাই সে প্রায়ই বাদই দেয়। এই পর্বের বিষয়ে সাধারণ ভুলগুলো:

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

• প্রতিটি present state-এর জন্য সমীকরণ থেকে next state হিসাব করে sequence মিলিয়েছি
• Excitation table-এর প্রতিটি x আর 0/1 নিজে মিলিয়েছি (বিশেষ করে JK-তে)
• প্রতিটি অব্যবহৃত state থেকে চালিয়ে দেখেছি — self-starting নাকি lock-out
• LFSR-এর tap-এর রীতি লিখে পুরো period গুনেছি; seed 0 নয়
• Verilog নকশা simulate করে waveform দেখেছি, আর IC-র তথ্য datasheet-এ মিলিয়েছি