সরাসরি পর্বে যান
পর্ব ৪২ · ৮৫-এর মধ্যে · মডিউল ৭

Button debouncing — software আর hardware পদ্ধতি

Button Debouncing — Software and Hardware Methods

Taught in Bangla, this lesson models mechanical contact bounce with a seeded button script: on the course's virtual BG-M3 board two real presses fire the EXTI ISR 20 times. It compares counter, shift-register and time-stamp debouncers sampled every 1 ms (the first two count exactly two presses), shows a waiting ISR locking up the firmware, builds a hybrid design where an edge wakes and a timer confirms, chooses the sample window, and calculates an RC filter with a Schmitt trigger for hardware debouncing.

এই পর্বে যা শিখবেন

  • Contact bounce কেন হয়, কতক্ষণ চলে, আর সরল কোড কেন একটি চাপকে কয়েকটি গোনে
  • Counter, shift-register আর time-stamp debouncer লেখা, নমুনা ধরে trace করা আর তুলনা করা
  • ISR-এ debounce বনাম periodic task, আর edge-interrupt দিয়ে জাগিয়ে timer দিয়ে যাচাইয়ের মিশ্র নকশা
  • নমুনার সময় (T) আর সংখ্যা (N) বাছাই, latency আর নিরাপত্তার হিসাব
  • RC আর Schmitt trigger-এর time constant আর threshold-পার হওয়ার সময় datasheet ধরে হিসাব

১ · বোতাম কেন লাফায় — contact bounce

ক্রিকেটের বল মাটিতে ফেললে সেটি একবারে থামে না; ছোট ছোট কয়েকটি লাফ দিয়ে তবেই স্থির হয়। একটি push button-এর ভেতরেও ঠিক এমন ঘটে। চাপ দিলে একটি ধাতব পাত আরেকটি পাতে গিয়ে ধাক্কা খায়, স্প্রিংয়ের মতো একটু ফিরে আসে, আবার লাগে। কয়েকবার এমন জোড়া-ছাড়ার পরে সংযোগ স্থির হয়। ছাড়ার সময়ও একই কাণ্ড। এই ঘটনার নাম contact bounce. মানুষের চোখে এটি অদৃশ্য, কারণ পুরোটা কয়েক মিলিসেকেন্ডের। কিন্তু 8 MHz-এ চলা একটি microcontroller এক মিলিসেকেন্ডে আট হাজার clock cycle পায়; তার কাছে প্রতিটি লাফ একটি আলাদা “চাপ”।

বাজারঘরের smart scale-এ বিপদটি সরাসরি। দোকানদার ঝুড়ি রেখে tare বোতাম একবার চাপলেন। Firmware যদি তিনটি চাপ গোনে, তাতে হয়তো ক্ষতি নেই, কারণ তিনবার একই ওজন জমা হয়। কিন্তু একই বোতাম যদি “পরের পণ্য” বা “দাম গুণ” বেছে নেয়, তাহলে একটি চাপে তিন ধাপ এগিয়ে যাবে। পর্ব ১৩-এ 8085-এর RST 7.5-এ tare বোতাম জোড়ার সময় আর পর্ব ২৪-এ 8255-এর keypad-এ এই সমস্যার কথা উঠেছিল; এই পর্বে তার পুরো সমাধান: debouncing, অর্থাৎ লাফানো সংকেত থেকে প্রতিটি চাপের জন্য একটি পরিষ্কার ঘটনা বের করা।

Bounce কতক্ষণ চলে? এর কোনো একক উত্তর নেই; বোতামের গঠন, ধাতু, বয়স আর চাপার ধরনের ওপর নির্ভর করে। Embedded প্রকৌশলী Jack Ganssle বেশ কয়েক ধরনের সুইচ বহুবার চেপে মেপেছিলেন (তাঁর লেখা “A Guide to Debouncing”); সেই মাপের সারাংশ হিসেবে বিভিন্ন সূত্রে গড় প্রায় 1.6 ms আর বেশিরভাগ সুইচের সর্বোচ্চ প্রায় 6.2 ms উল্লেখ আছে, তবে কিছু সুইচ এর চেয়ে অনেক বেশি লাফিয়েছে। শিক্ষা দুটি: “১ ms-এর বেশি লাফায় না” ধরনের ধারণা ভুল, আর নকশা করতে হয় খারাপতম বোতাম ধরে, নির্দিষ্ট বোতামের datasheet দেখে, সম্ভব হলে নিজে মেপে।

এই পর্বে আসল oscilloscope নেই, তাই bounce-কে একটি মডেলে আনা হলো। মডেলটি seed দেওয়া random generator: প্রতিটি চাপ বা ছাড়ায় ৩ থেকে ৬টি লাফ, প্রতিটি 0.1 থেকে 0.9 ms. Seed একই রাখলে প্রতিবার একই “লাফানো বোতাম” পাওয়া যায়, তাই একই সংকেত virtual board-এর script-এও দেওয়া যায়, আর ব্রাউজারের Python-এও। সময় লেখা হবে ms-এ, আর register-এর মান C-এর ধরনে, যেমন 0xFF.

# seed দেওয়া bounce-এর মডেল: একই seed মানে প্রতিবার একই "লাফানো" button
import random

def bounce(rng, t0, level):                 # একটি চাপ (1) বা ছাড়া (0)
    ev, t, cur = [], t0, level
    for _ in range(rng.randint(3, 6)):      # কয়বার লাফাবে
        ev.append((round(t, 1), cur))
        t += rng.randint(1, 9) / 10         # প্রতি লাফ 0.1 .. 0.9 ms
        cur ^= 1
    ev.append((round(t, 1), level))         # শেষে স্থির মান
    return ev

rng = random.Random(42)
ev = bounce(rng, 100.0, 1) + bounce(rng, 400.0, 0)
ev += [(550.0, 1), (550.2, 0)]              # 0.2 ms-এর noise spike
ev += bounce(rng, 700.0, 1) + bounce(rng, 850.0, 0)
edges, last = [], 0
for t, v in ev:                             # একই মানে "বদল" বাদ
    if v != last:
        edges.append((t, v)); last = v

def level(t):                               # সময় t-তে pin-এর মান
    v = 0
    for te, ve in edges:
        if te <= t: v = ve
    return v

print("edge সংখ্যা:", len(edges))
for t0 in (100, 400, 700, 850):
    near = [f"{t}:{v}" for t, v in edges if t0 <= t < t0 + 5]
    print(f"{t0} ms-এর কাছে:", " ".join(near))
for t0 in (98, 698):
    s = "".join(str(level(k + 0.005)) for k in range(t0, t0 + 14))
    print(f"1 ms নমুনা {t0}..{t0 + 13}:", s)

আসল আউটপুট (ব্রাউজারের Python):

edge সংখ্যা: 20
100 ms-এর কাছে: 100.0:1 100.1:0 100.6:1
400 ms-এর কাছে: 400.0:0 400.3:1 400.5:0 401.4:1 401.6:0
700 ms-এর কাছে: 700.0:1 700.1:0 700.2:1 700.4:0 700.8:1 701.2:0 702.1:1
850 ms-এর কাছে: 850.0:0 850.9:1 851.3:0
1 ms নমুনা 98..111: 00111111111111
1 ms নমুনা 698..711: 00110111111111

দুটি চাপ, দুটি ছাড়া আর একটি 0.2 ms-এর বৈদ্যুতিক spike মিলে ২০টি edge. দ্বিতীয় চাপটি (700 ms) সবচেয়ে অস্থির: 2.1 ms ধরে সাতটি বদল। শেষ দুই লাইন গুরুত্বপূর্ণ। প্রতি 1 ms-এ একবার পড়লে প্রথম চাপের সব লাফ দুই নমুনার মাঝে পড়েছে, তাই নমুনায় দেখা যায় শুধু পরিষ্কার 0011111…. দ্বিতীয় চাপে 701.2 থেকে 702.1 ms-এর 0.9 ms-এর ফাঁক 702 ms-এর নমুনায় ধরা পড়েছে: 00110111…. অর্থাৎ নমুনা নেওয়া নিজেই কিছু লাফ ছেঁকে ফেলে, কিন্তু সবগুলো নয়।

ছবি ৪২.১ — একটি লাফানো চাপ, তিনভাবে দেখা

seed 42-এর দ্বিতীয় চাপ (699–712 ms): ওপরে কাঁচা সংকেত, মাঝে 1 ms-এর নমুনা আর counter, নিচে RC বর্তনীর ভোল্টেজ

একটি লাফানো চাপ: কাঁচা সংকেত, 1 ms-এর নমুনা, counter আর RC-এর ভোল্টেজ ক · কাঁচা সংকেত (seed 42) 1 0 খ · 1 ms-এর নমুনা, counter (N = 5) 0 1 2 1 2 3 4 5 5 5 5 5 5 cnt ↑ counter 706 ↑ shift-8 710 filter নেই: 700, 703 গ · RC-এর ভোল্টেজ, τ = 10 ms VT+ 2.5 V VT− 1.6 V 4.5 0 V Y = 1, 711.81 ms 699 701 703 705 707 709 711 সময় (ms)
ছবি ৪২.১ — নীল ভরাট বিন্দু = নমুনায় 1. Counter 706 ms-এ ৫-এ পৌঁছে চাপ মানে, ৮টি পরপর 1 চাওয়া shift-register 710 ms-এ; filter ছাড়া কোড 700 আর 703 ms-এ দুটি চাপ গোনে। নিচে, একই লাফে RC-এর ভোল্টেজ সামান্য কাঁপে মাত্র, আর VT− পার হয় একবার, 711.81 ms-এ। সব মান lab-এর হিসাব আর board-এর run থেকে।

২ · Board-এ লাফানো বোতাম — একটি চাপ, অনেক interrupt

কোর্সের virtual বাজারঘর board BG-M3 কোনো আসল পণ্য নয়; এটি Unicorn-এ চলা একটি আসল ARMv7-M CPU আর Python-এ লেখা STM32-ধাঁচের peripheral (পর্ব ০৬)। এর PA0-তে একটি বোতাম, চাপলে 1, কারণ বাইরে একটি pull-down resistor ধরা হয়েছে, Spec decision 23 অনুযায়ী। অনেক আসল board-এ উল্টোটা চলে: pull-up resistor আর বোতাম GND-তে, তাই চাপলে 0, অর্থাৎ active-low. দুই ধরনের pin-এর ব্যবস্থা পর্ব ৪১-এর বিষয়; debounce-এর যুক্তি দুই ক্ষেত্রেই এক, শুধু 0 আর 1 অদলবদল।

