প্রজেক্ট — traffic light আর vending machine controller নকশা

১ · প্রজেক্টের পথ — specification থেকে যাচাই করা circuit

এই মডিউলের আগের চারটি পর্বে আপনি sequential লজিকের সব যন্ত্রপাতি হাতে পেয়েছেন: পর্ব ১৫-এ latch আর flip-flop, পর্ব ১৬-এ register আর counter, পর্ব ১৭-এ FSM নকশার পুরো পদ্ধতি (Moore, Mealy, state minimisation, state assignment, one-hot), আর পর্ব ১৮-এ timing, debouncing আর synchroniser. এই পর্বে নতুন কোনো তত্ত্ব নেই। এখানে আমরা সেই যন্ত্রপাতি দিয়ে দুটি আসল জিনিস বানাব — যেভাবে একটি ল্যাব রিপোর্ট বা প্রজেক্ট রিপোর্টে লেখা হয়।

প্রথম প্রজেক্ট একটি traffic light controller: একটি ব্যস্ত প্রধান সড়ক আর একটি পার্শ্ব রাস্তার মোড়ের সিগন্যাল। দ্বিতীয়টি একটি vending machine controller: ৫ আর ১০ টাকা নিয়ে ১৫ টাকার চা বা বিস্কুটের প্যাকেট দেয়, বেশি দিলে ভাংতি ফেরত দেয়। দুটিই finite state machine (FSM): প্রথমটি শেখায় FSM-কে একটি counter-এর সাথে জোড়া, দ্বিতীয়টি টাকার মতো “হারানো চলবে না” জিনিস সামলানোর সতর্কতা।

একটি প্রজেক্ট নিচের ধাপগুলো ধরে এগোয়, আর প্রতিটি ধাপের সিদ্ধান্ত লিখে রাখা হয়:

1. 📋চাহিদাR1…R6কী করতে হবে, কী কখনো নয়
3. 🔵State diagramMG → MY …অবস্থা আর তীর
5. 🧮Table → সমীকরণD1 = …encoding, K-map
7. 📝RTL + testbench.vsimulation
9. ✅Reviewtiming, LUTFPGA-তে নামানো

২ · প্রজেক্ট A, ধাপ ১ — মোড়টি বুঝে requirement লেখা

ধরুন একটি জেলা শহরের একটি প্রধান সড়ক, যেখানে সারাদিন বাস, ট্রাক আর রিকশা চলে। তার সাথে মিশেছে একটি মহল্লার পার্শ্ব রাস্তা, যেখানে গাড়ি আসে মাঝে মাঝে। এখন সিগন্যালটি একটি সাধারণ timer-এ চলে — পার্শ্ব রাস্তায় কেউ না থাকলেও প্রধান সড়ক বারবার থামে। পৌরসভা চায় “বুদ্ধিমান” সিগন্যাল: পার্শ্ব রাস্তার মুখে মাটির নিচে একটি গাড়ি শনাক্তকারী সেন্সর (যেমন রাস্তার নিচে তারের কুণ্ডলী — inductive loop — বা একটি ক্যামেরা) বসানো হবে। গাড়ি থাকলে সেন্সরের output C = 1.

“বুদ্ধিমান সিগন্যাল” কথাটি পরীক্ষা করা যায় না। তাই প্রথম কাজ এটিকে এমন কয়েকটি বাক্যে ভাঙা, যার প্রতিটির সত্য-মিথ্যা যাচাই করা যায়। এখানে সময় মাপা হবে tick-এ; ১ tick = ১ সেকেন্ড। Simulation সহজ রাখতে প্রধান সড়কের ন্যূনতম সবুজ ৮ tick ধরা হলো; বাস্তবে এটি আরও লম্বা, আর নকশায় এগুলো parameter, তাই বদলানো সহজ।

লক্ষ করুন R1 আর R2 “কখনো খারাপ কিছু ঘটবে না” ধরনের — এদের বলে safety property. R4–R5 বলে “ভালো কিছু ঘটবেই” — গাড়ি অপেক্ষা করলে একসময় সবুজ পাবেই। নিরাপত্তার শর্ত ভাঙা মানে দুর্ঘটনা, তাই এগুলো পরীক্ষা হবে প্রতিটি tick-এ, কোনো ব্যতিক্রম ছাড়া।

ধরে নেওয়া শর্ত (assumptions)

প্রতিটি নকশা কিছু জিনিস ধরে নেয়। সেগুলো লিখে না রাখলে পরে অন্য কেউ ভুল পরিবেশে circuit বসাতে পারেন। আমাদের তালিকা:

• A1 — tick আসে একটি ভাগ করা crystal থেকে। ঘড়ির ৩২.৭৬৮ kHz crystal-এর কম্পাঙ্ক ঠিক ২^১৫ Hz, তাই ১৫-বিটের একটি binary counter দিয়ে ভাগ করলে প্রতি সেকেন্ডে একটি tick (পর্ব ১৬)। FPGA বোর্ডের দ্রুত clock (যেমন ৫০ MHz) থেকে আমরা নতুন clock বানাব না, বরং প্রতি সেকেন্ডে এক cycle-এর একটি clock enable পালস বানাব (অংশ ৯)।
• A2 — সেন্সরের সংকেত synchronised. গাড়ি আসে যখন খুশি, clock-এর তালে নয়। এমন asynchronous input সরাসরি flip-flop-এ দিলে metastability-র ঝুঁকি থাকে; তাই C আগে একটি দুই-flip-flop-এর synchroniser পার হয় (পর্ব ১৮)।
• A3 — পথচারীর বোতাম (ঐচ্ছিক) debounced আর মনে রাখা। যান্ত্রিক বোতাম চাপলে কয়েক মিলিসেকেন্ড ধরে লাফায় (bounce), তাই আগে debouncing (পর্ব ১৮), তারপর একটি “অনুরোধ আছে” flip-flop, যা সবুজ দেওয়া পর্যন্ত অনুরোধ ধরে রাখে (অনুশীলন ১)।
• A4 — বাতি চলে Moore output থেকে, অর্থাৎ শুধু state থেকে; input-এর ঝাঁকুনি সরাসরি বাতিতে যায় না।
• A5 — বিদ্যুৎ চালু হলে reset. State register কোন মান নিয়ে জেগে উঠবে, তা জানা নেই; তাই power-on reset দিয়ে MG-তে শুরু।

৩ · প্রজেক্ট A, ধাপ ২ — state diagram, state table আর state assignment

বাতির সম্ভাব্য বৈধ অবস্থা চারটি: প্রধান সড়ক সবুজ (MG — main green), প্রধান সড়ক হলুদ (MY), পার্শ্ব রাস্তা সবুজ (SG), পার্শ্ব রাস্তা হলুদ (SY). প্রতিটি অবস্থায় অন্য রাস্তা লাল। তিনটি input: সেন্সর C, আর timer থেকে দুটি সংকেত — TS (short timeout: হলুদের ৩ tick শেষ) আর TL (long timeout: ৮ tick শেষ)। Output যেহেতু শুধু state-এর ওপর নির্ভর করে, এটি একটি Moore machine; প্রতিটি বৃত্তের ভেতরেই বাতির অবস্থা লেখা।

