ফ্লিপ-ফ্লপ, রেজিস্টার আর কাউন্টার

১ · যে সার্কিট মনে রাখে — combinational বনাম sequential

অফিসের লিফটে উঠে “৭” লেখা বোতামটি একবার চাপলেন। আঙুল সরিয়ে নিলেন, তবু বোতামের বাতি জ্বলেই থাকে। লিফট সাত তলায় পৌঁছালে তবেই বাতি নেভে। খেয়াল করুন, বোতামটি “মনে রেখেছে” যে কেউ একবার চেপেছিল — যদিও এই মুহূর্তে কেউ চাপছে না।

এবার বাসার কলিং বেলের কথা ভাবুন। যতক্ষণ চেপে রাখবেন, ততক্ষণ বাজবে; ছাড়লেই থামবে। বেলের কোনো স্মৃতি নেই — এখন চাপ আছে কি না, শুধু সেটুকুই দেখে।

ডিজিটাল সার্কিটও এই দুই রকমের। পর্ব ২০-এ দেখেছেন logic gate (AND, OR, NOT, NAND, NOR), আর পর্ব ২১-এ সেগুলো জুড়ে বানানো অ্যাডার, ডিকোডার, মাল্টিপ্লেক্সার। ওই সব সার্কিট কলিং বেলের মতো — আউটপুট নির্ভর করে শুধু এই মুহূর্তের ইনপুটের ওপর। এদের বলে combinational circuit. আর লিফটের বোতামের মতো যে সার্কিট আগের ঘটনা মনে রাখে, তার নাম sequential circuit.

স্মৃতির রহস্য — feedback

গেট দিয়ে স্মৃতি বানানো যায় কীভাবে? কৌশলটি অবাক করার মতো সহজ: একটি গেটের আউটপুট ঘুরিয়ে আবার ইনপুটে ফেরত দিন। একে বলে feedback. তখন আউটপুট নিজেই নিজেকে টিকিয়ে রাখে — যেমন দুজন বন্ধু একে অপরকে বারবার একই কথা মনে করিয়ে দিলে কথাটি আর ভোলা যায় না। এভাবে তৈরি সার্কিট একটি bit — 0 বা 1 — ধরে রাখতে পারে, যতক্ষণ বিদ্যুৎ আছে।

২ · SR latch — দুটি NOR গেটের আলিঙ্গন

সবচেয়ে সরল স্মৃতি-সার্কিটটি বানাতে লাগে মাত্র দুটি NOR গেট। মনে করিয়ে দিই: NOR-এর আউটপুট 1 হয় কেবল তখনই, যখন তার সব ইনপুট 0. কোনো একটি ইনপুটও 1 হলে আউটপুট 0 (পর্ব ২০)।

এখন দুটি NOR গেট এমনভাবে জুড়ুন যে প্রথমটির আউটপুট দ্বিতীয়টির ইনপুটে যায়, আর দ্বিতীয়টির আউটপুট প্রথমটির ইনপুটে — একে বলে cross-coupled, যেন দুজন হাত ধরাধরি করে আছে। বাকি দুটি খালি ইনপুটের নাম S (Set — 1 বসানো) আর R (Reset — 0 বসানো)। আউটপুট দুটির নাম Q আর Q′ (Q-এর উল্টো)। এই সার্কিটের নাম SR latch.

এবার ধাপে ধাপে দেখুন, S আর R বদলালে Q আর Q′ কী করে — আর আউটপুট কীভাবে ঘুরে এসে নিজেকে টিকিয়ে রাখে:

SR latch-এর truth table (NOR দিয়ে)

৩ · ক্লক — সবাইকে এক তালে চালানোর ঢোল