Board-এর EXTI line 0 প্রতিটি rising বা falling edge latch করে pending register (PR)-এ, আর ISR-কে সেটি 1 লিখে মুছতে হয়, Spec decision 27 অনুযায়ী। এটি একটি edge-triggered interrupt: প্রতিটি edge একটি ঘটনা। Reference lab-এর button.c দুটো কাজ একসাথে করে: EXTI0-এর ISR প্রতিটি কাঁচা edge গোনে (সরল নকশা যা দেখত), আর SysTick প্রতি 1 ms-এ PA0 পড়ে ৮টি পরপর একই নমুনা দেখলে চাপ মানে। প্রথমে reference-এর নিজের script দিয়ে, তারপর seed 42-এর script দিয়ে (আমার lab-এর gen_bounce.py ওপরের block-এর একই কোডে bounce_42.json বানায়):

$ python -B board.py run build/button.elf --script bounce_42.json
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0283 ms] UART: button demo: 8 ms debounce
[   100.0000 ms] > button pressed
[   100.1000 ms] > button released
[   100.6000 ms] > button pressed
[   107.0114 ms] GPIO PA5 LED ON
[   107.0699 ms] UART: press 1 accepted at t=107 ms, raw edges so far: 3
[   400.0000 ms] > button released
...                (আরও ১৪টি লাফ আর spike-এর লাইন)
[   702.1000 ms] > button pressed
[   710.0114 ms] GPIO PA5 LED OFF
[   710.0720 ms] UART: press 2 accepted at t=710 ms, raw edges so far: 17
[   850.0000 ms] > button released
[   850.9000 ms] > button pressed
[   851.3000 ms] > button released
[  1000.0600 ms] UART: summary: raw edges = 20, debounced presses = 2
[  1000.0609 ms] exit(0) after 8000487 cycles

সত্যিকারের run (বাজারঘর board BG-M3, Clang 22.1.8 / ziglang 0.17.1, Unicorn 2.1.4). Reference script-এ (button.json) ফল raw edges = 14, debounced presses = 2, প্রথম চাপ 110 ms-এ, ঠিক README-এর expected file-এর মতো; আমার lab-এ build করে চালানো আউটপুট সেই file-এর সঙ্গে লাইন ধরে মিলেছে। Seed 42-এ কাঁচা edge ২০টি, যা Python মডেলের ২০-এর সঙ্গে হুবহু এক, আর আসল চাপ দুটিই। অর্থাৎ ISR চলেছে ২০ বার, যার ১৮ বার অকারণে। Sub-millisecond অঙ্কগুলো (যেমন .0114) compiler-এর বানানো নির্দেশের সংখ্যার ওপর নির্ভর করে (Spec decision 30); কোন ms-এ কী ঘটল, তা নয়।

একটি জিনিস খেয়াল করুন: প্রথম চাপ মানা হয়েছে 107 ms-এ, চাপার ৭ ms পরে। এটিই debounce-এর দাম, দেরি। আরেকটি জিনিস: Smart scale-এর scale.c-ও একই ৮ নমুনার কৌশলে tare নেয়; README-এর run-এ বোতাম 420 ms-এ চাপা, tare হয়েছে 427 ms-এ।

৩ · Counter debouncer — ভোট গুনে সিদ্ধান্ত

সবচেয়ে সহজে বোঝা যায় এমন কৌশল একটি ভোট-গোনা। ভাবুন, পাড়ার ক্লাবের নির্বাচনে প্রতি ঘণ্টায় একজন করে ভোট দিচ্ছেন। “চাপা” ভোট এলে গণনা এক বাড়ে, “ছাড়া” এলে এক কমে, কিন্তু গণনা ০-এর নিচে বা N-এর ওপরে যায় না। গণনা N ছুঁলে ফল “চাপা”, ০ ছুঁলে “ছাড়া”; মাঝখানে থাকলে আগের ফলই বহাল। এর নাম counter বা integrator debouncer, কারণ এটি সময়ের সঙ্গে নমুনাগুলো যোগ করে। এক-আধটি উল্টো নমুনা গণনাকে একটু পিছিয়ে দেয়, কিন্তু সিদ্ধান্ত উল্টে দেয় না।

নিয়মটি C-তে কয়েক লাইন (আমার lab-এর deb_all.c-এর SysTick অংশ, N = 5, প্রতি 1 ms):

if (level) { if (cnt < 5u) cnt++; } else if (cnt) cnt--;
if (!cnt_state && cnt == 5u) { cnt_state = 1; note(&L[4], now); }  /* press */
else if (cnt_state && cnt == 0u) cnt_state = 0;                     /* release */
SysTick-এর প্রতি 1 ms-এর নমুনা
সময়
PA0 নমুনা
cnt
debounced
filter ছাড়া
  1. শুরু। বোতাম ছাড়া, cnt = 0, debounced অবস্থা “ছাড়া”। 700 ms-এর ঠিক আগে কিছু ঘটেনি।
  2. প্রথম 1. 700.0 ms-এ প্রথম লাফ, তাই 700 ms-এর নমুনা 1, cnt = 1. Filter ছাড়া কোড এখনই একটি চাপ গুনে ফেলেছে।
  3. আবার 1. 700.8–701.2 ms-এ সংযোগ লেগে ছিল, 701 ms-এর নমুনা সেটি দেখেছে: cnt = 2. মাঝের লাফগুলো দুই নমুনার ফাঁকে পড়ে অদৃশ্য।
  4. লাফ ধরা পড়ল। 701.2 থেকে 702.1 ms সংযোগ ছাড়া, তাই 702 ms-এর নমুনা 0: cnt এক কমে 1. Counter-এর সিদ্ধান্ত বদলায়নি; filter ছাড়া কোড ভাবছে বোতাম ছাড়া হয়েছে।
  5. আবার 1. 702.1 ms থেকে সংযোগ স্থির। cnt = 2. Filter ছাড়া কোড এখানে দ্বিতীয়, ভুল চাপটি গুনেছে, ঠিক যা board-এর poll-no-filter 703 ms-এ দেখিয়েছে।
  6. জমছে। cnt = 3. প্রতিটি পরিষ্কার নমুনা গণনাকে এক ধাপ এগিয়ে নিচ্ছে।
  7. প্রায়। cnt = 4. এখনো সিদ্ধান্ত “ছাড়া”, কারণ N = 5 ছোঁয়নি।
  8. চাপ মানা। 706 ms-এ cnt = 5, অবস্থা “চাপা”, একটি মাত্র ঘটনা। Board-এর counter-N5 হুবহু 706 লিখেছে। এরপর cnt ৫-এ আটকে থাকে, যতক্ষণ না ছাড়ার পরে ০-তে নামে।

লক্ষ করুন, counter-এর সিদ্ধান্তের দেরি পরিবর্তনশীল। কোনো লাফ ধরা না পড়লে N = 5 নমুনায়, অর্থাৎ প্রায় 5 ms-এ; প্রতিটি ধরা-পড়া উল্টো নমুনা আরও দুই নমুনা দেরি করায় (একটি কমে, একটি আবার পূরণে)। আর ছাড়ার দিকেও একই নিয়ম, তাই চাপ ধরে রাখার মাঝে একটি ক্ষণিকের 0 (যেমন হাত একটু কাঁপল) সিদ্ধান্ত বদলায় না।

৪ · Shift-register debouncer আর পাঁচ পদ্ধতির তুলনা

Reference-এর button.c আরেকটি কৌশল নেয়: শেষ ৮টি নমুনা একটি uint8_t-এ রাখা, ঠিক একটি shift register-এর মতো। প্রতি নমুনায় পুরোনো বিটগুলো এক ঘর বাঁয়ে সরে, নতুনটি ঢোকে বিট ০-তে। সব বিট 1 (0xFF) হলে চাপ, সব 0 হলে ছাড়া। Counter যেখানে “মোট কত ভোট” দেখে, shift-register দেখে “শেষ ৮টি কি সবাই একমত”। তাই এটি কঠোর: একটি মাত্র উল্টো নমুনা পুরো ঘড়ি আবার শুরু করায়। বিটের কাজগুলো (<<, |, mask) পর্ব ৩৫-এর।

#define DEBOUNCE_MASK 0xFFu               /* 8 samples */
static uint8_t history;                   /* last 8 samples, newest in bit 0 */
static uint8_t stable;                    /* debounced state */

void SysTick_Handler(void)                /* every 1 ms */
{
    ms_ticks++;
    uint8_t level = (uint8_t)((GPIOA->IDR >> BUTTON_PIN) & 1u);
    history = (uint8_t)((history << 1) | level);
    if (!stable && history == DEBOUNCE_MASK) {
        stable = 1;
        press_events++;                   /* main loop handles it */
    } else if (stable && history == 0u) {
        stable = 0;
    }
}
history (বিট ৭ … বিট ০)
সময়
নমুনা
history
hex
stable
  1. শুরু। history = 0x00: শেষ ৮টি নমুনাই 0. stable = 0.
  2. 700 ms. নমুনা 1: (0x00 << 1) | 1 = 0x01. ৮টির একটি মাত্র 1, সিদ্ধান্ত নেই।
  3. 701 ms. আবার 1: 0x03. দুটি 1 জমেছে।
  4. 702 ms, লাফ। নমুনা 0: 0x03 << 1 = 0x06. এই 0-টি এখন history-তে ঢুকে গেছে, আর ৭টি নমুনা ধরে বাঁয়ে সরতে থাকবে।
  5. 703 ms. 1 ফিরল: 0x0D = 00001101. Counter এখানে ছিল 2-এ; shift-register-এর হিসাবে কিন্তু 0-টি যতক্ষণ ভেতরে, ততক্ষণ 0xFF অসম্ভব।
  6. 706 ms. 0x6F = 01101111. ঠিক এই মুহূর্তে counter চাপ মেনে নিয়েছিল; shift-register তখনো অপেক্ষায়, কারণ বিট ৪-এ সেই 0.
  7. 709 ms. মাঝে 707 ms-এ 0xDF, 708 ms-এ 0xBF; 0-টি বিট ৭-এ পৌঁছে এবার 0x7F. আর একটি নমুনা।
  8. 710 ms, চাপ। 0-টি বাঁয়ে পড়ে গেল: 0xFF, stable = 1. Board-এর reference run-এ হুবহু “press 2 accepted at t=710 ms”.

এবার একই লাফানো সংকেতে পাঁচটি পদ্ধতি পাশাপাশি। এই block আগের block-এর edges আর level() ব্যবহার করে (দুটি একই namespace-এ চলে); time-stamp-এর দুটি পদ্ধতি পরের অংশে ব্যাখ্যা করা আছে:

# আগের block-এর edges আর level() দিয়ে পাঁচটি পদ্ধতি, প্রতি 1 ms-এ নমুনা
res = {k: [] for k in ("no-filter", "shift-8", "counter-5",
                       "ts-accept", "ts-quiet")}