Diagram আঁকার পরে দুটি সম্পূর্ণতার যাচাই করুন (পর্ব ১৭-এর নিয়ম)। (১) প্রতিটি state থেকে বেরোনো শর্তগুলোর OR = 1: MG-তে C·TL আর (C·TL)′ মিলে সবকিছু। (২) শর্তগুলো পরস্পর বর্জনশীল — একসাথে দুটি তীর সত্য হতে পারে না। SG-তে বেরোনোর শর্ত C′ + TL, থাকার শর্ত তার উল্টো (C′ + TL)′ = C·TL′ (De Morgan). চারটি state-এই দুই শর্ত পূরণ হয়েছে। এবার একই তথ্য state table-এ:

State minimisation: কোনো দুটি state কি সমতুল্য? Moore machine-এ সমতুল্য হতে হলে আগে output এক হতে হবে। এখানে চারটি state-এর বাতির নকশা চারটিই আলাদা, তাই কোনো জোড়া মেলানো যায় না — চার state-ই ন্যূনতম (state minimisation-এর পদ্ধতি পর্ব ১৭-এ)।

State assignment — কোন state-কে কোন বিট

চারটি state-এর জন্য binary-তে ২টি flip-flop যথেষ্ট। কিন্তু কোন state 00, কোনটি 01 — এই state assignment-এর সিদ্ধান্তে logic-এর আকার বদলায়। তিনটি বিকল্প পাশাপাশি:

আমাদের FSM একটি চক্র: MG → MY → SG → SY → MG. Gray ক্রমে (00 → 01 → 11 → 10 → 00) প্রতিটি পদক্ষেপে ঠিক একটি বিট বদলায় — ঠিক যেভাবে Gray code গোনে। লাভ দুটি: পাশাপাশি state K-map-এও পাশাপাশি পড়ে বলে সমীকরণ ছোট হয় (অংশ ৫), আর দুটি বিট একসাথে না বদলানোয় state থেকে বাতি decode করার সময় ক্ষণিক ভুল মান (যেমন 01 থেকে 10 যেতে এক ঝলক 00 বা 11) আসে না — বাতির driver-এ glitch-এর একটি উৎস দূর হয়। বাড়তি উপহার: প্রধান সড়কের লাল ঠিক Q₁, আর পার্শ্ব রাস্তার লাল ঠিক Q₁′ — কোনো gate-ই লাগে না।

One-hot-এ প্রতিটি state-এর নিজস্ব flip-flop; সমীকরণ diagram থেকে সরাসরি লেখা যায় (“MY-তে যাব যদি MG-তে থাকি আর C·TL, অথবা MY-তে থাকি আর TS′”)। দুটির আসল খরচের তুলনা অংশ ৯-এর প্রোগ্রামে।

৪ · প্রজেক্ট A, ধাপ ৩ — আগে আচরণের মডেল, তারপর gate

পেশাদার নকশাকাররা সমীকরণ বের করার আগে প্রায়ই একটি সরল software মডেল লেখেন, যা state table হুবহু অনুসরণ করে। একে বলা হয় golden model বা reference model — পরের প্রতিটি ধাপ (সমীকরণ, Verilog) এর সাথে মেলানো হবে। মডেলে timer-এর আচরণও স্পষ্ট করতে হয়।

Timer-এর নিয়ম, এক-বেশি-এক-কম ভুল ছাড়া

Timer t প্রতিটি tick-এ ১ বাড়ে, আর যে tick-এ state বদলায় তার পরে ০ থেকে শুরু হয়। কোনো state-এ ঢোকার প্রথম tick-এ t = 0, দ্বিতীয় tick-এ t = 1, …। কোনো state-এ ঠিক k tick থাকতে হলে বেরোনোর সিদ্ধান্ত নিতে হবে সেই tick-এ, যখন t = k − 1. তাই

“≥” ব্যবহার করা হয়েছে “=” নয়, কারণ প্রধান সড়কের সবুজে গাড়ি না এলে t বাড়তেই থাকে; তখন TL সত্যই থাকা উচিত, যাতে পরে গাড়ি এলেই সঙ্গে সঙ্গে সাড়া মেলে। ৪-বিটের timer ১৫-তে পৌঁছে থেমে যায় (saturate) — উল্টে ০-তে ফিরে গেলে TL হঠাৎ মিথ্যা হয়ে যেত।

নিচের stepper-এ একটি পূর্ণ চক্র দেখুন: tick ৩-এ পার্শ্ব রাস্তায় একটি গাড়ির সারি আসে, আর tick ১৫-তে সারি ফুরিয়ে যায়। প্রতিটি ধাপে দেখানো মানগুলো সেই tick-এর শুরুর অবস্থা; “পরের state” হলো tick শেষে clock-এর ধারে যা হবে।

একই নিয়ম এবার একটি প্রোগ্রামে, ৬০ tick ধরে। গাড়ির সেন্সরের সংকেত আগে থেকে লেখা (scripted): tick ৩–১৪-এ একটি ছোট সারি, তারপর লম্বা বিরতি, তারপর tick ৩৩ থেকে একটানা ভিড়। প্রোগ্রামটি প্রতিটি tick-এর state, timer আর দুই বাতি একটি সময়রেখায় ছাপায়, আর শেষে R1–R3 পরীক্ষা করে:

// Traffic-light controller = Moore FSM (controller) + 4-bit timer (datapath). 1 tick = 1 s.
const MG = 0, MY = 1, SG = 3, SY = 2;          // state code Q1Q0, Gray order 00-01-11-10
const GMIN = 8, YEL = 3;                        // main green >= 8 ticks, yellow = 3 ticks
function next(s, C, TS, TL) {                   // the state table
  if (s === MG) return C && TL ? MY : MG;       // leave only if a car waits AND min time over
  if (s === MY) return TS ? SG : MY;
  if (s === SG) return !C || TL ? SY : SG;      // side road empty, or max time over
  return TS ? MG : SY;                          // SY
}
const light = s => [s === MG ? "G" : s === MY ? "Y" : "R",   // main road
                    s === SG ? "G" : s === SY ? "Y" : "R"];  // side road