একটি SR latch ইনপুট বদলালেই সাড়া দেয়। কিন্তু একটি CPU-তে কোটি কোটি latch থাকে, আর প্রতিটি গেটের ভেতর দিয়ে সংকেত যেতে সামান্য সময় লাগে — একে বলে propagation delay. কোনো তার একটু লম্বা, কোনো পথে গেট একটু বেশি — ফলে কিছু bit আগে পৌঁছায়, কিছু পরে। সবাই নিজের ইচ্ছেমতো বদলালে মাঝপথের ভুল মানও মনে রাখা হয়ে যেত।

সমাধান হলো একটি clock signal — একটানা, নিয়মিত তালে 0 আর 1-এর মধ্যে ওঠানামা করা একটি সংকেত। নৌকাবাইচের কথা ভাবুন: ঢোলের প্রতিটি বাড়িতে সব মাঝি একসাথে বৈঠা ফেলেন। দুই বাড়ির মাঝের সময়ে সবাই প্রস্তুতি নেন, কিন্তু বৈঠা পড়ে শুধু ঢোলের শব্দে। ডিজিটাল সার্কিটেও তাই — দুই টিকের মাঝে গেটগুলো হিসাব শেষ করে, আর ক্লকের টিকে সব মেমরি একসাথে নতুন মান গ্রহণ করে।

ক্লকের দুটি মাপ মনে রাখুন। কম্পাঙ্ক (frequency, f): প্রতি সেকেন্ডে কতবার টিক — একক হার্জ (Hz). পর্যায়কাল (period, T): একটি টিক থেকে পরের টিক পর্যন্ত সময়। দুটির সম্পর্ক সরল: T = 1/f. একটি ৩ GHz CPU-র clock speed মানে সেকেন্ডে ৩০০ কোটি টিক; তাহলে T = ১ ÷ (৩ × ১০^৯) ≈ ০.৩৩ ন্যানোসেকেন্ড। এই সময়ে আলোও মাত্র প্রায় ১০ সেন্টিমিটার যেতে পারে! CPU প্রতিটি টিকে কী করে, আর কোর কী — বিস্তারিত পর্ব ২৪-এ।

Clocked SR flip-flop — দরজায় পাহারাদার

SR latch-এর সামনে দুটি AND গেট বসান: একটিতে S আর CLK, অন্যটিতে R আর CLK. এখন CLK = 0 হলে দুটি AND-এর আউটপুটই 0 — latch যা আছে তাই রাখে, S আর R যা-ই হোক। CLK = 1 হলেই কেবল S আর R ভেতরে পৌঁছায়। ক্লক যেন দরজার পাহারাদার — অনুমতি না দিলে কেউ ঢুকতে পারে না। একে বলে clocked SR flip-flop (কেউ কেউ gated SR latch বলেন)। পাঠ্যবইয়ে প্রায়ই এই কাজ দুটি NAND গেট দিয়ে দেখানো হয় — ফল একই।

এখানে Q_n মানে ক্লকের আগের মান, আর Q_n+1 মানে ক্লকের পরের মান। পরের অবস্থা আগের অবস্থার ওপর কীভাবে নির্ভর করে, তা দেখানো এই ধরনের টেবিলকে বলে characteristic table. Clocked SR-এর characteristic equation: Q_n+1 = S + R′Q_n (শর্ত: S·R = 0).

Level-triggered বনাম edge-triggered — latch আর flip-flop-এর আসল পার্থক্য

• Level-triggered (latch): CLK (বা enable) যতক্ষণ 1, ততক্ষণ দরজা খোলা — এর মধ্যে ইনপুট দশবার বদলালে আউটপুটও দশবার বদলায়। ছবি ২২.৩-এর সবুজ অংশের পুরো সময়টাই “খোলা”।
• Edge-triggered (flip-flop): শুধু ক্লকের ধারের মুহূর্তে — সাধারণত উঠতি ধারে (rising/positive edge), কখনো নামতি ধারে (falling/negative edge) — ইনপুটের একটি “ছবি তুলে” রাখে। বাকি পুরো সময় ইনপুট যা-ই করুক, আউটপুট স্থির।