prev = hist = sr = cnt = cs = 0
for k in range(1, 1000):                    # SysTick: k ms-এর ঠিক পরে পড়া
    v = level(k + 0.005)
    if v and not prev: res["no-filter"].append(k)
    prev = v
    hist = ((hist << 1) | v) & 0xFF         # শেষ ৮টি নমুনা
    if not sr and hist == 0xFF: sr = 1; res["shift-8"].append(k)
    elif sr and hist == 0: sr = 0
    cnt = min(cnt + 1, 5) if v else max(cnt - 1, 0)
    if not cs and cnt == 5: cs = 1; res["counter-5"].append(k)
    elif cs and cnt == 0: cs = 0

last_acc = last_edge = -10**6               # EXTI ISR: প্রতিটি edge-এ চলে
for t, v in edges:
    now = int(t - 0.01)                     # ISR-এর মুহূর্তে ms_ticks
    if v and now - last_acc >= 20:
        last_acc = now; res["ts-accept"].append(now)
    if v and now - last_edge >= 20:
        res["ts-quiet"].append(now)
    last_edge = now

for name, ts in res.items():
    print(f"{name:<10} চাপ={len(ts)}  সময় (ms): {ts}")

আসল আউটপুট (ব্রাউজারের Python):

no-filter  চাপ=5  সময় (ms): [100, 550, 700, 703, 851]
shift-8    চাপ=2  সময় (ms): [107, 710]
counter-5  চাপ=2  সময় (ms): [104, 706]
ts-accept  চাপ=5  সময় (ms): [99, 400, 549, 699, 850]
ts-quiet   চাপ=3  সময় (ms): [99, 549, 699]

মডেলটি অনুমান নয়: আমার lab-এর deb_all.c একই পাঁচটি পদ্ধতি C-তে board-এ চালায় (তিনটি SysTick-এ, দুটি EXTI0-এর ISR-এ), আর সত্যিকারের run-এ প্রতিটি সংখ্যা হুবহু এক এসেছে:

$ python -B board.py run build/deb_all.elf --script bounce_42.json
[  1000.0726 ms] UART: raw edges (EXTI ISR runs) = 20
[  1000.1617 ms] UART: ts-since-accept presses=5 at 99 400 549 699 850
[  1000.2268 ms] UART: ts-quiet-time   presses=3 at 99 549 699
[  1000.3171 ms] UART: poll-no-filter  presses=5 at 100 550 700 703 851
[  1000.3726 ms] UART: shift-reg-8     presses=2 at 107 710
[  1000.4281 ms] UART: counter-N5      presses=2 at 104 706

Seed 7 আর 2026 দিয়েও চালানো হয়েছে: দুই ক্ষেত্রেই shift-register আর counter ঠিক ২টি চাপ, filter ছাড়া কোড ৪ আর ৬টি, ts-since-accept ৫টি। Counter shift-register-এর চেয়ে আগে মেনেছে (104 বনাম 107, 706 বনাম 710), কারণ তার N ছোট আর একটি উল্টো নমুনা পুরো ঘড়ি নতুন করে শুরু করায় না। ISR-এর পদ্ধতিতে সময় 99, কারণ 100.0 ms-এর edge-এর মুহূর্তে SysTick-এর 100তম tick (100.005 ms-এ) তখনো আসেনি।

৫ · ISR-এ debounce, না periodic task-এ?

অনেকে প্রথমে ভাবেন, বোতাম মানেই interrupt: প্রতিটি edge-এ ISR, আর ISR-এ সময় দেখে সিদ্ধান্ত। একে বলে time-stamp debouncer. তার দুটি রূপ ওপরের তুলনায় আছে। প্রথম রূপ (ts-since-accept): “শেষ মানা চাপের পরে 20 ms গেলে rising edge-কে চাপ ধরা হবে”। এটি ছাড়ার লাফের rising edge-কেও চাপ ভাবে (400 আর 850 ms), কারণ শেষ চাপ তখন শত ms আগের। আর 550 ms-এর spike-ও চাপ। ফল ৫টি, ৩টি ভুল। দ্বিতীয় রূপ (ts-quiet): “আগের যেকোনো edge থেকে 20 ms নীরবতা থাকলে তবেই”। ছাড়ার লাফ এতে বাদ পড়ে, কিন্তু spike বাদ পড়ে না, কারণ spike-এর আগে লাইন অনেকক্ষণ শান্ত ছিল। শিক্ষা: প্রথম edge-এ সিদ্ধান্ত দ্রুত, কিন্তু noise আর আসল চাপকে আলাদা করতে হলে কিছুক্ষণ পরে আবার দেখতেই হয়।

তার চেয়েও বড় ঝুঁকি ISR-এর ভেতরে অপেক্ষা করা। ইন্টারনেটে প্রচলিত একটি নকশা: EXTI ISR-এ ঢুকে 20 ms অপেক্ষা, তারপর pin পড়া। আমার lab-এর isr_wait.c ঠিক তাই করে, অপেক্ষা গোনে SysTick-এর ms_ticks দিয়ে। Board-এ দুটির priority-ই 0, আর সমান priority কখনো preempt করে না (Spec decision 19):

$ python -B board.py run build/isr_wait.elf --script bounce_42.json --cycles 16000000
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0243 ms] UART: waiting inside the ISR
[  2000.0000 ms] stopped: cycle limit (16000000) reached after 16000000 cycles

100 ms-এ প্রথম চাপে ISR ঢুকেছে, আর বেরোয়নি: SysTick ISR-এর শেষ হওয়ার অপেক্ষায়, আর ISR SysTick-এর tick-এর অপেক্ষায়। 1000 ms-এ যে summary ছাপার কথা, তা 2000 ms-এও আসেনি। এবার EXTI0-কে priority 2 দিলে (SysTick 0 আগে ঢুকতে পারে) firmware চলে, কিন্তু presses = 4, আসল চাপ ২টি। কারণ: ISR-এর 20 ms অপেক্ষার মধ্যে বাকি লাফগুলো EXTI-এর PR আবার বসিয়ে দেয়, আর ISR ফেরার সঙ্গে সঙ্গে আবার ঢোকে; তখনো বোতাম চাপা, তাই আরেকটি “চাপ”। এর সঙ্গে presses ভ্যারিয়েবলটি volatile নয়, যা পর্ব ৩৪-এর আরেক ফাঁদ। ISR-এর নিয়ম (ছোট, অপেক্ষা নয়, flag দিয়ে কাজ main-এ পাঠানো) পর্ব ৪৩ (Interrupt আর ISR নকশা)-এর বিষয়; এখানে শুধু debounce-এর দিক।

ভালো মিশ্র নকশা: edge জাগায়, timer যাচাই করে

Periodic task (SysTick-এ প্রতি 1 ms নমুনা, এক ধরনের polling) সরল আর নির্ভরযোগ্য, কিন্তু চাপ থাকুক বা না থাকুক প্রতি সেকেন্ডে ১০০০ বার CPU জাগায়। Battery-তে চলা যন্ত্রে এটি দামি; সেখানে CPU WFI-তে ঘুমিয়ে থাকে আর বোতামের edge-এ জাগে (low-power-এর বিস্তারিত পর্ব ৬০-এ)। দুয়ের মাঝের পথ: প্রথম edge-এ ISR শুধু EXTI0 বন্ধ করে (interrupt masking) আর সময় লিখে রাখে; timer 20 ms পরে pin একবার পড়ে সিদ্ধান্ত নেয়, জমে থাকা PR মুছে EXTI0 আবার খোলে। আমার lab-এর deb_hybrid.c-এর ISR:

void EXTI0_IRQHandler(void)
{
    EXTI->PR = 1u;
    isr_runs++;
    EXTI->IMR = 0u;                 /* ignore the rest of the bounce */
    armed_at = ms_ticks;
    waiting = 1u;
}
/* SysTick: if (waiting && ms_ticks - armed_at >= 20u) { read PA0 once;
   accept a press if 1 and it was 0; EXTI->PR = 1u; EXTI->IMR = 1u; } */
$ python -B board.py run build/deb_hybrid.elf --script bounce_42.json
[  1000.0757 ms] UART: EXTI ISR runs = 5, presses = 2 at 119 719

সত্যিকারের run: ২০টি edge-এর জায়গায় ISR চলেছে মাত্র ৫ বার (দুটি চাপ, দুটি ছাড়া, একটি spike), আর spike-এর 20 ms পরে pin 0 পাওয়ায় সেটি বাতিল। দাম হলো দেরি, প্রায় 20 ms (119 আর 719 ms), আর একটি সীমা: 20 ms-এর চেয়ে ছোট আসল চাপ ধরা পড়বে না। এই উদাহরণে সরলতার জন্য SysTick সারাক্ষণ চলছে; low-power নকশায় timer শুধু অপেক্ষার সময় চালু রাখা হয়।

পদ্ধতিকোথায় চলেseed 42-এ চাপ (আসল ২)শক্তিদুর্বলতা
filter নেইperiodic৫সবচেয়ে দ্রুতধরা-পড়া প্রতিটি লাফ আর spike গোনে
counter (N = 5)periodic২ (104, 706)এক-আধটি উল্টো নমুনা সয়ে নেয়দেরি লাফের ওপর নির্ভর করে
shift-register (৮)periodic২ (107, 710)সরল, কঠোর একমতএকটি উল্টো নমুনা ঘড়ি নতুন করে শুরু করায়
time-stamp, শেষ চাপ থেকেEXTI ISR৫প্রথম edge-এ সাড়াছাড়ার লাফ আর spike-কে চাপ ভাবে
time-stamp, নীরবতা থেকেEXTI ISR৩ছাড়ার লাফ বাদspike বাদ পড়ে না; প্রতি edge-এ ISR
মিশ্র: edge জাগায়, timer যাচাইISR + timer২ (119, 719)কম ISR, ঘুমানো যায়দেরি বেশি; খুব ছোট চাপ হারায়

৬ · নমুনার সময় আর সংখ্যা বাছাই

Periodic debouncer-এর দুটি সংখ্যা: নমুনার সময় T আর পরপর কয়টি নমুনা লাগবে, N. দুয়ের গুণফল window = N × T, অর্থাৎ বোতামকে কতক্ষণ একটানা একমত থাকতে হবে। নিয়ম তিনটি:

  1. Window > সবচেয়ে লম্বা লাফের ফাঁক। চাপা অবস্থায় যদি সংযোগ 2.5 ms ছিন্ন থাকে, আর window 2 ms হয়, তাহলে debouncer “ছাড়া” মেনে নেবে, আর পরে আবার “চাপা”: একটি চাপ দুটি।
  2. দেরি মানুষ টের পাবে না এমন। চাপ মানতে লাগে মোটামুটি (N − 1) × T থেকে N × T, লাফ থাকলে আরও। কয়েক ms থেকে কয়েক দশ ms সাধারণত কেউ টের পান না; বহুল ব্যবহৃত একটি হাতের নিয়ম হলো দেরি কয়েক দশ ms-এর মধ্যে রাখা, তবে এটি প্রয়োগ আর মানুষভেদে আলাদা, কোনো বাঁধা মান নয়।
  3. T নিজে খুব ছোট নয়। T যত ছোট, প্রতি সেকেন্ডে তত বেশি ISR আর তত বেশি নমুনা লাফের ভেতর পড়ে। আবার T খুব বড় হলে একটি ছোট চাপ দুই নমুনার ফাঁকে হারাতে পারে।