const car = "000111111111111000000000000000000111111111111111111111111111"; // sensor C
let s = MG, t = 0, bad = [];
const row = { tick: "", car: "", state: "", timer: "", main: "", side: "" };
for (let k = 0; k < car.length; k++) {
  const C = car[k] === "1", TS = t >= YEL - 1, TL = t >= GMIN - 1;   // timer flags
  const [m, d] = light(s);
  row.tick += k % 10; row.car += car[k]; row.state += s;
  row.timer += t.toString(16); row.main += m; row.side += d;
  if (m === "G" && d === "G") bad.push(`tick ${k}: both green`);
  const n = next(s, C, TS, TL);
  t = n !== s ? 0 : Math.min(t + 1, 15);        // ST = (next != present) restarts timer
  s = n;
}
for (const w of ["main", "side"]) {             // check the light sequences
  for (const run of row[w].match(/G+|Y+|R+/g).slice(0, -1))
    if (run[0] === "Y" && run.length !== YEL) bad.push(`${w}: yellow lasted ${run.length}`);
  if (/GR|YG|RY/.test(row[w])) bad.push(`${w}: illegal order G->R, Y->G or R->Y`);
}
for (const g of row.main.match(/G+(?=Y)/g) || [])   // every green that ended
  if (g.length < GMIN) bad.push(`main green only ${g.length} ticks`);
for (let a = 0; a < car.length; a += 30)
  for (const key in row) console.log(key.padEnd(6) + row[key].slice(a, a + 30));
console.log("states: 0=MG 1=MY 3=SG 2=SY | timer in hex");
console.log(bad.length ? bad.join("\n") : "all safety checks passed");

tick  012345678901234567890123456789
car   000111111111111000000000000000
state 000000001113333322200000000000
timer 01234567012012340120123456789a
main  GGGGGGGGYYYRRRRRRRRGGGGGGGGGGG
side  RRRRRRRRRRRGGGGGYYYRRRRRRRRRRR
tick  012345678901234567890123456789
car   000111111111111111111111111111
state 000011133333333222000000001113
timer bcde01201234567012012345670120
main  GGGGYYYRRRRRRRRRRRGGGGGGGGYYYR
side  RRRRRRRGGGGGGGGYYYRRRRRRRRRRRG
states: 0=MG 1=MY 3=SG 2=SY | timer in hex
all safety checks passed

৫ · প্রজেক্ট A, ধাপ ৪ — timer datapath, K-map থেকে সমীকরণ আর যাচাই

Datapath: timer, তুলনা আর ST

Timer একটি ৪-বিটের counter (পর্ব ১৬), যার দুটি নিয়ন্ত্রণ: clear (ST = 1 হলে পরের tick-এ ০) আর enable (শুধু tick-এ গোনে)। Controller আর timer-এর মধ্যে কথা হয় মাত্র তিনটি সংকেতে: controller থেকে ST, timer থেকে TS আর TL. দুটি তুলনা (comparator) সরাসরি timer-এর বিট t₃t₂t₁t₀ থেকে:

• TS = (t ≥ 2) = t₃ + t₂ + t₁ — t ≥ 2 মানে t ০ বা ১ নয়; ০ আর ১-এ ওপরের তিন বিটই 0, বাকি সব মানে অন্তত একটি 1.
• TL = (t ≥ 7) = t₃ + t₂·t₁·t₀ — হয় t ≥ 8 (t₃ = 1), নয়তো ঠিক 7 = 0111.
• ST = (D₁ ⊕ Q₁) + (D₀ ⊕ Q₀) — পরের state বর্তমান state থেকে আলাদা হলেই 1. এটি controller-এর next-state logic-এর output থেকে তৈরি, তাই controller আর datapath একটি বন্ধ চক্রে বাঁধা — timing হিসাবে এটি গুরুত্বপূর্ণ (অংশ ৯)।

              ┌──────────────── controller (Moore FSM) ─────────────────┐
 car ─[2-FF sync]─▶ C ─▶┐                                                  │
                        ├─▶ next-state ─D1,D0─▶ [state reg Q1Q0] ─▶ output ─┼─▶ ৬টি বাতি
           TS, TL ─────▶┘     logic                    │          logic    │
              ▲                  └──── ST = (D ≠ Q) ◀──┘                    │
              │                         │                                   │
              │  ┌──────────── datapath (timer) ──▼──────────────┐          │
              └──┤ comparators ◀── [4-bit timer] ◀── +1 / clear   │          │
                 └────────────────────────────────────────────────┘          │
 clk (50 MHz) ─▶ সব flip-flop      tick (প্রতি সেকেন্ডে ১ cycle) ─▶ দুই register-এর enable

D₁ — তিন চলকের K-map

State table থেকে Q₁-এর পরের মান D₁ কখন 1? MY থেকে SG-তে গেলে (01 আর TS), SG-তে থাকলে বা SY-তে গেলে (11 থেকে দুটিরই Q₁ = 1), আর SY-তে থাকলে (10 আর TS′)। দেখা যায় D₁ শুধু Q₁, Q₀ আর TS-এর ওপর নির্ভর করে — C আর TL কোনো ভূমিকা রাখে না:

দুটি group: TS = 1 কলামে সারি 01 আর 11 → Q₀·TS; TS = 0 কলামে সারি 11 আর 10 → Q₁·TS′. তাই D₁ = Q₀·TS + Q₁·TS′. সারি 11-এর দুটি ঘর মিলিয়ে Q₁Q₀ নামে তৃতীয় একটি group-ও আঁকা যায়, কিন্তু সেটি বাড়তি — consensus theorem (পর্ব ০৭) অনুযায়ী Q₀·TS + Q₁·TS′ + Q₁Q₀ = Q₀·TS + Q₁·TS′. আর সমীকরণটি ভালো করে দেখুন: TS = 1 হলে D₁ = Q₀, TS = 0 হলে D₁ = Q₁ — এটি ঠিক একটি 2:1 mux, যার select TS (পর্ব ১২)।

D₀ — চার চলকের K-map, ধাপে ধাপে

D₀ নির্ভর করে Q₁, Q₀, C আর TL-এর ওপর (TS লাগে না — MY থেকে থাকা বা যাওয়া, দুই ক্ষেত্রেই Q₀ = 1; SY থেকে, দুই ক্ষেত্রেই 0). K-map-এর সারি Q₁Q₀ আর কলাম C·TL, দুটিই Gray ক্রমে 00, 01, 11, 10 (পর্ব ০৯):

Output সমীকরণ সরাসরি state code থেকে: প্রধান G = Q₁′Q₀′, প্রধান Y = Q₁′Q₀, প্রধান R = Q₁; পার্শ্ব G = Q₁Q₀, পার্শ্ব Y = Q₁Q₀′, পার্শ্ব R = Q₁′. এবার হাতের কাজ যন্ত্রে মেলানো যাক। নিচের প্রোগ্রামে একটি ছোট brute-force minimiser আছে — সব সম্ভাব্য implicant খুঁজে prime implicant রাখে, তারপর সবচেয়ে সস্তা cover বাছে (Quine-McCluskey-এর একই লক্ষ্য, পর্ব ১০)। এটি state table থেকে নিজে সমীকরণ বের করে, তারপর হাতে পাওয়া সমীকরণগুলোকে table-এর ৩২টি (state, input) সারিতে মেলায়:

// State table -> minimal SOP (brute-force prime implicants + cheapest cover) -> verify.
const V = ["Q1", "Q0", "C", "TS", "TL"];        // row m = Q1 Q0 C TS TL as 5 bits, Q1 = MSB
const bit = (m, i) => (m >> (4 - i)) & 1;
function next(s, C, TS, TL) {                   // same state table as the simulator
  if (s === 0) return C && TL ? 1 : 0;          // MG=00 -> MY=01
  if (s === 1) return TS ? 3 : 1;               // MY=01 -> SG=11
  if (s === 3) return !C || TL ? 2 : 3;         // SG=11 -> SY=10
  return TS ? 0 : 2;                            // SY=10 -> MG=00
}
const nx = m => next(m >> 3, bit(m, 2), bit(m, 3), bit(m, 4));
function minimise(f) {                          // a cube is [care mask, value]
  const cubes = [], on = [...Array(32).keys()].filter(f);
  for (let c = 0; c < 32; c++) for (let v = c; ; v = (v - 1) & c) {
    if ([...Array(32).keys()].every(m => (m & c) !== v || f(m))) cubes.push([c, v]);
    if (v === 0) break;
  }
  const P = cubes.filter(([c, v]) => !cubes.some(([d, w]) => d !== c && (d & c) === d && (v & d) === w));
  let best = null, lits = c => c.toString(2).split("1").length - 1;  // cost: terms, literals
  for (let s = 1; s < 2 ** P.length; s++) {
    const sel = P.filter((_, i) => (s >> i) & 1);
    if (!on.every(m => sel.some(([c, v]) => (m & c) === v))) continue;
    const cost = 100 * sel.length + sel.reduce((a, [c]) => a + lits(c), 0);
    if (!best || cost < best.cost) best = { cost, sel };
  }
  return best ? best.sel.map(([c, v]) => V.filter((_, i) => bit(c, i))
    .map(n => n + (bit(v, V.indexOf(n)) ? "" : "'")).join("·")).join(" + ") : "0";
}
const st = m => m >> 3, fns = { D1: m => nx(m) >> 1, D0: m => nx(m) & 1,
  mainG: m => st(m) === 0, mainY: m => st(m) === 1, mainR: m => bit(m, 0) === 1,
  sideG: m => st(m) === 3, sideY: m => st(m) === 2, sideR: m => bit(m, 0) === 0 };
for (const k in fns) console.log(`${k.padEnd(5)} = ${minimise(m => +fns[k](m))}`);
const hand = (q1, q0, C, TS, TL) =>             // equations read off the K-maps by hand
  2 * ((q0 & TS) | (q1 & !TS)) + ((!q1 & q0) | (!q1 & C & TL) | (q0 & C & !TL));
let ok = 0; for (let m = 0; m < 32; m++) ok += hand(...V.map((_, i) => bit(m, i))) === nx(m);
console.log(`hand equations vs state table: ${ok}/32 (state, input) rows match`);

D1    = Q0·TS + Q1·TS'
D0    = Q0·C·TL' + Q1'·C·TL + Q1'·Q0
mainG = Q1'·Q0'
mainY = Q1'·Q0
mainR = Q1
sideG = Q1·Q0
sideY = Q1·Q0'
sideR = Q1'
hand equations vs state table: 32/32 (state, input) rows match

৬ · প্রজেক্ট A, ধাপ ৫ — Verilog RTL আর testbench

সমীকরণ হাতে থাকলেও বাস্তবে নকশাকার সাধারণত gate নয়, RTL লেখেন — state table-টিই প্রায় হুবহু case দিয়ে — আর synthesis tool নিজে সমীকরণ বানায়। হাতের সমীকরণের কাজ তখন বোঝা, আর tool-এর ফল যাচাই করা। নিচের module-টি synthesizable, আর পর্ব ১৪-এর নিয়ম মেনে লেখা:

// Traffic-light controller: Moore FSM (controller) + 4-bit timer (datapath).
module traffic_ctrl #(parameter GMIN = 8, YEL = 3) (
    input  wire clk,           // fast board clock, e.g. 50 MHz
    input  wire rst,           // synchronous, active-high: go to MG
    input  wire tick,          // 1-cycle pulse once per second (clock ENABLE)
    input  wire car,           // side-road sensor, already synchronised
    output wire main_g, main_y, main_r,
    output wire side_g, side_y, side_r
);
    localparam [1:0] MG = 2'b00, MY = 2'b01, SG = 2'b11, SY = 2'b10;  // Gray order
    reg  [1:0] state, next;
    reg  [3:0] timer;
    wire ts = (timer >= YEL - 1);      // short timeout: yellow is over
    wire tl = (timer >= GMIN - 1);     // long timeout: min / max green is over

    always @(*) begin                   // next-state logic (combinational)
        next = state;                   // default = stay  -> no inferred latch
        case (state)
            MG: if (car && tl)  next = MY;
            MY: if (ts)         next = SG;
            SG: if (!car || tl) next = SY;
            SY: if (ts)         next = MG;
        endcase
    end

    always @(posedge clk) begin         // state register + timer datapath
        if (rst) begin
            state <= MG;
            timer <= 4'd0;
        end else if (tick) begin
            state <= next;
            if (next != state)        timer <= 4'd0;          // ST: restart
            else if (timer != 4'd15)  timer <= timer + 4'd1;  // saturate at 15
        end
    end

    assign main_g = (state == MG);
    assign main_y = (state == MY);
    assign main_r =  state[1];
    assign side_g = (state == SG);
    assign side_y = (state == SY);
    assign side_r = ~state[1];
endmodule

• দুটি always: একটি combinational (@(*), blocking =), একটি sequential (@(posedge clk), non-blocking <=)। শুরুর next = state-এর জন্য অনিচ্ছাকৃত latch হয় না।
• Reset synchronous: শুধু clock-এর ধারে কাজ করে (synchronous reset). অনেক নকশায় asynchronous reset-ও দেখা যায় (পর্ব ১৭–১৮)।
• tick একটি enable, clock নয়: সব flip-flop একই দ্রুত clock-এ চলে, শুধু tick = 1 হলে নতুন মান নেয়।
• Output assign দিয়ে, শুধু state থেকে — Moore. চারটি code-ই ব্যবহৃত, তাই এখানে default জরুরি নয়; vending machine-এ লাগবে।

Testbench-এর কাঠামো

Testbench শুধু simulation-এ চলে। দ্রুত simulation-এর জন্য এখানে প্রতিটি clock-ই একটি tick (tick = 1). Input বদলানো হয় clock-এর নিচের ধারে (negedge), যাতে DUT ওপরের ধারে স্থির মান দেখে — testbench-এর সবচেয়ে প্রচলিত race এড়ানোর কৌশল। আর নিরাপত্তার শর্তগুলো প্রতিটি cycle-এ নিজে পরীক্ষা হয় (self-checking):

`timescale 1ns/1ps
module tb_traffic;
    reg  clk = 0, rst = 1, tick = 1, car = 0;
    wire mg, my, mr, sg, sy, sr;
    reg  prev_mg = 0, prev_sg = 0;
    integer k, errors = 0;

    traffic_ctrl #(.GMIN(8), .YEL(3)) dut (.clk(clk), .rst(rst), .tick(tick), .car(car),
        .main_g(mg), .main_y(my), .main_r(mr), .side_g(sg), .side_y(sy), .side_r(sr));

    always #10 clk = ~clk;                       // 50 MHz; here every clock is a tick

    initial begin                                // directed test: same script as the JS model
        @(negedge clk) rst = 0;
        for (k = 0; k < 60; k = k + 1) begin
            car = (k >= 3 && k <= 14) || (k >= 33);
            @(negedge clk);
        end
        if (errors == 0) $display("PASS: all safety checks");
        else             $display("FAIL: %0d errors", errors);
        $finish;
    end

    always @(posedge clk) if (!rst) begin        // R1 and R2 checked every cycle
        if ((mg || my) && (sg || sy))  begin errors = errors + 1; $display("%0t both moving", $time); end
        if (mg + my + mr != 1 || sg + sy + sr != 1) begin errors = errors + 1; $display("%0t bad lamp code", $time); end
        if ((prev_mg && mr) || (prev_sg && sr))  begin errors = errors + 1; $display("%0t green to red", $time); end
        prev_mg <= mg;  prev_sg <= sg;
    end
endmodule

এটি একটি কাঠামো, পূর্ণ verification নয়। আরও কয়েকটি directed test লাগবে: গাড়ি কখনো না আসা, ন্যূনতম সময়ের পরে গাড়ি আসা, চক্রের মাঝখানে reset, আর সেন্সরে এক tick-এর ঝলক। Testbench-এ একই সময়রেখা ছাপিয়ে golden model-এর সাথে মেলানো সবচেয়ে সহজ যাচাই (পুরো তালিকা অংশ ৯-এ)।

৭ · প্রজেক্ট B — vending machine: Mealy না Moore, state table আর minimisation

এবার একটি অফিসের করিডোরে রাখা চায়ের যন্ত্র। দাম ১৫ টাকা। যন্ত্রের coin acceptor (টাকা চিনে নেওয়ার অংশ) প্রতিটি বৈধ টাকা ঢুকলে controller-কে এক cycle-এর একটি পালস পাঠায়: N (৫ টাকা) অথবা D (১০ টাকা)। বাংলাদেশে ১০ টাকা সাধারণত নোট, তাই ধরে নিন acceptor ৫ টাকার কয়েন আর ১০ টাকার নোট দুটিই নেয় — FSM-এর কাছে দুটিই কেবল একটি পালস। এছাড়া একটি “বাতিল” বোতাম X.

ধরে নেওয়া শর্ত: acceptor একবারে একটি টাকাই পাঠায় (N, D, X-এর মধ্যে এক cycle-এ বড়জোর একটি 1); তার পালস আগেই synchronised; আর চা ঢালার যন্ত্র (dispenser) VEND-এর এক cycle-এর পালস পেলেই নিজে পুরো কাজ শেষ করে।

Mealy না Moore?

State হবে “এখন পর্যন্ত কত টাকা জমা”। Mealy machine-এ output থাকে তীরের গায়ে — “১০ টাকা জমা অবস্থায় আরেকটি ১০ এলে: VEND আর CHG5, তারপর ০-তে”। তাই ১৫ বা ২০ টাকার আলাদা state লাগে না। Moore-এ output শুধু state থেকে, তাই “বিক্রি করছি” আর “বিক্রি করছি + ভাংতি দিচ্ছি” — দুটি আলাদা state লাগে:

আমাদের সিদ্ধান্ত Mealy: input-গুলো synchronised, এক cycle-এর পরিষ্কার পালস, তাই Mealy-র প্রধান দুর্বলতা (input-এর ঝাঁকুনি output-এ যাওয়া) এখানে প্রায় নেই; ৩টি state মানে ২টি flip-flop আর ছোট logic; আর VEND আসে টাকার পালসের একই cycle-এ। Output chip-এর বাইরে মোটর চালাতে গেলে অনেকে Mealy output-এর পরে একটি flip-flop বসান — তখন আচরণ কার্যত Moore-এর মতো, এক cycle দেরিতে।

প্রতিটি ঘরে “পরের state / output” — Mealy table এভাবেই লেখা হয়। Code 11 কোনো state-কে দেওয়া হয়নি; এটি একটি unused state, যার কথা পরের অংশে।

State minimisation — একটি বাড়তি state ধরা

প্রথমবার নকশা করতে গিয়ে অনেকেই “৫ + ৫ = ১০” আর “সরাসরি ১০” আলাদা রাখেন: S10a আর S10b. এরা কি আলাদা? Partition পদ্ধতিতে (পর্ব ১৭) দেখা যাক। প্রথমে output দিয়ে ভাগ: প্রতিটি input-এ (কিছু না, N, D, X) output — S0: সব শূন্য; S5: D-তে VEND, X-এ RET; S10a আর S10b দুটিরই: N-এ VEND, D-তে VEND + CHG5, X-এ RET. তাই প্রথম ভাগ {S0}, {S5}, {S10a, S10b}. পরের state দিয়ে: দুটিই কিছু না পেলে নিজের দলে থাকে, আর N, D, X-এ S0-তে যায়। ভাগ আর ভাঙে না, তাই S10a ≡ S10b — একটি S10-এ মিশিয়ে দেওয়া হলো। শিক্ষাটি সরল — state মনে রাখে ভবিষ্যতের জন্য যা দরকার (কত টাকা জমা), ইতিহাস নয় (কোন কোন কয়েন)।

নিচের stepper-এ ১০ + ১০ ক্রমটি দেখুন — Mealy output কীভাবে clock-এর ধারের আগেই আসে:

সমীকরণ আর ভাংতির logic

Encoding: S0 = 00, S5 = 01, S10 = 10 — জমা টাকা ÷ ৫-এর binary. চলক Q₁, Q₀, N, D, X. দুই ধরনের don't care আছে: unused state 11, আর অসম্ভব input-সমাহার (একসাথে দুটি বা তিনটি 1). এগুলো কাজে লাগিয়ে ন্যূনতম SOP (scratch script-এ একই minimiser দিয়ে যাচাই করা):

পড়ে দেখুন, প্রতিটি term একটি বাক্য। D₁: “৫ জমা আর ৫ এল (→ S10)”, “১০ জমা আর কিছু এল না (S10-তে থাকা)”, “০ জমা আর ১০ এল (→ S10)”. VEND: “১০ জমা আর ৫ এল”, অথবা “কিছু জমা আছে আর ১০ এল”। ভাংতির logic CHG5 = Q₁·D — ভাংতি লাগে কেবল একটি ক্ষেত্রে, ১০ জমা থাকা অবস্থায় আরেকটি ১০ এলে, কারণ ১০ + ১০ = ২০ = ১৫ + ৫. অন্য কোনো পথে মোট টাকা ১৫ পেরোয় না: ৫ + ১০ = ১৫, ১০ + ৫ = ১৫, ৫ + ৫ + ৫ = ১৫. RET-এ (Q₁ + Q₀) মানে “কিছু জমা আছে”; S0-তে বাতিল চাপলে কিছুই হয় না।

নিচের simulator Mealy table হুবহু অনুসরণ করে কয়েকটি ক্রম চালায়, প্রতিটি পদক্ষেপে output আর মোট বিক্রির টাকা ছাপায়, শেষে টাকার হিসাব (V4) আর transition coverage মেলায়:

// Vending machine as a Mealy FSM: price 15 taka, accepts 5 and 10 taka coins.
// State = money held so far. Outputs depend on the state AND this tick's input.
// Input per tick: "5", "10", "X" (cancel) or "-" (nothing). Outputs: VEND, CHG5, RET.
const T = {   //        input: [next state, VEND, CHG5, RET]
  S0:  { "-": ["S0", 0, 0, 0],  "5": ["S5", 0, 0, 0],  "10": ["S10", 0, 0, 0], X: ["S0", 0, 0, 0] },
  S5:  { "-": ["S5", 0, 0, 0],  "5": ["S10", 0, 0, 0], "10": ["S0", 1, 0, 0],  X: ["S0", 0, 0, 1] },
  S10: { "-": ["S10", 0, 0, 0], "5": ["S0", 1, 0, 0],  "10": ["S0", 1, 1, 0],  X: ["S0", 0, 0, 1] },
};
const held = s => Number(s.slice(1));            // S10 holds 10 taka
const tests = { "5+10": ["5", "-", "10"], "10+10": ["10", "10"], "5+5+5": ["5", "5", "5"],
  "10+5": ["10", "-", "5"], "5,cancel": ["5", "X"], "10,cancel": ["10", "X"],
  "cancel only": ["-", "X"] };
let inserted = 0, kept = 0, change = 0, refund = 0, sold = 0, s = "S0", seen = new Set();
console.log("state  in   next  VEND CHG5 RET   collected");
for (const [name, seq] of Object.entries(tests)) {
  console.log(`-- ${name}`);
  for (const inp of seq) {
    const [n, vend, chg, ret] = T[s][inp]; seen.add(s + inp);
    if (inp === "5" || inp === "10") inserted += Number(inp);
    if (ret) refund += held(s);                  // RET opens the escrow: held coins go back
    if (chg) change += 5;
    if (vend) { sold++; kept += 15; }
    console.log(`${s.padEnd(6)} ${inp.padEnd(4)} ${n.padEnd(5)}  ${vend}    ${chg}    ${ret}     ${kept}`);
    s = n;
  }
}
const balance = inserted === kept + change + refund + held(s);
console.log(`inserted ${inserted} = sold ${sold} x 15 (${kept}) + change ${change}` +
  ` + refunded ${refund} + held ${held(s)}`);
console.log(balance ? "money conserved: every taka is accounted for" : "MONEY LOST!");
console.log(`transition coverage: ${seen.size}/12 (state, input) pairs exercised`);

state  in   next  VEND CHG5 RET   collected
-- 5+10
S0     5    S5     0    0    0     0
S5     -    S5     0    0    0     0
S5     10   S0     1    0    0     15
-- 10+10
S0     10   S10    0    0    0     15
S10    10   S0     1    1    0     30
-- 5+5+5
S0     5    S5     0    0    0     30
S5     5    S10    0    0    0     30
S10    5    S0     1    0    0     45
-- 10+5
S0     10   S10    0    0    0     45
S10    -    S10    0    0    0     45
S10    5    S0     1    0    0     60
-- 5,cancel
S0     5    S5     0    0    0     60
S5     X    S0     0    0    1     60
-- 10,cancel
S0     10   S10    0    0    0     60
S10    X    S0     0    0    1     60
-- cancel only
S0     -    S0     0    0    0     60
S0     X    S0     0    0    0     60
inserted 80 = sold 4 x 15 (60) + change 5 + refunded 15 + held 0
money conserved: every taka is accounted for
transition coverage: 12/12 (state, input) pairs exercised

৮ · প্রজেক্ট B — কঠিন edge case আর Verilog

টাকার যন্ত্রে “সাধারণত ঠিক চলে” যথেষ্ট নয়। Design review-তে প্রথম প্রশ্নই হয়: অস্বাভাবিক কিছু ঘটলে কী হবে?

• একসাথে দুটি টাকা? Acceptor-এর পথে একবারে একটিই ঢোকে; দুটি একসাথে আটকালে acceptor চিনতে না পেরে ফেরতের ট্রেতে ফেলে — FSM কোনো পালসই পায় না। তাই N·D = 1 সমীকরণে don't care. তবু RTL-এ if … else if-এর ক্রমে একটি স্পষ্ট অগ্রাধিকার (X, তারপর N, তারপর D) রাখা হয়েছে, যাতে আচরণ নির্ধারিত থাকে। Don't care বাদ দিয়ে “অবৈধ input মানে কিছু না” ধরলে minimiser-এ D₁-এর খরচ প্রায় দ্বিগুণ — নিরাপত্তার একটি দাম আছে।
• চা ঢালার সময় আরেকটি টাকা? VEND-এর সাথেই state S0, তাই নতুন টাকা পরের কেনায় গোনা হয়; কিন্তু dispenser ব্যস্ত থাকাকালীন দ্বিতীয় VEND হারাতে পারে। সমাধান: dispenser-এর BUSY সংকেত, আর BUSY = 1 হলে acceptor বন্ধ — টাকা যান্ত্রিকভাবেই ফেরতের ট্রেতে যায়।
• S0-তে বাতিল: কিছু জমা নেই, তাই RET = 0. RET = X লিখলে খালি escrow-র ঢাকনা অকারণে খুলত — ক্ষতি নেই, কিন্তু পরীক্ষায় অবাক করা আচরণ।
• Unused state 11 — সত্যিকারের বিপদ। বিদ্যুতের ঝাঁকুনিতে state register 11 হয়ে গেলে don't care দিয়ে সরল করা সমীকরণ কী করে? Input না থাকলে D₁ = Q₁·N′D′X′ = 1, D₀ = Q₀·N′D′X′ = 1 → 11-তেই আটকে থাকে; তখন একটি ৫ টাকা এলে VEND = Q₁·N = 1 — ৫ টাকায় চা! Minimiser don't care-কে নিজের সুবিধামতো 0 বা 1 ধরেছে, আর সেই ধরে নেওয়া এখানে টাকার ক্ষতি। প্রতিকার: power-on reset, আর RTL-এ default: next = S0 (একটি self-correcting FSM). কিছু synthesis tool এই recovery পথও মুছে দিতে পারে, যদি না “safe FSM” ধরনের বিকল্প চালু থাকে — tool-এর manual দেখুন।

// Tea vending controller: price 15, coins 5 and 10, cancel returns the escrow.
module vending (
    input  wire clk, rst,
    input  wire coin5, coin10, cancel,     // 1-cycle synchronised pulses
    output reg  vend, change5, ret          // Mealy outputs (combinational)
);
    localparam [1:0] S0 = 2'd0, S5 = 2'd1, S10 = 2'd2;
    reg [1:0] state, next;

    always @(*) begin
        next = state;  vend = 1'b0;  change5 = 1'b0;  ret = 1'b0;   // defaults
        case (state)
            S0:  if (coin5)       next = S5;
                 else if (coin10) next = S10;
            S5:  if (cancel)      begin ret  = 1'b1;  next = S0;  end
                 else if (coin5)  next = S10;
                 else if (coin10) begin vend = 1'b1;  next = S0;  end
            S10: if (cancel)      begin ret  = 1'b1;  next = S0;  end
                 else if (coin5)  begin vend = 1'b1;  next = S0;  end
                 else if (coin10) begin vend = 1'b1;  change5 = 1'b1;  next = S0;  end
            default:              next = S0;    // unused code 2'b11: recover safely
        endcase
    end

    always @(posedge clk)
        if (rst) state <= S0;
        else     state <= next;
endmodule

Output এখানে reg হলেও flip-flop নয় — combinational always @(*)-এর ভেতরে মান পায় বলে Verilog-এর নিয়মে reg লিখতে হয় (পর্ব ১৪); শুরুর চারটি default-এ latch হয় না। Testbench-এ JS simulator-এর সাতটি ক্রম চালিয়ে প্রতিটি cycle-এ টাকার হিসাব (V4) মেলানো সবচেয়ে কার্যকর self-check, সাথে state 11 থেকে শুরু করা একটি test.

৯ · Design review — যাচাইয়ের পরিকল্পনা, timing, resource আর FPGA ল্যাব

যাচাইয়ের পরিকল্পনা

অংশ ৪-এর ৬০-tick চালনা traffic FSM-এর আটটি তীরের সবকটি ছুঁয়ে যায়, SG থেকে বেরোনোর দুই কারণসহ (গাড়ি ফুরানো আর সর্বোচ্চ সময়) — scratch script-এ গুনে দেখা। T6 একটি নকশার প্রশ্ন সামনে আনে: ন্যূনতম সবুজের পরে সেন্সরে এক tick-এর ভুল ঝলকেও পুরো চক্র শুরু হয়। অনেক বাস্তব নকশায় সেন্সর “পরপর দুই tick 1” হলে তবেই গাড়ি ধরা হয় — review-তেই এমন সিদ্ধান্ত বেরিয়ে আসে।

Timing — নির্বাচিত clock-এ নকশা কি চলবে?

পর্ব ১৮-এর সূত্র: সর্বনিম্ন clock period T ≥ t_clk→Q + (সবচেয়ে লম্বা combinational পথ) + t_setup. ধরুন একটি উদাহরণ-প্রযুক্তিতে t_clk→Q = ১.০ ns, NOT = ০.৪, AND = ০.৮, OR = ০.৯, XOR = ১.০ ns আর t_setup = ০.৬ ns. Traffic controller-এর সবচেয়ে লম্বা পথ খুঁজি:

• Timer → TL → D₀: clk→Q (১.০) + TL-এর AND আর OR (০.৮ + ০.৯) + TL′-এর NOT (০.৪) + Q₀·C·TL′-এর AND (০.৮) + D₀-এর OR (০.৯) + setup (০.৬) = ৫.৪ ns.
• সেই পথ → ST → timer clear: D₀ তৈরি হয় ৪.৮ ns-এ; তারপর XOR (১.০) + OR (০.৯) = ST ৬.৭ ns-এ; clear-এর NOT আর AND (০.৪ + ০.৮) = ৭.৯; setup যোগে ৮.৫ ns. এটিই critical path — controller থেকে datapath-এ ফেরার চক্র।

তাই T_min = ৮.৫ ns, f_max = ১ ÷ ৮.৫ ns ≈ ১১৭.৬ MHz. বোর্ডের ৫০ MHz clock-এর period ২০ ns, তাই slack = ২০ − ৮.৫ = ১১.৫ ns — নিরাপদ। আমরা নকশাটি ১ Hz-এর আলাদা clock-এ না চালিয়ে দ্রুত clock আর tick enable-এ চালাই, যাতে timing-এর হিসাব একটি মাত্র clock-এর ওপর হয়। Hold শর্ত আর asynchronous input-এর synchroniser-সহ পর্ব ১৮-এর পুরো চেকলিস্ট মেলাতে হবে।

Resource গণনা — binary বনাম one-hot

Traffic controller-এ binary encoding-এ flip-flop ২ (state) + ৪ (timer) = ৬টি। কিন্তু শুধু flip-flop দিয়ে খরচ মাপা যায় না — logic কত বড়? নিচের প্রোগ্রাম দুই FSM-এর জন্য দুই encoding-এ পূর্ণ next-state আর output logic-এর ন্যূনতম SOP-এর term আর literal গোনে। Binary-তে unused code আর অসম্ভব input don't care; one-hot-এ প্রতিটি তীর একটি AND term (state-বিট × শর্ত), যেভাবে হাতে লেখা হয়:

function sop(n, f) {   // minimal SOP of f (1, 0, null = don't care) -> {t: terms, l: literals}
  const all = [...Array(1 << n).keys()], on = all.filter(m => f(m) === 1), C = [];
  for (let c = 0; c < 1 << n; c++) for (let v = 0; v < 1 << n; v++)    // every cube (care, value)
    if (!(v & ~c) && all.every(m => (m & c) !== v || f(m) !== 0)) C.push([c, v]);
  const P = C.filter(([c, v]) => !C.some(([d, w]) => d !== c && (d & c) === d && (v & d) === w));
  let best = { t: on.length ? 99 : 0, l: 0 };   // primes P; now the cheapest cover of "on"
  for (let s = 1; on.length && s < 1 << P.length; s++) {
    const sel = P.filter((_, i) => (s >> i) & 1);
    if (sel.length > best.t || !on.every(m => sel.some(([c, v]) => (m & c) === v))) continue;
    const l = sel.reduce((a, [c]) => a + c.toString(2).split("1").length - 1, 0);
    if (sel.length < best.t || l < best.l) best = { t: sel.length, l };
  } return best; }
const traffic = { S: 4, code: [0, 1, 3, 2], valid: () => true, step: (s, i) => {  // i = C TS TL
  const C = i >> 2, TS = (i >> 1) & 1, TL = i & 1;      // outputs: mG mY mR sG sY sR (Moore)
  return [[C && TL ? 1 : 0, TS ? 2 : 1, !C || TL ? 3 : 2, TS ? 0 : 3][s],
          [s === 0, s === 1, s > 1, s === 2, s === 3, s < 2].map(Number)]; } };
const VT = [[[0, 0, 0, 0], [1, 0, 0, 0], [2, 0, 0, 0], [0, 0, 0, 0]],   // inputs -, 5, 10, X
            [[1, 0, 0, 0], [2, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1]],   // [next, VEND, CHG5, RET]
            [[2, 0, 0, 0], [0, 1, 0, 0], [0, 1, 1, 0], [0, 0, 0, 1]]];  // (Mealy)
const vending = { S: 3, code: [0, 1, 2], valid: i => (i & (i - 1)) === 0,  // i = N D X, one-hot
  step: (s, i) => { const [n, ...o] = VT[s][[0, 4, 2, 1].indexOf(i)]; return [n, o]; } };
const add = (a, b) => ({ t: a.t + b.t, l: a.l + b.l }), Z = { t: 0, l: 0 };
console.log("FSM      encoding  FFs  next-state terms/literals  output terms/literals");
for (const [name, M] of [["traffic", traffic], ["vending", vending]]) {
  let bn = Z, bo = Z, hn = Z, ho = Z, nO = M.step(0, 0)[1].length;
  const g = (m, pick) => { const s = M.code.indexOf(m >> 3);           // unused code: don't care
    return s < 0 || !M.valid(m & 7) ? null : pick(M.step(s, m & 7)); };
  for (let b = 0; b < 2; b++) bn = add(bn, sop(5, m => g(m, r => (M.code[r[0]] >> b) & 1)));
  for (let k = 0; k < nO; k++) bo = add(bo, sop(5, m => g(m, r => r[1][k])));
  for (let s = 0; s < M.S; s++) for (let j = 0; j < M.S + nO; j++) {   // one-hot: one AND per arc
    const r = i => M.step(s, i), c = sop(3, i => !M.valid(i) ? null : j < M.S ? +(r(i)[0] === j) : r(i)[1][j - M.S]);
    if (j < M.S) hn = add(hn, { t: c.t, l: c.l + c.t }); else ho = add(ho, { t: c.t, l: c.l + c.t }); }
  for (const [e, f, a, b] of [["binary", 2, bn, bo], ["one-hot", M.S, hn, ho]])
    console.log(`${name.padEnd(8)} ${e.padEnd(9)} ${f}    ${(a.t + " / " + a.l).padEnd(27)}${b.t} / ${b.l}`);
}

FSM      encoding  FFs  next-state terms/literals  output terms/literals
traffic  binary    2    5 / 12                     6 / 10
traffic  one-hot   4    10 / 22                    8 / 8
vending  binary    2    5 / 16                     6 / 12
vending  one-hot   3    11 / 27                    6 / 12

সম্ভাব্য সম্প্রসারণ

• ২০ টাকার নোট: S0-তে ২০ এলে ভাংতি ৫, S5-তে ১০, S10-তে ১৫ — তাই CHG5 আর CHG10 দুটি output, বা ভাংতি ছাড়ার জন্য আলাদা একটি ছোট FSM — আরেকটি controller-datapath ভাগ।
• বাতিল বোতাম: debounce না করলে এক চাপে কয়েকটি X পালস; আমাদের নকশায় দ্বিতীয়টি S0-তে নিরীহ, কিন্তু সব নকশায় নয়।
• Display: জমা টাকা দেখাতে দুটি 7-segment display (পর্ব ১২) — Moore output (অনুশীলন ৪); traffic-এ পথচারীর জন্য বাকি সেকেন্ডের countdown.
• পথচারী পারাপার: অনুশীলন ১-এ।

নকশাটি FPGA ল্যাবে

শিক্ষার্থীদের FPGA বোর্ডে সাধারণত একটি crystal oscillator (অনেক বোর্ডে ৫০ বা ১০০ MHz), কয়েকটি বোতাম, switch আর LED থাকে। নকশা নামাতে লাগে:

1. Pin constraint: কোন port কোন pin-এ, একটি constraint ফাইলে (নিচে Xilinx-ধাঁচের উদাহরণ; pin নাম কাল্পনিক — বোর্ডের manual দেখুন), সাথে clock-এর period, যাতে timing analysis লক্ষ্য জানে।
2. Tick generator: ৫০ MHz থেকে প্রতি সেকেন্ডে এক cycle-এর enable — ৫ কোটি পর্যন্ত গোনা counter. ২^২৫ ≈ ৩.৩৬ কোটি কম, ২^২৬ ≈ ৬.৭১ কোটি যথেষ্ট, তাই ২৬ বিট। একে প্রায়ই clock divider বলা হয়, কিন্তু output-কে নতুন clock হিসেবে নয়, enable হিসেবে ব্যবহার করুন।
3. বোতাম: প্রতিটি আগে synchroniser, তারপর debounce (কয়েক মিলিসেকেন্ড ধরে একই মান পেলে তবে গ্রহণ), তারপর edge detector দিয়ে এক cycle-এর পালস। নইলে একবার “১০ টাকা” চাপলে FSM কয়েকটি D পালস দেখবে — বিনা পয়সায় চা!
4. LED আর reset: কিছু বোর্ডে LED বা বোতাম active-low; schematic দেখে প্রয়োজনে উল্টে নিন। একটি বোতাম reset-এর জন্য রাখুন।

// 50 MHz clock -> one-cycle 'tick' every second (a clock ENABLE, not a new clock)
reg [25:0] div  = 26'd0;
reg        tick = 1'b0;
always @(posedge clk) begin
    if (div == 26'd49_999_999) begin
        div  <= 26'd0;
        tick <= 1'b1;
    end else begin
        div  <= div + 26'd1;
        tick <= 1'b0;
    end
end

## constraints (Xilinx XDC style) -- replace PIN_x with the pins in your board manual
set_property PACKAGE_PIN PIN_CLK [get_ports clk]
set_property IOSTANDARD LVCMOS33 [get_ports clk]
create_clock -period 20.000 -name sys_clk [get_ports clk]
set_property PACKAGE_PIN PIN_BTN0 [get_ports car_btn]
set_property PACKAGE_PIN PIN_LED0 [get_ports main_g]

১০ · AI-এর যুগে — প্রজেক্টে AI-কে সহকারী রাখুন, বিচারক নয়

AI চ্যাটবট কয়েক সেকেন্ডে একটি traffic light controller-এর Verilog দেবে — কিন্তু সেটি আপনার requirement জানে না, আর প্রায়ই চোখে না পড়া ভুল আনে। এমন প্রজেক্টে AI-এর সাধারণ ভুল:

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

• AI-এর দেওয়া সমীকরণ বা টেবিল নিজের script-এ state table-এর সব সারিতে মিলিয়েছি (এই পর্বের দ্বিতীয় প্রোগ্রামের মতো)
• Verilog নিজে simulate করেছি, আর golden model-এর সময়রেখার সাথে tick ধরে ধরে মিলিয়েছি
• Synthesis report-এ latch, multiple driver বা “unused state removed” ধরনের সতর্কবার্তা পড়েছি
• প্রতিটি বাইরের input-এ synchroniser আর debounce আছে, আর সব flip-flop একই clock-এ চলে — নিশ্চিত করেছি
• Pin নাম, clock কম্পাঙ্ক আর active-low সংকেত বোর্ডের manual থেকে মিলিয়েছি, AI-এর কথায় নয়