ক্যামেরার উদাহরণে বোঝা সহজ: latch হলো ভিডিও — যতক্ষণ রেকর্ড চলছে, সব নড়াচড়া ধরে। Flip-flop হলো শাটার চাপা স্থিরচিত্র — ঠিক এক মুহূর্তের ছবি। কম্পিউটারের নকশায় flip-flop বেশি নিরাপদ, কারণ টিকের মাঝের এলোমেলো মানগুলো সে গ্রহণই করে না। নকশার প্রতীকে ক্লক ইনপুটের পাশে ছোট ত্রিভুজ (▷) মানে edge-triggered; ত্রিভুজের আগে ছোট বৃত্ত মানে নামতি ধারে কাজ করে।

৪ · D, JK আর T flip-flop — তিন রকম স্মৃতি-কোষ

SR-এর নিষিদ্ধ অবস্থা নকশাকারীদের মাথাব্যথা। এর তিনটি জনপ্রিয় সমাধান আছে — তিনটি আলাদা flip-flop. নিচের ছবিতে তাদের প্রতীক:

D flip-flop — “যা দেবে, তাই রাখব”

D flip-flop-এ ইনপুট একটিই — D (Data বা Delay). ভেতরে D সরাসরি S-এ যায়, আর একটি NOT গেট পার হয়ে R-এ যায়। ফলে S আর R কখনো একসাথে 1 হতে পারে না — নিষিদ্ধ অবস্থা চিরতরে বিদায়। নিয়মটি এক বাক্যের: ক্লকের ধারে Q = D, বাকি সময় Q স্থির। পরীক্ষার খাতায় যেমন — প্রশ্ন দেখে উত্তর লেখার সময় যা-ই ভাবুন, ঘণ্টা বাজার মুহূর্তে খাতায় যা লেখা আছে, সেটিই জমা। রেজিস্টারের প্রতিটি bit এই D flip-flop-এ রাখা হয় — এটিই ডিজিটাল দুনিয়ার মৌলিক ১-bit মেমরি কোষ।

Characteristic equation: Q_n+1 = D. সরল বলেই আজকের প্রায় সব চিপে D flip-flop-ই সবচেয়ে বেশি ব্যবহৃত।

JK flip-flop — নিষিদ্ধ অবস্থাকে কাজে লাগানো

JK flip-flop-এ J কাজ করে S-এর মতো (set), K কাজ করে R-এর মতো (reset). কিন্তু ভেতরে আউটপুট Q আর Q′ ঘুরিয়ে এনে ইনপুটের গেটে দেওয়া হয়, যাতে J = K = 1 হলে নিষিদ্ধ না হয়ে আউটপুট উল্টে যায় — 0 থাকলে 1, 1 থাকলে 0. একে বলে toggle. টিভির রিমোটের পাওয়ার বোতাম এমন — একবার চাপলে চালু, আবার চাপলে বন্ধ।

Characteristic equation: Q_n+1 = J·Q′_n + K′·Q_n. একটি সতর্কতা: পুরোনো level-triggered JK-তে CLK অনেকক্ষণ 1 থাকলে J = K = 1 অবস্থায় আউটপুট একবার নয়, বারবার উল্টাতে থাকত — একে বলে race-around condition. সমাধান হিসেবে আসে master-slave JK (দুটি latch পরপর — একটি ক্লক 1 থাকার সময় নেয়, অন্যটি 0 হলে ছাড়ে) আর পরে edge-triggered JK.

T flip-flop — শুধু উল্টানো, তাই কম্পাঙ্ক অর্ধেক

JK-এর J আর K একসাথে জুড়ে একটি ইনপুট বানালে পাওয়া যায় T flip-flop (Toggle). T = 0 হলে মনে রাখে, T = 1 হলে প্রতিটি ক্লকের ধারে উল্টে যায়। Characteristic equation: Q_n+1 = T ⊕ Q_n (⊕ = XOR).