প্রথম নিয়মটি board-এ পরীক্ষা করা হলো। button.c-এর একটি কপিতে শুধু SysTick-এর LOAD বদলে T = 0.25 ms (LOAD = 8000000 / 4000 − 1 = 1999), N একই ৮, তাই window 2 ms. Script-এ একটি চাপ, যার মাঝে 103.0 থেকে 105.5 ms পর্যন্ত 2.5 ms-এর একটি লম্বা ফাঁক:

$ python -B board.py run build/button_fast.elf --script long_bounce.json
[     0.0380 ms] UART: button demo: 8 samples x 0.25 ms = 2 ms
[   100.0000 ms] > button pressed
[   101.7614 ms] GPIO PA5 LED ON
[   101.8199 ms] UART: press 1 accepted at tick=407, raw edges so far: 1
[   103.0000 ms] > button released
[   105.5000 ms] > button pressed
[   107.2614 ms] GPIO PA5 LED OFF
[   107.3199 ms] UART: press 2 accepted at tick=429, raw edges so far: 3
[   300.0000 ms] > button released
[  1000.0579 ms] UART: summary: raw edges = 4, debounced presses = 2

সত্যিকারের run: একটি চাপ, দুটি “accepted”, আর LED জ্বলে আবার নিভে গেছে, যেন দুবার চাপা। একই script reference-এর 1 ms × 8 (window 8 ms) firmware-এ দিলে ফল press 1 accepted at t=113 ms আর debounced presses = 1: 100–102 ms-এর তিনটি 1, 103–105 ms-এর তিনটি 0, তারপর 106 থেকে 113 ms-এর ৮টি 1. Window ফাঁকের চেয়ে বড় হওয়ায় ফাঁকটি শুধু দেরি বাড়িয়েছে, ভুল চাপ নয়।

Debouncer-কে firmware-এ বসানোর আগে host-এ পরীক্ষা করা সহজ, কারণ এটি শুধু একটি ছোট state machine (state machine-এর সাধারণ নকশা Theory of Computation পর্ব ২৪-এ)। নিচের C program counter debouncer-কে একটি reusable function বানিয়ে seed 42-এর আসল নমুনা দিয়ে চালায়, N বদলে বদলে:

#include <stdio.h>
#include <stdint.h>

typedef struct { uint8_t count, state, n; } debounce_t;

/* call every sample period; returns 1 once per accepted press */
static int debounce_step(debounce_t *d, int raw)
{
    if (raw) { if (d->count < d->n) d->count++; }
    else if (d->count) d->count--;
    if (!d->state && d->count == d->n) { d->state = 1; return 1; }
    if (d->state && d->count == 0) d->state = 0;
    return 0;
}

static void run(const char *name, const char *s, uint8_t n)
{
    debounce_t d = {0, 0, n};
    int presses = 0;
    printf("%-8s N=%u:", name, (unsigned)n);
    for (int k = 0; s[k]; k++)
        if (debounce_step(&d, s[k] == '1')) { presses++; printf(" @%d", k); }
    printf("  presses=%d\n", presses);
}

int main(void)
{   /* seed-42 1 ms samples: 698..711 ms, then 846..857 ms */
    const char *s = "00110111111111" "111101000000";
    run("bouncy", s, 5);
    run("bouncy", s, 2);
    run("bouncy", s, 1);
    run("spike", "0001000000", 5);
    return 0;
}

আসল আউটপুট:

bouncy   N=5: @8  presses=1
bouncy   N=2: @3  presses=1
bouncy   N=1: @2 @5 @19  presses=3
spike    N=5:  presses=0

নমুনার স্ট্রিং দুই টুকরা: সূচক ০ = 698 ms থেকে ১৩ = 711 ms, তারপর সূচক ১৪ = 846 ms থেকে. N = 5-এ সূচক ৮ = 706 ms, board-এর counter-এর সঙ্গে এক। N = 1 মানে filter নেই: সূচক ২, ৫ আর ১৯ = 700, 703 আর 851 ms, ঠিক board-এর poll-no-filter-এর তিনটি ভুল-সমেত মান। N = 2 এই নমুনায় পার পেয়েছে, কিন্তু তা এই একটি লাফের ভাগ্য; ২টি পরপর উল্টো নমুনা এলেই ভাঙবে। একই function lab-এ Clang (ziglang 0.17.1) দিয়ে host-এ compile করে একই আউটপুট পাওয়া গেছে; এটিই “আগে host-এ test, তারপর hardware” পদ্ধতি (পর্ব ৬৪-এ বিস্তারিত)।

নকশার সূত্র

window = N × T > সবচেয়ে লম্বা bounce-এর ফাঁক (নিরাপত্তার মার্জিন সহ) · চাপ মানার দেরি ≈ (N − 1) × T থেকে N × T, লাফ থাকলে বেশি · SysTick-এর LOAD = SystemCoreClock × T − 1 (8 MHz-এ T = 1 ms → 7999). সাধারণ শুরু: T = 1–5 ms, window 10–20 ms, তারপর আসল বোতামে যাচাই।

৭ · Hardware debouncing — RC আর Schmitt trigger

কখনো software-এ debounce সম্ভব নয় বা যথেষ্ট নয়: বোতাম যদি সরাসরি একটি counter chip, একটি flip-flop-এর clock বা একটি reset pin-এ যায়, বা CPU ঘুমে থাকে আর প্রতিটি লাফে জেগে উঠলে battery খরচ হয়। তখন লাফগুলো বর্তনীতেই মসৃণ করা হয়। সবচেয়ে প্রচলিত উপায় একটি RC low-pass filter আর তার পরে একটি Schmitt trigger.

ছবি ৪২.২ — RC আর 74HC14 দিয়ে debounce

বোতাম GND-তে (active-low); Schmitt inverter উল্টে দেয়, তাই PA0-তে চাপলে 1, বাজারঘর board-এর মতো

RC + Schmitt trigger debounce বর্তনী VCC 4.5 V R1 10 kΩ A বোতাম R2 100 kΩ B C 100 nF 74HC14 PA0 চাপলে 1 চাপলে: C খালি হয় R2 দিয়ে, τ = R2·C = 10 ms ছাড়লে: C ভরে R1 + R2 দিয়ে, τ = 11 ms B ধীরে চলে; 74HC14-এর দুই সীমা একটিই বদল দেয়
ছবি ৪২.২ — উদাহরণের বর্তনী, board-এ মডেল করা নয়: মানগুলো এই পর্বের হিসাবের জন্য বেছে নেওয়া। R2 বোতাম চাপলে C-কে সরাসরি শর্ট হতে দেয় না, তাই discharge-ও ধীর আর সুইচের ভেতর দিয়ে হঠাৎ বড় current যায় না।

বর্তনীর গল্প: বোতাম খোলা থাকলে C ধীরে R1 + R2 দিয়ে VCC পর্যন্ত ভরে, বিন্দু B উঁচু, inverter-এর output 0. বোতাম চাপলে A শূন্যে নামে, C খালি হতে থাকে R2 দিয়ে। কতটা দ্রুত, তা বলে time constant τ = R × C: এক τ সময়ে খালি হওয়া C-এর ভোল্টেজ শুরুর প্রায় ৩৭%-এ নামে। লাফ মানে A কয়েকবার 0 আর VCC-র মাঝে দোলে, কিন্তু 0.1–0.9 ms-এর লাফে 10 ms-এর τ-এর C প্রায় কিছুই টের পায় না; B ধীরে, প্রায় সরলভাবে নামে।

তাহলে Schmitt trigger কেন? B-এর ধীর ঢাল যখন একটি সাধারণ logic input-এর threshold-এর কাছে, তখন একটু noise-ই output-কে কয়েকবার 0-1 করে দেয়, যেন bounce ফিরে এল; আর CMOS input মাঝামাঝি ভোল্টেজে বেশিক্ষণ থাকা তার জন্য ভালো নয়। Schmitt trigger-এর দুটি threshold: ওঠার সময় VT+ পার হলে তবে বদল, নামার সময় VT− পার হলে তবে, আর মাঝের ফাঁকটি (hysteresis) noise গিলে ফেলে। Texas Instruments-এর SN74HC14 datasheet (SCLS085L, ১৯৮২-এর, সংশোধন ফেব্রুয়ারি ২০২৫) VCC = 4.5 V আর 25 °C-এ দেয়: VT+ min 1.55, typ 2.5, max 3.13 V; VT− min 0.9, typ 1.6, max 2.45 V; hysteresis min 0.4 V. Datasheet শুধু 2, 4.5 আর 6 V-এর টেবিল দেয়, তাই হিসাব VCC = 4.5 V ধরে।

উদাহরণ: R1 = 10 kΩ, R2 = 100 kΩ, C = 100 nF. বোতাম চাপার কত পরে PA0 = 1 হবে, আর ছাড়ার কত পরে 0?

  1. Discharge τd = R2 × C = 100 kΩ × 100 nF = 10 ms. Charge τc = (R1 + R2) × C = 110 kΩ × 100 nF = 11 ms.
  2. চাপলে V(t) = VCC × e−t/τd. VT− = 1.6 V-এ: t = τd × ln(VCC / VT−) = 10 ms × ln(4.5 / 1.6) = 10 ms × 1.034 ≈ 10.34 ms.
  3. ছাড়লে V(t) = VCC × (1 − e−t/τc). VT+ = 2.5 V-এ: t = −τc × ln(1 − 2.5 / 4.5) = 11 ms × ln 2.25 ≈ 8.92 ms.
  4. খারাপতম threshold-এ: চাপলে VT− max 2.45 V → 6.08 ms, min 0.9 V → 16.09 ms; ছাড়লে VT+ min 1.55 V → 4.64 ms, max 3.13 V → 13.08 ms. নকশা নিরাপদ হতে হলে সবচেয়ে ছোট সময় (4.64 ms) সবচেয়ে লম্বা লাফের চেয়ে বড় রাখতে হবে।
  5. চাপা অবস্থায় R1 দিয়ে স্থির current = 4.5 V / 10 kΩ = 0.45 mA; খুব ছোট, কিন্তু battery-র যন্ত্রে বোতাম চেপে রাখলে এটিও হিসাবে আসে।
