টাইমার ও কাউন্টার

১ · টাইমার/কাউন্টার আসলে কী

টাইমার/কাউন্টারTimer/Counterএকটি হার্ডওয়্যার রেজিস্টার যা প্রতি ক্লক পালসে নিজে থেকে বাড়ে বা কমে — CPU-কে কোনো ইনস্ট্রাকশন চালাতে হয় না। হলো মাইক্রোকন্ট্রোলারের ভেতরে বসানো একটি সাধারণ কিন্তু অত্যন্ত গুরুত্বপূর্ণ পেরিফেরাল — একটি রেজিস্টার যা প্রতি ক্লক সাইকেলে (বা প্রিস্কেল করা ক্লকে) নিজে থেকে ১ করে বাড়ে, সম্পূর্ণ স্বয়ংক্রিয়ভাবে, CPU-এর কোনো হস্তক্ষেপ ছাড়াই। রেজিস্টার আর্কিটেকচারের সাধারণ ধারণার জন্য Computer Architecture কোর্স দেখুন — এই পাঠ ধরে নিচ্ছে সেই ভিত্তি আছে এবং সরাসরি টাইমার পেরিফেরালের আচরণে যাচ্ছে।

কাউন্টার একটি নির্দিষ্ট সর্বোচ্চ মান (যেমন ৮-বিট হলে ২৫৫, ১৬-বিট হলে ৬৫৫৩৫) পর্যন্ত বেড়ে তারপর ওভারফ্লো করে ০-তে ফিরে যায় — অথবা একটি প্রোগ্রামযোগ্য reload/compare রেজিস্টার-এ পৌঁছালেই ম্যাচ ইভেন্ট ঘটিয়ে নিজে থেকে রিসেট হয়ে আবার গোনা শুরু করে। প্রতিটি ওভারফ্লো/ম্যাচ ইভেন্ট একটি হার্ডওয়্যার ইন্টারাপ্ট জেনারেট করতে পারে — অর্থাৎ একবার কনফিগার করে দিলে টাইমার নিজে থেকেই নিয়মিত বিরতিতে CPU-কে "জাগিয়ে দেয়", পোলিং লুপের প্রয়োজন ছাড়াই (L17-এর পোলিং বনাম ইন্টারাপ্ট তুলনার মতোই — এখানে ইভেন্টটা সময়-ভিত্তিক)।

২ · প্রিস্কেলার — ক্লককে ধীর করা

মাইক্রোকন্ট্রোলারের মূল ক্লক সাধারণত মেগাহার্টজ রেঞ্জে (যেমন ১৬ MHz) — সরাসরি এই গতিতে একটি ৮/১৬-বিট কাউন্টার চালালে তা প্রতি সেকেন্ডে লক্ষ লক্ষ বার ওভারফ্লো করবে, যা বেশিরভাগ বাস্তব-জীবনের টাইমিং কাজের (যেমন ১ সেকেন্ড পরপর একটি LED ব্লিংক করানো) জন্য অপ্রয়োজনীয়ভাবে দ্রুত এবং ইন্টারাপ্ট ওভারহেড বাড়িয়ে দেবে। এই সমস্যা সমাধানের জন্য থাকে প্রিস্কেলার — একটি বিভাজক (divider) যা মূল ক্লককে N দিয়ে ভাগ করে কাউন্টারে পাঠায়, ফলে কাউন্টার প্রতি N ক্লক সাইকেলে একবার বাড়ে।

৩ · ইন্টারাপ্ট পিরিয়ড গণনার সূত্র

প্রিস্কেলার ও reload ভ্যালু জানা থাকলে ইন্টারাপ্ট ঠিক কত সেকেন্ড পরপর ফায়ার হবে তা নির্ভুলভাবে গণনা করা যায়:

$$ T_{period} = \dfrac{N_{prescaler} \times N_{reload}}{f_{clock}} $$

এখানে $N_{prescaler}$ হলো প্রিস্কেলার ডিভিশন ফ্যাক্টর, $N_{reload}$ হলো reload/compare রেজিস্টারে সেট করা টার্গেট ভ্যালু, এবং $f_{clock}$ হলো মূল ক্লক ফ্রিকোয়েন্সি (Hz)। নিচের কোড সেলে কয়েকটি বাস্তব কনফিগারেশনের জন্য এই সূত্র সরাসরি প্রয়োগ করে পিরিয়ড গণনা করা হয়েছে।

class Timer:
    def __init__(self, clock_hz, prescaler, reload_value):
        self.clock_hz = clock_hz
        self.prescaler = prescaler
        self.reload_value = reload_value

    def formula_period_s(self):
        # সূত্র: T = (prescaler * reload) / clock_hz
        return (self.prescaler * self.reload_value) / self.clock_hz


configs = [
    ("কনফিগ A", Timer(clock_hz=16_000_000, prescaler=1, reload_value=16_000)),
    ("কনফিগ B", Timer(clock_hz=16_000_000, prescaler=64, reload_value=25_000)),
    ("কনফিগ C", Timer(clock_hz=8_000_000, prescaler=1024, reload_value=7_813)),
]

print("ক্লক + প্রিস্কেলার + reload থেকে ইন্টারাপ্ট পিরিয়ড:")
for name, t in configs:
    period_s = t.formula_period_s()
    print(f"  {name}: clock={t.clock_hz:>10,} Hz, prescaler={t.prescaler:>5}, "
          f"reload={t.reload_value:>6} -> period={period_s*1000:.4f} ms "
          f"(~{1/period_s:.2f} Hz ইন্টারাপ্ট রেট)")

৪ · সিমুলেশন দিয়ে সূত্র যাচাই

উপরের সূত্র নির্ভুল কিনা তা যাচাই করার সবচেয়ে ভালো উপায় হলো কাউন্টারকে সত্যিই tick-by-tick গণনা করিয়ে দেখা — প্রতিটি tick-এ কাউন্টার ১ করে বাড়বে, যতক্ষণ না reload ভ্যালুতে পৌঁছায়। নিচের কোড সেলে এই সিমুলেশন চালিয়ে গণনা করা tick সংখ্যা দিয়ে বের করা পিরিয়ডকে সূত্রের পিরিয়ডের সাথে সরাসরি তুলনা করা হয়েছে।

class SimulatedTimer:
    def __init__(self, clock_hz, prescaler, reload_value):
        self.clock_hz = clock_hz
        self.prescaler = prescaler
        self.reload_value = reload_value

    def formula_period_s(self):
        return (self.prescaler * self.reload_value) / self.clock_hz

    def run_until_overflow(self):
        # সত্যিকারের tick-by-tick গণনা: কাউন্টার ০ থেকে শুরু করে
        # প্রতি tick-এ ১ করে বাড়ে, reload_value-এ পৌঁছালে থামে
        count = 0
        ticks_counted = 0
        while count < self.reload_value:
            count += 1
            ticks_counted += 1
        return ticks_counted


t = SimulatedTimer(clock_hz=16_000_000, prescaler=64, reload_value=25_000)  # কনফিগ B

ticks_counted = t.run_until_overflow()
simulated_period_s = (ticks_counted * t.prescaler) / t.clock_hz
formula_period_s = t.formula_period_s()

print(f"reload_value          = {t.reload_value}")
print(f"সিমুলেশনে গোনা ticks   = {ticks_counted}")
print(f"সিমুলেশন থেকে পিরিয়ড   = {simulated_period_s*1000:.4f} ms")
print(f"সূত্র থেকে পিরিয়ড       = {formula_period_s*1000:.4f} ms")
print(f"দুটো মেলে?              = {abs(simulated_period_s - formula_period_s) < 1e-9}")