T = 1 রেখে ক্লক দিলে মজার একটি জিনিস ঘটে। প্রতি দুটি ক্লক-টিকে Q একবার 0 থেকে 1 হয়ে আবার 0-তে ফেরে — অর্থাৎ Q-এর কম্পাঙ্ক ক্লকের ঠিক অর্ধেক। নিচের timing diagram (সময়ের সাথে সংকেতের ছবি) দেখুন:

এই কারণে T flip-flop-কে বলে frequency divider (কম্পাঙ্ক ভাজক)। দুটি পরপর জুড়লে ÷ ৪, তিনটিতে ÷ ৮, n-টিতে ÷ 2ⁿ. এই সরল কৌশলটি পরের অংশের কাউন্টারের ভিত্তি।

চারটি এক টেবিলে

৫ · রেজিস্টার — flip-flop-এর সারি

একটি flip-flop রাখে ১ bit. কিন্তু CPU কাজ করে একসাথে ৮, ১৬, ৩২ বা ৬৪ bit নিয়ে। সমাধান সোজা: অনেকগুলো D flip-flop পাশাপাশি বসান, সবার ক্লক একই তারে জুড়ে দিন। এটিই register. চারটি D flip-flop = একটি 4-bit register; প্রতিটির নিজের D ইনপুট আর নিজের Q আউটপুট, আর একটিই ক্লক।

ক্লকের ধারে চারটি bit একসাথে ভেতরে ঢোকে — একে বলে parallel load. যেমন D-তে 1011 দিয়ে একটি পালস দিলে রেজিস্টারে 1011 বসে। এরপর D-তে যা-ই দিন, পরের পালস না আসা পর্যন্ত রেজিস্টার 1011-ই ধরে রাখে। ধারণাগতভাবে CPU-র একটি 64-bit register হলো এমন ৬৪টি flip-flop-এর সারি (আধুনিক চিপে register file তৈরি হয় বিশেষ ধরনের দ্রুত, SRAM-সদৃশ কোষে, কিন্তু মূল নীতি একই)। মেমরির সব স্তরের মধ্যে register কেন সবচেয়ে দ্রুত, তা পর্ব ০৪-এ দেখেছেন।

Shift register — bit-এর লাইন সরে সরে চলা

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

নিচের stepper-এ সিরিয়াল ইনপুটে একটি একটি করে 1, 0, 1, 1 পাঠানো হচ্ছে — দেখুন bit-গুলো কীভাবে লাইন ধরে এগোয়:

চার রকম shift register

বাঁয়ে সরানো = ২ দিয়ে গুণ

দশমিকে একটি সংখ্যার শেষে 0 বসালে (৩৫ → ৩৫০) মান ১০ গুণ হয়। বাইনারিতে একই কারণে প্রতিটি bit এক ঘর বাঁয়ে সরালে মান ২ গুণ হয়: 0011 (৩) → 0110 (৬) → 1100 (১২)। আর ডানে সরালে ২ দিয়ে ভাগ (ভাগশেষ ফেলে): 1100 (১২) → 0110 (৬)। CPU-তে গুণ-ভাগের চেয়ে shift অনেক সস্তা ও দ্রুত, তাই compiler সুযোগ পেলেই “× ৮”-কে “৩ ঘর বাঁয়ে সরানো” বানিয়ে দেয় (পর্ব ১৭-এর বাইনারি গণিতের সাথে মিলিয়ে দেখুন)। তবে খেয়াল রাখুন: 4-bit রেজিস্টারে 1100-কে আবার বাঁয়ে সরালে বাঁ প্রান্তের 1 হারিয়ে যায় — ফল 1000 (৮), ২৪ নয়। এটি overflow.

৬ · কাউন্টার — পালস গোনার যন্ত্র