বিন্দু B আর inverter-এর output Y
সময়
বোতাম
V(B)
Y (PA0)
মন্তব্য
  1. অপেক্ষা। বোতাম খোলা, C পুরো ভরা, V(B) = 4.5 V. Inverter-এর input উঁচু, তাই Y = 0.
  2. প্রথম স্পর্শ। 700.0 ms-এ সংযোগ লাগল; A এখন 0 V, C R2 দিয়ে খালি হতে শুরু করে, τ = 10 ms.
  3. প্রথম লাফ। 0.1 ms পরেই সংযোগ ছাড়া। এর মধ্যে V নেমেছে মাত্র 4.500 থেকে 4.455 V: 0.1 ms হলো τ-এর এক শতাংশ।
  4. আবার লাগা। 700.1–700.2 ms খোলা অবস্থায় C আবার একটু ভরেছে (4.456 V), এবার আবার খালি হওয়া শুরু। লাফগুলো B-তে শুধু হালকা ঢেউ।
  5. আরও লাফ। 700.4 ms-এ 4.367 V, 700.8 ms-এ 4.372 V, আর 701.2 ms-এ শেষবার খোলার মুহূর্তে 4.201 V. Threshold-এর ধারেকাছেও নেই, তাই Y নড়েনি।
  6. স্থির সংযোগ। 702.1 ms থেকে বোতাম চাপা, V = 4.224 V থেকে মসৃণভাবে নামছে। VT− পর্যন্ত সময় = 10 ms × ln(4.224 / 1.6) = 9.71 ms.
  7. মাঝামাঝি। 708.40 ms-এ V = 2.25 V = VCC-র অর্ধেক। একটি মাত্র threshold-এর input এখানে বদলাত, আর ±50 mV noise-এর মডেলে সেটি ১১ বার কেঁপেছে। Schmitt-এর VT− এখনো নিচে।
  8. VT− পার। 711.81 ms-এ V = 1.6 V: Y = 1, একবারই। চাপ থেকে দেরি 11.81 ms, শেষ লাফ থেকে 9.71 ms. Software-এর counter একই চাপ মেনেছিল 706 ms-এ।
  9. ছাড়া। 850.0 ms-এ বোতাম খোলে, 850.9–851.3 ms আরেকবার লাগে (লাফ), তারপর স্থির খোলা। 851.3 ms-এ V মাত্র 0.340 V, এখান থেকে R1 + R2 দিয়ে ভরা শুরু, τ = 11 ms.
  10. VT+ পার। 859.36 ms-এ V = 2.5 V: Y = 0, আবার একবারই। এক চাপ, দুটি পরিষ্কার বদল। সব মান lab-এর rc.py-এ সঠিক সূত্রে হিসাব করা।
# RC + Schmitt trigger: SN74HC14-এর 4.5 V-এর typical threshold
import math, random
VCC, R1, R2, C = 4.5, 10e3, 100e3, 100e-9
VTP, VTN = 2.5, 1.6                       # VT+ আর VT− (typ, 25 °C)
td = R2 * C * 1e3                         # চাপলে discharge, ms
tc = (R1 + R2) * C * 1e3                  # ছাড়লে charge, ms
print(f"tau: discharge {td:.1f} ms, charge {tc:.1f} ms")
print(f"চাপ থেকে VT- পর্যন্ত: {td * math.log(VCC / VTN):.2f} ms")
print(f"ছাড়া থেকে VT+ পর্যন্ত: {-tc * math.log(1 - VTP / VCC):.2f} ms")

sw_edges = [(700.0, 1), (700.1, 0), (700.2, 1), (700.4, 0), (700.8, 1),
            (701.2, 0), (702.1, 1)]       # seed 42-এর দ্বিতীয় চাপ
rng = random.Random(1)
v, sw, i, dt = VCC, 0, 0, 0.01            # 0.01 ms-এর ধাপ
schmitt = plain = 0
s_edges, p_edges = [], []
for n in range(69900, 72000):             # 699.00 .. 719.99 ms
    t = n / 100
    while i < len(sw_edges) and sw_edges[i][0] <= t:
        sw = sw_edges[i][1]; i += 1
    v += ((0 if sw else VCC) - v) * (1 - math.exp(-dt / (td if sw else tc)))
    vn = v + rng.uniform(-0.05, 0.05)     # ±50 mV noise
    new = 1 if vn < VTN else 0 if vn > VTP else schmitt
    if new != schmitt: schmitt = new; s_edges.append(t)
    newp = 1 if vn < 2.25 else 0          # একটি মাত্র threshold
    if newp != plain: plain = newp; p_edges.append(t)
print("Schmitt output-এর বদল:", len(s_edges), s_edges)
print("এক-threshold-এর বদল:", len(p_edges), p_edges[:6], "...")

আসল আউটপুট (ব্রাউজারের Python):

tau: discharge 10.0 ms, charge 11.0 ms
চাপ থেকে VT- পর্যন্ত: 10.34 ms
ছাড়া থেকে VT+ পর্যন্ত: 8.92 ms
Schmitt output-এর বদল: 1 [711.64]
এক-threshold-এর বদল: 11 [708.32, 708.34, 708.35, 708.38, 708.4, 708.41] ...

প্রথম তিন লাইন ওপরের হাতের হিসাব। Noise যোগ করায় Schmitt-এর বদল 711.64 ms-এ, noise-ছাড়া হিসাবের 711.81 ms-এর সামান্য আগে, কারণ একটি নিচের দিকের noise-এর ঝাঁকুনি আগেই VT− ছুঁয়েছে; কিন্তু বদল একটিই। একটি মাত্র threshold (2.25 V) হলে, V যখন ধীরে সেই সীমা পেরোচ্ছে, ±50 mV noise-এ output 708.32 থেকে ১১ বার উল্টেছে: hardware-এর ভেতরে নতুন করে “bounce”. এটি একটি সরল গাণিতিক মডেল, আসল chip-এর মাপ নয়; noise-এর মান উদাহরণের জন্য ধরা।

আরেকটি পুরোনো hardware পদ্ধতি দুই-দিকের (SPDT) সুইচ আর একটি SR latch: সুইচ একটি contact ছেড়ে অন্যটিতে যাওয়ার পথে লাফালেও কখনো উল্টো contact ছোঁয় না, তাই latch প্রথম স্পর্শেই বদলায় আর লাফে নড়ে না। এর logic Computer Architecture পর্ব ১৫-এ। আর অনেক microcontroller-এর digital input-এ নিজস্ব ছোট hysteresis থাকে; তার মান chip-এর datasheet-এ দেখতে হয়, তবে সেটি সাধারণত RC-র ধীর ঢালের জন্য যথেষ্ট নয় বলে ধরে নেওয়াই নিরাপদ। 3.3 V-এর বর্তনীতে 3.3 V-এর জন্য বৈশিষ্ট্য দেওয়া কোনো Schmitt chip বেছে তার datasheet-এর threshold দিয়ে একই হিসাব করুন।

নিরাপত্তা: এই পর্বের সব বর্তনী কম ভোল্টেজের (৩.৩–৫ V) logic-এর জন্য। ঘরের mains-এর সুইচ বা relay-এর contact-এর সংকেত কখনো সরাসরি microcontroller-এ আনবেন না; সেখানে isolation (যেমন optocoupler) আর অভিজ্ঞ কারও নকশা লাগে। লম্বা তারে বোতাম থাকলে ESD আর noise-এর জন্য series resistor আর সুরক্ষার কথা পর্ব ৪১-এ।

আরও গভীরে: Schmitt trigger-এর নাম মার্কিন বিজ্ঞানী Otto H. Schmitt-এর নামে; তিনি ১৯৩০-এর দশকে, ছাত্রাবস্থায়, স্নায়ুর সংকেত নিয়ে কাজের সময় vacuum tube দিয়ে এটি বানান, আর ১৯৩৮ সালের দিকে প্রকাশ করেন (সূত্রভেদে বছর সামান্য আলাদা)। একই hysteresis-এর ধারণা বাজারঘরের cold room-এর alarm-এও আছে: 8.00 °C-এর ওপরে চালু, কিন্তু 7.50 °C-এর নিচে না নামা পর্যন্ত বন্ধ নয়, আর ৩টি পরপর reading-এর নিশ্চিতকরণ আসলে সময়ের দিকে একটি debouncer. আর একটি সূক্ষ্মতা: বোতাম CPU-র clock-এর সঙ্গে মিল রেখে চাপা হয় না, তাই ঠিক sampling-এর মুহূর্তে বদলালে flip-flop metastability-তে পড়তে পারে; chip-এর input পথে সাধারণত synchronizer থাকে (Computer Architecture পর্ব ১৮)।

পরীক্ষা ও ইন্টারভিউতে: (১) “Switch bounce কী, আর কেন সমস্যা?” → চাপা-ছাড়ার মুহূর্তে contact কয়েক ms লাফায়, edge বা সরল polling একটি চাপকে কয়েকটি গোনে। (২) “দুটি software debounce লিখুন” → counter (N পর্যন্ত গুনে, ০ পর্যন্ত নেমে) আর shift-register, যেখানে শেষ N নমুনা সব 1 বা সব 0 হতে হয়। (৩) “RC debounce-এ R = 100 kΩ, C = 100 nF হলে τ?” → 10 ms; VT− পর্যন্ত t = τ × ln(VCC / VT−)। (৪) “Schmitt trigger কেন?” → দুই threshold-এর hysteresis ধীর বা noisy ঢালে একটিই বদল দেয়। (৫) “ISR-এ delay_ms(20) দিলে?” → ISR আটকে যায়, অন্য interrupt দেরি বা deadlock, আর অপেক্ষার মধ্যে আসা edge আবার ISR চালায়; বরং flag আর timer.

৮ · AI-এর যুগে debounce-এর কোড যাচাই

“Arduino-তে button debounce” লিখলে AI assistant এক মুহূর্তে কোড দেয়, আর সেটি টেবিলে একবার চেপে দেখলে প্রায়ই কাজও করে। গোলমাল লুকিয়ে থাকে খারাপ বোতাম, noise আর interrupt-এর সঙ্গে মেলামেশায়। সবচেয়ে চেনা ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
ISR-এর ভেতরে delay() বা busy-wait দিয়ে debouncePriority আর tick-এর উৎস দেখুন; board-এ চালালে সমান priority-তে আটকে যায়
“শেষ চাপের পরে X ms” ধরনের time-stamp, যা ছাড়ার লাফকে চাপ ভাবেছাড়ার লাফ আর spike-সহ seed দেওয়া script দিয়ে চাপ গুনুন
ISR আর main-এর ভাগ করা flag volatile নয়, বা RMW অরক্ষিতClang-এর -S আর পর্ব ৩৪–৩৫-এর নিয়ম
নির্দিষ্ট chip-এর EXTI/GPIO register-এর নাম বা বিট বানিয়ে বলেChip-এর reference manual আর vendor header মিলিয়ে দেখুন
“bounce 1 ms-এর বেশি নয়” বা RC-এর সময় ভুল সূত্রেτ = R × C আর ln-এর সূত্রে নিজে হিসাব; datasheet-এর min/max threshold দিয়ে খারাপতম ঘটনা
Schmitt ছাড়া RC সরাসরি সাধারণ input-এধীর ঢালে noise মডেল করে বদল গুনুন (অংশ ৭-এর block)

