ফ্লিপ-ফ্লপ — D, JK, T ফ্লিপ-ফ্লপ

১ · ল্যাচ বনাম ফ্লিপ-ফ্লপ — level-triggered বনাম edge-triggered

L13-এর SR ও D ল্যাচ দুটোই level-triggered — যতক্ষণ Enable সিগন্যাল উঁচু (1) থাকে, ততক্ষণ আউটপুট ইনপুটের যেকোনো পরিবর্তনে সাড়া দিতে থাকে। এটা ছোট, বিচ্ছিন্ন সার্কিটে সমস্যা না হলেও, যখন একগুচ্ছ মেমরি এলিমেন্ট একসাথে সিঙ্ক্রোনাইজড হয়ে কাজ করতে হয় (যেমন CPU-এর ভেতরের শত শত রেজিস্টার), তখন level-triggered আচরণ টাইমিং রেস তৈরি করতে পারে — একটা ল্যাচের আউটপুট এখনো বদলাতে বদলাতেই আরেকটা ল্যাচ সেই অস্থির মান পড়ে ফেলতে পারে।

ফ্লিপ-ফ্লপFlip-Flopএজ-ট্রিগারড মেমরি এলিমেন্ট — শুধুমাত্র ক্লক সিগন্যালের একটি নির্দিষ্ট ট্রানজিশন মুহূর্তে (সাধারণত 0→1 রাইজিং এজ) আউটপুট আপডেট হয়। এই সমস্যার সমাধান দেয় — এটা edge-triggered: আউটপুট শুধু তখনই বদলায় যখন ক্লক সিগন্যাল ঠিক 0 থেকে 1-এ ট্রানজিশন করে (রাইজিং এজ), তার বাইরে যতই ইনপুট বদলাক না কেন, আউটপুট স্থির থাকে। এই "শুধু একটা নির্দিষ্ট মুহূর্তে সাড়া দেওয়া" বৈশিষ্ট্যটাই একগুচ্ছ ফ্লিপ-ফ্লপকে একই ক্লক সিগন্যালে একসাথে, নির্ভরযোগ্যভাবে আপডেট হতে দেয় — সরাসরি M6-এর CPU ডেটাপাথ ও M7-এর পাইপলাইন স্টেজের ভিত্তি, যেগুলো পুরোপুরি ক্লকড ফ্লিপ-ফ্লপ রেজিস্টার দিয়ে তৈরি।

২ · D ফ্লিপ-ফ্লপ

সবচেয়ে সরল ও সবচেয়ে বেশি ব্যবহৃত — প্রতিটি ক্লক এজে Q ঠিক সেই মুহূর্তের D-এর মান গ্রহণ করে। এটাই L15-এর রেজিস্টারের মূল বিল্ডিং ব্লক — একটা N-বিট রেজিস্টার আসলে N-টা D ফ্লিপ-ফ্লপ একই ক্লক শেয়ার করে পাশাপাশি বসানো।

৩ · JK ফ্লিপ-ফ্লপ — SR-এর অবৈধ অবস্থার সমাধান, ভিন্নভাবে

JK ফ্লিপ-ফ্লপJK Flip-Flopদুটি ইনপুট J (set) ও K (reset) নিয়ে কাজ করা ফ্লিপ-ফ্লপ, যেখানে J=K=1 হলে Q টগল করে — SR ল্যাচের অবৈধ অবস্থার জন্য একটা সুনির্দিষ্ট, দরকারি আচরণ সংজ্ঞায়িত করে দেয়। SR ল্যাচের মতোই দুটি ইনপুট নেয় — J (Set-এর মতো) ও K (Reset-এর মতো)। J=K=0 হলে Hold, J=1,K=0 হলে Set (Q=1), J=0,K=1 হলে Reset (Q=0) — এখন পর্যন্ত সবই SR-এর মতোই। কিন্তু আসল পার্থক্য J=K=1 হলে — SR ল্যাচে এটা ছিল অবৈধ, JK ফ্লিপ-ফ্লপে এটা একটা সংজ্ঞায়িত, দরকারি আচরণ: Q তার বিপরীত মানে টগল করে (0 হলে 1, 1 হলে 0)। এইভাবে JK ফ্লিপ-ফ্লপ SR-এর "সমস্যার" কেসটাকেই একটা নতুন, দরকারি বৈশিষ্ট্যে রূপান্তরিত করে ফেলে।