অংশ ৪-এ দেখেছেন, T = 1 রাখা একটি T flip-flop ক্লকের কম্পাঙ্ক অর্ধেক করে। এখন কয়েকটি T flip-flop শিকলের মতো জুড়ুন: প্রথমটির ক্লকে আসল পালস, আর প্রতিটির Q পরেরটির ক্লকে। প্রতিটি flip-flop আগেরটির চেয়ে অর্ধেক গতিতে উল্টায় — আর মিলিয়ে পড়লে দেখা যায়, তারা বাইনারিতে গুনছে! এটিই counter, আর এই নকশার নাম ripple counter বা asynchronous counter.

নিয়মটি একটি: FF0 প্রতিটি পালসে উল্টায়; বাকি প্রতিটি উল্টায় কেবল তখন, যখন তার আগেরটি 1 থেকে 0-তে নামে। ঠিক যেমন বাইনারিতে ১ যোগ করলে ডান দিকের 1-গুলো 0 হয়ে carry বাঁয়ে যায় (পর্ব ১৭)। এবার ধাপে ধাপে গুনুন:

কয়টি flip-flop লাগবে — mod-N কাউন্টার

একটি কাউন্টার যতগুলো আলাদা অবস্থা পার হয়ে আবার শুরুতে ফেরে, সেই সংখ্যাকে বলে তার modulus. এমন কাউন্টারকে বলে mod-N counter. n-টি flip-flop-এ সর্বোচ্চ 2ⁿটি অবস্থা (০ থেকে 2ⁿ − ১)। তাই mod-N কাউন্টারের জন্য সবচেয়ে ছোট n নিতে হয়, যাতে 2ⁿ ≥ N হয়।

Mod-10 (decade) কাউন্টার — ডিজিটাল ঘড়ির অঙ্ক

৪টি flip-flop স্বাভাবিকভাবে ০ থেকে ১৫ পর্যন্ত গোনে। কিন্তু ঘড়ির একক অঙ্কের দরকার ০ থেকে ৯. কৌশল: কাউন্টার যখনই 1010 (দশ) ছোঁয়, তখনই সব flip-flop-কে 0 করে দেওয়া হয়। 1010-এ শুধু Q3 আর Q1 একসাথে 1 (০ থেকে ৯-এর মধ্যে আর কোথাও এমন হয় না), তাই একটি NAND গেটে Q3 আর Q1 দিলে তার আউটপুট 0 হয়ে সব flip-flop-এর active-low clear ইনপুট চালিয়ে দেয়। ফলে 1010 অবস্থাটি মুহূর্তের জন্য তৈরি হয়েই মিলিয়ে যায়, আর গোনা চলে ০, ১, … ৯, ০, ১, … — এটিই decade counter. ৭৪-সিরিজের পুরোনো চিপ 7490 এমন একটি decade counter, আর 7493 একটি 4-bit বাইনারি কাউন্টার — ল্যাবে এগুলো প্রায়ই দেখা যায়। একই কৌশলে যেকোনো mod-N বানানো যায়: N-এর বাইনারি রূপে যে bit-গুলো 1, সেগুলো NAND-এ দিন।

Synchronous কাউন্টার আর up/down কাউন্টার

Ripple counter-এর দুর্বলতা হলো ঢেউ। প্রতিটি flip-flop-এ কয়েক ন্যানোসেকেন্ড দেরি জমতে জমতে বড় কাউন্টারে শেষ bit অনেক পরে বদলায়, আর মাঝপথে কিছুক্ষণ ভুল সংখ্যা (যেমন 011 থেকে 100-এ যাওয়ার পথে 010, তারপর 000) দেখা যায়। দ্রুত সার্কিটে এটি বিপজ্জনক।

সমাধান synchronous counter: সব flip-flop একই ক্লক পায়, আর প্রতিটি উল্টাবে কি না তা ঠিক করে ছোট কিছু AND গেট। নিয়ম বাইনারি যোগ থেকেই আসে — একটি bit উল্টায় কেবল তখন, যখন তার ডানের সব bit 1: T0 = 1, T1 = Q0, T2 = Q0·Q1, T3 = Q0·Q1·Q2. সব একই ধারে বদলায়, ঢেউ নেই — দ্রুত আর নির্ভরযোগ্য, শুধু গেট একটু বেশি লাগে। CPU-র ভেতরের কাউন্টারগুলো (যেমন পরের নির্দেশের ঠিকানা রাখা program counter, পর্ব ২৪) এ ধরনের synchronous নকশায় চলে।

Up/down counter দুই দিকেই গুনতে পারে — একটি নিয়ন্ত্রণ তার (UP/DOWN) ঠিক করে। নিচে গোনার (down) জন্য পরের flip-flop-এর ক্লকে Q-এর বদলে Q′ দেওয়া হয় (ripple নকশায়), ফলে ৭, ৬, ৫ … ০, ৭ — এভাবে চলে। ক্রিকেটের স্কোরবোর্ডে “বাকি বল” বা মাইক্রোওয়েভের টাইমার এমন নিচে-গোনা কাউন্টার।

নিজে চালিয়ে দেখুন — register আর কাউন্টারের সিমুলেটর

নিচের ছোট প্রোগ্রামটি সত্যিকারের সময় বা টাইমার ছাড়াই ক্লক পালস “অনুকরণ” করে — লুপের প্রতিটি ঘুর একটি পালস। প্রথমে একটি 4-bit D register, তারপর একটি 4-bit ripple counter আর একটি mod-10 কাউন্টার পাশাপাশি ১৬টি পালস পায়। চালান চাপুন:

// D flip-flop register: ক্লকের ধারে Q = D, বাকি সময় মান ধরে রাখে
const reg = [0, 0, 0, 0];
const clockIn = (d) => d.forEach((b, i) => { reg[i] = b; });
clockIn([1, 0, 1, 1]);
console.log("পালস ১ → register:", reg.join(""));
console.log("D = 0110, ক্লক নেই → register:", reg.join(""));
clockIn([0, 1, 1, 0]);                 // এবার ক্লক এল
console.log("পালস ২ → register:", reg.join(""));
// T flip-flop (T=1) দিয়ে ripple counter; q[0] = LSB
function tick(q) {
  for (let i = 0; i < q.length; i++) {
    q[i] ^= 1;                        // toggle
    if (q[i] === 1) break;            // 1→0 হলেই শুধু পরেরটিতে ঢেউ যায়
  }
}
const c4 = [0, 0, 0, 0], c10 = [0, 0, 0, 0], out4 = [], out10 = [];
for (let p = 1; p <= 16; p++) {
  tick(c4); tick(c10);
  out4.push([...c4].reverse().join(""));
  if (c10[3] && c10[1]) c10.fill(0);  // 1010 (দশ) হলেই clear
  out10.push(parseInt([...c10].reverse().join(""), 2));
}
console.log("4-bit:", out4.join(" "));
console.log("mod-10:", out10.join(" "));

৭ · কোথায় কাজে লাগে — ঘড়ি থেকে state machine

ডিজিটাল ঘড়ি আর স্টপওয়াচ

হাতের ডিজিটাল ঘড়ির ভেতরে একটি ছোট কোয়ার্টজ স্ফটিক সেকেন্ডে ঠিক ৩২,৭৬৮ বার কাঁপে। সংখ্যাটি অদ্ভুত মনে হলেও আসলে 2¹⁵. তাই ১৫টি T flip-flop পরপর জুড়লে (প্রতিটি ÷ ২) শেষে পাওয়া যায় ঠিক ১ Hz — সেকেন্ডে একটি পালস। সেই পালস যায় একটি mod-10 কাউন্টারে (সেকেন্ডের একক অঙ্ক), তার প্রতি ১০ পালসে একটি পালস যায় mod-6 কাউন্টারে (সেকেন্ডের দশক অঙ্ক) — দুটি মিলে mod-60. একইভাবে মিনিট, তারপর ঘণ্টার জন্য mod-12 বা mod-24. প্রতিটি কাউন্টারের আউটপুট পর্ব ২১-এর BCD-to-7-segment ডিকোডার দিয়ে পর্দার অঙ্কে বদলায়। স্টপওয়াচও একই — শুধু শুরু-থামা-রিসেট বোতাম যোগ হয়।

মেমরি কোষ — SRAM

CPU-র cache যে SRAM দিয়ে তৈরি, তার প্রতিটি কোষ মূলত একটি latch: দুটি NOT গেট (inverter) মুখোমুখি জোড়া — একটির আউটপুট অন্যটির ইনপুট, ঠিক SR latch-এর মতো আড়াআড়ি feedback — আর পড়া-লেখার জন্য দুটি ট্রানজিস্টর। মোট ৬টি transistor, তাই একে বলে 6T কোষ। বিদ্যুৎ থাকা পর্যন্ত মান ধরে রাখে, refresh লাগে না। কেন cache-এ এটিই ব্যবহার হয়, আর মেমরি হায়ারার্কি কীভাবে সাজানো — পর্ব ২৫-এ।

Finite state machine — অবস্থার মানচিত্র

এবার সবচেয়ে বড় ধারণা। কয়েকটি flip-flop মিলে মনে রাখে যন্ত্রটি এখন কোন “অবস্থা”-য় আছে, আর combinational লজিক ঠিক করে ইনপুট দেখে পরের অবস্থা কী হবে (ছবি ২২.১ আবার দেখুন)। নির্দিষ্টসংখ্যক অবস্থা আর তাদের মধ্যে যাওয়ার নিয়ম — এই মডেলকে বলে finite state machine (FSM). চৌরাস্তার ট্রাফিক বাতি এর সহজ উদাহরণ (সময়গুলো কাল্পনিক, শুধু বোঝার জন্য):

এই একই ছকে চলে লিফট (কোন তলায়, ওপরে না নিচে যাচ্ছে, দরজা খোলা না বন্ধ), ওয়াশিং মেশিন (ভেজানো → ধোয়া → নিংড়ানো), ভেন্ডিং মেশিন (কত টাকা ঢুকেছে), এমনকি CPU-র নিয়ন্ত্রণ অংশ — যা প্রতিটি নির্দেশের জন্য fetch, decode, execute ধাপে ঘোরে (পর্ব ২৪)। কম্পিউটার আসলে একটি বিশাল state machine: register, cache আর RAM-এর সব bit মিলে তার “অবস্থা”, আর প্রতিটি ক্লক টিকে সে পরের অবস্থায় যায়।

৮ · AI-এর যুগে — flip-flop-এর উত্তর যাচাই করুন

AI চ্যাটবট flip-flop-এর ব্যাখ্যা খুব গুছিয়ে লেখে, কিন্তু সময়ের খুঁটিনাটি (timing) আর সীমান্ত-অবস্থায় (edge case) প্রায়ই অস্পষ্ট বা ভুল বলে — কারণ নামগুলো কাছাকাছি (SR/JK/T), আর অনলাইনের নোটেই এগুলো প্রায়ই গুলিয়ে থাকে। ভালো খবর: এখানে যাচাই করা খুব সহজ — characteristic table আর একটি ছোট সিমুলেটরই বিচারক।

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

• প্রতিটি পালসের ফল নিজে characteristic table থেকে মিলিয়েছি (উপরের prompt-এর সঠিক উত্তর: 1, 1, 0, 1, 0, 1)
• SR-এর S = R = 1 অবস্থাকে “নিষিদ্ধ/অনির্ধারিত” বলা হয়েছে, toggle বা “1” নয়
• latch (level) আর flip-flop (edge) আলাদা করে বলা হয়েছে, উদাহরণসহ
• কাউন্টারের যেকোনো দাবি (কয়টি flip-flop, কোন ক্রমে গোনে) 2ⁿ হিসাব বা ছোট সিমুলেটরে চালিয়ে দেখেছি
• NAND আর NOR latch-এর নিয়ম গুলিয়ে ফেলা হয়নি — প্রশ্নে কোন গেট, আগে দেখেছি