AI-কে প্রসঙ্গ, সংখ্যা আর যাচাইয়ের শর্ত শুরুতেই দিন:

আমি ARM Cortex-M3-এর firmware লিখছি (C, Clang -O2, 8 MHz). PA0-তে একটি push button, চাপলে 1. SysTick প্রতি 1 ms-এ interrupt দেয়। ১. SysTick-এর ISR থেকে প্রতি 1 ms-এ ডাকার মতো একটি counter debouncer লেখো (N = 5), যা প্রতি চাপে main-কে একবার জানায়; ISR-এ কোনো অপেক্ষা বা printf রাখবে না, ভাগ করা ভ্যারিয়েবল volatile রাখবে। ২. Window, চাপ মানার সর্বনিম্ন আর সর্বোচ্চ দেরি হিসাব করে দেখাও। ৩. এই নমুনা-স্ট্রিং (প্রতি 1 ms) দিয়ে হাতে trace করো আর বলো কোন সূচকে চাপ মানা হবে: 00110111111111 ৪. RC debounce-এ R2 = 100 kΩ, C = 100 nF, VCC = 4.5 V, Schmitt-এর VT- = 1.6 V হলে চাপার কত পরে output বদলাবে, সূত্রসহ। ৫. কোনো নির্দিষ্ট chip-এর register বা threshold নিয়ে নিশ্চিত না হলে বলো "নিশ্চিত নই, datasheet দেখুন"; মান বানিয়ে বলবে না।

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

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১“Bounce সাধারণত ১ ms-এর কম” — এই ধারণা কেন টেকে না, আর একজন firmware প্রকৌশলী কোন সংখ্যা ধরে নকশা করবেন?

Bounce একটি যান্ত্রিক ঘটনা, তাই তার দৈর্ঘ্য কোনো logic family-র মতো একটি সংখ্যায় বাঁধা নয়। ধাতব পাতের ভর, স্প্রিংয়ের শক্তি, contact-এর ধাতু আর তার ওপরের অক্সাইডের স্তর, চাপার গতি, এমনকি তাপমাত্রা সবই ফল বদলায়। নতুন বোতামে যা ০.৫ ms, কয়েক বছর ব্যবহারের পরে, ধুলো আর আর্দ্রতায়, তা কয়েক গুণ হতে পারে। চাপা আর ছাড়ার bounce-ও আলাদা; কিছু সুইচ ছাড়ার সময় অনেক বেশি লাফায়।

Jack Ganssle-এর পরিচিত পরীক্ষায় বিভিন্ন সুইচ শতাধিকবার চেপে মাপা হয়েছিল। সেই ফল নিয়ে লেখা বিভিন্ন সূত্রে গড় প্রায় 1.6 ms আর বেশিরভাগের সর্বোচ্চ প্রায় 6.2 ms পাওয়া যায়, আর কয়েকটি ব্যতিক্রমী সুইচ এর চেয়েও অনেক বেশি লাফিয়েছে। এই পর্বের board-এর পরীক্ষাও দেখিয়েছে, একটি মাত্র 2.5 ms-এর ফাঁক 2 ms window-এর debouncer-কে বোকা বানায়। তাই “গড়” দিয়ে নকশা করা মানে প্রতি কয়েকশো চাপে একটি ভুল মেনে নেওয়া।

ব্যবহারিক পথ তিনটি ধাপের। প্রথমে বোতামের datasheet দেখা: অনেক নির্মাতা bounce time-এর একটি সর্বোচ্চ মান দেন, যদিও মাপার শর্ত আলাদা হতে পারে। দ্বিতীয়ত, সম্ভব হলে oscilloscope বা logic analyzer দিয়ে কয়েকটি নমুনা বোতাম বহুবার মাপা, চাপা আর ছাড়া দুই দিকেই। তৃতীয়ত, পাওয়া খারাপতম মানের ওপর মার্জিন: window সাধারণত তার দুই-তিন গুণ, যেমন 10–20 ms, কারণ এতে দেরি এখনো মানুষের কাছে অদৃশ্য। যন্ত্রের আয়ু আর পরিবেশ (বাজারের ধুলো, কোল্ড রুমের আর্দ্রতা) কঠিন হলে আরও বেশি।

আর একটি কথা: debouncer-কে এমন নকশা করুন যাতে window একটি constant বদলেই বাড়ানো যায়, আর test-এ seed দেওয়া খারাপ লাফের script থাকে। মাঠ থেকে “মাঝে মাঝে দুবার গোনে” অভিযোগ এলে তখন পুরো নকশা নয়, একটি সংখ্যা বদলাতে হবে।

মূল উপলব্ধি: Bounce-এর দৈর্ঘ্য বোতাম, বয়স আর পরিবেশ-নির্ভর একটি বণ্টন; গড় নয়, মাপা বা datasheet-এর খারাপতম মানের ওপর মার্জিন রেখে window বাছাই করতে হয়।

প্র ০২8085-এর যুগে বোতাম প্রায়ই RST 7.5-এর মতো edge-input-এ বা 8255-এর keypad-এ যেত। তখনকার আর এখনকার debounce-এর পথ কীভাবে আলাদা, আর কেন?

১৯৭০-৮০-এর দশকের একটি 8085 system-এ CPU-র ভেতরে কোনো timer peripheral ছিল না; সময় মাপতে হতো software delay loop দিয়ে (পর্ব ১১-এর 14N + 4 T-state-এর হিসাব) বা বাইরের 8253 timer দিয়ে। Keypad scan করার প্রচলিত পথ ছিল: একটি key চাপা দেখলে কয়েক ms-এর delay loop চালানো, তারপর আবার scan করে মেলানো; মিললে তবেই key মানা। CPU-র তখন অন্য কাজ কম, তাই কয়েক ms আটকে থাকা সহ্য করা যেত। পর্ব ২৪-এর 8255 keypad-এর নকশা এই ধারার।

RST 7.5 ছিল edge-sensitive আর ভেতরে একটি flip-flop-এ latch করা। বোতাম সরাসরি সেখানে দিলে প্রতিটি লাফ একটি নতুন edge, আর ISR শেষ হতে না হতেই flip-flop আবার বসে থাকত। তাই সেই যুগে hardware debounce প্রায় অপরিহার্য ছিল: SPDT সুইচের সঙ্গে SR latch, বা RC আর Schmitt trigger chip (TTL-এর 74LS14, পরে CMOS-এর 74HC14 ধরনের)। TI-এর SN74HC14-এর datasheet-এর প্রথম তারিখ ১৯৮২; এই chip-এর প্রয়োগের তালিকায় আজও “debounce a switch” লেখা আছে।

আজকের microcontroller-এ ছবিটি বদলেছে। SysTick-এর মতো timer core-এর অংশ, EXTI-এর মতো edge-detector প্রতিটি pin-এ, আর একটি bit-এর হিসাব প্রায় খরচহীন। ফলে বেশিরভাগ ভোক্তা-যন্ত্রে debounce software-এ সরে এসেছে: বাড়তি যন্ত্রাংশ নেই, board-এ জায়গা লাগে না, আর window একটি constant-এ বদলানো যায়। কিন্তু hardware পথ মরে যায়নি। Reset pin, সরাসরি counter বা flip-flop-এ যাওয়া সংকেত, শিল্প-পরিবেশের লম্বা তার, আর ঘুমন্ত CPU যেখানে প্রতিটি লাফে জাগলে battery খরচ হয়, সেখানে RC বা Schmitt এখনো বেছে নেওয়া হয়। অনেক নকশায় দুটোই থাকে: হালকা RC noise কমায়, software শেষ সিদ্ধান্ত নেয়।

মূল পার্থক্য তাই প্রযুক্তির চেয়ে খরচের ভারসাম্যে: আগে CPU-র সময় সস্তা আর যন্ত্রাংশ দরকারি ছিল; এখন CPU-র একটি ছোট ISR প্রায় বিনামূল্যে, কিন্তু প্রতিটি বাড়তি যন্ত্রাংশ উৎপাদন আর জায়গার খরচ।

মূল উপলব্ধি: Debounce-এর যুক্তি একই রয়েছে, বদলেছে কোথায় তা সস্তা: পুরোনো যুগে delay loop আর বাইরের chip, আজ timer-এর একটি ছোট state machine, আর hardware শুধু যেখানে software পৌঁছাতে পারে না।

প্র ০৩Battery-তে চলা একটি বাজারঘর-ধাঁচের যন্ত্রে বোতাম পড়তে polling, edge interrupt আর মিশ্র নকশার মধ্যে কোনটি বেছে নেবেন? Latency, শক্তি আর নির্ভরযোগ্যতা মিলিয়ে বিচার করুন।

Periodic polling-এর সবচেয়ে বড় গুণ নির্ধারিত আচরণ। প্রতি 1 ms-এ একবার, প্রতিবার একই ছোট কাজ; লাফ যত বেশিই হোক ISR-এর সংখ্যা বাড়ে না, আর counter বা shift-register-এর যুক্তি সহজে test করা যায়। এই পর্বে board-এ এই দুটিই প্রতিটি seed-এ ঠিক ২টি চাপ দিয়েছে। দাম হলো শক্তি: চাপ না থাকলেও প্রতি সেকেন্ডে ১০০০ বার জাগা। Mains-এ চলা smart scale-এ এটি নগণ্য, কিন্তু coin cell-এ চলা একটি তাপমাত্রার logger-এ এটিই battery-র আয়ু ঠিক করে দিতে পারে (power budget-এর হিসাব পর্ব ৬২-এ)।

শুধু edge interrupt-এর গুণ উল্টো: চাপ না থাকলে CPU পুরো ঘুমায়, আর প্রথম edge-এ সঙ্গে সঙ্গে জাগে, তাই latency সবচেয়ে কম। কিন্তু লাফ মানে interrupt-এর ঝড়: board-এ দুটি চাপে ২০টি ISR. আর শুধু time-stamp দিয়ে সিদ্ধান্ত নিলে noise আর ছাড়ার লাফ চাপ হয়ে যায়, যা তুলনার টেবিলে দেখা গেছে। ESD বা কাছের motor-এর noise-এ ঘুমন্ত যন্ত্রের বারবার জাগাও শক্তি নষ্ট করে।

