এই পর্বে যা শিখবেন
- একটি আধুনিক microcontroller timer-এর অংশগুলো: prescaler, counter, auto-reload, update event, capture/compare channel, আর shadow register কেন
- যেকোনো লক্ষ্য frequency-র জন্য PSC আর ARR হিসাব করা, ১৬ বিটের সীমা আর ভুলের হার মিলিয়ে
- Input capture দিয়ে period আর frequency মাপা, overflow গোনা আর overcapture চেনা; output compare আর one-pulse mode-এর সময়ের হিসাব
- Virtual বাজারঘর board-এ SysTick-কে সময়ের ভিত্তি বানানো, সূক্ষ্ম timestamp নিরাপদে পড়া, আর software দিয়ে capture-এর কাজ চালিয়ে দেখা
- Unsigned wrap-এর গণিত দিয়ে overflow-নিরাপদ সময়ের তুলনা আর timer-নির্ভর কাজের সূচি লেখা
১ · Timer কী — clock গোনা একটি counter
রেলস্টেশনের প্ল্যাটফর্মে একজন কর্মী একটি বড় ঘড়ি দেখে প্রতি ১৫ মিনিটে ঘণ্টা বাজান। তিনি নিজে সময় “অনুভব” করেন না; ঘড়ির কাঁটা গোনে, তিনি শুধু দেখেন কাঁটা কখন একটি দাগ ছুঁল। Microcontroller-এর timer ঠিক এই ঘড়ি। ভেতরে একটি counter, যা প্রতিটি clock pulse-এ এক বাড়ে বা কমে। Clock-এর frequency জানা থাকলে গণনা মানেই সময়: 1 MHz-এর clock-এ ১০০০ গণনা = 1 ms. একই counter যদি clock-এর বদলে বাইরের কোনো pin-এর pulse গোনে, যেমন একটি পাখার প্রতি ঘূর্ণনের একটি pulse, তখন তাকে counter বলা হয়। Hardware একই, শুধু কী গোনা হচ্ছে তা আলাদা।
কেন আলাদা hardware? পর্ব ১২-এর delay subroutine-এ CPU নিজে নির্দেশ চালিয়ে সময় নষ্ট করত, আর সেই সময়ে অন্য কিছু করতে পারত না। একটি interrupt এলে loop লম্বা হয়ে যেত, compiler বা clock বদলালে সময় বদলে যেত। Timer CPU-র পাশে স্বাধীনভাবে গোনে: CPU ঘুমাতে পারে, অন্য কাজ করতে পারে, আর timer নির্দিষ্ট মুহূর্তে একটি interrupt দিয়ে জাগায়, বা নিজেই একটি pin বদলায়, যেখানে CPU-র কোনো দেরির প্রভাব পড়ে না।
এই ধারণা নতুন নয়। 8085-এর যুগে বাইরে একটি আলাদা chip, 8253/8254, বসাতে হতো; তার তিনটি ১৬ বিটের down-counter, ছয়টি mode আর control word পুরো পর্ব ২৫-এ। Counter-এর flip-flop-স্তরের গঠন Computer Architecture-এর পর্ব ১৬-এ। আজকের microcontroller সেই chip-কে ভেতরে এনেছে, আর কয়েকটি নতুন ক্ষমতা যোগ করেছে: prescaler, auto-reload, capture আর compare. এই পর্বে সেগুলোই। Clock কোথা থেকে আসে আর কোন timer কোন bus-এর clock পায়, তা পর্ব ৩৩-এ দেখেছেন; সেখানকার একটি ফল এখানে কাজে লাগবে: STM32F103-এ 72 MHz SYSCLK আর APB1 = 36 MHz হলে TIM2–TIM4-এর clock ×2 = 72 MHz.
লেখার নিয়ম আর lab: এই পর্বে hex লেখা হয় C-র ধাঁচে, যেমন 0xFFFFFFFF. কোর্সের virtual বাজারঘর board BG-M3-এ (আসল Cortex-M chip-এর আদলে বানানো শেখার মডেল, আসল পণ্য নয়; পর্ব ০৬) কোনো general-purpose timer peripheral নেই, আছে শুধু ARM-এর SysTick (reference lab-এর README, Spec decision 22). তাই board-এর সব সংখ্যা আমার lab-এ আসল firmware চালিয়ে পাওয়া: C-তে লেখা, Clang 22.1.8 দিয়ে compile (PyPI-র ziglang 0.17.1, MIT; LLVM অংশ Apache-2.0 with LLVM exception), Unicorn 2.1.4-এ (binding BSD, engine GPLv2) চালানো। STM32F103-এর timer-এর তথ্য ST-এর reference manual RM0008-এর অধ্যায় ১৫ (TIM2–TIM5) থেকে; সেই timer-এর আচরণ এখানে একটি ছোট Python মডেলে দেখানো হয়েছে, যেটি আমার lab-এ পরীক্ষা করা, কিন্তু আসল silicon নয়। কোন অংশ মডেল, তা প্রতিবার বলা থাকবে। হাতে কোনো আসল board বা oscilloscope ছিল না।
বাজারঘরের দুটি device-এর প্রায় সব কাজই timer-এর ছন্দে বাঁধা (README-র “বাজারঘর devices”): smart scale প্রতি 100 ms-এ ওজন মাপে, cold-storage monitor প্রতি 1 s-এ তাপমাত্রা পড়ে (SysTick 10 ms, LOAD = 79 999, ১০০ tick), আর প্রতি 10 s-এ telemetry পাঠায়। Button-এর debounce-এ 8 ms-এর নমুনা, watchdog-এ 100 ms. এই পর্বের শেষে আপনি এই প্রতিটি সংখ্যা কোন register-এর কোন মান থেকে আসে, তা হিসাব করতে পারবেন।
২ · একটি আধুনিক timer-এর ভেতরে — prescaler, counter, auto-reload আর update event
RM0008 STM32F103-এর general-purpose timer TIM2–TIM5-এর বৈশিষ্ট্য এভাবে দেয় (§15.2): একটি ১৬ বিটের up, down বা up/down auto-reload counter; একটি ১৬ বিটের prescaler, যা counter-এর clock-কে “1 থেকে 65536-এর যেকোনো সংখ্যা দিয়ে” ভাগ করে; আর চারটি স্বাধীন channel, যার প্রতিটি input capture, output compare, PWM বা one-pulse mode-এ চলতে পারে। নিচের ছবিটি একটি timer আর তার একটি channel-কে সরল করে দেখায়।
ছবি ৪৪.১ — একটি general-purpose timer (STM32 TIMx-এর ধাঁচে, সরল করা)
ওপরে সময়ের পথ: clock → prescaler → counter → ARR-এর সঙ্গে তুলনা → update event; নিচে channel 1: compare-এ pin বদলায়, capture-এ pin-এর edge CNT-কে CCR1-এ ধরে
অংশগুলো এক এক করে। Prescaler input clock CK_PSC-কে PSC + 1 দিয়ে ভাগ করে counter-এর clock CK_CNT বানায়; RM0008-এর ভাষায় “CK_CNT = fCK_PSC / (PSC[15:0] + 1)”. PSC = 0 মানে ভাগ নেই। Counter (CNT, offset 0x24) upcounting mode-এ 0 থেকে ARR পর্যন্ত গোনে; ARR-এ পৌঁছানোর পরের গণনায় 0-তে ফেরে আর একটি overflow ঘটে। তাই একটি পূর্ণ চক্র ARR + 1 গণনা। এই ঘটনার নাম update event (UEV): status register-এর UIF বিট 1 হয়, DIER-এর UIE চালু থাকলে একটি interrupt যায়। এটিই timer-এর সবচেয়ে সরল ব্যবহার: “প্রতি 1 ms-এ একবার CPU-কে ডাকা”। 8254-এর mode 2 (rate generator)-এর আধুনিক রূপ, তবে এবার counter ওপরের দিকে গোনে। STM32-এর counter down বা দুই দিকে (centre-aligned) গুনতেও পারে; দুই দিকের গণনা PWM-এ কাজে লাগে, যা পর্ব ৪৫ (PWM)-এর বিষয়।
একটি জিনিস 8254-এ ছিল না: shadow register. PSC সবসময়, আর ARR যদি CR1-এর ARPE বিট 1 হয়, “buffered”: লেখা মান সঙ্গে সঙ্গে কাজে লাগে না, পরের update event-এ লাগে (RM0008 §15.3.1). কারণটি নিরাপত্তা: ধরুন counter এখন 700-তে আর আপনি ARR 999 থেকে 500-এ নামালেন। সরাসরি বদলালে counter 500 পেরিয়ে গেছে, তাই 500-এর সঙ্গে আর মিলবে না, আর সাধারণত ১৬ বিটের শেষ পর্যন্ত গুনে তবেই ঘুরবে: একটি অনেক লম্বা, ভুল চক্র (প্র ০৪-এ আরও)। Shadow থাকলে বর্তমান চক্র পুরোনো মানে শেষ হয়, নতুন চক্র নতুন মানে শুরু হয়। শুরুতে মান সঙ্গে সঙ্গে বসাতে EGR-এর UG বিট (বিট ০) লিখে একটি update জোর করে ঘটানো হয়।
| Offset | Register | এই পর্বে দরকারি বিট |
|---|---|---|
| 0x00 | CR1 | CEN (০) চালু, UDIS (১), URS (২), OPM (৩) one-pulse, DIR (৪), CMS (৬:৫), ARPE (৭) |
| 0x0C | DIER | UIE (০) update interrupt, CC1IE (১) |
| 0x10 | SR | UIF (০), CC1IF (১), CC1OF (৯) overcapture |
| 0x14 | EGR | UG (০): এখনই একটি update |
| 0x18 | CCMR1 | CC1S (১:০) channel-এর দিক; input-এ IC1PSC (৩:২), IC1F (৭:৪); output-এ OC1M (৬:৪) |
| 0x20 | CCER | CC1E (০) চালু, CC1P (১) polarity |
| 0x24 · 0x28 · 0x2C | CNT · PSC · ARR | counter; prescaler (reset 0x0000); auto-reload (reset 0xFFFF) |
| 0x34–0x40 | CCR1–CCR4 | চারটি channel-এর capture/compare মান |
সারণির offset আর বিট RM0008-এর §15.4 থেকে (TIM2-এর base ঠিকানা 0x40000000, APB1 bus-এ)। পরের STM32 পরিবারে নাম প্রায় এক, কিন্তু কিছু বিট আর counter-এর প্রস্থ আলাদা (কোনো কোনো timer ৩২ বিটের), তাই নিজের chip-এর manual-ই শেষ কথা।
৩ · PSC আর ARR-এর হিসাব — 1 kHz থেকে 1 Hz
একটি update event-এর frequency আর period:
fUEV = fTIM ÷ ((PSC + 1) × (ARR + 1)) · TUEV = (PSC + 1) × (ARR + 1) ÷ fTIM
শর্ত: 0 ≤ PSC ≤ 65535, 0 ≤ ARR ≤ 65535. একটি গণনার সময় (tick) = (PSC + 1) ÷ fTIM.
হিসাবের পথ সবসময় একই। প্রথমে মোট ভাগ N = fTIM ÷ fলক্ষ্য. তারপর N-কে দুটি গুণনীয়কে ভাঙুন, (PSC + 1) আর (ARR + 1), যার প্রতিটি ৬৫৫৩৬-এর মধ্যে। একাধিক জোড়া মিললে বাছাইয়ের দুটি নীতি: “গোল” tick (1 µs বা 0.1 ms, পড়তে আর অন্য হিসাবে সহজ), অথবা সবচেয়ে ছোট PSC, যাতে ARR বড় হয় আর compare-এর ধাপ সূক্ষ্ম হয় (PWM-এর resolution, পর্ব ৪৫)। N পূর্ণসংখ্যা না হলে ঠিক frequency পাওয়া যায় না, তখন ভুলের হার ppm-এ (প্রতি দশ লক্ষে) জানাতে হয়। নিচের block তিনটি লক্ষ্যের জন্য সব বৈধ জোড়া খোঁজে।
# f_UEV = f_TIM / ((PSC+1) × (ARR+1)); PSC আর ARR দুটিই ১৬ বিট (0..65535)
F_TIM = 72_000_000 # STM32F103: TIM2 clock 72 MHz (পর্ব ৩৩)
def plans(f_target):
n = round(F_TIM / f_target) # মোট ভাগ = (PSC+1)(ARR+1)
out = []
for p1 in range(1, 65537): # p1 = PSC+1
if n % p1 == 0 and n // p1 <= 65536:
out.append((p1 - 1, n // p1 - 1))
return n, out
for f in (1000, 1, 44100):
n, ok = plans(f)
real = F_TIM / n
print(f"target {f} Hz: N = {n}, real {real:.3f} Hz, error {1e6*(real-f)/f:+.0f} ppm")
if not ok:
print(" no PSC/ARR pair fits 16 bits"); continue
fine = ok[0] # সবচেয়ে বড় ARR = সূক্ষ্মতম ধাপ
tidy = next((p for p in ok if F_TIM / (p[0] + 1) in (1e6, 1e4)), fine)
for name, (psc, arr) in (("finest", fine), ("round ", tidy)):
tick_ns = 1e9 * (psc + 1) / F_TIM
print(f" {name} PSC={psc:5d} ARR={arr:5d} tick {tick_ns:8.2f} ns,"
f" {len(ok)} pairs in total")আসল আউটপুট (ব্রাউজারের Python):
target 1000 Hz: N = 72000, real 1000.000 Hz, error +0 ppm
finest PSC= 1 ARR=35999 tick 27.78 ns, 82 pairs in total
round PSC= 71 ARR= 999 tick 1000.00 ns, 82 pairs in total
target 1 Hz: N = 72000000, real 1.000 Hz, error +0 ppm
finest PSC= 1124 ARR=63999 tick 15625.00 ns, 78 pairs in total
round PSC= 7199 ARR= 9999 tick 100000.00 ns, 78 pairs in total
target 44100 Hz: N = 1633, real 44090.631 Hz, error -212 ppm
finest PSC= 0 ARR= 1632 tick 13.89 ns, 4 pairs in total
round PSC= 0 ARR= 1632 tick 13.89 ns, 4 pairs in total
1 kHz-এ N = 72 000, আর ৮২টি বৈধ জোড়া। “round” জোড়া PSC = 71: counter-এর clock 72 MHz ÷ 72 = 1 MHz, প্রতি গণনা 1 µs, আর ARR = 999. “finest” জোড়া PSC = 1, ARR = 35 999: প্রতি গণনা 27.78 ns, compare-এর ধাপ প্রায় ৩৬ গুণ সূক্ষ্ম। 1 Hz-এ N = 72 000 000, যা একা ARR-এ ধরে না, তাই PSC বড় করতেই হয়: 7199 আর 9999 মনে রাখা সহজ, আর প্রতি গণনা 0.1 ms-এর। শেষ লক্ষ্য 44.1 kHz (অডিওর একটি প্রচলিত হার) থেকে শিক্ষা: 72 MHz ÷ 44 100 = 1632.65…, পূর্ণসংখ্যা নয়; সবচেয়ে কাছের N = 1633 দেয় 44 090.631 Hz, −212 ppm. এমন ক্ষেত্রে clock-এর উৎস বদলাতে হয়, নয়তো ভুলটি মেনে নিতে হয়।
| ধাপ | |
| হিসাব | |
| PSC | |
| ARR | |
| tick |
- লক্ষ্য ঠিক করা। প্রতি 1 ms-এ একটি update event চাই, অর্থাৎ 1 kHz. TIM2-এর clock 72 MHz, কারণ APB1-এর prescaler 2 হলে timer পায় ×2 (পর্ব ৩৩)। এই ধাপ ভুললে সব হিসাব দুই গুণ ভুল।
- মোট ভাগ। N = 72 000 000 ÷ 1000 = 72 000. এটিই (PSC + 1) × (ARR + 1).
- সীমা দেখা। 72 000 > 65 536, তাই শুধু ARR দিয়ে হবে না; PSC + 1 অন্তত 2 (72 000 ÷ 65 536 = 1.10, ওপরের দিকে গোল)।
- PSC বাছাই। PSC + 1 = 72 নিলে counter-এর clock ঠিক 1 MHz, প্রতি গণনা 1 µs. তাই PSC = 71, 72 নয়: register-এ ভাজকের চেয়ে এক কম লেখা হয়।
- ARR বাছাই। ARR + 1 = 72 000 ÷ 72 = 1000, তাই ARR = 999. Counter 0, 1, … 999 গোনে: মোট ১০০০টি অবস্থা।
- যাচাই। 72 × 1000 = 72 000, আর 72 MHz ÷ 72 000 = 1000 Hz ঠিক, ভুল 0 ppm. Python block-এর “round” লাইন একই জোড়া দিয়েছে।
- সূক্ষ্ম বিকল্প। PSC = 1, ARR = 35 999-ও 1 kHz দেয়, কিন্তু প্রতি গণনা 27.78 ns. একই period-এ compare-এর ৩৬ হাজার ধাপ, PWM-এর জন্য ভালো। কোর্সের board-এ তুলনীয় কাজ SysTick-এর LOAD = 7999, যা 8 MHz-এ 1 ms দেয়।
৪ · বাজারঘর board-এর SysTick — আসল tick-এর সময়
Cortex-M-এর SysTick একটি ২৪ বিটের down-counter, ARM নিজেই architecture-এর অংশ হিসেবে Cortex-M3/M4-এ রেখেছে, যাতে প্রতিটি RTOS একই ঠিকানায় একটি নিয়মিত tick পায়। এর register মাত্র চারটি (CTRL, LOAD, VAL, CALIB, 0xE000E010 থেকে), আর LOAD-এর হিসাব, ২৪ বিটের সীমা আর ভুল clock ধরলে কী হয়, তা পর্ব ৩৩-এ। এখানে প্রশ্ন অন্য: tick-গুলো ঠিক কখন আসে, আর একটি tick-এর ভেতরের সূক্ষ্ম সময় কীভাবে পড়া যায়।
Board-এর নিয়ম (Spec decision 22): SysTick সবসময় 8 MHz core clock গোনে; period = LOAD + 1 cycle; counter 0-তে পৌঁছালে interrupt; VAL-এ লিখলে counter আর COUNTFLAG মুছে যায়। আমার lab-এর tick_times.c তিনটি LOAD পরপর চালায়, আর প্রতিটি tick-এর ISR-এ board-এর বিশেষ MARK register-এ লেখে (শুধু emulator-এ আছে, Spec decision 29), যাতে board প্রতিটি tick-এর সময় ছাপে:
void SysTick_Handler(void)
{
ticks++;
SIMCTRL->MARK = ticks; /* time-stamped line from the board */
}
static void run(uint32_t load)
{
SysTick->CTRL = 0; /* stop */
SysTick->LOAD = load;
SysTick->VAL = 0; /* clear counter and COUNTFLAG */
ticks = 0;
uart_puts("LOAD=");
uart_put_u32(load);
uart_puts("\r\n");
SysTick->CTRL = SysTick_CTRL_CLKSOURCE | SysTick_CTRL_TICKINT | SysTick_CTRL_ENABLE;
while (ticks < 3u)
__WFI();
SysTick->CTRL = 0;
}সত্যিকারের run · Clang 22.1.8 (ziglang 0.17.1), Unicorn 2.1.4, বাজারঘর board BG-M3
$ python -B bd.py build fw/tick_times.c -o build/tick_times.elf
$ python -B bd.py run build/tick_times.elf
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0243 ms] UART: LOAD=7999
[ 1.0260 ms] MARK 1
[ 2.0260 ms] MARK 2
[ 3.0260 ms] MARK 3
[ 3.0454 ms] UART: LOAD=799
[ 3.1471 ms] MARK 1
[ 3.2471 ms] MARK 2
[ 3.3471 ms] MARK 3
[ 3.3715 ms] UART: LOAD=79999
[ 13.3733 ms] MARK 1
[ 23.3732 ms] MARK 2
[ 33.3732 ms] MARK 3
[ 33.3746 ms] exit(0) after 266997 cycles
(bd.py হলো reference lab-এর board.py-এর একটি ছোট wrapper, যা শুধু Zig-এর cache আমার lab-এর ভেতরে রাখে; board-এর কোড অপরিবর্তিত।) প্রথম দলে MARK 1.0260, 2.0260, 3.0260 ms: ঠিক 1.0000 ms পরপর, অর্থাৎ 8000 cycle = 7999 + 1. দ্বিতীয় দলে 0.1000 ms = 800 cycle, তৃতীয় দলে 10.0000 ms = 80 000 cycle, যা cold-storage monitor-এর 10 ms tick (CALIB-এর TENMS-ও 79 999). তৃতীয় দলের প্রথম MARK-এ শেষ অঙ্ক 3, পরের দুটিতে 2: ISR-এর store-টি প্রথমবার এক cycle (0.125 µs) পরে পৌঁছেছে, কারণ interrupt আসার মুহূর্তে CPU কোথায় ছিল তার ওপর handler-এর প্রথম নির্দেশের সময় নির্ভর করে (Spec decision 20 আর 30). Tick-এর period নিজে এক cycle-ও নড়েনি। আসল Cortex-M3-এ exception-এ ঢুকতেই প্রায় ১২ cycle লাগে আর অন্য interrupt চললে আরও দেরি; board-এ ঢোকা 0 cycle (Spec decision 17). তাই board-এ যা দেখছেন তা যুক্তি, আসল chip-এর timing নয়।
Tick-এর ভেতরের সময় — দুই ধাপের পড়া আর race
1 ms-এর tick দিয়ে 1 ms-এর চেয়ে সূক্ষ্ম কিছু মাপা যায় না। কিন্তু VAL পড়লে বোঝা যায় বর্তমান tick-এর কতটা পেরিয়েছে: elapsed = LOAD − VAL cycle. তাই একটি সূক্ষ্ম timestamp = ms_ticks × 1000 + (7999 − VAL) ÷ 8 µs. সমস্যা: এটি দুটি আলাদা পড়া। যদি প্রথমে ms_ticks পড়ার পরে আর VAL পড়ার আগে tick-এর interrupt ঢুকে পড়ে, তাহলে ms পুরোনো কিন্তু VAL নতুন tick-এর শুরুর (প্রায় 7999), আর ফল প্রায় 1 ms পেছনে। এটি একটি race condition; ISR আর shared data-র সাধারণ নিয়ম পর্ব ৪৩-এর বিষয়, এখানে শুধু timer-এর দিকটি:
static uint32_t now_us_naive(void)
{
uint32_t ms = ms_ticks;
uint32_t val = SysTick->VAL;
return ms * 1000u + (RELOAD - val) / 8u; /* 8 cycles = 1 us */
}
static uint32_t now_us_safe(void)
{
uint32_t ms, val;
do {
ms = ms_ticks;
val = SysTick->VAL;
} while (ms != ms_ticks); /* tick came in between: retry */
return ms * 1000u + (RELOAD - val) / 8u;
}সত্যিকারের run · Clang 22.1.8 (ziglang 0.17.1), Unicorn 2.1.4, বাজারঘর board BG-M3
$ python -B bd.py run build/micros.elf
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 200.0722 ms] UART: naive: calls=63950 backwards=17 worst=997 us
[ 400.0648 ms] UART: safe : calls=57080 backwards=0 worst=0 us
[ 400.0655 ms] exit(0) after 3200524 cycles
দুটি function প্রতিটি 200 ms ধরে বারবার ডাকা হয়েছে, আর প্রতিটি নতুন মান আগেরটির চেয়ে ছোট হলে “backwards” গোনা হয়েছে। Naive ধরনে ২০০টি tick-এর মধ্যে ১৭ বার সময় পেছনে গেছে, সবচেয়ে বেশি 997 µs. নিরাপদ ধরনে ms_ticks আবার পড়ে মেলানো হয়: মাঝে tick এলে দুই মান আলাদা, তাই আবার চেষ্টা; ফল শূন্য। সংখ্যা ১৭ নিজে ভাগ্যের ব্যাপার: কতবার interrupt ঠিক দুই পড়ার ফাঁকে পড়ে তা নির্দেশের বিন্যাসের ওপর নির্ভর করে; এই firmware-এর একটি আগের সংস্করণে, যেখানে loop-এর শর্ত আলাদা ছিল, একই পরীক্ষায় ১৩১ বার এসেছিল। এই অস্থিরতাই race-এর চেহারা: কোড বদলালে bug লুকায় বা বেরোয়। আসল chip-এ আরেকটি ফাঁদ আছে: interrupt বন্ধ রেখে পড়লে tick-এর ISR চলে না, অথচ VAL ঘুরে যায়; তখন CTRL-এর COUNTFLAG বা SCB-র ICSR-এর PENDSTSET বিট দেখে এক ms যোগ করতে হয়।
৫ · Output compare আর one-pulse — নির্দিষ্ট মুহূর্তে কাজ
Output compare-এ channel-এর CCR1-এ একটি মান লেখা থাকে। Counter যখনই সেই মান ছোঁয়, hardware CC1IF বসায় আর CCMR1-এর OC1M অনুযায়ী আউটপুট সংকেত OC1REF বদলায় (RM0008 §15.3.8): 000 = কিছু না, 001 = match-এ active, 010 = match-এ inactive, 011 = toggle, 100/101 = জোর করে inactive/active, 110/111 = PWM mode 1 আর 2. Toggle mode-এ প্রতি চক্রে একবার উল্টায়, তাই pin-এ একটি square wave আসে, যার frequency update-এর অর্ধেক; 8254-এর mode 3-এর কাজ, কিন্তু CPU ছাড়া, আর CCR1 দিয়ে phase-ও বাছা যায়। Jitter শূন্যের কাছে, কারণ pin বদলায় hardware, কোনো ISR নয়।
One-pulse mode-এ (CR1-এর OPM বিট) counter পরের update event-এ নিজেই থেমে যায়। PWM mode 2-এর সঙ্গে মিলিয়ে একবার একটি নির্দিষ্ট দেরির পরে একটি নির্দিষ্ট দৈর্ঘ্যের pulse পাওয়া যায়; RM0008 (§15.3.10) বলে, দেরি tDELAY ঠিক করে CCR1, আর pulse-এর দৈর্ঘ্য tPULSE = ARR − CCR1 + 1 (গণনায়)। এটি 8254-এর mode 1-এর উত্তরসূরি, যেমন একটি solenoid-কে ঠিক 20 ms-এর জন্য চালানো। নিচের block-টি একটি ছোট মডেল: প্রতিটি CK_PSC tick-এ prescaler আর counter এগোয়, shadow register update-এ ভরা হয়, CCR1-এ toggle বা PWM mode 2. এটি RM0008-এর বর্ণনা থেকে লেখা মডেল, আসল silicon নয়; capture/compare-এর preload, dead-time বা trigger input মডেল করা নেই।
# STM32F1 TIMx-এর সরল মডেল (RM0008 §15.3): upcounting, PSC আর ARR-এর shadow,
# UEV/UIF, CCR1-এ output compare (toggle বা PWM mode 2) আর one-pulse (OPM)
class Tim:
def __init__(s, psc, arr, ccr1, oc="toggle", opm=False):
s.PSC, s.ARR, s.CCR1, s.oc, s.opm = psc, arr, ccr1, oc, opm
s.psc_sh, s.arr_sh = psc, arr # shadow: UG লিখে শুরুতেই ভরা
s.pc = s.CNT = s.UIF = 0; s.CEN = 1; s.ref = 0
def clock(s): # CK_PSC-এর একটি tick
if not s.CEN: return
s.pc += 1
if s.pc <= s.psc_sh: return # prescaler: PSC+1 tick-এ এক গণনা
s.pc = 0
if s.CNT == s.arr_sh: # overflow -> update event
s.CNT, s.UIF = 0, 1
s.psc_sh, s.arr_sh = s.PSC, s.ARR # নতুন PSC (আর ARPE=1-এ ARR) এখন
if s.opm: s.CEN = 0 # one-pulse: UEV-তে থামে
else:
s.CNT += 1
if s.oc == "toggle" and s.CNT == s.CCR1: s.ref ^= 1
if s.oc == "pwm2": s.ref = int(s.CNT >= s.CCR1 and s.CEN == 1)
t = Tim(psc=1, arr=4, ccr1=2) # CK_CNT = f/2, UEV প্রতি 10 tick-এ
row = []
for k in range(1, 25):
t.clock()
if k == 12: t.PSC = 0 # চলার মাঝে PSC বদল
row.append(f"{t.CNT}{'*' if t.UIF else ''}{'^' if t.ref else ''}"); t.UIF = 0
print("CNT:", " ".join(row))
p = Tim(psc=0, arr=7, ccr1=3, oc="pwm2", opm=True); out = ""
for k in range(12):
out += "1" if p.ref else "0"; p.clock()
print("one-pulse OC1REF:", out, "| delay =", out.index("1"), "pulse =", out.count("1"))আসল আউটপুট (ব্রাউজারের Python):
CNT: 0 1 1 2^ 2^ 3^ 3^ 4^ 4^ 0*^ 0^ 1^ 1^ 2 2 3 3 4 4 0* 1 2^ 3^ 4^
one-pulse OC1REF: 000111110000 | delay = 3 pulse = 5
প্রথম লাইনে প্রতিটি CK_PSC tick-এর পরে CNT; * = update event (UIF), ^ = OC1REF উঁচু। PSC = 1, তাই CNT প্রতি দুই tick-এ এক বাড়ে, আর প্রথম UEV দশম tick-এ: (1 + 1) × (4 + 1) = 10. CNT = 2 হলে toggle: চতুর্থ tick-এ উঁচু, চৌদ্দতম tick-এ নিচু। দ্বাদশ tick-এ firmware PSC = 0 লিখেছে, কিন্তু counter তখনো দুই tick-এ এক গোনে; বিশতম tick-এর UEV-তে shadow ভরার পরে তবেই প্রতি tick-এ এক গণনা (0* 1 2^ 3^ 4^). এটিই “পরের update event-এ” নিয়ম। দ্বিতীয় লাইন one-pulse: CCR1 = 3, ARR = 7, PWM mode 2. Pulse শুরু তিন tick পরে (tDELAY = CCR1 = 3) আর পাঁচ tick চওড়া (7 − 3 + 1 = 5), তারপর counter থেমে যায়, আর OC1REF 0-তেই থাকে।
৬ · Input capture — একটি সংকেতের period মাপা
Input capture হলো উল্টো দিক: pin-এ একটি edge এলেই hardware সেই মুহূর্তের CNT-কে CCR1-এ কপি করে রাখে আর CC1IF বসায় (RM0008 §15.3.5). ক্রিকেটের DRS-এর ক্যামেরার কথা ভাবুন: বল কখন প্যাডে লাগল, তা ক্যামেরার নিজস্ব frame-সংখ্যায় লেখা থাকে; আম্পায়ার পরে ধীরে দেখলেও মুহূর্তটি বদলায় না। তেমনি ISR দেরিতে চললেও CCR1-এর মান edge-এর মুহূর্তের। RM0008-এর ধাপ: CCMR1-এ CC1S = 01 (TI1 থেকে input), দরকার হলে IC1F-এ digital filter আর IC1PSC-এ প্রতি কয়েকটি edge-এ একবার capture, CCER-এ CC1P দিয়ে কোন edge (0 = rising), CC1E = 1 দিয়ে capture চালু, আর DIER-এ CC1IE. CCR1 পড়লেই CC1IF মুছে যায়। আগের মান না পড়েই আরেকটি capture এলে CC1OF (overcapture) বসে: একটি মাপ হারিয়েছে।
দুটি পরপর rising edge-এর CCR1-এর পার্থক্য = period, গণনায়। ১৬ বিটের counter 65 536-এ ঘোরে, কিন্তু unsigned বিয়োগ ১৬ বিটে রাখলে একবার ঘোরা নিজে থেকেই ঠিক হয়ে যায় (অংশ ৭)। একাধিকবার ঘুরলে update event গুনতে হয়। নিচের মডেলে TIM2 72 MHz, PSC = 71 (1 µs-এর গণনা), ARR = 0xFFFF; সংকেত প্রথমে 50 Hz, তারপর 80 Hz, শেষে 1 Hz:
# Input capture-এর মডেল (RM0008 §15.3.5): TIM2 72 MHz, PSC=71 -> CNT প্রতি 1 µs,
# ARR=0xFFFF (free-running ১৬ বিট)। প্রতিটি rising edge-এ CNT -> CCR1, CC1IF=1
edges = [63000 + 20000 * k for k in range(3)] # 50 Hz
edges += [edges[-1] + 12500 * k for k in range(1, 3)] # 80 Hz
edges += [edges[-1] + 1_000_000 * k for k in range(1, 3)] # 1 Hz (ধীর)
prev_ccr = prev_ovf = None
for t in edges: # t = µs, timer চালুর পর থেকে
ovf, ccr = divmod(t, 65536) # ovf = এ পর্যন্ত কতবার UEV (overflow)
if prev_ccr is None:
print(f"t={t:8d} us CCR1={ccr:5d} (first edge)")
else:
p16 = (ccr - prev_ccr) & 0xFFFF # শুধু ১৬ বিটের পার্থক্য
pfull = (ovf - prev_ovf) * 65536 + ccr - prev_ccr # UEV গুনে পূর্ণ সময়
print(f"t={t:8d} us CCR1={ccr:5d} 16-bit diff={p16:5d} us"
f" with overflows={pfull:7d} us -> {1e6 / pfull:6.2f} Hz")
prev_ccr, prev_ovf = ccr, ovf
# overcapture: ISR দেরিতে এলে দুটি capture-এর মাঝে CCR1 একবারও পড়া হয়নি
cc1if = cc1of = 0
for ccr in (1000, 21000): # দুটি edge, firmware পড়েনি
if cc1if: cc1of = 1 # আগের মান না পড়েই নতুন capture
cc1if, last = 1, ccr
print(f"late read: CCR1={last}, CC1IF={cc1if}, CC1OF={cc1of} (first edge lost)")আসল আউটপুট (ব্রাউজারের Python):
t= 63000 us CCR1=63000 (first edge)
t= 83000 us CCR1=17464 16-bit diff=20000 us with overflows= 20000 us -> 50.00 Hz
t= 103000 us CCR1=37464 16-bit diff=20000 us with overflows= 20000 us -> 50.00 Hz
t= 115500 us CCR1=49964 16-bit diff=12500 us with overflows= 12500 us -> 80.00 Hz
t= 128000 us CCR1=62464 16-bit diff=12500 us with overflows= 12500 us -> 80.00 Hz
t= 1128000 us CCR1=13888 16-bit diff=16960 us with overflows=1000000 us -> 1.00 Hz
t= 2128000 us CCR1=30848 16-bit diff=16960 us with overflows=1000000 us -> 1.00 Hz
late read: CCR1=21000, CC1IF=1, CC1OF=1 (first edge lost)
দ্বিতীয় edge-এ CCR1 = 17 464, প্রথমটির (63 000) চেয়ে ছোট, কারণ মাঝে counter একবার ঘুরেছে; তবু ১৬ বিটের পার্থক্য ঠিক 20 000 µs = 50 Hz. 80 Hz-এ 12 500 µs. কিন্তু 1 Hz-এর edge-এর মাঝে counter ১৫ বারের বেশি ঘুরেছে: ১৬ বিটের পার্থক্য 16 960 µs, যা 58.96 Hz বলে ভুল বোঝাত। Update event গুনে (overflow × 65 536 যোগ করে) পূর্ণ 1 000 000 µs. শেষ লাইনে overcapture: দুটি edge-এর মাঝে firmware CCR1 পড়েনি, তাই CCR1-এ শুধু পরেরটি, আর CC1OF = 1. মডেলটি edge-এর মুহূর্তকে নিখুঁত ধরে; আসল chip-এ input-এর synchroniser আর filter কয়েকটি clock-এর স্থির দেরি যোগ করে, যা period-এর পার্থক্যে বাদ পড়ে যায়।
| সময় t | |
| ঘটনা | |
| CCR1 | |
| UEV গণনা | |
| period |
- প্রথম edge. t = 63 000 µs-এ rising edge; hardware CNT = 63 000-কে CCR1-এ কপি করে, CC1IF = 1. ISR CCR1 পড়ে মানটি রেখে দেয়; পড়াতেই CC1IF মুছে যায়।
- Overflow. t = 65 536 µs-এ CNT 65 535 থেকে 0-তে ফেরে, একটি update event. CCR1 বদলায় না; firmware চাইলে UIF দেখে একটি overflow-গণনা বাড়ায়।
- দ্বিতীয় edge. CNT = 83 000 − 65 536 = 17 464. বিয়োগ 17 464 − 63 000 ঋণাত্মক, কিন্তু ১৬ বিটে (mod 65 536) = 20 000 µs. Frequency = 1 000 000 ÷ 20 000 = 50 Hz.
- তৃতীয় edge. CCR1 = 37 464; পার্থক্য সরাসরি 20 000. একবার ঘোরা থাকুক বা না থাকুক, ১৬ বিটের unsigned বিয়োগ একই উত্তর দেয়।
- সংকেত বদলাল। এখন 80 Hz; শেষ edge-এ CCR1 = 62 464, period 12 500 µs. Firmware কিছু না বদলেই নতুন frequency পেল।
- ধীর সংকেত। 1 Hz: দুই edge-এর মাঝে 1 000 000 µs, যা 65 536-এর ১৫ গুণের বেশি। শুধু ১৬ বিটের পার্থক্য দেয় 16 960 (ভুল)। UEV গণনা 1 থেকে 17: (17 − 1) × 65 536 + 13 888 − 62 464 = 1 000 000 µs ✓. বিকল্প: বড় PSC বা ৩২ বিটের timer.
- Overcapture. ISR দেরিতে এল, মাঝে দুটি edge: CCR1-এ শুধু শেষেরটি (21 000), আর CC1OF = 1. প্রথম edge-এর মাপ হারিয়ে গেছে; firmware-কে flag দেখে মাপটি বাতিল করতে হয়।
Board-এ software capture — EXTI আর SysTick দিয়ে
কোর্সের board-এ capture-এর hardware নেই, কিন্তু ধারণাটি software-এ চালানো যায়: PA0-র প্রতিটি rising edge-এ EXTI0-এর ISR প্রথম কাজ হিসেবে SysTick থেকে cycle-এর হিসাবে একটি timestamp নেয় (অংশ ৪-এর নিরাপদ পড়া, এবার µs নয়, cycle-এ)। Script PA0-তে একটি square wave দেয়: চারটি edge 50 Hz-এ, তিনটি 80 Hz-এ, তিনটি প্রায় 333 Hz-এ, যার period 3.003 ms. SysTick-এর priority (1) EXTI-এর (2) চেয়ে বেশি রাখা হয়েছে, যাতে edge-এর ISR চলার সময়েও tick গোনা থামে না।
static uint32_t now_cycles(void)
{
uint32_t ms, val;
do {
ms = ms_ticks;
val = SysTick->VAL;
} while (ms != ms_ticks);
return ms * 8000u + (RELOAD - val);
}
void EXTI0_IRQHandler(void)
{
uint32_t t = now_cycles(); /* "capture" first */
EXTI->PR = 1u; /* write 1 to clear */
if (n_edges < N_EDGES)
stamp[n_edges++] = t;
}সত্যিকারের run · Clang 22.1.8 (ziglang 0.17.1), Unicorn 2.1.4, বাজারঘর board BG-M3
$ python -B bd.py run build/capture.elf --script fw/capture.json
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0000 ms] > PA0: square wave 50 Hz -> 80 Hz -> 333 Hz
[ 133.5699 ms] UART: edge 2 period=160000 cycles f=50.00 Hz
[ 133.6289 ms] UART: edge 3 period=160000 cycles f=50.00 Hz
[ 133.6879 ms] UART: edge 4 period=160000 cycles f=50.00 Hz
[ 133.7469 ms] UART: edge 5 period=160000 cycles f=50.00 Hz
[ 133.8059 ms] UART: edge 6 period=100000 cycles f=80.00 Hz
[ 133.8649 ms] UART: edge 7 period=100000 cycles f=80.00 Hz
[ 133.9239 ms] UART: edge 8 period=100000 cycles f=80.00 Hz
[ 133.9830 ms] UART: edge 9 period=24024 cycles f=333.00 Hz
[ 134.0450 ms] UART: edge 10 period=24024 cycles f=333.00 Hz
[ 134.0462 ms] exit(0) after 1072370 cycles
প্রতিটি period ঠিক: 160 000 cycle = 20 ms = 50.00 Hz, 100 000 cycle = 12.5 ms = 80.00 Hz, 24 024 cycle = 3.003 ms = 333.00 Hz. সব একই, কারণ board-এ edge থেকে ISR-এর প্রথম পড়া পর্যন্ত দেরি প্রতিবার সমান (exception-এ ঢোকা 0 cycle আর আর কোনো interrupt চলছিল না)। আসল chip-এ এখানেই hardware capture জেতে: software-এর timestamp-এ ঢোকার দেরি, চলমান অন্য ISR, flash-এর wait state, সব মিলে প্রতিটি edge-এ কয়েক cycle থেকে অনেক µs-এর jitter; hardware capture-এ edge-এর মুহূর্ত counter নিজেই ধরে, ISR যখনই আসুক। Board-এর run তাই যুক্তি দেখায় (wrap-নিরাপদ বিয়োগ, Hz × 100-এর পূর্ণসংখ্যার হিসাব), latency-র বাস্তব নয়।
৭ · Overflow-নিরাপদ সময়ের হিসাব — unsigned wrap
প্রতিটি counter একদিন ঘুরে যায়। ১৬ বিটের 1 µs-এর counter 65.536 ms-এ, ৩২ বিটের ms counter প্রায় 49.71 দিনে, ৩২ বিটের µs counter প্রায় 71.58 মিনিটে। Cold-storage monitor মাসের পর মাস বন্ধ হয় না, তাই এই মুহূর্তটি তার জীবনে নিশ্চিত আসবে। প্রশ্ন শুধু, তখন সময়ের তুলনাগুলো ঠিক থাকবে কি না।
উপমা — দেয়ালঘড়ি: রাত 11 টায় কেউ বলল “দুই ঘণ্টা পরে ডাকবেন”। এখন ঘড়িতে 1 টা। “1 ≥ 11 + 2?” জিজ্ঞেস করলে উত্তর না, অথচ সময় পেরিয়ে গেছে। ঠিক প্রশ্ন “11 থেকে কত ঘণ্টা গেল?”, অর্থাৎ (1 − 11) mod 12 = 2. ঘড়ির কাঁটা ঘুরে আসে, কিন্তু দুটি সময়ের ব্যবধান ঠিক থাকে, যতক্ষণ ব্যবধান এক পাক-এর চেয়ে কম।
C-র unsigned গণিত ঠিক এই ঘড়ি: uint32_t-এর প্রতিটি যোগ-বিয়োগ 232-এর modular arithmetic, আর এটি standard-এ নিশ্চিত, undefined behaviour নয় (signed overflow-এর মতো নয়; পর্ব ৩৪)। তাই নিয়ম একটি: সময় নয়, ব্যবধান তুলনা করুন। (uint32_t)(now - start) >= period সঠিক, যতক্ষণ আসল ব্যবধান 232-এর কম; now >= start + period wrap-এর কাছে ভুল। একটি নির্দিষ্ট “deadline” রাখতে চাইলে (int32_t)(now - deadline) >= 0, যা ব্যবধান 231-এর কম হলে ঠিক (Linux kernel-এর time_after() macro এই কৌশলেই লেখা)। ১৬ বিটের ক্ষেত্রে একটি বাড়তি ফাঁদ: uint16_t দুটি বিয়োগ করলে C আগে দুটিকেই int বানায় (integer promotion), তাই ফল ঋণাত্মক হতে পারে; আবার uint16_t-এ cast করতে হয়। নিচের C কোড আসল compiler-এ চলে (Wandbox):
#include <stdio.h>
#include <stdint.h>
int main(void)
{
/* 32-bit ms counter: start just before the wrap, now just after */
uint32_t start = 0xFFFFFF00u, now = 0x00000064u;
printf("32-bit: now - start = %lu ms\n", (unsigned long)(now - start));
printf("naive now >= start+200: %d\n", now >= start + 200u);
printf("safe (now - start) >= 200: %d\n", (now - start) >= 200u);
/* 16-bit timer counter (CNT), two input captures around overflow */
uint16_t c1 = 65000u, c2 = 1500u;
int wrong = c2 - c1; /* both promoted to int! */
uint16_t right = (uint16_t)(c2 - c1); /* back to 16 bits: mod 65536 */
printf("16-bit: c2 - c1 as int = %d\n", wrong);
printf("16-bit: (uint16_t)(c2 - c1) = %u ticks\n", (unsigned)right);
/* deadline test with a signed difference (valid for gaps < 2^31) */
uint32_t deadline = 0xFFFFFFF0u, t = 0x00000010u;
printf("deadline passed? %s\n", (int32_t)(t - deadline) >= 0 ? "yes" : "no");
return 0;
}আসল আউটপুট (আমার lab-এ Clang 22.1.8 দিয়ে host-এ compile করে; Wandbox-এও একই ছাপে):
32-bit: now - start = 356 ms
naive now >= start+200: 0
safe (now - start) >= 200: 1
16-bit: c2 - c1 as int = -63500
16-bit: (uint16_t)(c2 - c1) = 2036 ticks
deadline passed? yes
start = 0xFFFFFF00, now = 0x64: ব্যবধান 0x100 + 0x64 = 356 ms, unsigned বিয়োগ ঠিক তাই দিয়েছে। কিন্তু start + 200 ঘুরে 0xC8 = 200 হয়েছে, আর 100 ≥ 200 মিথ্যা: naive তুলনা বলছে “সময় হয়নি”, অথচ 356 ms পেরিয়েছে। ১৬ বিটে c2 - c1-কে int-এ রাখলে −63 500; uint16_t-এ ফেরালে 2036, যা capture-এর আসল period. Deadline 0xFFFFFFF0 আর t = 0x10: পার্থক্য 0x20 = 32, signed হিসেবে ধনাত্মক, তাই “yes”.
এবার board-এ, আসল SysTick আর আসল wrap দিয়ে। wrap.c-এ ms counter শুরু হয় 0xFFFFF830-এ, অর্থাৎ ঘোরার ঠিক 2000 ms আগে। একটি 500 ms-এর পর্যায়ক্রমিক কাজ তিনভাবে লেখা: A = naive now >= next, B = ব্যবধান (uint32_t)(now - last) >= 500, C = deadline (int32_t)(now - next) >= 0. B চললে একটি লাইন ছাপা হয়, সঙ্গে আগের লাইনের পর থেকে A আর C কতবার চলেছে:
uint32_t nextA = start + 500u, lastB = start, nextC = start + 500u;
uint32_t a = 0, c = 0;
while ((uint32_t)(ms_ticks - start) < 4000u) {
uint32_t now = ms_ticks;
if (now >= nextA) { a++; nextA += 500u; }
if ((int32_t)(now - nextC) >= 0) { c++; nextC += 500u; }
if ((uint32_t)(now - lastB) >= 500u) {
lastB += 500u;
uart_puts("t="); uart_put_u32(now - start);
uart_puts(" now="); hex(now);
uart_puts(" B fired; since last line A="); uart_put_u32(a);
uart_puts(" C="); uart_put_u32(c);
uart_puts("\r\n");
a = 0; c = 0;
}
__WFI();
}
uart_puts("A next="); hex(nextA);সত্যিকারের run · Clang 22.1.8 (ziglang 0.17.1), Unicorn 2.1.4, বাজারঘর board BG-M3
$ python -B bd.py run build/wrap.elf
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 500.0766 ms] UART: t=500 now=0xFFFFFA24 B fired; since last line A=1 C=1
[ 1000.0793 ms] UART: t=1000 now=0xFFFFFC18 B fired; since last line A=1 C=1
[ 1500.0793 ms] UART: t=1500 now=0xFFFFFE0C B fired; since last line A=1 C=1
[ 2000.0832 ms] UART: t=2000 now=0x00000000 B fired; since last line A=499 C=1
[ 2500.0790 ms] UART: t=2500 now=0x000001F4 B fired; since last line A=0 C=1
[ 3000.0790 ms] UART: t=3000 now=0x000003E8 B fired; since last line A=0 C=1
[ 3500.0790 ms] UART: t=3500 now=0x000005DC B fired; since last line A=0 C=1
[ 4000.0282 ms] UART: A next=0x0003CE9C
[ 4000.0291 ms] exit(0) after 32000233 cycles
| t (শুরু থেকে) | |
| now | |
| A: now ≥ next | |
| B: now − last ≥ 500 | |
| C: (int32)(now − next) ≥ 0 |
- শুরু। now = 0xFFFFF830, ঘোরার 2000 ms আগে। A আর C-এর next = now + 500 = 0xFFFFFA24; B-এর last = now. 500, 1000 আর 1500 ms-এ তিনটিই একবার করে চলেছে (log-এ A=1 C=1).
- 1500 ms. A চলে, আর next += 500 = 0xFFFFF830 + 2000 = 0x1_0000_0000, যা ৩২ বিটে 0x00000000. Counter এখনো ঘোরেনি, কিন্তু next ঘুরে গেছে।
- 1501 ms. A: 0xFFFFFE0D ≥ 0? সত্য, তাই A আবার চলে, মাত্র 1 ms পরে! B: ব্যবধান 1 < 500, চলে না। C: 0xFFFFFE0D − 0 signed হিসেবে −499, চলে না।
- 1999 ms. A প্রতিটি ms-এ চলেছে, 1501 থেকে 1999: ৪৯৯ বার। প্রতিবার next 500 বেড়েছে: 499 × 500 = 249 500 = 0x3CE9C. B আর C ঠিকঠাক অপেক্ষায় (ব্যবধান 499, পার্থক্য −1).
- 2000 ms: wrap. now = 0x00000000. B: 0 − 0xFFFFFE0C = 0x1F4 = 500, চলে। C: 0 − 0 = 0 ≥ 0, চলে। A: 0 ≥ 0x3CE9C? না। Log-এর লাইন:
A=499 C=1. - তারপর। B আর C প্রতি 500 ms-এ নিয়মিত। A চুপ: now 0x3CE9C ছুঁতে আরও প্রায় 249.5 s লাগবে। আসল device-এ এর মানে প্রথমে ৪৯৯ বার পাগলের মতো কাজ, তারপর চার মিনিটের বেশি নীরবতা, তাও প্রায় ৫০ দিন পরপর একবার, যা পরীক্ষাগারে প্রায় কখনো ধরা পড়ে না।
৮ · Timer দিয়ে কাজের সূচি — বাজারঘরের device-এর ছন্দ
একটি device-এ সাধারণত অনেকগুলো পর্যায়ক্রমিক কাজ, প্রত্যেকটির নিজের ছন্দ। Cold-storage monitor-এ তাপমাত্রা পড়া প্রতি 1 s, telemetry প্রতি 10 s, alarm-এর LED-এর মিটমিট হয়তো প্রতি 250 ms. প্রতিটির জন্য আলাদা hardware timer রাখা অপচয়। প্রচলিত নকশা তাই একটি সময়ের ভিত্তি (time base): একটি timer, সাধারণত SysTick, প্রতি 1 ms বা 10 ms-এ একটি tick দেয়; ISR শুধু একটি volatile counter বাড়ায়; আর main loop প্রতিটি কাজের জন্য অংশ ৭-এর B ধরনের তুলনা করে। Reference lab-এর coldroom.c ঠিক এভাবে 10 ms-এর tick থেকে ১০০টি গুনে প্রতি সেকেন্ডে পড়ে, আর ১০টি পড়ায় একবার telemetry পাঠায়।
static volatile uint32_t ms_ticks; /* SysTick ISR: ms_ticks++ */
static uint32_t last_read, last_tx, last_blink;
for (;;) {
uint32_t now = ms_ticks; /* একবার পড়া, ৩২ বিট: atomic */
if ((uint32_t)(now - last_read) >= 1000u) { last_read += 1000u; read_temp(); }
if ((uint32_t)(now - last_tx) >= 10000u) { last_tx += 10000u; send_telemetry(); }
if ((uint32_t)(now - last_blink) >= 250u) { last_blink += 250u; blink_if_alarm(); }
__WFI(); /* পরের tick পর্যন্ত ঘুম */
}এটি উদাহরণ, এই রূপে চালানো হয়নি, তবে এর প্রতিটি অংশ ওপরের আসল run-গুলোতে পরীক্ষিত: B ধরনের তুলনা wrap পেরিয়েছে, আর __WFI() দিয়ে tick-এর মাঝে CPU ঘুমায়। তিনটি সূক্ষ্ম সিদ্ধান্ত লক্ষ করুন। এক, last += period, last = now নয়: কোনো কাজ একবার 3 ms দেরিতে চললে পরের বার সেই দেরি জমে না, ছন্দ ঘড়ির সঙ্গে বাঁধা থাকে (drift নেই)। দুই, now একবার পড়ে সব তুলনায় একই মান; ৩২ বিটের পড়া Cortex-M3-এ একটি নির্দেশ, তাই এখানে অংশ ৪-এর race নেই (৮ বিটের AVR-এ ৩২ বিটের counter পড়া চারটি নির্দেশ, সেখানে interrupt বন্ধ রেখে পড়তে হয়)। তিন, কাজগুলো ছোট আর blocking নয়; একটি কাজ যদি 1 s আটকে থাকে, বাকিরা দেরি পাবে। এই নকশা super loop-এর একটি রূপ, যার পুরো আলোচনা, state machine-সহ, পর্ব ৫৫ (Super loop আর state machine)-এ, আর কাজগুলোকে আলাদা task বানানো RTOS পর্ব ৫৬-এ।
কখন hardware timer-এর নিজের interrupt বা output লাগে? যখন সময়ের নির্ভুলতা ms-এর চেয়ে সূক্ষ্ম, বা jitter সহ্য হয় না: একটি ADC-কে নিয়মিত 1 kHz-এ নমুনা নিতে timer-এর update event সরাসরি ADC চালু করতে পারে (STM32-এ timer-এর trigger output, পর্ব ৪৭), একটি motor-এর PWM (পর্ব ৪৫), বা একটি শব্দ-সংকেতের নির্দিষ্ট মুহূর্ত মাপা, যা input capture-এর কাজ। নিয়ম: সময় যত কঠোর, CPU-কে তত দূরে রাখুন; hardware যেটা পারে, hardware-কে করতে দিন।
| কাজ | ভালো পছন্দ | কেন |
|---|---|---|
| ms-স্তরের পর্যায়ক্রমিক কাজ (1 s পড়া, 10 s telemetry) | SysTick + main loop-এ ব্যবধানের তুলনা | একটি timer, অনেক কাজ; কয়েক ms দেরি সমস্যা নয় |
| নিয়মিত ADC-র নমুনা, শব্দ | Timer-এর update event থেকে hardware trigger | CPU-র দেরি নমুনার সময়ে ঢোকে না |
| Frequency বা pulse-এর দৈর্ঘ্য মাপা | Input capture | Edge-এর মুহূর্ত hardware ধরে; ISR দেরিতে এলেও ঠিক |
| একটি নির্দিষ্ট দৈর্ঘ্যের একক pulse | One-pulse mode | দৈর্ঘ্য counter-এ বাঁধা, software ভুলে লম্বা হয় না |
| দীর্ঘ ঘুমের পরে জাগা, তারিখ-সময় | RTC বা low-power timer | Core-এর clock বন্ধ থাকলেও চলে (পর্ব ৬০) |
আরও গভীরে: Input-এর edge সরাসরি counter-এর clock-এ ধরা যায় না, কারণ বাইরের সংকেত timer-এর clock-এর সঙ্গে মেলানো নয়; তাই প্রতিটি capture input-এর পথে একটি synchroniser (কয়েকটি flip-flop) থাকে, যা metastability-র ঝুঁকি কমায় আর একটি স্থির দেরি যোগ করে। RM0008-এর IC1F filter তার পরে N টি পরপর নমুনা একমত হলে তবেই edge মানে, যা শব্দে ভরা তারে ভুয়া capture আটকায়, অনেকটা পর্ব ৪২-এর debouncing-এর hardware রূপ। Timer-গুলোকে একে অপরের সঙ্গে জোড়াও যায়: STM32-এর master/slave mode-এ একটি timer-এর update অন্যটির clock বা trigger হতে পারে, যা দুটি ১৬ বিটের timer দিয়ে একটি ৩২ বিটের counter বানায়, ঠিক যেমন পর্ব ২৫-এ দুটি 8254 counter cascade করা হয়েছিল।
পরীক্ষা ও ইন্টারভিউতে: (১) “72 MHz-এ 1 kHz update-এর PSC আর ARR?” → PSC = 71, ARR = 999 (দুটিতেই +1). (২) “PSC = 7199, ARR = 9999, 72 MHz-এ period?” → 7200 × 10 000 ÷ 72 MHz = 1 s. (৩) “Input capture আর output compare-এর পার্থক্য?” → capture বাইরের edge-এ CNT ধরে রাখে (মাপা), compare CNT = CCR হলে pin বদলায় (তৈরি করা)। (৪) “millis()-এর ধরনের ৩২ বিটের ms counter কবে ঘোরে আর তুলনা কীভাবে লিখবেন?” → প্রায় 49.7 দিনে; (uint32_t)(now - start) >= interval. (৫) “চলার মাঝে PSC বদলালে কখন কাজে লাগে?” → পরের update event-এ; সঙ্গে সঙ্গে চাইলে EGR-এর UG.
৯ · AI-এর যুগে timer-এর কোড যাচাই
“STM32-এ প্রতি 1 ms-এ একটি interrupt-এর কোড চাই” লিখলে AI assistant দ্রুত কোড দেয়, আর বেশিরভাগ সময় কাছাকাছি ঠিক। কিন্তু timer-এর ভুল প্রায়ই ছোট সংখ্যার ভুল, যা compile-এ ধরা পড়ে না: একটি “+1”, একটি ×2, একটি তুলনার দিক। এগুলো device-এ ধরা পড়ে দিনের পর দিন পরে। সবচেয়ে চেনা ভুল আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
| PSC বা ARR-এ “+1” ভোলে (PSC = 72, ARR = 1000 লেখে) | f = fTIM ÷ ((PSC+1)(ARR+1)) নিজে হিসাব করুন; ARR = 1000 মানে ১০০১টি অবস্থা |
| Timer-এর clock APB1-এর সমান ধরে (36 MHz), ×2 ভোলে | Clock tree মিলিয়ে নিন (পর্ব ৩৩, RM0008-এর clock-এর অধ্যায়); একটি LED toggle-এর সময় মেপে দেখুন |
| এক পরিবারের register বা বিট অন্য পরিবারে বসায়, ঠিকানা বানিয়ে বলে | নির্দিষ্ট chip-এর reference manual-এর register map, vendor-এর header |
if (millis() >= next) বা now > start + timeout লেখে | ব্যবধানের তুলনায় বদলান; counter-কে wrap-এর কাছে শুরু করে পরীক্ষা করুন (অংশ ৭-এর board run) |
Status flag মোছে TIM2->SR &= ~UIF দিয়ে, বা ISR-এ flag মোছেই না | RM0008-এ SR-এর বিট “0 লিখে মোছা”; SR = ~UIF এক store-এ শুধু সেই বিট মোছে। Flag না মুছলে ISR বারবার ঢোকে |
Timer-এর ISR-এ printf, delay বা লম্বা হিসাব | ISR-এ শুধু flag বা counter; কাজ main loop-এ (পর্ব ৪৩) |
AI-কে কাজে লাগাতে chip, clock আর যাচাইয়ের শর্ত শুরুতেই স্পষ্ট বলুন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১8254-এর যুগে বড় সময় মাপতে দুটি counter cascade করা হতো। আজকের timer prescaler আর auto-reload রাখে, অথচ সরাসরি ৩২ বা ৬৪ বিটের counter বানালেই তো হতো। Prescaler কেন এখনো আছে, আর এর দাম কী?
পর্ব ২৫-এ দেখেছেন, ১৯৮১-র IBM PC-তে 8253-এর counter 0 প্রায় 1.19318 MHz-এর clock-কে 65 536 দিয়ে ভাগ করে প্রায় 18.2 Hz-এর system tick দিত; এর চেয়ে ধীর কিছু চাইলে software-এ গুনতে হতো, বা দুটি counter জুড়তে হতো। Microcontroller-এর নকশাকারদের সামনে একই সমস্যা: একটি ১৬ বিটের counter 72 MHz-এ মাত্র 0.91 ms-এ ঘোরে। দুই পথ: counter চওড়া করা, অথবা আগে clock ধীর করা। Prescaler দ্বিতীয় পথ, আর এটি সস্তা: একটি ১৬ বিটের ভাজক যোগ করলে একটি ১৬ বিটের counter-এর পাল্লা 65 536 গুণ বাড়ে। এই পর্বের হিসাবে PSC আর ARR দুটিই সর্বোচ্চ হলে 72 MHz-এ period প্রায় 59.65 s.
চওড়া counter-এর দাম silicon আর শক্তিতে। প্রতিটি বিট একটি flip-flop, আর একটি দ্রুত clock-এ চলা ৩২ বিটের adder প্রতিটি tick-এ বেশি transistor বদলায়। Capture আর compare-এর register-ও সমান চওড়া হতে হয়, প্রতিটি channel-এ। STM32F1-এর সব general-purpose timer ১৬ বিটের; পরের পরিবারে TIM2 আর TIM5-এর মতো কয়েকটি ৩২ বিটের timer আসে, কিন্তু সবগুলো নয়, কারণ বেশিরভাগ কাজে ১৬ বিট আর prescaler যথেষ্ট।
Prescaler-এর দাম resolution-এ। PSC বাড়ালে প্রতিটি গণনা মোটা হয়: 1 Hz-এর জন্য PSC = 7199 নিলে tick 0.1 ms, তাই input capture-এ বা compare-এ 0.1 ms-এর চেয়ে সূক্ষ্ম কিছু ধরা যায় না। সেই কারণে একই 1 kHz-এর জন্য PSC = 1 আর ARR = 35 999 PWM-এ ভালো, কিন্তু 1 Hz-এর জন্য বাধ্য হয়ে মোটা tick নিতে হয়। আরেকটি দাম: prescaler-এর ভেতরের গণনা firmware দেখতে পায় না, তাই PSC বদলের মুহূর্ত shadow দিয়ে সামলাতে হয়, নয়তো একটি অর্ধেক-ভাগ হওয়া চক্র আসে।
আর cascade একেবারে হারায়নি। STM32-এর master/slave mode-এ একটি timer-এর update অন্যটির clock হতে পারে, যা পুরোনো 8254-এর OUT থেকে CLK-এ তার জোড়ারই আধুনিক রূপ। দীর্ঘ সময়ের জন্য আজও প্রচলিত সমাধান software-এ: একটি tick-এর ISR একটি ৩২ বিটের counter বাড়ায়, ঠিক যেমন বাজারঘরের firmware-এ ms_ticks.
মূল উপলব্ধি: Prescaler হলো সস্তায় পাল্লা কেনা: ছোট counter-এ দীর্ঘ সময়, বিনিময়ে মোটা resolution; তাই প্রতিটি নকশায় সঠিক PSC হলো পাল্লা আর সূক্ষ্মতার মাঝে একটি সচেতন আপস।
প্র ০২“৪৯.৭ দিনের bug” আর “২৪৮ দিনের bug” কী, আর একটি counter-এর wrap কীভাবে বড় system-এ সমস্যা ঘটিয়েছে? নকশাকাররা এখন এই ঝুঁকি কীভাবে আগেভাগে ধরেন?
232 ms প্রায় ৪৯.৭১ দিন, এই পর্বের হিসাবেই দেখা সংখ্যা। ১৯৯৯ সালের দিকে Microsoft একটি সমস্যা স্বীকার করেছিল, যেখানে Windows 95 আর 98 টানা প্রায় ৪৯.৭ দিন চললে থেমে যেতে পারত; মূলে ছিল একটি ৩২ বিটের ms counter-এর ঘুরে যাওয়া। খুব কম মানুষ তখন একটি PC এত দিন বন্ধ না করে চালাতেন, তাই bug-টি বছরের পর বছর লুকিয়ে ছিল। এটিই wrap-এর bug-এর বৈশিষ্ট্য: পরীক্ষায় কয়েক ঘণ্টা বা কয়েক দিন চালালে কখনো দেখা যায় না।
দ্বিতীয় উদাহরণ আরও গুরুতর। ২০১৫ সালে মার্কিন FAA Boeing 787-এর জন্য একটি নির্দেশ (airworthiness directive) জারি করে: generator control unit-এর software-এ একটি counter টানা প্রায় ২৪৮ দিন power-এ থাকলে overflow হতো, আর সব generator একসাথে বন্ধ হওয়ার ঝুঁকি ছিল; সমাধান না আসা পর্যন্ত নিয়মিত power বন্ধ-চালু করার নির্দেশ দেওয়া হয়। প্রকাশিত বিবরণগুলো অনুযায়ী ২৪৮ দিন প্রায় 231 centisecond-এর সমান, অর্থাৎ একটি signed ৩২ বিটের counter যা প্রতি 10 ms-এ বাড়ে; নির্মাতা ভেতরের বিস্তারিত প্রকাশ করেনি, তাই এই অংশটি সতর্কভাবে পড়ুন। শিক্ষা একই: overflow-এর দিন কাগজে হিসাব করা যায়, আর device-টি সেই দিন পর্যন্ত বাঁচবে কি না, সেটিই প্রশ্ন।
আজকের প্রতিরোধ তিন স্তরে। কোডে: এই পর্বের নিয়ম, সময় নয় ব্যবধান তুলনা, unsigned গণিত, আর signed পার্থক্য শুধু অর্ধেক পাল্লার মধ্যে। Linux kernel এর time_after() আর time_before() macro এই কৌশলে লেখা। পরীক্ষায়: counter-কে wrap-এর কাছে শুরু করা। Linux kernel নিজেই তার jiffies counter boot-এর সময় এমন একটি মানে শুরু করে যাতে boot-এর কয়েক মিনিট পরেই wrap হয়, যাতে wrap-এর bug সাধারণ ব্যবহারে দ্রুত বেরিয়ে আসে। এই পর্বের wrap.c-এর 0xFFFFF830 থেকে শুরু একই কৌশল। নকশায়: প্রয়োজনে ৬৪ বিটের সময়, যা ms-এ কোটি কোটি বছরে ঘোরে, আর নিরাপত্তা-গুরুত্বপূর্ণ system-এ নিয়মিত পরিকল্পিত restart বা watchdog-ভিত্তিক পুনরুদ্ধার (পর্ব ৬১)।
বাজারঘরের cold-storage monitor-এর ক্ষেত্রে এর মানে সরাসরি: device মাসের পর মাস চলবে, তাই ৫০তম দিনে তার 1 s-এর পড়া, 10 s-এর telemetry আর alarm-এর confirmation-এর হিসাব যেন ঠিক থাকে, তা board-এ wrap-এর কাছে শুরু করে প্রমাণ করা উচিত, ৫০ দিন অপেক্ষা করে নয়।
মূল উপলব্ধি: Wrap অবশ্যম্ভাবী আর তার তারিখ হিসাবযোগ্য; তাই bug-টি ধরা পড়ে না দুর্ভাগ্যে, ধরা পড়ে না কারণ কেউ পরীক্ষায় counter-কে সেখানে নিয়ে যায়নি। ব্যবধানের গণিত আর wrap-এর কাছে শুরু করা পরীক্ষা মিলে এই শ্রেণির bug প্রায় শূন্যে নামে।
প্র ০৩Board-এর software capture আর STM32-এর hardware input capture একই period দিয়েছে। তাহলে hardware capture কেন দরকার? কোন পরিস্থিতিতে software-এর timestamp যথেষ্ট, আর কোথায় নয়?
Board-এর run-এ প্রতিটি period নিখুঁত এসেছে, কারণ মডেলে exception-এ ঢুকতে 0 cycle লাগে, আর edge আসার সময় অন্য কোনো interrupt চলছিল না (Spec decision 17 অনুযায়ী)। আসল Cortex-M3-এ edge থেকে ISR-এর প্রথম নির্দেশ পর্যন্ত প্রায় ১২ cycle লাগে, flash-এর wait state থাকলে আরও, আর বর্তমান নির্দেশ শেষ হওয়ার অপেক্ষাও আছে। এগুলো স্থির থাকলে সমস্যা নয়, কারণ দুটি timestamp-এর পার্থক্যে স্থির দেরি কেটে যায়। সমস্যা হলো পরিবর্তনশীল দেরি: edge-এর মুহূর্তে যদি একটি সমান বা বেশি priority-র ISR চলে, যেমন UART-এর receive, তবে EXTI-এর ISR সেটি শেষ হওয়া পর্যন্ত অপেক্ষা করে। তখন একটি timestamp কয়েক µs দেরিতে, পরেরটি সময়মতো, আর period-এ সেই কয়েক µs-এর jitter.
Hardware capture-এ edge-এর মুহূর্তে counter-এর মান একটি register-এ জমে যায়; ISR পরে যখনই আসুক, CCR1 বদলায় না। তাই jitter নামে timer-এর এক গণনার কাছাকাছি, সঙ্গে input synchroniser-এর স্থির দেরি। 72 MHz-এ PSC = 0 নিলে সেটি প্রায় 14 ns, যেখানে software-এর পথে বাধা কয়েক µs হওয়া সাধারণ। দ্বিতীয় সুবিধা: hardware-এর digital filter (IC1F) শব্দে ভরা edge বাদ দেয়, আর IC1PSC দিয়ে প্রতি ৮টি edge-এ একবার capture নিয়ে উচ্চ frequency-তে interrupt-এর চাপ কমানো যায়। তৃতীয়: overcapture flag জানিয়ে দেয় কোনো মাপ হারিয়েছে, software-এর পথে যা চুপচাপ হারায়।
তাহলে software কখন যথেষ্ট? যখন প্রয়োজনীয় নির্ভুলতা বিরক্তিকর দেরির চেয়ে অনেক বড়। একটি পাখার tachometer, যা প্রতি সেকেন্ডে কয়েকশ pulse দেয় আর যার জন্য ১% নির্ভুলতাই যথেষ্ট, software-এ মাপা চলে। একটি বোতাম কতক্ষণ চাপা ছিল, তাও। কিন্তু একটি ultrasonic distance sensor-এর echo-র দৈর্ঘ্য, যেখানে প্রতি 1 µs মানে প্রায় 0.17 mm দূরত্ব (শব্দের গতি প্রায় 343 m/s ধরে, আসা-যাওয়ার জন্য অর্ধেক), সেখানে কয়েক দশক µs-এর jitter মানে কয়েক mm-এর ভুল; বা একটি power line-এর frequency সূক্ষ্মভাবে মাপা; বা motor-এর encoder-এর দ্রুত pulse. এসব জায়গায় hardware capture.
একটি চাপা অবস্থাও আছে: যে chip-এ timer channel কম বা সব ব্যবহৃত, সেখানে software capture একটি বাস্তব বিকল্প, আর তখন নকশাকার edge-এর interrupt-কে সবচেয়ে বেশি priority দেন, যাতে অন্য ISR তাকে আটকাতে না পারে (পর্ব ৩০-এর priority).
মূল উপলব্ধি: স্থির দেরি period থেকে কেটে যায়, পরিবর্তনশীল দেরি কাটে না; hardware capture মুহূর্তটি CPU-র আগেই ধরে রেখে এই পরিবর্তনশীলতা মুছে দেয়, তাই নির্ভুলতার দাবি যত কঠোর, capture তত hardware-এর কাজ।
প্র ০৪PSC সবসময় আর ARR ঐচ্ছিকভাবে “buffered”: লেখা মান পরের update event-এ কাজে লাগে। এই shadow register-এর নকশা কোন সমস্যা সমাধান করে, আর কখন উল্টো এটিই বিভ্রান্তি তৈরি করে?
একটি চলমান counter-এর সীমা হঠাৎ বদলানো মানে একটি চক্রের মাঝখানে নিয়ম বদলানো। ধরুন counter এখন 700, ARR ছিল 999, আর firmware ARR-এ 500 লিখল। Shadow না থাকলে (ARPE = 0) নতুন মান সঙ্গে সঙ্গে কাজে লাগে; counter 700 থেকে ওপরে যায়, 500 আর কখনো মেলে না, ফলে counter ১৬ বিটের শেষ পর্যন্ত গুনে ঘোরে। এই চক্রটি 65 536 − 700 গণনার, অর্থাৎ প্রত্যাশার অনেক গুণ লম্বা। ST-এর timer-সংক্রান্ত লেখায় এমন সতর্কতা পাওয়া যায়; তবু নিজের chip-এর manual মিলিয়ে নিন। PWM-এ এর মানে একটি বিকৃত pulse, motor-এর একটি ঝাঁকুনি। Shadow-সহ (ARPE = 1) বর্তমান চক্র পুরোনো সীমায় শেষ হয়, নতুন চক্র নতুন সীমায় শুরু: কোনো অর্ধেক বা অতিরিক্ত লম্বা চক্র নেই।
PSC-এর ক্ষেত্রে shadow বাধ্যতামূলক, কারণ prescaler-এর ভেতরের গণনা firmware-এর চোখের বাইরে; চক্রের মাঝে ভাজক বদলালে একটি গণনা পুরোনো আর নতুনের মাঝামাঝি দৈর্ঘ্যের হতে পারত। এই পর্বের Python মডেলে দেখেছেন, দ্বাদশ tick-এ PSC = 0 লেখার পরেও বিশতম tick-এর UEV পর্যন্ত counter পুরোনো হারে চলেছে।
বিভ্রান্তি আসে শুরুতে। Reset-এর পরে firmware PSC = 7199 লিখে timer চালু করল, আর অবাক হয়ে দেখল প্রথম update খুব দ্রুত এল। কারণ shadow-তে তখনো reset-এর 0, আর নতুন PSC কাজে লাগবে প্রথম UEV-এর পরে; ARR-এর reset মান 0xFFFF হওয়ায় প্রথম চক্রটি পুরো ভিন্ন দৈর্ঘ্যের হতে পারে। সমাধান: চালুর আগে EGR-এ UG লিখে একটি update জোর করা, যা shadow ভরে আর counter 0 করে। কিন্তু UG নিজেও একটি update event, তাই UIF বসে আর interrupt চালু থাকলে ISR একবার অকারণে চলে; সেটি এড়াতে CR1-এর URS বিট, যা RM0008 অনুযায়ী UG-এর update-এ UIF বসতে দেয় না, অথবা চালুর আগে UIF মুছে দেওয়া। এই ছোট ক্রমটি ভুললে প্রথম tick-এ একটি ভুয়া ঘটনা আসে, যা বাজারঘরের scale-এ হয়তো একটি অকাল মাপ।
একই নকশা CCR-এর জন্যও আছে (OC1PE), PWM-এ duty বদলের সময় বিকৃতি এড়াতে; তার আলোচনা পর্ব ৪৫-এ।
মূল উপলব্ধি: Shadow register চলমান counter-এর নিয়ম শুধু চক্রের সীমানায় বদলায়, তাই কোনো অর্ধেক চক্র আসে না; দাম হলো একটি চক্রের দেরি আর শুরুর UG-এর ক্রম, যা জানা না থাকলে প্রথম tick-টিই ভুল হয়।
প্র ০৫একটি Cortex-M chip-এ SysTick, একাধিক general-purpose timer, RTC আর low-power timer থাকে। ARM কেন SysTick-কে core-এর অংশ বানাল, আর একটি RTOS বা ব্যাটারির device-এ কোন সময়ের ভিত্তি কোন কাজে বাছবেন?
Cortex-M-এর আগে প্রতিটি microcontroller নির্মাতা নিজের timer বানাত, ভিন্ন ঠিকানা, ভিন্ন বিট, ভিন্ন interrupt নম্বরে। একটি RTOS-কে নতুন chip-এ নিতে প্রতিবার tick-এর কোড নতুন করে লিখতে হতো। ARM ARMv7-M আর ARMv6-M architecture-এ SysTick-কে core-এর system peripheral হিসেবে সংজ্ঞায়িত করল: একই ঠিকানা 0xE000E010, একই চারটি register, একই exception নম্বর ১৫ (ARMv7-M-এ এটি সবসময় থাকে; ARMv6-M-এ, যেমন Cortex-M0+-এ, নির্মাতা চাইলে বাদ দিতে পারে, তাই datasheet দেখে নিন). ফলে একটি RTOS-এর tick-এর কোড যেকোনো Cortex-M-এ প্রায় হুবহু চলে, chip যেই বানাক। এই কোর্সের virtual board-ও ঠিক সেই ঠিকানা ব্যবহার করে, তাই এখানে লেখা SysTick-এর কোড আসল chip-এ অর্থবহ।
SysTick-এর সীমাও জানা দরকার: এটি ২৪ বিটের, শুধু নিচের দিকে গোনে, কোনো capture বা compare channel নেই, কোনো pin নেই। আর core-এর clock বা তার একটি ভাগে চলে, তাই core ঘুমালে, অর্থাৎ deep sleep-এ clock বন্ধ হলে, SysTick-ও থামে। তাই তার কাজ একটিই: OS বা super loop-এর নিয়মিত tick, ms-স্তরের সময়ের ভিত্তি।
General-purpose timer সেখানে যেখানে সময় একটি pin বা সংকেতের সঙ্গে বাঁধা: PWM, input capture, output compare, ADC-র trigger. RTC আর low-power timer চলে আলাদা ধীর clock-এ, যেমন 32.768 kHz-এর crystal (215 Hz, তাই ১৫ বার অর্ধেক করলে ঠিক 1 Hz), আর core-এর clock বন্ধ থাকলেও চলে। ব্যাটারির device-এ এটাই মুখ্য: প্রতি 1 ms-এ একটি SysTick-এর interrupt প্রতিবার CPU-কে জাগায়, যা শক্তি খায়। তাই অনেক RTOS “tickless idle” দেয়: কাজ না থাকলে নিয়মিত tick বন্ধ করে, পরের কাজের সময় পর্যন্ত একটি low-power timer সাজিয়ে deep sleep-এ যায়, জেগে উঠে ঘুমের সময়টুকু tick-এর গণনায় যোগ করে। বিস্তারিত পর্ব ৬০ আর ৬২-এ।
বাজারঘরের cold-storage monitor-এর জন্য তাহলে একটি যুক্তিসঙ্গত বিন্যাস: জাগা অবস্থায় SysTick-এর 10 ms tick (README-র নকশা), প্রতি সেকেন্ডের পড়ার মাঝে লম্বা ঘুম দরকার হলে low-power timer বা RTC-র alarm, আর alarm-এর buzzer বা কোনো সংকেতের দৈর্ঘ্যের জন্য একটি general-purpose timer-এর one-pulse বা PWM. প্রতিটি সময়ের ভিত্তির নিজস্ব শক্তি, নির্ভুলতা আর ঘুমে টিকে থাকার ক্ষমতা আছে; নকশার কাজ মিলিয়ে বাছা।
মূল উপলব্ধি: SysTick সব Cortex-M-এ এক রকম বলে portable tick-এর জন্য আদর্শ, কিন্তু ঘুমে থামে আর pin ছোঁয় না; সংকেতের কাজে general-purpose timer, ঘুমের মধ্যে সময় রাখতে RTC বা low-power timer বেছে নিন।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি সংখ্যা Python-এ, এই পর্বের timer মডেলে বা কোর্সের virtual board-এ চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — cold room-এর 10 ms tick, STM32F103-এ: SYSCLK 72 MHz, APB1 prescaler 2. TIM2 দিয়ে প্রতি 10 ms-এ একটি update interrupt চাই, যা একটি
volatile uint32_ttick বাড়াবে; main loop প্রতি ১০০ tick-এ (1 s) তাপমাত্রা পড়বে আর প্রতি ১০০০ tick-এ (10 s) telemetry পাঠাবে। PSC আর ARR হিসাব করুন (দুটি “গোল” বিকল্প), init, ISR আর loop লিখুন।TIM2-এর clock: APB1 = 36 MHz, prescaler 1 নয়, তাই ×2 = 72 MHz (পর্ব ৩৩)। N = 72 000 000 × 0.01 = 720 000. বিকল্প ১: PSC = 7199 (10 kHz, প্রতি গণনা 0.1 ms), ARR = 99. বিকল্প ২: PSC = 71 (1 MHz), ARR = 9999. দুটিই (PSC+1)(ARR+1) = 720 000; Python-এ যাচাই করা। দ্বিতীয়টিতে CNT পড়লে সরাসরি µs পাওয়া যায়।
static volatile uint32_t tick10; /* প্রতি 10 ms-এ +1 */ void TIM2_IRQHandler(void) { TIM2->SR = ~TIM_SR_UIF; /* rc_w0: শুধু UIF মোছা */ tick10++; } void tim2_init(void) { RCC->APB1ENR |= RCC_APB1ENR_TIM2EN; TIM2->PSC = 71; TIM2->ARR = 9999; /* 72 MHz / 72 / 10000 = 100 Hz */ TIM2->CR1 = TIM_CR1_URS; /* UG-এ UIF বসবে না */ TIM2->EGR = TIM_EGR_UG; /* shadow ভরা, CNT = 0 */ TIM2->DIER = TIM_DIER_UIE; NVIC_EnableIRQ(TIM2_IRQn); TIM2->CR1 |= TIM_CR1_CEN; } /* main loop */ uint32_t last_rd = tick10, last_tx = tick10; for (;;) { uint32_t now = tick10; if ((uint32_t)(now - last_rd) >= 100u) { last_rd += 100u; read_temp(); } if ((uint32_t)(now - last_tx) >= 1000u) { last_tx += 1000u; send_telemetry(); } __WFI(); }এটি উদাহরণ (CMSIS-ধাঁচের STM32F1 header-এর নাম); কোর্সের board-এ TIM2 নেই, তাই চালানো হয়নি। হিসাব আর গঠন যাচাই করা: PSC/ARR Python-এ, loop-এর ব্যবধানের তুলনা board-এর
wrap.c-এ wrap পেরিয়ে। Board-এ একই নকশা SysTick-এ: LOAD = 79 999, README-র cold room-এর মতোই।last += periodথাকায় দেরি জমে না। -
ভুল খুঁজুন — capture-এর firmware: একটি fan-এর tachometer TIM3-এর CH1-এ (PSC দিয়ে 1 µs-এর গণনা, ARR = 0xFFFF) বসানো। কোড:
volatile uint16_t prev; volatile int32_t period_us;আর ISR-এuint16_t c = TIM3->CCR1; period_us = c - prev; prev = c; TIM3->SR &= ~TIM_SR_CC1IF;. Main loop-এif (millis() >= next) { next = millis() + 1000; print(1000000 / period_us); }. মাঝে মাঝে ঋণাত্মক বা অদ্ভুত frequency আসে, আর ৪৯ দিনের বেশি চললে ছাপা বন্ধ হয়ে যাওয়ার অভিযোগ। চারটি ভুল খুঁজুন।১. Integer promotion:
c - prev-এ দুটিuint16_tআগেintহয়; counter ঘোরার পরে (c ছোট, prev বড়) ফল ঋণাত্মক, যেমন 1500 − 65 000 = −63 500. ঠিক:period_us = (uint16_t)(c - prev);, তাহলে 2036. এই দুটি সংখ্যা অংশ ৭-এর C কোডের আসল run থেকে। ২. Flag মোছা: CCR1 পড়াতেই CC1IF মুছে যায় (RM0008 §15.3.5), তাই শেষ লাইন অপ্রয়োজনীয়; আরSR &= ~…একটি read-modify-write: পড়া আর লেখার মাঝে অন্য কোনো flag (যেমন UIF) বসলে লেখার সময় তার জায়গায় 0 গিয়ে সেটি মুছে যায়। rc_w0 বিটে ঠিক রূপTIM3->SR = ~TIM_SR_CC1IF;. ৩. Wrap-অনিরাপদ তুলনা:millis() >= nextঘোরার কাছে ভাঙে; board-এরwrap.c-এ ঠিক এই ধরন ৪৯৯ বার পরপর চলে তারপর প্রায় 249.5 s চুপ ছিল (period 500 ms-এ; এখানে 1000 ms-এ নীরবতা আরও লম্বা)। ঠিক:if ((uint32_t)(millis() - last) >= 1000u) { last += 1000u; … }. ৪. ধীর সংকেত আর ভাগে শূন্য: fan থামলে বা খুব ধীর হলে দুই edge-এর মাঝে counter একাধিকবার ঘোরে, ১৬ বিটের পার্থক্য ভুল (অংশ ৬-এর 1 Hz-এর উদাহরণে 16 960 µs); আর প্রথম edge-এর আগেperiod_us= 0 হলে1000000 / period_usভাগে শূন্য। ঠিক: update event গুনে পূর্ণ period, একটি timeout (যেমন 2 s কোনো edge না এলে frequency = 0), আর ভাগের আগে শূন্য পরীক্ষা। সঙ্গে,period_us৩২ বিটের, তাই Cortex-M3-এ এক নির্দেশে পড়া যায়; ৮ বিটের chip-এ main-এ পড়ার সময় interrupt বন্ধ রাখতে হতো। -
আগে বলুন, তারপর মেলান — counter-এর trace: একটি STM32-ধাঁচের timer upcounting-এ, PSC = 2, ARR = 3, CCR1 = 1, OC1M = toggle (011), OC1REF শুরুতে 0. প্রথম ২৪টি CK_PSC tick-এর পরে CNT কত, কোন tick-এ update event, আর কোন tick-এ OC1REF বদলায়? Update-এর frequency আর OC1-এর square wave-এর frequency fTIM-এর কত ভাগ?
প্রতি ৩ tick-এ এক গণনা (PSC + 1 = 3), চক্রে ৪টি অবস্থা (ARR + 1 = 4) থাকে। অংশ ৫-এর মডেলে চালিয়ে পাওয়া (
*= UEV,^= OC1REF উঁচু):0 0 1^ 1^ 1^ 2^ 2^ 2^ 3^ 3^ 3^ 0*^ 0^ 0^ 1 1 1 2 2 2 3 3 3 0*CNT প্রথম বাড়ে তৃতীয় tick-এ (1), আর CNT = CCR1 = 1 হওয়ায় সেখানেই OC1REF উঁচু। Update event দ্বাদশ আর চব্বিশতম tick-এ: প্রতি 3 × 4 = 12 tick-এ একবার, অর্থাৎ fUEV = fTIM ÷ 12. পরের toggle পঞ্চদশ tick-এ (CNT আবার 1), OC1REF নিচু; তার পরেরটি সাতাশতম tick-এ। তাই OC1-এর পূর্ণ চক্র ২৪ tick: fOC1 = fTIM ÷ 24, update-এর অর্ধেক, আর duty ৫০%. CCR1 বদলালে frequency একই থাকে, শুধু phase সরে।
-
হিসাব — পাল্লা আর wrap: (ক) STM32F103-এ fTIM = 72 MHz হলে PSC আর ARR দুটিই সর্বোচ্চ রেখে update-এর period কত? (খ) কোর্সের board-এ (8 MHz) SysTick-এর সর্বোচ্চ period কত, আর LOAD = 799 দিলে? (গ) ৩২ বিটের ms counter আর ৩২ বিটের µs counter কত দিন বা মিনিটে ঘোরে? (ঘ)
(int32_t)(now - deadline) >= 0ধরনের deadline-এর তুলনা সর্বোচ্চ কত দিনের ব্যবধান পর্যন্ত ঠিক থাকে (ms counter)?(ক) 65 536 × 65 536 ÷ 72 000 000 ≈ 59.65 s. (খ) 224 ÷ 8 MHz = 2.097152 s (LOAD = 16 777 215); LOAD = 799 দিলে 800 cycle = 100 µs, যা board-এর আসল run-এ MARK 3.1471, 3.2471, 3.3471 ms হিসেবে দেখা গেছে। (গ) 232 ms ≈ 49.71 দিন; 232 µs ≈ 71.58 মিনিট. (ঘ) 231 ms ≈ 24.86 দিন; তার বেশি ব্যবধানে signed পার্থক্য উল্টো চিহ্ন পায়। সব সংখ্যা Python-এ চালিয়ে মেলানো:
59.652…,2.097152,49.710…,71.582…,24.855…. ব্যবধানের (B) তুলনা পুরো 232 পর্যন্ত চলে, তাই পর্যায়ক্রমিক কাজের জন্য সেটিই সহজ পছন্দ।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমSTM32F103-এর TIM2 channel 1-এ rising edge-এর input capture সাজানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- RCC-র APB1ENR-এ TIM2-এর clock চালু করা
- PSC আর ARR লিখে counter-এর গণনার হার আর পাল্লা ঠিক করা
- CCMR1-এ CC1S = 01 (TI1 থেকে input) আর দরকারমতো IC1F filter বসানো
- CCER-এ CC1P = 0 (rising edge) আর CC1E = 1 দিয়ে capture চালু করা
- DIER-এ CC1IE চালু করে NVIC-এ TIM2-এর interrupt খোলা
- CR1-এ CEN = 1 দিয়ে counter চালু করা
একটি STM32 timer-এর clock 72 MHz, PSC = 7199, ARR = 9999, upcounting. Update event কত frequency-তে আসবে?
- 10 kHz
- 0.99 Hz
- 1 Hz
- 10 Hz
একটি ১৬ বিটের free-running timer প্রতি 1 µs-এ এক গোনে। পরপর দুটি input capture-এ CCR1 = 65000, তারপর CCR1 = 1500 (মাঝে counter একবার ঘুরেছে)। C-তে (uint16_t)(c2 - c1) দিয়ে period কত?
- −63500 µs
- 2036 µs
- 1500 µs
- 66500 µs
একটি uint32_t ms counter-এ start = 0xFFFFFF00, now = 0x00000064 (মাঝে counter ঘুরেছে)। কোন প্রকাশটি সঠিকভাবে বলে যে 200 ms পেরিয়েছে?
now >= start + 200now > start && now - start >= 200(int32_t)now - (int32_t)start >= 200(uint32_t)(now - start) >= 200
STM32-এর একটি timer one-pulse mode-এ (OPM = 1), channel 1 PWM mode 2, CCR1 = 3, ARR = 7, upcounting. Trigger-এর পরে pulse-এর দেরি আর দৈর্ঘ্য কত গণনা?
- দেরি 3, দৈর্ঘ্য 5
- দেরি 3, দৈর্ঘ্য 4
- দেরি 5, দৈর্ঘ্য 3
- দেরি 0, দৈর্ঘ্য 8
একটি STM32 general-purpose timer চলার সময় firmware PSC register-এ নতুন মান লিখল। RM0008 অনুযায়ী নতুন ভাগ কখন কাজে লাগে?
- লেখার পরের গণনা থেকেই
- পরের update event-এ
- শুধু CEN বন্ধ করে আবার চালু করলে
- শুধু পরের reset-এর পরে
একটি Cortex-M chip-এ SysTick 8 MHz core clock গোনে। LOAD = 799 লিখলে SysTick-এর interrupt কতক্ষণ পরপর আসবে?
- 99.875 µs
- 1 ms
- 100 µs
- 10 µs
Input capture-এর ISR দেরিতে চলায় একটি capture-এর মান পড়ার আগেই আরেকটি edge এসে CCR1 নতুন মানে লিখে দিল। STM32-এর TIMx_SR-এ কোন flag এটি জানায়?
- UIF
- শুধু CC1IF
- CEN
- CC1OF
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- গঠন: clock → prescaler (÷ PSC+1) → counter (0 … ARR) → update event (UIF, interrupt); PSC সবসময় আর ARR (ARPE = 1-এ) পরের update-এ কাজে লাগে, শুরুতে UG.
- হিসাব: fUEV = fTIM ÷ ((PSC+1)(ARR+1)); আগে timer-এর আসল clock (APB ×2), তারপর ১৬ বিটের সীমার মধ্যে গুণনীয়ক; 72 MHz → 1 kHz = PSC 71, ARR 999.
- Channel: input capture edge-এর মুহূর্তে CNT ধরে (period = ১৬ বিটের পার্থক্য, বহুবার ঘুরলে UEV গোনা, CC1OF মানে হারানো মাপ); output compare CNT = CCR1-এ pin বদলায়; one-pulse-এ দেরি CCR1, দৈর্ঘ্য ARR − CCR1 + 1.
- SysTick (board-এর আসল run): period = LOAD + 1 cycle; tick ঠিক 1 ms, 100 µs, 10 ms পরপর; ms আর VAL দুই ধাপে পড়লে race, আবার পড়ে মেলালে নিরাপদ।
- Wrap: সময় নয়, ব্যবধান তুলনা:
(uint32_t)(now - last) >= period, deadline-এ(int32_t)(now - next) >= 0; ১৬ বিটের বিয়োগ আবারuint16_t-এ; counter-কে wrap-এর কাছে শুরু করে পরীক্ষা।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ২৫ · 8253/8254 programmable timerআগের ভিত্তিতিনটি counter, ছয়টি mode, control word আর cascade: আজকের timer-এর পূর্বসূরি।
- পর্ব ৩৩ · Clock, reset আর power domainআগের ভিত্তিTimer কোন clock পায়, APB-র ×2 আর SysTick-এর LOAD-এর সীমা।
- Computer Architecture পর্ব ১৬ · Register, shift register আর counterপাশের ট্র্যাকFlip-flop দিয়ে counter কীভাবে বানানো হয়।
- C প্রোগ্রামিং পর্ব ৫৪ · এমবেডেড Cপাশের ট্র্যাকvolatile, register-এর pointer আর ISR-এর সঙ্গে C.
- Operating Systems পর্ব ২০ · Multiprocessor আর real-time schedulingপাশের ট্র্যাকTimer-এর tick থেকে real-time scheduling-এর তত্ত্ব: RM আর EDF.