৪ · T ফ্লিপ-ফ্লপ — টগল ফ্লিপ-ফ্লপ

T ফ্লিপ-ফ্লপT Flip-Flop (Toggle)JK ফ্লিপ-ফ্লপের সরলীকৃত সংস্করণ, যেখানে J ও K একটি একক ইনপুট T-তে বাঁধা — T=1 হলে টগল, T=0 হলে hold। হলো JK ফ্লিপ-ফ্লপেরই একটা সরলীকৃত সংস্করণ — J ও K-কে একসাথে বেঁধে একটাই ইনপুট T বানানো হয়েছে (J=K=T)। T=0 হলে Hold, T=1 হলে Toggle — ব্যস, এই দুটোই এর একমাত্র আচরণ। এই সরলতাই T ফ্লিপ-ফ্লপকে কাউন্টার বানানোর আদর্শ উপাদান করে তোলে (L16-এ দেখবেন) — একটা বাইনারি কাউন্টারের প্রতিটা বিট আসলে একটা T ফ্লিপ-ফ্লপ, যেটা নির্দিষ্ট শর্তে ক্রমাগত টগল করেই গণনা বাড়ায়।

৫ · কোড সেলে যাচাই — এজ-ট্রিগারিং ও টগল আচরণ

প্রতিটি ক্লাসের clock_tick() মেথডই একমাত্র জায়গা যেখানে .q বদলাতে পারে — মেথডটা কল হওয়া মানেই একটা রাইজিং ক্লক এজ ঘটেছে বলে ধরে নেওয়া হচ্ছে, ঠিক যেমন বাস্তব হার্ডওয়্যারে শুধু এজ মুহূর্তেই আউটপুট আপডেট হয়।

class DFlipFlop:
    """edge-triggered -- .q শুধুমাত্র clock_tick() কল হলেই আপডেট হয় (প্রতিটি কল = একটি রাইজিং এজ)"""
    def __init__(self, initial_q=0):
        self.q = initial_q

    def clock_tick(self, d):
        self.q = d
        return self.q


class JKFlipFlop:
    """J=K=0 hold, J=1,K=0 set, J=0,K=1 reset, J=K=1 toggle"""
    def __init__(self, initial_q=0):
        self.q = initial_q

    def clock_tick(self, j, k):
        if j == 0 and k == 0:
            pass                      # Hold
        elif j == 1 and k == 0:
            self.q = 1                # Set
        elif j == 0 and k == 1:
            self.q = 0                # Reset
        else:                         # j == 1 and k == 1
            self.q = 1 - self.q       # Toggle
        return self.q


class TFlipFlop:
    """JK-এর J=K=T সংস্করণ -- T=1 হলে toggle, T=0 হলে hold"""
    def __init__(self, initial_q=0):
        self.q = initial_q

    def clock_tick(self, t):
        if t == 1:
            self.q = 1 - self.q       # Toggle
        return self.q                 # t == 0 -> Hold


print("D ফ্লিপ-ফ্লপ -- প্রতিটি clock_tick()-এ Q = D")
print("-" * 60)
d_ff = DFlipFlop()
for i, d in enumerate([1, 1, 0, 1, 0], start=1):
    before = d_ff.q
    after = d_ff.clock_tick(d)
    print(f"টিক {i}: D={d} | আগে Q={before} -> পরে Q={after}")

print()
print("JK ফ্লিপ-ফ্লপ -- J=K=1 হলে প্রতি টিকে Q টগল করে")
print("-" * 60)
jk = JKFlipFlop(initial_q=0)
jk_sequence = [(1, 0, "Set"), (0, 0, "Hold"), (1, 1, "Toggle"), (1, 1, "Toggle"), (1, 1, "Toggle"), (0, 1, "Reset")]
for j, k, label in jk_sequence:
    before = jk.q
    after = jk.clock_tick(j, k)
    print(f"টিক: J={j} K={k} ({label:6s}) | আগে Q={before} -> পরে Q={after}")

print()
print("T ফ্লিপ-ফ্লপ -- T=1 হলে টগল, T=0 হলে hold (JK-এর J=K=T সংস্করণ)")
print("-" * 60)
t_ff = TFlipFlop(initial_q=0)
for i, t in enumerate([1, 1, 0, 1, 1, 1], start=1):
    before = t_ff.q
    after = t_ff.clock_tick(t)
    print(f"টিক {i}: T={t} | আগে Q={before} -> পরে Q={after}")