মিশ্র নকশা দুই জগতের ভালোটা নেয়: ঘুমের সময় শুধু edge-এর পাহারা; প্রথম edge-এ ISR line বন্ধ করে একটি timer চালু করে; timer-এর শেষে pin পড়ে সিদ্ধান্ত, তারপর line আবার খোলা। Board-এ ISR ৫ বার, চাপ ঠিক ২টি, আর spike বাতিল। এর সীমা দুটি: যাচাইয়ের সময়ের চেয়ে ছোট চাপ হারায়, আর একবার মাত্র পড়ায় যাচাইয়ের মুহূর্তে লাফ চললে ভুল হতে পারে; সমাধান হিসেবে timer চলার সময় কয়েকটি নমুনা নিয়ে counter চালানো যায়, তারপর timer বন্ধ।

কাজেই উত্তর প্রয়োজনভেদে: mains-এ চলা, সব সময় জেগে থাকা যন্ত্রে সরল periodic debouncer; battery-র যন্ত্রে মিশ্র নকশা; আর খুব কম latency-র দরকারে (যেমন একটি গেমের বোতাম) প্রথম edge-এ সাড়া দিয়ে পরে নিশ্চিত হওয়ার কৌশল, ভুল সাড়া ফিরিয়ে নেওয়ার ব্যবস্থাসহ। প্রতিটি ক্ষেত্রে ISR ছোট, অপেক্ষাহীন।

মূল উপলব্ধি: Polling নির্ভরযোগ্য কিন্তু শক্তি খায়, edge interrupt দ্রুত আর সাশ্রয়ী কিন্তু লাফে ঝড় তোলে; বাস্তব নকশা প্রায়ই edge দিয়ে জাগে আর timer দিয়ে যাচাই করে।

প্র ০৪Schmitt trigger-এর hysteresis, বাজারঘরের cold room-এর alarm-এর 0.50 °C hysteresis আর ৩ বার নিশ্চিতকরণ, আর software debouncer: এরা কি একই ধারণার ভিন্ন রূপ?

হ্যাঁ, আর এই মিলটি দেখতে পারা embedded নকশার একটি গুরুত্বপূর্ণ দক্ষতা। তিনটিরই সমস্যা এক: একটি সংকেত সীমার কাছে কাঁপছে, আর আমরা চাই প্রতিটি আসল বদলে ঠিক একটি সিদ্ধান্ত। সমাধানেরও দুটি মাত্রা: মানের দিকে ফাঁক আর সময়ের দিকে ধৈর্য।

Schmitt trigger মানের দিকে ফাঁক রাখে: 74HC14-এ 4.5 V-এ ওঠার সীমা typ 2.5 V, নামার 1.6 V. ভোল্টেজ যতক্ষণ এই দুইয়ের মাঝে, output আগের অবস্থায়। Otto Schmitt ১৯৩০-এর দশকে স্নায়ুর আবেগ নিয়ে কাজের সময় এই আচরণের একটি tube-বর্তনী বানিয়েছিলেন। Cold room-এর firmware ঠিক একই কাজ করে তাপমাত্রায়: 8.00 °C-এর ওপরে alarm, কিন্তু বন্ধ হবে 7.50 °C-এর নিচে নামলে; reference README-এর run-এ 7.75 °C-এর reading তাই কোনো দিকেই গোনা হয়নি। আবার ঘরের পুরোনো thermostat বা পানির ট্যাংকের পাম্পের float switch-ও এই কারণে দুটি আলাদা সীমায় চালু-বন্ধ হয়, নইলে পাম্প সীমার কাছে মুহূর্তে মুহূর্তে চালু-বন্ধ হতো।

সময়ের দিকে ধৈর্য হলো debouncer: counter বা shift-register N বার একমত না হলে সিদ্ধান্ত বদলায় না। Cold room-এর “৩টি পরপর reading” নিয়মটি ঠিক N = 3-এর একটি shift-register debouncer, শুধু নমুনার সময় 1 s. RC বর্তনী দুটোর মাঝামাঝি: এটি সময়ের ওপর গড় করে (low-pass), তারপর Schmitt মানের ফাঁক দেয়। Digital filtering-এর moving average (পর্ব ৬৮) একই পরিবারের সদস্য।

পার্থক্য দামের ধরনে। মানের ফাঁক কোনো দেরি যোগ করে না, কিন্তু ফাঁকের ভেতরের আসল ছোট বদল দেখতে দেয় না। সময়ের ধৈর্য যেকোনো মানের বদল দেখে, কিন্তু প্রতিটি সিদ্ধান্তে দেরি যোগ করে। তাই cold room-এ দুটিই আছে, আর ভালো hardware debounce-এও দুটি।

মূল উপলব্ধি: Hysteresis (মানের ফাঁক) আর debouncing (সময়ের ধৈর্য) একই সমস্যার দুই হাতিয়ার; বোতাম, তাপমাত্রা বা যেকোনো sensor-এ সীমার কাছে কাঁপা সংকেত সামলাতে দুটিকে চিনে মিলিয়ে ব্যবহার করুন।

প্র ০৫কোন বোতামে debounce-এর একটি ভুল নিছক বিরক্তি, আর কোন বোতামে বিপদ? Emergency stop-এর মতো নিরাপত্তার বোতাম কি software debouncer দিয়ে পড়া উচিত?

প্রথমে ফলের দিক থেকে ভাগ করা যায়। Smart scale-এর tare বোতাম দুবার গোনা হলে একই ওজন দুবার জমা হয়, কেউ টেরও পান না। একটি মেনুর “পরের” বোতাম দুবার গুনলে বিরক্তি, ক্রেতা আবার ফিরে আসেন। কিন্তু একটি দরজার lock-এর কোড, একটি ওষুধ দেওয়ার পাম্পের মাত্রা বাড়ানোর বোতাম, বা একটি যন্ত্র চালু-বন্ধের toggle-এ একটি চাপ দুটি হলে ফল উল্টে যায়: চালু চাপলে চালু হয়ে আবার বন্ধ, বা মাত্রা দুই ধাপ বাড়ে। এসব ক্ষেত্রে toggle-এর বদলে আলাদা “চালু” আর “বন্ধ” বোতাম, বা নিশ্চিতকরণ চাওয়া, debounce-এর সঙ্গে নকশার স্তরের সুরক্ষা।

ভুলের উল্টো দিকও আছে: আসল চাপ হারানো। Window বেশি বড় বা মিশ্র নকশার যাচাইয়ের সময় বেশি লম্বা হলে একটি দ্রুত চাপ হারাতে পারে; ভোক্তা-যন্ত্রে এতে ক্রেতা আবার চাপেন, কিন্তু একটি alarm থামানোর বোতামে এর মানে হতে পারে বিপদের সময় সাড়া না পাওয়া।

Emergency stop একটি আলাদা জগৎ। শিল্প-যন্ত্রে এমন বোতাম সাধারণত firmware-এর ওপর নির্ভর করে না: এর contact সরাসরি শক্তির পথ কাটে বা একটি নিরাপত্তা-relay-এর পথে যায়, প্রায়ই দুটি আলাদা contact দিয়ে (redundancy), আর software শুধু খবর পায়। কারণ software-এর debouncer, ISR বা গোটা firmware আটকে যেতে পারে, যেমন এই পর্বের board-এ ISR-এর ভেতরে অপেক্ষা পুরো firmware চিরতরে থামিয়ে দিয়েছিল। Functional safety-র মানদণ্ডগুলো (IEC 61508-এর মতো, পর্ব ৬৩-এ পরিচয়) এমন ঝুঁকির জন্য নির্দিষ্ট কাঠামো চায়। এখানে নির্দিষ্ট নিয়মের বিস্তারিত নয়, শুধু নীতি: যেখানে মানুষের নিরাপত্তা জড়িত, সেখানে একক software পথের ওপর ভরসা নয়।

তাই প্রতিটি বোতামের জন্য নকশার আগে তিনটি প্রশ্ন: দুবার গুনলে কী হবে? না গুনলে কী হবে? আর firmware আটকে গেলে কী হবে? উত্তর দেখে ঠিক হয় debounce-এর window, নকশার স্তরের সুরক্ষা, আর hardware-এর পথ লাগবে কি না।

মূল উপলব্ধি: Debounce-এর ভুলের দাম বোতামের কাজের ওপর নির্ভর করে; বিরক্তির বোতামে software যথেষ্ট, কিন্তু নিরাপত্তার বোতামে সুরক্ষা hardware আর নকশার স্তরে, software শুধু দর্শক।

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর lab-এ চালিয়ে বা হিসাব-script দিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — এক port-এর ৮টি বোতাম একসাথে: Smart scale-এ ৮টি বোতাম একটি ৮ বিটের port-এ (1 = চাপা)। একটি function uint8_t port_debounce(uint8_t raw) লিখুন, যা প্রতি 5 ms-এ ডাকা হবে, শেষ ৪টি নমুনা রাখবে, আর নতুন করে মানা চাপগুলোর বিট ফেরত দেবে। কোনো বোতাম তখনই চাপা, যখন ৪টি নমুনাই 1; ছাড়া, যখন ৪টিই 0; নইলে আগের অবস্থা। Window কত? পরীক্ষার input: bit0 (tare) লাফায় 0, 1, 0, 1, …; bit1 (rate) 25 ms থেকে পরিষ্কার; bit2-এ 20 ms-এ একটি মাত্র নমুনার spike.
    #define NS 4u                       /* last 4 samples, 5 ms apart */
    static uint8_t s[NS], idx, state;
    
    static uint8_t port_debounce(uint8_t raw)
    {
        uint8_t all1 = 0xFF, any1 = 0x00, old = state;
        s[idx] = raw;
        idx = (uint8_t)((idx + 1u) % NS);
        for (uint8_t i = 0; i < NS; i++) { all1 &= s[i]; any1 |= s[i]; }
        state = (uint8_t)((state & any1) | all1);   /* keep unless all agree */
        return (uint8_t)(state & ~old);             /* new presses only */
    }

    যুক্তি: all1 = ৪টি নমুনার AND, যে বিট ৪ বারই 1 তা 1; any1 = OR, যে বিট ৪ বারই 0 তা 0. নতুন state = (পুরোনো state AND any1) OR all1: সবাই 1 হলে বসে, সবাই 0 হলে মোছে, নইলে আগের মান। Window = 4 × 5 ms = 20 ms. Host-এ সত্যিকারের run (raw = 00, 01, 00, 01, 05, 03, 03, 03, 03, 02, 03, 00, …): t=30 ms raw=0x03 state=0x01 press: tare, t=40 ms raw=0x03 state=0x03 press: rate; 20 ms-এর spike (0x05-এর বিট ২) কখনো state-এ আসেনি; 45 ms-এ tare-এর একটি 0 (0x02) কিছু বদলায়নি; সব বোতাম ছাড়ার পরে 70 ms-এ state=0x00. সুবিধা: ৮টি বোতাম একসাথে, প্রতি নমুনায় কয়েকটি bitwise নির্দেশ।

  2. ভুল খুঁজুন — ISR-এ অপেক্ষা: একজন লিখলেন: static uint32_t presses; আর void EXTI0_IRQHandler(void) { EXTI->PR = 1u; uint32_t t0 = ms_ticks; while (ms_ticks - t0 < 20u) { } if ((GPIOA->IDR >> 0) & 1u) presses++; }, যেখানে ms_ticks SysTick-এর ISR বাড়ায়, আর দুই interrupt-এর priority সমান। বোতাম চাপলে কী হবে? EXTI-এর priority কম করে দিলে কী হবে? তিনটি ভুল লিখুন আর ঠিক নকশা বলুন।

    সমান priority-তে SysTick EXTI-এর ISR-কে preempt করতে পারে না (Cortex-M-এ সমান priority-র exception অপেক্ষা করে; বাজারঘর board-এ Spec decision 19), তাই ms_ticks আর বাড়ে না আর while চিরকাল ঘোরে। সত্যিকারের run (isr_wait.c, seed 42): শুধু waiting inside the ISR, তারপর stopped: cycle limit (16000000) reached, 1000 ms-এর summary কখনো আসেনি। EXTI-কে priority 2 দিলে (SysTick 0) firmware চলে, কিন্তু ফল presses = 4, আসল চাপ ২টি: অপেক্ষার মধ্যে লাফগুলো PR আবার বসায়, ISR ফিরেই আবার ঢোকে, বোতাম তখনো চাপা। ভুল তিনটি: (১) ISR-এর ভেতরে blocking অপেক্ষা; (২) অপেক্ষার মধ্যে জমা edge (PR) মোছা হয়নি বা line বন্ধ করা হয়নি; (৩) presses ISR আর main ভাগ করে কিন্তু volatile নয়। ঠিক নকশা: periodic counter বা shift-register debouncer, অথবা অংশ ৫-এর মিশ্র নকশা (ISR line বন্ধ করে সময় লেখে, timer পরে যাচাই করে, PR মুছে line খোলে), সব ভাগ করা ভ্যারিয়েবল volatile.

  3. হিসাব — নিজের RC বর্তনী: ছবি ৪২.২-এর বর্তনীতে R1 = 10 kΩ, R2 = 47 kΩ, C = 220 nF, VCC = 4.5 V, SN74HC14-এর typical threshold ধরুন: VT+ = 2.5 V আর VT− = 1.6 V. (ক) দুই τ কত? (খ) চাপার আর ছাড়ার কত পরে output বদলাবে? (গ) datasheet-এর min/max threshold ধরলে সময়ের সীমা কত? (ঘ) সবচেয়ে লম্বা লাফ 6.2 ms হলে নকশা কি নিরাপদ?

    (ক) τd = 47 kΩ × 220 nF = 10.34 ms; τc = 57 kΩ × 220 nF = 12.54 ms. (খ) চাপলে t = 10.34 × ln(4.5 / 1.6) ≈ 10.69 ms; ছাড়লে t = 12.54 × ln(4.5 / 2.0) ≈ 10.17 ms. (গ) চাপলে VT− max 2.45 V → 6.29 ms, min 0.9 V → 16.64 ms; ছাড়লে VT+ min 1.55 V → 5.30 ms, max 3.13 V → 14.91 ms. সব মান lab-এর হিসাব-script-এ সঠিক সূত্রে মেলানো। (ঘ) সবচেয়ে ছোট সময় 5.30 ms, যা 6.2 ms-এর চেয়ে কম; অর্থাৎ খারাপতম chip আর খারাপতম বোতাম একসাথে পড়লে ছাড়ার লাফ পার হয়ে যেতে পারে। আসলে RC লাফের সময় পুরো ভরে না বা পুরো খালি হয় না, তাই এটি রক্ষণশীল হিসাব; তবু নিরাপদ নকশার জন্য C বাড়ানো (যেমন 330 nF) বা software-এ একটি ছোট দ্বিতীয় স্তর রাখা ভালো।

  4. আগে বলুন, তারপর মেলান — দুই debouncer: প্রতি 1 ms-এর নমুনা (সূচক ০ থেকে): 0110100111111100100000. Counter debouncer (N = 3, ০ থেকে শুরু) আর ৪ বিটের shift-register debouncer (চাপ = 1111, ছাড়া = 0000) কোন সূচকে চাপ আর কোন সূচকে ছাড়া মানবে?

    Counter (N = 3): cnt চলে 0, 1, 2, 1, 2, 1, 0, 1, 2, 3 → সূচক ৯-এ চাপ। তারপর ১৪ থেকে নমুনা 0, 0, 1, 0, 0: cnt 2, 1, 2, 1, 0 → সূচক ১৮-এ ছাড়া। Shift-register (৪ বিট): 1111 প্রথম আসে সূচক ৭–১০-এর চারটি 1-এ, তাই ১০-এ চাপ; ছাড়ায় সূচক ১৬-এর 1-টি ঢুকে যাওয়ায় 0000 আসে সূচক ১৭–২০-এ, তাই ২০-এ ছাড়া। Python-এ চালিয়ে মেলানো: counter press [9] release [18], shift press [10] release [20]. লক্ষ করুন, শুরুর 1-1-0-1 লাফে counter 2 পর্যন্ত উঠলেও চাপ মানেনি, আর দুটিই একটি মাত্র চাপ দিয়েছে; counter এক নমুনা আগে, কারণ উল্টো নমুনা তার পুরো হিসাব মোছে না।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রম“Edge interrupt জাগায়, timer যাচাই করে” ধরনের মিশ্র debouncer-এ একটি বোতাম চাপার পরের ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. বোতামের প্রথম edge-এ EXTI-এর ISR চলে
  2. ISR pending বিট মুছে ওই line-এর interrupt বন্ধ করে আর সময় লিখে রাখে
  3. Timer নির্ধারিত সময় (যেমন 20 ms) গোনে, এর মধ্যে লাফগুলো উপেক্ষিত
  4. Timer শেষে pin পড়ে চাপ মানা হয় বা বাতিল হয়
  5. অপেক্ষার মধ্যে জমা pending বিট মুছে line-এর interrupt আবার খোলা হয়

একটি shift-register debouncer প্রতি 2 ms-এ বোতাম পড়ে, আর পরপর ৮টি নমুনা 1 হলে চাপ মানে। বোতাম স্থিরভাবে চাপা হওয়ার পর (আর কোনো লাফ নেই) চাপ মানতে কত দেরি হবে?

  • প্রায় 2 ms
  • ঠিক 8 ms
  • প্রায় 14 থেকে 16 ms
  • প্রায় 256 ms

RC debounce বর্তনীতে বোতাম চাপলে capacitor 100 kΩ দিয়ে খালি হয়, C = 100 nF. Time constant τ কত?

  • 1 ms
  • 10 ms
  • 100 ms
  • 10 µs

RC debounce-এর পরে সাধারণ inverter-এর বদলে 74HC14-এর মতো Schmitt-trigger inverter কেন ব্যবহার করা হয়?

  • এর propagation delay অনেক কম বলে
  • শুধু active-low বোতামকে active-high বানাতে
  • RC-এর time constant বাড়াতে
  • ধীর আর noisy ভোল্টেজেও দুই threshold-এর hysteresis একটিই পরিষ্কার বদল দেয়

একটি Cortex-M firmware-এ বোতামের EXTI ISR-এর ভেতরে লেখা আছে while (ms_ticks - t0 < 20u) { }, যেখানে ms_ticks বাড়ায় SysTick-এর ISR, আর দুটির priority সমান। বোতাম চাপলে সবচেয়ে সম্ভাব্য ফল কী?

  • Firmware EXTI-এর ISR-এ চিরতরে আটকে যায়
  • 20 ms পরে চাপ ঠিকঠাক একবার গোনা হয়
  • SysTick tail-chaining-এ ঢুকে ms_ticks বাড়িয়ে দেয়
  • CPU সঙ্গে সঙ্গে HardFault-এ যায়

একটি counter debouncer (N = 5, ০ থেকে শুরু; 1 পেলে +1 সর্বোচ্চ 5, 0 পেলে −1 সর্বনিম্ন 0; ৫ ছুঁলে চাপ) পরপর এই নমুনাগুলো পায়: 1, 1, 0, 1, 1, 1, 1. কোন নমুনায় (১ থেকে গুনে) চাপ মানা হবে?

  • ৫ম
  • ৬ষ্ঠ
  • ৭ম
  • কখনোই না, কারণ মাঝে একটি 0 এসেছে

একটি time-stamp debouncer edge-interrupt-এ চলে: “শেষ মানা চাপের পরে 20 ms পেরোলে rising edge-কে চাপ ধরা হবে”। লাফানো বোতামে এর সবচেয়ে সাধারণ ভুল কী?

  • চাপার সময়ের লাফগুলোকে আলাদা চাপ গোনে
  • ছাড়ার লাফের rising edge আর noise spike-কে নতুন চাপ গোনে
  • চাপ মানতে খুব বেশি দেরি করে
  • প্রথম চাপের পরে আর কোনো interrupt আসে না

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. Bounce: চাপা আর ছাড়ার মুহূর্তে contact কয়েক ms লাফায়; seed 42-এ দুটি চাপে ২০টি edge. নকশা হয় খারাপতম বোতাম ধরে।
  2. Software: counter (N পর্যন্ত গুনে) এক-আধটি উল্টো নমুনা সয়, shift-register (শেষ N সব একমত) কঠোর; দুটিই board-এ ঠিক ২টি চাপ দিয়েছে।
  3. ISR: ISR-এ অপেক্ষা নয়; time-stamp একা ছাড়ার লাফ আর spike-কে চাপ ভাবে; ভালো পথ edge দিয়ে জাগানো আর timer দিয়ে যাচাই।
  4. নমুনা: window = N × T সবচেয়ে লম্বা ফাঁকের চেয়ে বড়, দেরি ≈ (N − 1) × T থেকে N × T; 2 ms window 2.5 ms-এর ফাঁকে একটি চাপকে দুটি গুনেছে।
  5. Hardware: τ = R × C; t = τ × ln(VCC / VT−) চাপে, −τ × ln(1 − VT+ / VCC) ছাড়ায়; Schmitt-এর hysteresis ধীর ঢালে একটিই বদল দেয়; datasheet-এর min/max দিয়ে খারাপতম হিসাব।

পরের পর্বে: পর্ব ৪৩ (Interrupt আর ISR নকশা). ISR-এর নিয়ম, ISR আর main-এর ভাগ করা data আর critical section, board-এ মাপা latency আর jitter, priority আর কাজ ISR থেকে main-এ পাঠানো।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান