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

Digital filtering আর sensor fusion — moving average থেকে complementary filter

Digital Filtering and Sensor Fusion — From Moving Average to Complementary Filter

Taught in Bangla, this lesson treats each filter as a noise-versus-delay trade. Real firmware on the virtual BG-M3 board runs a moving average, an EMA and a median of five on a noisy scale: the average cuts spread from 22 g to 9 g but needs 80 ms to follow a step, and a 6 ms knock moves the average and EMA while the median ignores it. It writes a fixed-point EMA with shifts, compares FIR and IIR responses, fuses gyro and accelerometer with a complementary filter, and shows a 1-D Kalman gain settling near 0.248.

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

  • Noise-এর ধরন চেনা (এলোমেলো, hum, spike, drift) আর প্রতিটির জন্য ঠিক filter বাছাই
  • Ring buffer আর চলমান যোগফলে moving average, তার দেরি (N − 1)/2 নমুনা হিসাব করা
  • Fixed-point-এ EMA লেখা, α থেকে time constant বের করা, আর Clang-এর আসল assembly পড়া
  • FIR আর IIR-এর পার্থক্য, frequency response আর −3 dB বিন্দু মডেলে মাপা
  • Accelerometer আর gyro মিলিয়ে complementary filter, আর এক-মাত্রার Kalman filter-এর ধারণা

১ · Noise কোথা থেকে আসে, আর filter কেন

বাজারে মাছের দোকানে দাঁড়িপাল্লার কাঁটা কখনো সঙ্গে সঙ্গে থামে না। মাছ রাখার পর কাঁটা কয়েকবার এদিক-ওদিক দোলে, তারপর থামে। অভিজ্ঞ দোকানদার প্রথম দোলায় দাম বলেন না; একটু অপেক্ষা করেন, চোখে চোখে “গড়” করে নেন। আর কেউ পাল্লায় হাত লাগালে সেই মুহূর্তের মাপ তিনি একেবারেই গোনেন না। একটি digital filter ঠিক এই দোকানদারের কাজটি করে: অনেকগুলো কাঁচা মাপ থেকে একটি বিশ্বাসযোগ্য মান বানায়।

পর্ব ৪৭-এ দেখেছেন, ADC-র প্রতিটি মাপে কিছু noise থাকে, আর N টির গড়ে এলোমেলো noise প্রায় √N গুণ কমে। সেখানে স্কেল একবারে ৪টি মাপ নিয়ে গড় করত। এই পর্বে প্রশ্নটি বড়: noise নানা রকমের, আর প্রতিটির ওষুধ আলাদা।

ধরনকেমন দেখায়বাজারঘরের উদাহরণপ্রধান ওষুধ
এলোমেলো (random)প্রতিটি মাপ আসল মানের আশপাশে লাফায়Amplifier আর ADC-র noise, ±কয়েক countগড়: moving average, EMA
পর্যায়বৃত্ত (hum)নির্দিষ্ট frequency-র ঢেউMains-এর 50 Hzনমুনার আগে RC filter, 20 ms-এর গুণিতকে গড় (পর্ব ৪৭)
Spike (outlier)হঠাৎ একটি অনেক দূরের মানপাল্লায় হাতের ধাক্কা, একটি ভুল I2C পড়াMedian filter, যুক্তিসংগত সীমার পরীক্ষা
Drift আর biasধীরে ধীরে সরে যাওয়া বা স্থির ভুলতাপে load cell-এর শূন্য সরে যাওয়া, gyro-র biasCalibration, tare, অন্য sensor-এর সাথে fusion

শেষ সারিটি খেয়াল করুন: গড় drift সারায় না। ধীর ভুল আর ধীর আসল বদল একই রকম দেখায়, তাই কোনো low-pass filter দুটিকে আলাদা করতে পারে না। সেখানে লাগে calibration (পর্ব ৬৫ আর পর্ব ৬৬-এর বিষয়) বা দ্বিতীয় একটি sensor, যা অংশ ৬-এর sensor fusion.

প্রথমে দেখা যাক filter না থাকলে কী হয়। কোর্সের virtual বাজারঘর board (আসল কোনো পণ্য নয়, Cortex-M3 chip-এর আদলে বানানো একটি শিক্ষণ-মডেল) script-এ adc_noise_counts দিলে প্রতিটি conversion-এ −8 থেকে +8 count-এর একটি নির্ধারিত noise যোগ করে, একটি নির্দিষ্ট LCG আর seed 12345 দিয়ে (Spec decision 25). নিচে reference-এর scale.c হুবহু, শুধু script-এ noise যোগ করা; স্কেল ৪টি মাপের গড় নেয়, প্রতি 100 ms-এ একবার। এই পর্বের ঠিকানা আর মান C-এর ধরনে, যেমন 0x40012400.

সত্যিকারের run · board.py (reference lab), firmware Clang 22.1.8 (ziglang 0.17.1) দিয়ে compile করা:

$ python -B board.py run build/scale.elf --script scale_noise.json
[     0.0729 ms] UART: scale ready: zero=400 counts, span=1400 counts per 2000 g, rate=65.50 Tk/kg
[   100.0890 ms] UART: raw=401 gross=1 g tare=0 g net=1 g price=0.07 Tk
[   200.0889 ms] UART: raw=400 gross=0 g tare=0 g net=0 g price=0.00 Tk
[   250.0000 ms] > load on the scale: 150 g
[   300.0978 ms] UART: raw=506 gross=151 g tare=0 g net=151 g price=9.89 Tk
[   400.0978 ms] UART: raw=499 gross=141 g tare=0 g net=141 g price=9.24 Tk
[   420.0000 ms] > button pressed
[   427.0341 ms] UART: TARE set to 141 g
[   500.0999 ms] UART: raw=508 gross=154 g tare=141 g net=13 g price=0.85 Tk
[   600.0999 ms] UART: raw=507 gross=153 g tare=141 g net=12 g price=0.79 Tk
[   650.0000 ms] > load on the scale: 1400 g
[   700.1125 ms] UART: raw=1378 gross=1397 g tare=141 g net=1256 g price=82.27 Tk
[   800.1125 ms] UART: raw=1377 gross=1396 g tare=141 g net=1255 g price=82.20 Tk

(কয়েকটি লাইন বাদ দেওয়া; পুরো run 1201 ms-এ exit(0).) README-র noise ছাড়া run-এ একই script-এ ফল ছিল tare=150 g, net=1250 g, price=81.88 Tk. Noise থাকায় তিনটি সমস্যা দেখা দিল। প্রথমত, ঝুড়ির ওজন ধরার মুহূর্তে গড় ছিল 141 g, তাই tare ভুল 9 g নিয়ে বসে গেল, আর খালি ঝুড়িতেই net দেখাল 13 g, দাম 0.85 টাকা। দ্বিতীয়ত, একই 1400 g-এ দাম 82.27 থেকে 82.20 টাকায় লাফাল; ক্রেতার চোখে দাঁড়িপাল্লাটি অস্থির। তৃতীয়ত, ভুলটা দোকানের লোকসান বা ক্রেতার ঠকা, দুই দিকেই যেতে পারে। ৪টির গড় যথেষ্ট নয়। প্রশ্ন হলো, কোন filter, কতটা, আর কী দামে।

২ · Moving average — ring buffer, চলমান যোগফল আর দেরি

স্কেলের নিয়ম ছিল “৪টি মাপ নেওয়া, গড় করা, তারপর আবার নতুন করে ৪টি”। একটি বিকল্প হলো moving average (চলমান গড়): প্রতিটি নতুন নমুনায় শেষ N টির গড়। ক্রিকেটে একজন ব্যাটসম্যানের “শেষ ৮ ইনিংসের গড়” যেমন প্রতিটি নতুন ইনিংসে একটি পুরোনো ইনিংস ফেলে দিয়ে নতুনটি যোগ করে, ঠিক তেমনি। এতে প্রতি নমুনায় একটি করে মসৃণ output আসে।

Firmware-এ প্রতিবার N টি যোগ করার দরকার নেই। শেষ N টি নমুনা একটি ring buffer-এ থাকে, আর একটি চলমান যোগফল রাখা হয়: নতুন নমুনা যোগ, সবচেয়ে পুরোনোটি বাদ। প্রতি নমুনায় একটি যোগ, একটি বিয়োগ আর একটি ভাগ (N = 2k হলে shift), N যত বড়ই হোক। Ring buffer-এর তত্ত্ব DSA পর্ব ১৪-এ; N = 8 হলে index-এর জন্য n & 7 যথেষ্ট, আলাদা শর্ত লাগে না।

int32_t g = grams((int32_t)adc_read());   /* README calibration, div_round */
sum += g - ring[n & 7u];                  /* new in, oldest out */
ring[n & 7u] = g;
win5[n % 5u] = g;                         /* last 5 for the median */
n++;
if (n == 1) y8 = g * 256;                 /* start the EMA at the first sample */
y8 += (g * 256 - y8) / 4;                 /* EMA, alpha = 1/4, Q8 state */
int32_t ma8  = (sum + 4) / 8;             /* rounded mean of 8 */
int32_t ema  = (y8 + 128) / 256;          /* back to whole grams */
int32_t med5 = median5(win5);             /* insertion sort of 5 */

এটি আমার lab-এর filt.c-এর মূল অংশ (reference-এর scale.c থেকে নেওয়া adc_read() আর README-র calibration). Firmware প্রতি 10 ms-এ একটি conversion নেয় আর চারটি output পাশাপাশি হিসাব করে: কাঁচা, ৮টির moving average, EMA আর ৫টির median. Script: পাল্লায় 1400 g, ±8 count noise, 505 থেকে 511 ms পর্যন্ত একটি ধাক্কা (3000 g), আর 805 ms-এ ওজন বদলে 2000 g. নিচের stepper সেই run-এর moving average-এর ভেতরটি দেখায়।

প্রতি 10 ms-এ একটি নমুনা (g)
সময়
নতুন নমুনা
বাদ পড়ল
ring (৮টি)
sum
(sum + 4) / 8
  1. শান্ত অবস্থা, 500 ms. নতুন 1399 এল, সবচেয়ে পুরোনো 1401 বাদ গেল। যোগফল 11210, গোল করা গড় (11210 + 4) ÷ 8 = 1401 g. কাঁচা নমুনা 1389 থেকে 1410-এ লাফালেও output প্রায় স্থির।
  2. ধাক্কা, 510 ms. একটি নমুনা 3011 g. যোগফল 11210 + 3011 − 1401 = 12820, গড় 1603 g. এক নমুনার 1611 g বাড়তি আট ভাগে ছড়িয়ে প্রায় 201 g হয়ে output-এ ঢুকল।
  3. পরের নমুনা, 520 ms. পাল্লা আবার স্বাভাবিক, নতুন 1396. কিন্তু 3011 এখনো ring-এ বসে আছে, তাই গড় 1601 g. Moving average-এর স্মৃতি ঠিক ৮ নমুনা লম্বা।
  4. এখনো ভুল, 580 ms. ধাক্কার পর ৭টি স্বাভাবিক নমুনা এসেছে, তবু output 1600 g: পুরো 80 ms ধরে দাম প্রায় 13 টাকা বেশি দেখাত। গড় spike সরায় না, শুধু ছড়িয়ে দেয়।
  5. মুক্তি, 590 ms. নতুন 1409 এসে 3011-কে বের করে দিল: 12799 + 1409 − 3011 = 11197, গড় 1400 g. একটি ধাক্কার প্রভাব ঠিক N = 8 নমুনা পরে পুরো মুছে যায়; এটি FIR filter-এর বৈশিষ্ট্য, যা অংশ ৫-এ।

Moving average-এর একটি দাম আছে, তার নাম দেরি। ৮টির গড় আসলে শেষ ৮টি নমুনার “মাঝখানের” সময়ের মান বলে, অর্থাৎ বর্তমান থেকে (8 − 1) ÷ 2 = 3.5 নমুনা পিছিয়ে; একে বলে group delay. প্রতি 10 ms-এ নমুনা হলে 35 ms দেরি। ধাপের মতো হঠাৎ বদলে (1400 থেকে 2000 g) output পুরোটা পৌঁছাতে N টি নমুনা লাগে। Board-এর run-এর সারাংশ:

সত্যিকারের run · board.py, lab-এর filt.c আর filt.json (noise ±8 count):

$ python -B board.py run build/filt.elf --script filt.json
[     0.0304 ms] UART: t_ms raw ma8 ema med5 (grams)
[   500.0935 ms] UART: 500 1399 1401 1399 1399
[   505.0000 ms] > load on the scale: 3000 g
[   510.0925 ms] UART: 510 3011 1603 1802 1399
[   511.0000 ms] > load on the scale: 1400 g
[   520.0921 ms] UART: 520 1396 1601 1700 1397
[   805.0000 ms] > load on the scale: 2000 g
[   810.0951 ms] UART: 810 1990 1477 1551 1406
[   830.0947 ms] UART: 830 2009 1628 1748 1990
[   880.0923 ms] UART: 880 2006 2001 1943 2004
[  1201.0920 ms] UART: raw : steady 1389..1411, knock max 3011, 1990 g at sample 1
[  1201.1768 ms] UART: ma8 : steady 1395..1404, knock max 1603, 1990 g at sample 8
[  1201.2636 ms] UART: ema : steady 1395..1404, knock max 1802, 1990 g at sample 16
[  1201.3484 ms] UART: med5: steady 1390..1409, knock max 1407, 1990 g at sample 3
[  1201.3492 ms] exit(0) after 9610794 cycles

(মাঝের কিছু সারি বাদ।) “steady” মানে 200 থেকে 500 ms-এ, পাল্লায় 1400 g থাকার সময়, output-এর সর্বনিম্ন আর সর্বোচ্চ। কাঁচা মাপের ফারাক 22 g, moving average আর EMA-র 9 g, median-এর 19 g. ধাক্কার পরে সর্বোচ্চ মান আর 2000 g-এর ধাপে কত নম্বর নমুনায় output 1990 g ছুঁয়েছে, সেটিও আছে। সময়ের সংখ্যার শেষ অঙ্কগুলো compiler-এর ওপর নির্ভর করে (Spec decision 30), কারণ board-এ এক instruction = এক cycle (Spec decision 17); মানগুলো নির্ভর করে না।

ছবি ৬৮.১ — একই নমুনায় চারটি filter, 450 থেকে 1000 ms

ধূসর বিন্দু: কাঁচা নমুনা · নীল: moving average ৮ · কমলা ড্যাশ: EMA α = 1/4 · সবুজ: median ৫

চারটি filter-এর output: ধাক্কা আর ধাপে 1400 1600 1800 2000 500 ms 700 ms 900 ms ধাক্কা 3011 g ↑
ছবি ৬৮.১ — বিন্দু আর রেখা board-এর run-এর হুবহু নমুনা থেকে আঁকা (lab-এর একটি script board-এর একই LCG চালিয়ে প্রতিটি নমুনা বের করেছে, আর run-এর ছাপা সারিগুলোর সাথে মিলেছে)। ধাক্কায় median নড়ে না; ধাপে moving average সরলরেখায় ৮ নমুনায় ওঠে, EMA বাঁকা পথে অনেক দেরিতে।

৩ · Exponential moving average — এক লাইনের filter, fixed-point-এ

Moving average-এর জন্য N টি নমুনা মনে রাখতে হয়। ৬৪ বা ২৫৬ নমুনার গড়ে সেটি RAM-এর বোঝা। Exponential moving average (EMA) মাত্র একটি সংখ্যা মনে রাখে:

y ← y + α × (x − y)   ·   0 < α ≤ 1

অর্থাৎ নতুন মাপ আর পুরোনো অনুমানের ফারাকের একটি ভাগ (α) দিয়ে অনুমান সংশোধন। রেলস্টেশনের ঘোষকের কথা ভাবুন: ট্রেন দেরিতে চলছে শুনে তিনি প্রতিবার পুরো নতুন খবরে ঝাঁপ দেন না, আগের অনুমান থেকে খানিকটা সরান। α বড় হলে (যেমন 1/2) filter দ্রুত সাড়া দেয় কিন্তু কম মসৃণ; ছোট হলে (1/16) খুব মসৃণ কিন্তু ধীর। সূত্রটি খুললে দেখা যায়, k ধাপ আগের নমুনার ওজন α(1 − α)k, যা জ্যামিতিক হারে কমে; তাই এর নাম “exponential”, বাংলায় সূচকীয়।

মূল সূত্র

নমুনার ব্যবধান Ts হলে EMA-র time constant τ ≈ Ts × (1 − α) ÷ α · α ≈ Ts ÷ (τ + Ts) · একটি ধাপের ৬৩% পেতে প্রায় τ, ৯৫% পেতে প্রায় 3τ · একই noise কমানোর তুলনা: α ≈ 2 ÷ (N + 1) হলে EMA আর N নমুনার moving average প্রায় সমান মসৃণ।

Microcontroller-এ α = 1/2k নেওয়া প্রচলিত, যাতে ভাগের বদলে shift চলে। কিন্তু পূর্ণসংখ্যায় একটি ফাঁদ আছে, যা পর্ব ৪০-এ দেখেছেন: y আর x যদি দুটিই পূর্ণ গ্রাম হয়, তাহলে (x − y) ÷ 4 যখন 1-এর কম, সংশোধন শূন্য, আর y আসল মান থেকে ৩ g দূরে আটকে থাকতে পারে। সমাধান: state-কে বাড়তি ভগ্নাংশ বিটে রাখা। filt.c-এ y8 = গ্রাম × 256, অর্থাৎ ৮টি ভগ্নাংশ বিট (Q format-এ বললে Q8). Output-এর সময় (y8 + 128) ÷ 256 করে গোল করা হয়। নিচের stepper 805 ms-এর ধাপের পরের হিসাব, board-এর run-এর হুবহু সংখ্যায়।

1y8 = 1404 g × 256 (প্রায়)2d  = x × 256 − y83y8 = y8 + d / 44out = (y8 + 128) / 2565out ≥ 1990 ?
ধাপের শেষে
সময়
x (g)
d
d / 4
y8
out (g)
  1. শুরু, 800 ms. পাল্লায় 1400 g. y8 = 359504, অর্থাৎ 359504 ÷ 256 ≈ 1404.3 g; output (359504 + 128) ÷ 256 = 1404 g. noise-এর জন্য আসল 1400-এর চেয়ে একটু বেশি।
  2. ধাপ, 810 ms. নতুন x = 1990 g. d = 1990 × 256 − 359504 = 149936, তার চার ভাগের এক 37484. y8 = 396988, output 1551 g: এক ধাপে ফারাকের ঠিক এক-চতুর্থাংশ পথ।
  3. 820 ms. আবার 1990. বাকি ফারাকের আবার এক-চতুর্থাংশ: d = 112452, যোগ 28113, output 1661 g. প্রতি ধাপে বাকি দূরত্ব 3/4 গুণ হয়, তাই পথটি বাঁকা।
  4. 830 ms. x = 2009. d = 89203; ÷ 4 = 22300.75, C-র ভাগ ছেঁটে 22300. ছাঁটা অংশ মাত্র 0.75 ÷ 256 g, Q8-এর কারণে প্রায় অদৃশ্য। পূর্ণ গ্রামে রাখলে এই ছাঁটাই প্রতিবার ১ গ্রাম পর্যন্ত হতো।
  5. 880 ms, ৮ নমুনা পরে. Output 1943 g. Moving average এই সময়ে 2001 g-এ পৌঁছে গেছে। EMA-র বাকি দূরত্ব (3/4)8 ≈ 10% , তাই এখনো প্রায় 57 g বাকি।
  6. 960 ms, ১৬তম নমুনা. Output 1991 g, প্রথমবার 1990 ছুঁল। α = 1/4-এ EMA-র noise কমানো moving average ৮-এর সমান (দুটিরই ফারাক 9 g), কিন্তু ধাপে পৌঁছাতে দ্বিগুণ সময়: লম্বা লেজের দাম।

C-তে ÷ 4 না লিখে >> 2 লিখলে কী বদলায়? Signed সংখ্যায় দুটি এক নয়: ভাগ শূন্যের দিকে ছাঁটে, shift −∞-এর দিকে। Compiler তাই ÷ 4-এর জন্য বাড়তি কাজ করে। আমার lab-এ দুটি সংস্করণ Clang দিয়ে Cortex-M3-এর জন্য compile করা হলো:

সত্যিকারের run · Clang 22.1.8 (ziglang 0.17.1), --target=thumbv7m-none-eabi -mcpu=cortex-m3 -O2 -S:

/* ema.c */
int32_t ema_div(int32_t y8, int32_t x)   { return y8 + (x * 256 - y8) / 4; }
int32_t ema_shift(int32_t y8, int32_t x) { return y8 + ((x * 256 - y8) >> 2); }

ema_div:
	rsb	r1, r0, r1, lsl #8
	asrs	r2, r1, #31
	add.w	r1, r1, r2, lsr #30
	add.w	r0, r0, r1, asr #2
	bx	lr
ema_shift:
	rsb	r1, r0, r1, lsl #8
	add.w	r0, r0, r1, asr #2
	bx	lr

(Directive-এর লাইনগুলো বাদ।) কোথাও গুণ বা ভাগের instruction নেই। rsb … lsl #8 এক instruction-এ x × 256 − y8 করে। ÷ 4-এ বাড়তি দুটি instruction ঋণাত্মক d-তে 3 যোগ করে, যাতে ছাঁটাই শূন্যের দিকে হয়; >> 2-এ সেটি নেই, তাই y সবসময় একটু নিচের দিকে ঝোঁকে। Q8-এ সেই ঝোঁক 1/256 g-এর ঘরে, তাই দুটিই চলে; কিন্তু পূর্ণ সংখ্যার state-এ একমুখী ছাঁটাই কতটা আটকে দেয়, তার হিসাব পর্ব ৪০-এর ভাবনার প্রশ্নে আছে। একটি সূক্ষ্ম কথা: signed সংখ্যার ডানে shift C standard-এ implementation-defined; Clang আর GCC-তে এটি arithmetic shift, তবু নিয়মটি জেনে লিখুন।

৪ · Median filter — ধাক্কার ওষুধ

গড় সব মানকে সমান ভোট দেয়, তাই একটি পাগলাটে মানও ভোট পায়। Median filter অন্যভাবে ভাবে: শেষ ৫টি নমুনা ছোট থেকে বড়ে সাজানো, তারপর মাঝেরটি নেওয়া। ক্লাসের পাঁচজনের মাসিক টিফিন খরচের মাঝের মান নিলে একজন ধনী বন্ধুর বিশাল খরচ ফলকে টানতে পারে না; গড় নিলে পারত। ৫টির median-এ একসাথে দুটি পর্যন্ত spike কোনো প্রভাব ফেলে না।

জানালার ৫টি নমুনা (g)
সময়
নতুন
সাজানো
median
moving avg ৮
  1. শান্ত, 500 ms. জানালায় 1389 থেকে 1410. সাজালে মাঝে 1399. Median এলোমেলো noise কিছুটা কমায়, তবে গড়ের মতো নয়: run-এ শান্ত অবস্থায় median-এর ফারাক 19 g, গড়ের 9 g.
  2. ধাক্কা, 510 ms. 3011 এল, কিন্তু সাজালে সে সবচেয়ে ডানে যায়। মাঝের মান 1399 অপরিবর্তিত। একই মুহূর্তে moving average 1603 g-এ লাফিয়েছে।
  3. 520 ms. জানালায় এখনো 3011, তবু median 1397. বাকি চারটি স্বাভাবিক মান মাঝেরটি ঠিক করে দেয়।
  4. 550 ms. 3011 জানালার শেষ প্রান্তে, পাঁচ নমুনা পরে বেরোবে। median 1396; moving average তখনো 1598 g.
  5. 560 ms. 3011 বেরিয়ে গেল। পুরো সময়ে median-এর সর্বোচ্চ ছিল 1407 g, যা শান্ত অবস্থার noise-এর সীমার ভেতরে। ধাক্কাটি ফলে কোনো চিহ্নই রাখেনি।
  6. ধাপে, 830 ms. 2000 g-এর পর তৃতীয় নমুনায় জানালায় তিনটি নতুন মান, তাই মাঝেরটি হঠাৎ 1990: median ধাপকে ধাপ হিসেবেই রাখে, ঢালু করে না। দেরি (৫ − ১) ÷ ২ = ২ নমুনা।

Median-এর সীমাও আছে। এটি রৈখিক নয়, তাই অংশ ৫-এর frequency response দিয়ে বোঝা যায় না। একটানা তিনটি বা বেশি spike (৫-এর জানালায়) পার হয়ে যায়। আর প্রতি নমুনায় সাজাতে হয়: ৫টিতে insertion sort-এ খারাপতম ১০টি তুলনা, যা ছোট; ৩টির median আরও সস্তা, মাত্র ৩টি তুলনা (অনুশীলন ১-এ)। বাস্তবে একটি প্রচলিত জোড় হলো আগে ছোট median (spike বাদ), তারপর EMA বা moving average (noise কমানো)। পর্ব ৬৩-এ তিনটি sensor-এর মাঝের মান নিয়ে ভোটের কথা দেখেছেন; সেটি একই ধারণা, সময়ের বদলে sensor-এর ওপর।

নিচের Python block board-এর ADC noise-এর হুবহু নকল করে (একই LCG আর seed, Spec decision 25), আর একই নমুনায় অনেক রকম filter পাশাপাশি চালায়। N বা α বদলে নিজে দর-কষাকষি দেখুন।

# Board-এর ADC noise-এর হুবহু নকল (একই LCG, seed 12345) দিয়ে filter-এর দর-কষাকষি
import statistics

def samples():                     # প্রতি 10 ms-এ একটি নমুনা, 1.2 s
    seed, out = 12345, []
    for n in range(1, 121):
        t = 10 * n
        g = 3000 if 505 <= t < 511 else (2000 if t >= 805 else 1400)
        seed = (1103515245 * seed + 12345) & 0x7FFFFFFF
        raw = round(400 + 0.7 * g + (seed >> 16) % 17 - 8)
        out.append((t, round((raw - 400) * 2000 / 1400)))
    return out

def moving_avg(xs, n):
    return [sum(xs[max(0, i - n + 1):i + 1]) / min(n, i + 1) for i in range(len(xs))]

def ema(xs, a):
    y, out = xs[0], []
    for x in xs:
        y += a * (x - y)
        out.append(y)
    return out

data = samples()
ts = [t for t, _ in data]
xs = [g for _, g in data]
for name, ys in [("raw", xs), ("MA 4", moving_avg(xs, 4)), ("MA 8", moving_avg(xs, 8)),
                 ("MA 16", moving_avg(xs, 16)), ("EMA 1/4", ema(xs, 1 / 4)), ("EMA 1/8", ema(xs, 1 / 8))]:
    steady = [y for t, y in zip(ts, ys) if 200 <= t <= 500]
    knock = max(y for t, y in zip(ts, ys) if 510 <= t <= 600)
    k = next(i for i, t in enumerate(ts) if t > 805 and ys[i] >= 1990) - 79
    print(f"{name:8s} std={statistics.pstdev(steady):4.1f} g  knock={knock:6.0f} g  "
          f"1990 g at sample {k}")

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

raw      std= 6.9 g  knock=  3011 g  1990 g at sample 1
MA 4     std= 4.2 g  knock=  1799 g  1990 g at sample 4
MA 8     std= 2.6 g  knock=  1602 g  1990 g at sample 8
MA 16    std= 1.1 g  knock=  1501 g  1990 g at sample 16
EMA 1/4  std= 2.8 g  knock=  1802 g  1990 g at sample 16
EMA 1/8  std= 1.6 g  knock=  1601 g  1990 g at sample 34

এখানে float-এ হিসাব, তাই moving average ৮-এর knock 1602, board-এর পূর্ণসংখ্যার 1603 নয়; বাকি সব board-এর সাথে মেলে (EMA 1/4: 1802 আর ১৬তম নমুনা)। Standard deviation (std) মানে ছড়ানো। পড়ার নিয়মটি সহজ: প্রতিটি সারিতে noise কমলে দেরি বাড়ে। N দ্বিগুণে std প্রায় √2 গুণ কমে, আর দেরি দ্বিগুণ। MA 8 আর EMA 1/4 প্রায় সমান মসৃণ (2.6 আর 2.8 g), α ≈ 2 ÷ (N + 1) নিয়ম মেনে, কিন্তু ধাপে EMA দ্বিগুণ ধীর। কোনো সারিই ধাক্কাকে পুরো সরাতে পারেনি; সেটি শুধু median পারে। কাঁচা noise-এর std 6.9 g তত্ত্বের কাছে: ±8 count-এর সমান-সম্ভাবনার noise-এ σ ≈ 4.9 count ≈ 7.0 g.

৫ · FIR বনাম IIR — দুই পরিবারের filter

এতক্ষণের রৈখিক filter দুটি পরিবারের প্রতিনিধি। Moving average একটি FIR filter (finite impulse response): output শুধু শেষ কয়েকটি input-এর ওজনযুক্ত যোগফল, যেমন y = (x0 + x1 + … + x7) ÷ 8. EMA একটি IIR filter (infinite impulse response): output-এ আগের output ফেরত আসে, yk = (1 − α) yk−1 + α xk. একটিমাত্র নমুনার ধাক্কা দিলে (impulse response) FIR-এর প্রভাব N নমুনায় শূন্য হয়; IIR-এর প্রভাব প্রতি ধাপে কমে, কিন্তু তাত্ত্বিকভাবে কখনো শূন্য নয়।

Filter-কে আরেকভাবে দেখা যায়: কোন frequency কতটা পার হতে দেয়, তার নাম frequency response. ধীর বদল (আসল ওজন) পার হোক, দ্রুত কাঁপুনি আটকে যাক, এমন filter একটি low-pass filter. যেখানে gain 1/√2-এ নামে, তা cutoff frequency. নিচের block দুটি filter-এর gain হিসাব করে, প্রতি 10 ms-এ নমুনা (fs = 100 Hz) ধরে।

# FIR (moving average) বনাম IIR (EMA): কোন frequency কতটা পার হয়, আর একটি ধাক্কার স্মৃতি কত দীর্ঘ
import cmath, math

FS = 100.0                                   # নমুনার হার: প্রতি 10 ms-এ একটি

def gain_ma(f, n):                           # FIR: n টি সমান ওজন 1/n
    z = cmath.exp(-2j * math.pi * f / FS)
    return abs(sum(z ** k for k in range(n)) / n)

def gain_ema(f, a):                          # IIR: y[k] = y[k-1] + a (x[k] - y[k-1])
    z = cmath.exp(-2j * math.pi * f / FS)
    return abs(a / (1 - (1 - a) * z))

print(" f (Hz)   MA 8   EMA 1/4")
for f in (0, 1, 2, 5, 10, 12.5, 25, 50):
    print(f"{f:7.1f}  {gain_ma(f, 8):5.3f}   {gain_ema(f, 0.25):5.3f}")

def cutoff(gain):                            # gain প্রথম 1/√2-এর নিচে নামে কোথায়
    f = 0.0
    while gain(f) >= 1 / math.sqrt(2):
        f += 0.01
    return f

print(f"-3 dB: MA 8 = {cutoff(lambda f: gain_ma(f, 8)):.2f} Hz, "
      f"EMA 1/4 = {cutoff(lambda f: gain_ema(f, 0.25)):.2f} Hz")

# একটি নমুনার ধাক্কা (impulse) কত নমুনা পরে পুরো মুছে যায়?
x = [1.0] + [0.0] * 40
y, ema_out = 0.0, []
for v in x:
    y += 0.25 * (v - y)
    ema_out.append(y)
ma_out = [sum(x[max(0, i - 7):i + 1]) / 8 for i in range(len(x))]
print("MA 8 : শেষ অশূন্য ধাপ", max(i for i, v in enumerate(ma_out) if v != 0))
print("EMA  : ২০ ধাপ পরে", f"{ema_out[20]:.6f}", ", ৪০ ধাপ পরে", f"{ema_out[40]:.2e}")

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

 f (Hz)   MA 8   EMA 1/4
    0.0  1.000   1.000
    1.0  0.990   0.977
    2.0  0.959   0.917
    5.0  0.760   0.678
   10.0  0.238   0.423
   12.5  0.000   0.353
   25.0  0.000   0.200
   50.0  0.000   0.143
-3 dB: MA 8 = 5.58 Hz, EMA 1/4 = 4.62 Hz
MA 8 : শেষ অশূন্য ধাপ 7
EMA  : ২০ ধাপ পরে 0.000793 , ৪০ ধাপ পরে 2.51e-06

0 Hz-এ (স্থির ওজন) দুটিরই gain 1: আসল মান অক্ষত। Moving average ৮-এর gain 12.5, 25 আর 50 Hz-এ ঠিক শূন্য, কারণ ঠিক পুরো চক্রের গড় শূন্য; এই “শূন্য বিন্দু” fs ÷ N-এর গুণিতকে। পর্ব ৪৭-এর 20 ms-এর জানালা 50 Hz মুছে দেয়, একই কারণে। EMA-র কোনো শূন্য বিন্দু নেই, gain ধীরে কমে, 50 Hz-এও 0.143 থেকে যায়। শেষ দুই লাইন impulse response: FIR-এর প্রভাব ৭ নম্বর ধাপের পর একেবারে শূন্য, IIR-এর ৪০ ধাপ পরেও 2.51 × 10−6. তত্ত্বের সূত্রে 20 ধাপ পরে 0.25 × 0.7520 ≈ 0.000793, হুবহু মিলেছে। এগুলো মডেল-হিসাব; আসল বর্তনীর আগের analog filter (পর্ব ৬৬-এর বিষয়) এর বাইরে।

FIR

আগের output ফেরত আসে না, তাই সবসময় স্থিতিশীল। সহগ প্রতিসম হলে সব frequency সমান দেরিতে পার হয় (linear phase), তরঙ্গের আকার বিকৃত হয় না। তীক্ষ্ণ cutoff-এ অনেক সহগ, অনেক গুণ আর অনেক RAM লাগে।

Moving average, ওজনযুক্ত গড়

IIR

Feedback-এর জন্য অল্প হিসাবে তীক্ষ্ণ filter, অল্প RAM. কিন্তু সহগ ভুল হলে বা fixed-point-এ গোল করার ভুলে অস্থির হতে পারে, ছোট ছোট স্থায়ী দোলনও (limit cycle) দেখা দিতে পারে। দেরি frequency-ভেদে আলাদা।

EMA, biquad

এর বাইরে তীক্ষ্ণ filter-এর নকশা, যেমন Butterworth বা biquad-এর সহগ বের করা, digital signal processing-এর আলাদা বিষয়; এই কোর্সে তা বিস্তারিত নয়। বাস্তবে Cortex-M-এ হাতে লেখার বদলে Arm-এর বিনামূল্যের CMSIS-DSP library প্রায়ই ব্যবহার হয়, যাতে arm_fir_q15 বা arm_biquad_cascade_df1_q31-এর মতো FIR আর biquad IIR function আছে, float আর Q15/Q31 দুই রূপে। Cortex-M4-এর DSP instruction (যেমন SMLAD, একসাথে দুটি ১৬ বিটের গুণ-যোগ) এই function-গুলোকে দ্রুত করে; Cortex-M3-এ সেগুলো নেই। নির্দিষ্ট function-এর নাম আর argument library-র নিজের documentation-এ দেখে নেবেন।

৬ · Sensor fusion — accelerometer আর gyro মেলানো

বাজারঘরের দুটি device-এ একটি করে sensor. কিন্তু ফোন, drone বা ব্যালান্স রোবটে একই রাশি দুটি আলাদা sensor মাপে, আর দুটির দোষ আলাদা। তাদের মিলিয়ে একটি ভালো অনুমান বানানোর নাম sensor fusion. সবচেয়ে চেনা উদাহরণ একটি IMU: একটি chip-এ accelerometer আর gyroscope, দুটিই MEMS প্রযুক্তিতে silicon-এর ওপর বানানো খুদে যান্ত্রিক কাঠামো। পরিচিত একটি উদাহরণ InvenSense-এর (বর্তমানে TDK-র অংশ) MPU-6050: তার product specification অনুযায়ী ৩ অক্ষের gyro (±250 থেকে ±2000 °/s পর্যন্ত বাছাইযোগ্য পাল্লা) আর ৩ অক্ষের accelerometer (±2 থেকে ±16 g), I2C-তে পড়া যায় (পর্ব ৫১)। নির্দিষ্ট মানগুলো নিজের chip-এর datasheet থেকে নেবেন। কোর্সের virtual board-এ কোনো IMU নেই, তাই এই অংশের সব সংখ্যা একটি seed দেওয়া Python মডেল থেকে, board থেকে নয়।

Accelerometer: ধীরে ঠিক, কিন্তু কাঁপে

স্থির অবস্থায় সে শুধু মাধ্যাকর্ষণ মাপে। দুই অক্ষের মাপ থেকে হেলানোর কোণ θ = atan2(ay, az). কিন্তু device নড়লে বা কাঁপলে সেই ত্বরণও যোগ হয়, তখন কোণ ভুল। দীর্ঘ সময়ে গড়ে ঠিক।

Gyro: দ্রুত আর মসৃণ, কিন্তু সরে যায়

কৌণিক বেগ (°/s) মাপে। প্রতি নমুনায় বেগ × dt যোগ করলে কোণ। কাঁপুনিতে ভোলে না, কিন্তু তার ছোট স্থির ভুল, gyro bias, প্রতি ধাপে যোগ হয়: 1 °/s bias দশ সেকেন্ডে 10° ভুল।

সমাধানটি সুন্দর: gyro-র দ্রুত অংশ রাখা আর ধীর অংশ (drift) বাদ দেওয়া, অর্থাৎ gyro-কে একটি high-pass filter-এ পাঠানো; আর accelerometer-এর ধীর অংশ রাখা, দ্রুত কাঁপুনি বাদ দেওয়া, অর্থাৎ low-pass. দুটি filter-এর ওজন যোগ করলে ১ হয়, তাই নাম complementary filter (পরিপূরক)। Firmware-এ এটি এক লাইন:

θ ← A × (θ + ωgyro × dt) + (1 − A) × θaccel

ছবি ৬৮.২ — Complementary filter-এর পথ

ওপরে gyro: integrate তারপর A-গুণ (দ্রুত অংশ) · নিচে accelerometer: atan2 তারপর (1 − A)-গুণ (ধীর অংশ) · যোগফল আবার পরের ধাপে ফেরত

Complementary filter: gyro-র দ্রুত অংশ আর accelerometer-এর ধীর অংশ যোগ Gyro ω °/s + θ + ω·dt × A 0.98 Accel ay, az atan2 × (1−A) 0.02 + θ কোণ আগের θ (এক নমুনা দেরি)
ছবি ৬৮.২ — প্রতি নমুনায় ৯৮% ওজন gyro দিয়ে এগোনো অনুমানের, ২% accelerometer-এর। লাল ফেরত-পথের কারণে এটি একটি IIR filter: accelerometer-এর অংশ একটি EMA, যা ধীরে ধীরে gyro-র drift টেনে ঠিক করে।

A কত হবে? A আর dt মিলে একটি time constant দেয়, τ = A × dt ÷ (1 − A). এর চেয়ে দ্রুত বদলে gyro-কে বিশ্বাস, ধীর বদলে accelerometer-কে। dt = 10 ms আর A = 0.98-এ τ = 0.49 s. Drone বা ব্যালান্স রোবটের অনেক উদাহরণে A প্রায় 0.95 থেকে 0.99-এর মধ্যে দেখা যায়, কিন্তু ঠিক মান sensor-এর noise আর নড়াচড়ার ধরন দেখে বাছতে হয়। নিচের stepper একটি হাতে-হিসাবযোগ্য উদাহরণ: device 0.1 s-এ 0° থেকে 30°-এ হেলে যায় (300 °/s), gyro-র bias 1 °/s, আর হেলানোর সময় ঝাঁকুনিতে accelerometer 10° বেশি দেখায়।

নমুনা k-এর পরে (মডেল)
k (সময়)
আসল কোণ
gyro, accel
θ + ω·dt
নতুন θ
শুধু gyro
  1. নিয়ম। প্রতি 10 ms-এ: gyro-র বেগ × 0.01 s আগের কোণে যোগ, সেটির ৯৮% আর accelerometer-এর কোণের ২% যোগ। শুরুতে কোণ 0°, device স্থির।
  2. প্রথম নমুনা. Gyro 301 °/s (আসল 300 + bias 1), তাই ভবিষ্যদ্বাণী 3.01°. Accelerometer ঝাঁকুনিতে 13° বলছে। 0.98 × 3.01 + 0.02 × 13 = 3.2098°. আসল 3°; ঝাঁকুনির ভুল ২% ওজনে সামান্যই ঢুকল।
  3. দ্বিতীয় নমুনা. 0.98 × 6.2198 + 0.02 × 16 = 6.4154°. দ্রুত হেলানোর সময় output প্রায় পুরোটাই gyro-র কথা মেনে চলে; accelerometer-এর ঝাঁকুনি শুধু অল্প অল্প ঢোকে।
  4. হেলানো শেষ, 0.1 s. আসল 30°, filter 31.92°. দশটি নমুনায় ঝাঁকুনির +10° ভুল কিছুটা জমেছে: ভুল প্রায় 1.9°. শুধু gyro এখানে ভালো, 30.10°. দ্রুত বদলের সময় কোনো filter-ই নিখুঁত নয়।
  5. স্থির হলো, 0.11 s. এখন gyro শুধু bias, 1 °/s; accelerometer সঠিক 30°. ভবিষ্যদ্বাণী 31.9289, ২% ওজনে 30° টেনে নামায়: 31.8903°. এখান থেকে accelerometer ধীরে ধীরে ভুল সারাবে।
  6. 0.6 s. Filter 31.01°, ভুল প্রায় 1.9° থেকে 1.0°-এ নেমেছে, τ = 0.49 s-এর হারে। শুধু gyro এখন 30.60°, আর তার ভুল সময়ের সাথে বাড়ছেই।
  7. 5 s. Filter 30.4901°-এ থিতু; শুধু gyro 35.00°, প্রতি সেকেন্ডে আরও ১° সরছে। থিতু ভুল ঠিক bias × τ = 1 × 0.49 = 0.49°: complementary filter gyro-র bias পুরো মোছে না, ছোট একটি স্থির ভুলে বেঁধে রাখে।

এবার একটি বেশি বাস্তব মডেল: gyro-তে bias আর এলোমেলো noise, accelerometer-এ noise আর হেলানোর শুরুতে ঝাঁকুনি, ১০ সেকেন্ড ধরে। এটি একটি seed দেওয়া মডেল, কোনো আসল chip-এর মাপ নয়।

# Complementary filter: gyro (দ্রুত কিন্তু drift করে) + accelerometer (ধীরে ঠিক, কিন্তু কাঁপে)
import math, random

rng = random.Random(68)
DT, A = 0.01, 0.98                         # 100 Hz, ফিল্টারের ওজন
BIAS = 1.0                                 # gyro-র স্থির ভুল, °/s (মডেলে ধরা)

def true_tilt(t):                          # 1 s থেকে 2 s-এ 0° থেকে 30°-এ হেলানো
    return 0.0 if t < 1 else (30.0 * (t - 1) if t < 2 else 30.0)

gyro_only = comp = 0.0
err = {"gyro": [], "accel": [], "comp": []}
for k in range(1, 1001):                    # 10 সেকেন্ড
    t = k * DT
    th = true_tilt(t)
    rate = (th - true_tilt(t - DT)) / DT   # আসল কৌণিক বেগ, °/s
    gyro = rate + BIAS + rng.gauss(0, 0.3)
    push = 0.15 if 1 <= t < 1.2 else 0.0   # হেলানো শুরুর ঝাঁকুনি, g
    ay = math.sin(math.radians(th)) + push + rng.gauss(0, 0.05)
    az = math.cos(math.radians(th)) + rng.gauss(0, 0.05)
    acc = math.degrees(math.atan2(ay, az))
    gyro_only += gyro * DT
    comp = A * (comp + gyro * DT) + (1 - A) * acc
    for name, v in (("gyro", gyro_only), ("accel", acc), ("comp", comp)):
        err[name].append(v - th)
    if k in (110, 150, 200, 300, 1000):
        print(f"t={t:3.1f} s  আসল {th:5.1f}°  gyro {gyro_only:5.1f}°  "
              f"accel {acc:5.1f}°  comp {comp:5.1f}°")

for name, e in err.items():
    rms = math.sqrt(sum(x * x for x in e) / len(e))
    print(f"{name:5s}: RMS ভুল {rms:4.2f}°, শেষ ভুল {e[-1]:+5.2f}°")
print(f"সময়-ধ্রুবক τ = A·dt/(1−A) = {A * DT / (1 - A):.2f} s")

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

t=1.1 s  আসল   3.0°  gyro   4.1°  accel  10.2°  comp   5.6°
t=1.5 s  আসল  15.0°  gyro  16.5°  accel  16.7°  comp  17.5°
t=2.0 s  আসল  30.0°  gyro  32.0°  accel  35.4°  comp  31.5°
t=3.0 s  আসল  30.0°  gyro  33.0°  accel  31.3°  comp  30.6°
t=10.0 s  আসল  30.0°  gyro  39.9°  accel  26.2°  comp  30.5°
gyro : RMS ভুল 5.75°, শেষ ভুল +9.90°
accel: RMS ভুল 3.15°, শেষ ভুল -3.83°
comp : RMS ভুল 0.94°, শেষ ভুল +0.47°
সময়-ধ্রুবক τ = A·dt/(1−A) = 0.49 s

শুধু gyro দশ সেকেন্ডে প্রায় 10° সরে গেছে (bias 1 °/s × 10 s). শুধু accelerometer কখনো দূরে যায় না, কিন্তু প্রতিটি মাপ কাঁপে (শেষ মাপেই −3.83°), আর ঝাঁকুনির সময় 1.1 s-এ 10.2°, যেখানে আসল 3°. Complementary filter-এর RMS ভুল 0.94°, দুটির যেকোনোটির চেয়ে অনেক কম, আর শেষ ভুল +0.47°, stepper-এর bias × τ = 0.49°-এর প্রায় সমান। RMS মানে ভুলের বর্গের গড়ের বর্গমূল, পুরো সময়ের একটি মাপ। A বাড়িয়ে 0.995 বা কমিয়ে 0.9 করে চালিয়ে দেখুন: একদিকে ঝাঁকুনি কম ঢোকে কিন্তু bias-এর স্থির ভুল বাড়ে, অন্যদিকে উল্টো।

সীমা মনে রাখুন: এখানে শুধু এক অক্ষের হেলানো। তিন অক্ষে ঘোরা কোণগুলো একে অপরের সাথে জড়িয়ে যায়, আর বড় কোণে atan2-এর সরল সূত্র বা Euler কোণ সমস্যায় পড়ে; সেখানে quaternion আর বিশেষ fusion algorithm লাগে। আর accelerometer থেকে কোণ পাওয়া যায় শুধু ঘোরার দুটি অক্ষে; ঘড়ির কাঁটার মতো ঘোরা (yaw) মাধ্যাকর্ষণে ধরা পড়ে না, তার জন্য magnetometer বা অন্য উৎস লাগে।

৭ · Kalman filter — অনিশ্চয়তা দিয়ে ওজন ঠিক করা

EMA আর complementary filter-এ ওজন (α, A) হাতে বাছতে হয়। Kalman filter প্রশ্নটি উল্টে দেয়: “আমার অনুমান কতটা অনিশ্চিত, আর নতুন মাপ কতটা অনিশ্চিত?” দুটি অনিশ্চয়তা variance-এ রাখা হয়, আর তাদের অনুপাত থেকে প্রতিটি ধাপে ওজন বের হয়, যার নাম Kalman gain K. দুই সাক্ষীর কথা শুনে বিচারক যেমন বেশি নির্ভরযোগ্য জনের কথায় বেশি ওজন দেন, অনেকটা সেরকম। এক-মাত্রায়, একটি প্রায় স্থির রাশির (যেমন পাল্লার ওজন) জন্য, পুরো filter চার লাইন:

এক-মাত্রার Kalman filter

ভবিষ্যদ্বাণী: x̂ একই থাকে, অনিশ্চয়তা বাড়ে, P ← P + q · gain: K = P ÷ (P + r) · সংশোধন: x̂ ← x̂ + K × (z − x̂) · অনিশ্চয়তা কমে: P ← (1 − K) × P. এখানে z নতুন মাপ, r মাপের noise-এর variance, q প্রতি ধাপে আসল মান কতটা বদলাতে পারে তার variance.

সংশোধনের লাইনটি দেখুন: হুবহু EMA-র লাইন, শুধু α-র জায়গায় K, আর K প্রতি ধাপে নিজেই বদলায়। Board-এর একই noise-এর নমুনায় (r = 49 g², কারণ σ ≈ 7 g) দুটি q দিয়ে চালানো যাক।

# এক-মাত্রার Kalman filter: স্কেলের ওজন, board-এর একই noise (LCG, seed 12345)
import statistics

def samples():                             # প্রতি 10 ms-এ এক নমুনা; 805 ms-এ 1400 → 2000 g
    seed, out = 12345, []
    for n in range(1, 121):
        t = 10 * n
        g = 3000 if 505 <= t < 511 else (2000 if t >= 805 else 1400)
        seed = (1103515245 * seed + 12345) & 0x7FFFFFFF
        raw = round(400 + 0.7 * g + (seed >> 16) % 17 - 8)
        out.append((t, round((raw - 400) * 2000 / 1400)))
    return out

def kalman(zs, q, r=49.0):                 # r = noise-এর variance (≈ 7 g)², q = প্রতি ধাপে আসল ওজনের বদল
    x, p, ks, xs = zs[0], r, [], []
    for z in zs[1:]:
        p += q                             # ভবিষ্যদ্বাণী: ওজন একই, অনিশ্চয়তা বাড়ে
        k = p / (p + r)                    # Kalman gain: মাপকে কতটা বিশ্বাস
        x += k * (z - x)                   # সংশোধন
        p *= 1 - k
        ks.append(k)
        xs.append(x)
    return ks, [zs[0]] + xs

data = samples()
ts, zs = [t for t, _ in data], [z for _, z in data]
for q in (0.0, 4.0):
    ks, xs = kalman(zs, q)
    print(f"q={q}: K =", " ".join(f"{ks[i]:.3f}" for i in (0, 1, 2, 4, 9, 19, 39)))
    steady = [x for t, x in zip(ts, xs) if 200 <= t <= 500]
    hit = [i - 79 for i, t in enumerate(ts) if t > 805 and xs[i] >= 1990]
    print(f"   std={statistics.pstdev(steady):.1f} g, শেষ মান {xs[-1]:.0f} g, "
          f"1990 g at sample {hit[0] if hit else 'কখনো না'}")

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

q=0.0: K = 0.500 0.333 0.250 0.167 0.091 0.048 0.024
   std=0.5 g, শেষ মান 1613 g, 1990 g at sample কখনো না
q=4.0: K = 0.520 0.375 0.314 0.267 0.249 0.248 0.248
   std=2.7 g, শেষ মান 2000 g, 1990 g at sample 16

q = 0 মানে “ওজন কখনো বদলায় না”। তখন K = 1/2, 1/3, 1/4 … হয়, অর্থাৎ filter শুরু থেকে সব নমুনার সাধারণ গড়: std মাত্র 0.5 g, কিন্তু 2000 g-এর ধাপ সে প্রায় মানেই না, শেষে 1613 g. ভুল মডেল নিখুঁত দেখালেও ভুল উত্তর দেয়। q = 4 মানে “প্রতি ধাপে ওজন ২ গ্রামের মতো বদলাতে পারে”; K দ্রুত থিতু হয় 0.248-এ। তত্ত্বেও থিতু অবস্থায় P− = (q + √(q² + 4qr)) ÷ 2 = 16.14, K = 16.14 ÷ 65.14 ≈ 0.248. ফলটি প্রায় হুবহু EMA α = 1/4: std 2.7 g, ১৬তম নমুনায় 1990 g, tradeoff.py-এর EMA 1/4 সারির মতো।

তাহলে Kalman filter-এর লাভ কোথায়? প্রথমত, ওজনটি অনুমানে নয়, noise-এর মাপা variance থেকে আসে। দ্বিতীয়ত, শুরুতে K বড়, তাই চালু হওয়ার পরপর filter দ্রুত থিতু হয়। তৃতীয়ত, আসল শক্তি একাধিক মাত্রায়: অবস্থান আর বেগ একসাথে, বা gyro-র bias-কে একটি আলাদা অজানা হিসেবে ধরে অনুমান করা, যা complementary filter পারে না। সেখানে P একটি matrix, আর হিসাব অনেক বেশি; অ-রৈখিক মডেলে লাগে extended বা unscented রূপ। Statistics-এর দিক থেকে Kalman filter আর exponential smoothing-এর সম্পর্ক Machine Learning পর্ব ৫১-এ আছে। এই কোর্সে ছোট microcontroller-এর জন্য নিয়মটি সরল: এক মাত্রায় থিতু K নিয়ে একটি EMA প্রায়ই যথেষ্ট; বহু মাত্রার Kalman তখনই, যখন মডেল জানা আর হিসাবের সময় ও float-এর সামর্থ্য আছে।

Rudolf E. Kálmán ১৯৬০ সালে ASME-র Journal of Basic Engineering-এ “A New Approach to Linear Filtering and Prediction Problems” প্রকাশ করেন। NASA Ames-এর Stanley F. Schmidt-এর দল এর একটি অ-রৈখিক রূপ (পরে extended Kalman filter নামে পরিচিত) Apollo-র চাঁদ-যাত্রার নেভিগেশনের জন্য গড়ে তোলেন বলে ইতিহাসে ব্যাপকভাবে বর্ণিত। Median-ভিত্তিক মসৃণ করার পদ্ধতি পরিসংখ্যানবিদ John Tukey ১৯৭০-এর দশকে জনপ্রিয় করেন বলে ধরা হয়। আর complementary filter-এর সরল রূপ শৌখিন ব্যালান্স রোবট আর drone-এর জগতে ২০০০-এর দশকের শেষ দিকে খুব ছড়িয়ে পড়ে; R. Mahony ও সহকর্মীদের ২০০৮ সালের nonlinear complementary filter আর S. Madgwick-এর ২০১০ সালের orientation filter-এর প্রতিবেদন এই ধারার পরিচিত কাজ।

আরও গভীরে: MEMS gyro-র ভেতরে একটি খুদে ভর নির্দিষ্ট frequency-তে দোলে; device ঘুরলে Coriolis বলে ভরটি আড়াআড়ি সরে, আর সেই সরণ capacitance-এর বদল হিসেবে মাপা হয়। Bias তাই তাপমাত্রা আর যান্ত্রিক চাপের সাথে বদলায়, আর chip-ভেদে আলাদা; এ কারণে firmware চালুর সময় device স্থির থাকলে কয়েকশো নমুনার গড় নিয়ে bias বিয়োগ করা একটি প্রচলিত কৌশল। Sensor-এর noise আর bias-এর স্থিতিশীলতা প্রকাশের একটি মানক উপায় Allan variance, যা IEEE-র gyro-পরীক্ষার মানদণ্ডে ব্যবহৃত হয়; ভালো IMU-র datasheet-এ “bias instability” বা “noise density” সেভাবেই দেওয়া থাকে।

পরীক্ষা ও ইন্টারভিউতে: (১) “N নমুনার moving average-এর দেরি কত?” → (N − 1)/2 নমুনা; প্রতি 10 ms-এ N = 8 হলে 35 ms. (২) “EMA-তে α = 1/8, নমুনা প্রতি 10 ms; time constant?” → τ ≈ 10 × (1 − 1/8) ÷ (1/8) = 70 ms. (৩) “Spike বাদ দিতে কোন filter?” → median; গড় spike-কে ছড়িয়ে দেয়। (৪) “FIR আর IIR-এর পার্থক্য?” → IIR-এ output ফেরত আসে (feedback), কম হিসাব কিন্তু অস্থিরতার ঝুঁকি; FIR সবসময় স্থিতিশীল, linear phase সম্ভব। (৫) “Complementary filter-এ gyro আর accelerometer-এর ভূমিকা?” → gyro-র দ্রুত অংশ (high-pass), accelerometer-এর ধীর অংশ (low-pass); A = 0.98, dt = 10 ms-এ τ = 0.49 s.

৮ · AI-এর যুগে filter-এর কোড আর হিসাব যাচাই

“Sensor-এর reading মসৃণ করার C কোড দিন” লিখলে AI assistant কয়েক সেকেন্ডে কোড দেয়, প্রায়ই float-এ, প্রায়ই চলেও। কিন্তু filter-এর ভুল প্রায়ই চোখে পড়ে না: সংখ্যা মসৃণ দেখায়, শুধু দেরিতে, বা ধীরে ভুল দিকে সরে। সবচেয়ে চেনা ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
Fixed-point EMA-তে ভগ্নাংশ বিট রাখে না, বা y + (x - y) >> 3 লেখে (অগ্রাধিকারের ভুল)-Wall -Werror-এ Clang নিজেই ধরে (অনুশীলন ২); স্থির input-এ চালিয়ে output দেখা
Moving average-এর যোগফল uint16_t-এ, বা প্রতিবার পুরো buffer আবার যোগ করেN × সর্বোচ্চ মান হিসাব করে type বাছাই; চলমান যোগফল ব্যবহার
Spike-এর জন্যও গড় সুপারিশ করে, median-এর কথা বলে নাSeed দেওয়া spike-সহ নমুনায় (অংশ ৪-এর block) চালিয়ে দেখা
Filter-এর দেরি উল্লেখ করে না, control loop-এ বা alarm-এ সেই দেরি ভুলে যায়(N − 1)/2 আর τ হাতে হিসাব; ধাপ দিয়ে সময় মাপা
Complementary filter-এ dt নির্দিষ্ট ধরে, অথচ loop-এর আসল ব্যবধান অনিয়মিত; বা gyro-র একক (rad/s বনাম °/s) গুলিয়ে ফেলেTimer থেকে আসল dt মাপা; sensor-এর datasheet-এ সংবেদনশীলতার একক মেলানো
নির্দিষ্ট IMU-র register-এর ঠিকানা বা scale factor বানিয়ে বলেনিজের chip-এর datasheet আর register map মিলিয়ে দেখা

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

আমি একটি ARM Cortex-M3 microcontroller-এ (FPU নেই, C, Clang -O2) load cell-এর ওজন মাপছি, প্রতি 10 ms-এ একটি ADC নমুনা, গ্রামে int32_t. Noise প্রায় ±8 count (σ ≈ 7 g), আর মাঝে মাঝে পাল্লায় ধাক্কার spike আসে। ১. Spike বাদ দিতে ৩ বা ৫ নমুনার median, তারপর EMA α = 1/4 — এমন একটি function লেখো, পুরো integer-এ; EMA-র state-এ ৮টি ভগ্নাংশ বিট রাখবে, আর ঋণাত্মক মানেও গোল করা ঠিক থাকবে। ২. মোট দেরি নমুনা আর ms-এ হিসাব করে দেখাও, ধাপে ধাপে। ৩. প্রতিটি যোগফল আর গুণফলের সর্বোচ্চ মান হিসাব করে দেখাও যে int32_t-এ আঁটে। ৪. একটি পরীক্ষার তালিকা দাও: স্থির ওজন, একক spike, পরপর দুটি spike, ধাপ; প্রতিটিতে প্রত্যাশিত ফল। ৫. কোনো chip-এর register বা library function-এর নাম নিয়ে নিশ্চিত না হলে বলো "নিশ্চিত নই, datasheet বা documentation দেখুন"; বানিয়ে বলবে না।

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

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

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

প্র ০১Filter যত মসৃণ, তত দেরি। একটি সাধারণ display-এ এই দেরি তেমন ক্ষতি করে না, কিন্তু একটি alarm বা feedback control-এ কেন বিপজ্জনক হতে পারে? বাজারঘরের cold room-এর নিয়ম দিয়ে ব্যাখ্যা করুন।

Display-এ দেরি মানে মানুষ এক সেকেন্ড পরে সঠিক সংখ্যা দেখেন; ক্ষতি সামান্য। কিন্তু filter-এর output দিয়ে যদি সিদ্ধান্ত হয়, তাহলে দেরি সরাসরি সিদ্ধান্তের দেরি। বাজারঘরের cold room প্রতি 1 s-এ তাপমাত্রা পড়ে, আর পরপর ৩টি মাপ সীমার বাইরে হলে তবেই alarm চালু করে (README-র নিয়ম)। এই “৩টি পরপর” নিয়ম নিজেই একটি filter, অনেকটা median-এর মতো: একটি ভুল মাপে alarm বাজে না, কিন্তু আসল বিপদেও কমপক্ষে ৩ সেকেন্ড দেরি হয়। এর আগে যদি কেউ α = 1/8-এর একটি EMA বসান, বাড়তি দেরি হবে আরও অনেক। অনুশীলন ১-এর run-এ median-৩ আর EMA 1/8-এর জোড় 4.00 °C থেকে −0.50 °C-এর হঠাৎ পতনের পর ১০টি নমুনা পরেও output দেখিয়েছে মাত্র t16 = 14, অর্থাৎ 0.875 °C; ঘরটি আসলে বরফের নিচে, আর filter তখনো বলছে সব ঠিক।

Feedback control-এ সমস্যাটি আরও গভীর। Controller মাপা মান দেখে heater বা motor চালায়। Filter যদি সংকেতকে পিছিয়ে দেয়, controller আসলে অতীতের অবস্থার জবাব দেয়। Gain বেশি হলে সে বেশি ঠেলে, ফল দেরিতে দেখে আরও ঠেলে, আর সিস্টেম লক্ষ্য পেরিয়ে দোলে; চরমে দোলন বাড়তেই থাকে। Control তত্ত্বে একে বলা হয় phase lag, আর moving average-এর (N − 1)/2 নমুনার দেরি সরাসরি সেই lag. PID control-এর নকশায় এটি নিয়ে পর্ব ৬৯-এ আরও কথা হবে।

তাহলে প্রকৌশলী কী করেন? প্রথমত, কোন সিদ্ধান্তের জন্য কত দেরি গ্রহণযোগ্য, সেটি আগে লিখে রাখেন (cold room-এ হয়তো এক মিনিট, একটি drone-এর ভারসাম্যে কয়েক মিলিসেকেন্ড)। দ্বিতীয়ত, সেই সীমার ভেতরে noise যতটা কমানো যায়, filter বাছেন। তৃতীয়ত, একাধিক পথ রাখেন: display-এর জন্য খুব মসৃণ filter, আর নিরাপত্তার alarm-এর জন্য দ্রুত পথ, হয়তো শুধু ছোট median আর একটি চরম সীমা, যা একটি মাপেই কাজ করে। চতুর্থত, sampling rate বাড়ান: একই সময়ের জানালায় বেশি নমুনা মানে একই দেরিতে বেশি গড়।

মূল উপলব্ধি: Filter-এর দেরি সিদ্ধান্তের দেরি; নকশার শুরুতেই প্রতিটি output-এর জন্য দেরির বাজেট ঠিক করে, তার ভেতরে noise কমানোর filter বাছতে হয়, আর নিরাপত্তার পথ আলাদা রাখতে হয়।

প্র ০২Median filter spike মোছে কিন্তু এলোমেলো noise ভালো কমায় না, আর গড় ঠিক উল্টো। গণিতের দিক থেকে এর কারণ কী, আর বাস্তবে দুটির মধ্যে বাছাই কীভাবে করবেন?

গড় প্রতিটি নমুনাকে সমান ওজন দেয়, তাই একটি নমুনা যত দূরেই যাক, ফল তার সমানুপাতে সরে: 3011 g-এর একটি মান ৮টির গড়কে প্রায় 201 g সরিয়েছে। পরিসংখ্যানের ভাষায় গড়ের “breakdown point” শূন্য: একটিমাত্র যথেষ্ট খারাপ মান ফলকে যত খুশি দূরে নিতে পারে। Median-এর breakdown point প্রায় অর্ধেক: ৫টির জানালায় দুটি মান অসীমে গেলেও মাঝের মান বাকি তিনটির মধ্যে থাকে। এজন্য median-কে বলা হয় robust.

কিন্তু এর দাম আছে। এলোমেলো, ঘণ্টা-আকৃতির (Gaussian) noise-এ গড়ই সবচেয়ে দক্ষ: একই নমুনা-সংখ্যায় সবচেয়ে কম ছড়ানো। পরিসংখ্যানের একটি পরিচিত ফল হলো, বড় নমুনায় median-এর variance গড়ের প্রায় π/2 ≈ 1.57 গুণ। আর board-এর noise সমান-সম্ভাবনার (uniform), যেখানে median আরও দুর্বল; run-এ শান্ত অবস্থায় median-৫-এর ফারাক 19 g, কাঁচার 22 g থেকে সামান্যই কম, যেখানে moving average-৮ নামিয়েছে 9 g-এ। কারণ median শুধু মাঝের অবস্থান দেখে, বাকি নমুনার মান থেকে তথ্য ফেলে দেয়।

আরেকটি পার্থক্য: median রৈখিক নয়। দুটি সংকেতের যোগের median তাদের median-এর যোগ নয়। ফলে frequency response দিয়ে তাকে বিশ্লেষণ করা যায় না, আর তার আচরণ input-এর আকারের ওপর নির্ভর করে। আবার এই অ-রৈখিকতারই একটি সুবিধা আছে: median ধাপকে ধাপ হিসেবে রাখে, ঢালু করে না, তাই হঠাৎ বদলের সময় বা ধার বজায় রাখতে (যেমন ছবির noise কমানোয়) কাজের।

বাছাইয়ের ব্যবহারিক নিয়ম তাই noise-এর ধরন দেখে। প্রথমে কিছু কাঁচা নমুনা রেকর্ড করে দেখুন: শুধু ছোট এলোমেলো কাঁপুনি হলে গড় বা EMA. মাঝে মাঝে বিচ্ছিন্ন, বড় spike (যোগাযোগের ভুল, যান্ত্রিক ধাক্কা) থাকলে আগে ছোট median (৩ বা ৫), তারপর গড়। খুব বেশি spike, বা একটানা কয়েকটি, হলে filter নয়, উৎস খুঁজুন: তার, grounding, I2C-এর pull-up. আর একটি সস্তা সহায়ক: শারীরিকভাবে অসম্ভব মান (5000 g-এর স্কেলে 30 kg, cold room-এ +100 °C) সরাসরি বাতিল।

মূল উপলব্ধি: গড় এলোমেলো noise-এ সবচেয়ে দক্ষ কিন্তু spike-এ ভঙ্গুর, median spike-এ শক্ত কিন্তু noise-এ কম দক্ষ; noise-এর ধরন মেপে বাছুন, প্রায়ই দুটিকে পরপর বসান।

প্র ০৩Kalman filter Apollo-র নেভিগেশনে ব্যবহার হয়েছিল বলে বিখ্যাত। তাহলে আজকের প্রতিটি microcontroller-এ কেন সবাই Kalman filter চালান না, আর কখন সেটি সত্যিই দরকার?

১৯৬০ সালে R. E. Kálmán যখন তাঁর পদ্ধতি প্রকাশ করেন, সেটি ছিল রৈখিক সিস্টেমের জন্য। Apollo-র মহাকাশযানের গতি অ-রৈখিক, আর NASA Ames-এর Stanley Schmidt-এর দল এর একটি রূপান্তর (বর্তমান মডেলের চারপাশে রৈখিক করে নেওয়া, যা পরে extended Kalman filter নামে পরিচিত) কাজে লাগায় বলে ইতিহাসে বর্ণিত। Apollo-র guidance computer-এর ক্ষমতা ছিল আজকের সাধারণ microcontroller-এর চেয়েও অনেক কম, অথচ হিসাবটি সেখানে চলত; কারণ মহাকাশযানের গতির পদার্থবিদ্যা খুব ভালোভাবে জানা ছিল, আর প্রতিটি মাপের noise-এর মাপও।

এখানেই মূল শর্ত: Kalman filter মডেল-নির্ভর। এটি সর্বোত্তম (রৈখিক সিস্টেম আর Gaussian noise-এর শর্তে) তখনই, যখন সিস্টেম কীভাবে বদলায় (state model), মাপ কীভাবে state-এর সাথে যুক্ত, আর q ও r-এর মতো noise-এর মান ঠিক জানা। মডেল ভুল হলে ফলও ভুল, আর এই পর্বের q = 0-এর উদাহরণ দেখিয়েছে কতটা নিঃশব্দে: std মাত্র 0.5 g, অথচ ওজন বদলের পরেও output 1613 g-এ আটকে। একটি দোকানের পাল্লায় কেউ কখন কী রাখবেন তার কোনো পদার্থবিদ্যা নেই; তাই বড় মডেলের লাভ কম।

খরচও আছে। n মাত্রার state-এ প্রতি ধাপে n × n matrix-এর গুণ আর একটি ছোট matrix-এর উল্টানো লাগে; float ছাড়া Cortex-M3-এ fixed-point-এ এটি লেখা কঠিন আর সংখ্যার পাল্লা নিয়ে ঝুঁকিপূর্ণ (P matrix ধনাত্মক থাকা উচিত, গোল করার ভুলে তা ভাঙতে পারে)। তার ওপর q আর r মাপা আর tuning করা নিজেই একটি প্রকল্প। এক মাত্রায়, স্থির q আর r-এ, filter থিতু হয়ে একটি EMA হয়ে যায়; তখন সরাসরি থিতু K দিয়ে EMA চালানোই সস্তা আর একই ফল।

কখন দরকার? যখন একাধিক sensor ভিন্ন হারে আসে (GPS প্রতি সেকেন্ডে, IMU প্রতি মিলিসেকেন্ডে), যখন সরাসরি না মাপা কিছু অনুমান করতে হয় (gyro-র bias, ব্যাটারির charge-এর অবস্থা), আর যখন মডেল ভালো জানা (গাড়ি, drone, ব্যাটারি)। তখন Cortex-M4F বা M7-এর মতো FPU-সহ chip আর পরীক্ষিত library সাধারণত বাছাই হয়। ছোট device-এ প্রথমে সরল filter, পরিমাপ করে দেখা যে সেটি অপর্যাপ্ত, তবেই Kalman.

মূল উপলব্ধি: Kalman filter-এর শক্তি তার মডেলে, আর দুর্বলতাও সেখানে; মডেল জানা, একাধিক sensor আর লুকানো রাশি থাকলে এটি অমূল্য, নইলে এক-মাত্রায় তার থিতু রূপ একটি EMA-ই যথেষ্ট।

প্র ০৪ফোন আর drone-এ complementary filter, Mahony বা Madgwick-এর filter আর Kalman filter, সবই কোণ মাপতে ব্যবহার হয়। একটি ছোট ব্যালান্স রোবট বা খেলনা drone-এর জন্য কোনটি কেন বাছবেন?

সবগুলোর মূল ধারণা এক: gyro-র দ্রুত তথ্য আর accelerometer (আর কখনো magnetometer)-এর ধীর কিন্তু drift-হীন তথ্য মেলানো। পার্থক্য কতটা মডেল আর হিসাব লাগে। এক অক্ষের complementary filter এই পর্বের এক লাইন: প্রতি নমুনায় কয়েকটি গুণ-যোগ আর একটি atan2. ২০০০-এর দশকের শেষে শৌখিন রোবট নির্মাতাদের মধ্যে এটি ব্যাপক জনপ্রিয় হয়, কারণ ৮ বিটের microcontroller-এও চলে আর বোঝা সহজ।

তিন অক্ষে ঘোরার সময় কোণগুলো একে অপরের সাথে জড়ায়, আর Euler কোণে একটি বিশেষ অবস্থানে একটি অক্ষ হারিয়ে যায়, যার নাম gimbal lock. এজন্য orientation সাধারণত quaternion-এ রাখা হয়। ২০০৮ সালে R. Mahony ও সহকর্মীরা complementary filter-এর একটি অ-রৈখিক রূপ প্রকাশ করেন, যেখানে accelerometer-এর দেখানো “নিচের দিক” আর অনুমিত দিকের ফারাক দিয়ে gyro-র মাপ সংশোধন হয়, একটি PI-ধরনের নিয়মে, যা gyro-র bias-ও ধীরে অনুমান করে। ২০১০ সালে S. Madgwick-এর প্রতিবেদন gradient descent-ভিত্তিক একটি দক্ষ orientation filter দেয়। দুটিই খোলা উৎসের অনেক drone আর IMU library-তে দেখা যায়; বিস্তারিত সূত্র তাঁদের মূল লেখায়।

Extended Kalman filter আরও সাধারণ: gyro-র bias, accelerometer-এর ভুল, এমনকি GPS আর barometer এক কাঠামোয় আনা যায়, আর প্রতিটি অনুমানের অনিশ্চয়তাও পাওয়া যায়। দাম হলো matrix-এর হিসাব, float-এর প্রয়োজন আর tuning-এর জটিলতা। উন্নত flight controller-এ এই পথ প্রচলিত বলে জানা যায়, যেখানে FPU-সহ শক্তিশালী chip থাকে।

একটি ছোট ব্যালান্স রোবটে শুধু একটি অক্ষের হেলানো দরকার, আর loop দ্রুত চলে; complementary filter এখানে প্রায় সবসময় যথেষ্ট, সঙ্গে চালুর সময় স্থির অবস্থায় gyro-র bias মেপে বিয়োগ। খেলনা drone-এ তিন অক্ষ লাগে, তাই quaternion-ভিত্তিক Mahony বা Madgwick ধরনের filter সাধারণ পছন্দ। আর যেখানে অবস্থান, উচ্চতা আর একাধিক sensor মেলাতে হয়, সেখানে Kalman. যেটিই বাছুন, যাচাই একই: পরিচিত কোণে স্থির রেখে, জোরে ঝাঁকিয়ে, আর দীর্ঘ সময় চালিয়ে drift মেপে।

মূল উপলব্ধি: সব fusion algorithm একই দুই তথ্যের মিশ্রণ, কেবল মডেল আর হিসাবের মাত্রা আলাদা; প্রয়োজনের সবচেয়ে সরলটি বেছে, পরিমাপ করে যাচাই করে, তবেই জটিলতর পথে যান।

প্র ০৫একটি IIR filter কাগজে নিখুঁত, কিন্তু microcontroller-এর fixed-point-এ সেটি আটকে যায়, দোলে বা অস্থির হয়। কেন, আর এড়ানোর উপায় কী?

IIR-এর output ফেরত আসে, তাই প্রতিটি ধাপের ছোট গোল করার ভুলও ফেরত আসে আর জমতে পারে। সবচেয়ে সরল উদাহরণ এই পর্বের EMA: পূর্ণ গ্রামের state-এ α = 1/4 হলে (x − y) ÷ 4 যখন 1-এর কম, সংশোধন শূন্য, তাই y আসল মান থেকে ৩ g পর্যন্ত দূরে চিরকাল আটকে থাকতে পারে। পর্ব ৪০-এর হিসাবে α = 1/16-এ ছাঁটাইসহ y 100-এর লক্ষ্যে 85-এ আটকে গিয়েছিল। এটি একটি “dead band”; বড় filter-এ এর আত্মীয় হলো limit cycle, যেখানে input শূন্য হলেও output ছোট মানে স্থায়ীভাবে দোলে।

দ্বিতীয় সমস্যা সহগের quantization. একটি তীক্ষ্ণ low-pass IIR-এর pole-গুলো একক বৃত্তের খুব কাছে থাকে; সহগ Q15-এ গোল করলে pole সামান্য সরে, আর বৃত্তের বাইরে গেলে filter অস্থির: output বাড়তেই থাকে। উঁচু order-এর একটি filter একবারে লিখলে এই সংবেদনশীলতা অনেক বাড়ে। এজন্য প্রচলিত নিয়ম হলো filter-কে দ্বিতীয়-order-এর ছোট ছোট টুকরোয় (biquad) ভাগ করে পরপর বসানো, যা CMSIS-DSP-এর biquad cascade function-গুলো করে।

তৃতীয় সমস্যা overflow. Feedback-এ মান হঠাৎ বড় হলে ৩২ বিটের accumulator-ও ভরে যেতে পারে; two's complement-এ উপচে পড়া মান হঠাৎ উল্টো চিহ্নে লাফায়, যা একটি control loop-এর জন্য ভয়ংকর। সমাধান: state-এ যথেষ্ট headroom, প্রয়োজনে saturation, আর পরীক্ষায় সর্বোচ্চ input.

এড়ানোর উপায় তাই কয়েক স্তরের। State-এ বাড়তি ভগ্নাংশ বিট রাখা (এই পর্বের Q8), গোল করা, accumulator চওড়া রাখা; উঁচু order-এ biquad cascade; সহগ গোল করার পরে pole আবার পরীক্ষা; আর নকশার পরে host-এ bit-exact মডেল চালিয়ে আসল firmware-এর output-এর সাথে মেলানো, যেমন এই পর্বে Python-এর replica আর board-এর run নমুনা ধরে মিলেছে। যেখানে পারা যায়, FIR (যা সবসময় স্থিতিশীল) বা EMA-র মতো একটি সরল, বিশ্লেষণযোগ্য IIR. আর FPU-সহ chip-এ float সরাসরি অনেক সমস্যা কমায়, যদিও float-এরও নিজস্ব গোল করার ভুল আছে।

মূল উপলব্ধি: IIR-এর feedback গোল করার ভুল, সহগের quantization আর overflow-কে বারবার ফেরত আনে; বাড়তি ভগ্নাংশ বিট, biquad-এ ভাগ আর bit-exact মডেলে যাচাই এর প্রধান ওষুধ।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — cold room-এর filter: Cold room-এর sensor প্রতি 1 s-এ t16 দেয়, 1/16 °C এককে (README অনুযায়ী 64 মানে 4.00 °C). মাঝে মাঝে একটি ভুল I2C পড়া spike আনে। একটি tfilt_push() লিখুন: আগে ৩টির median, তারপর EMA α = 1/8, state-এ ৮টি ভগ্নাংশ বিট, শূন্যের নিচের তাপমাত্রাতেও ঠিক গোল করা। Input 64, 65, 64, 400, 64, 65, তারপর একটানা −8 (−0.50 °C) দিলে output কেমন হবে?
    static int32_t med3(int32_t a, int32_t b, int32_t c)
    {
        if (a > b) { int32_t t = a; a = b; b = t; }  /* a <= b */
        if (b > c) b = c;                              /* b = min(b, c) */
        return (a > b) ? a : b;                        /* max(a, min(b, c)) */
    }
    
    typedef struct { int32_t w[3]; uint32_t n; int32_t y8; } tfilt_t;
    
    static int32_t tfilt_push(tfilt_t *f, int32_t x)
    {
        f->w[f->n % 3u] = x;
        f->n++;
        int32_t m = (f->n < 3u) ? x : med3(f->w[0], f->w[1], f->w[2]);
        if (f->n == 1u)
            f->y8 = m * 256;                           /* start at the first value */
        f->y8 += (m * 256 - f->y8) / 8;
        return div_round(f->y8, 256);                  /* half away from zero */
    }

    Median-৩ মাত্র তিনটি তুলনায় হয়। div_round() reference-এর bglib.c-এর function (শূন্য থেকে দূরে গোল), তাই −0.5 °C-এর কাছেও গোল করা ঠিক থাকে; (y8 + 128) / 256 ঋণাত্মক মানে ভুল দিকে গোল করত। সত্যিকারের run (lab-এর ex.c, board-এ): task1: 64 64 64 64 64 64 64 55 47 40 34 29 24 20 17 14. 400-এর spike (25 °C) কোনো চিহ্ন রাখেনি। তাপমাত্রা −8-এ নামার পর প্রথম −8-এ median তখনো 64 (জানালায় 64, 65, −8), দ্বিতীয়টিতে median −8, তারপর EMA প্রতি ধাপে বাকি দূরত্বের ১/৮ করে নামে: 55, 47, 40 … ১০টি নমুনা পরে মাত্র 14, অর্থাৎ 0.875 °C. একই নিয়মের হিসাব-script বলে, প্রথম −8-এর পর output −7-এ নামতে ৩১টি নমুনা, মানে ৩১ সেকেন্ড লাগে। মানে এই filter cold room-এর alarm-এর জন্য খুব ধীর; display-এর জন্য ঠিক, কিন্তু README-র ৩-মাপের alarm-নিয়ম কাঁচা বা শুধু median-করা মানে চালানোই নিরাপদ (ভাবনার প্রশ্ন ১)।

  2. ভুল খুঁজুন — এক লাইনের EMA: একজন লিখলেন:
    static uint16_t y;                /* EMA, alpha = 1/8 */
    uint16_t ema(uint16_t x)
    {
        y = y + (x - y) >> 3;
        return y;
    }
    ADC-তে স্থির 1380 count এলে প্রথম পাঁচটি output কী হবে? কয়টি ভুল আছে, আর Clang -Wall কী বলে?

    (১) অগ্রাধিকার: C-তে >>-এর অগ্রাধিকার +-এর চেয়ে কম, তাই লাইনটি আসলে (y + x − y) >> 3 = x ÷ 8. প্রতিবার output 1380 >> 3 = 172, কোনো filtering নেই। সত্যিকারের run (lab-এর ex.c): task2 bad : 172 172 172 172 172. Board-এর build-এ (-Wall -Wextra -Werror) Clang 22.1.8 এটি compile-ই করতে দেয়নি: error: operator '>>' has lower precedence than '+'; '+' will be evaluated first [-Werror,-Wshift-op-parentheses]; চালানোর জন্য সেই warning ইচ্ছা করে বন্ধ করতে হয়েছিল। (২) ভগ্নাংশ বিট নেই: বন্ধনী ঠিক করলেও পূর্ণ count-এর state-এ (x − y) >> 3 যখন 1-এর কম, y আটকে যায়, আসল মান থেকে ৭ count পর্যন্ত দূরে। (৩) শুরু: y 0 থেকে শুরু হয়, তাই চালুর পর ধীরে ধীরে উঠতে অনেক নমুনা লাগে; প্রথম নমুনায় y = x বসানো ভালো। (৪) ঋণাত্মক ফারাক: এখানে uint16_t int-এ promote হয় বলে (x − y) ঋণাত্মক হতে পারে আর >> arithmetic shift; কিন্তু type uint32_t হলে বিয়োগ উল্টে বিশাল ধনাত্মক হতো। সংশোধিত রূপ: int32_t Q8 state, প্রথম নমুনায় শুরু, y8 += (x * 256 - y8) / 8, output div_round(y8, 256). Run: task2 good: 1380 1380 1380 1380 1380.

  3. হিসাব — দেরি, শূন্য বিন্দু আর time constant: (ক) প্রতি 1 ms-এ নমুনা, N = 10-এর moving average: দেরি কত ms? প্রথম শূন্য বিন্দু কোন frequency-তে? 50 Hz-এর hum কি মুছে যায়? (খ) প্রতি 10 ms-এ নমুনা, EMA-র τ = 0.5 s চাই: α কত? α = 1/2k-এর কোনটি কাছাকাছি, আর তাতে ধাপের ৯৫% পেতে কত সময়? (গ) Complementary filter, A = 0.98, dt = 10 ms, gyro-র bias 0.5 °/s: থিতু ভুল কত?

    (ক) দেরি (10 − 1) ÷ 2 = 4.5 নমুনা = 4.5 ms. শূন্য বিন্দু fs ÷ N-এর গুণিতকে: 100 Hz, 200, 300 Hz. 50 Hz সেখানে নেই; হিসাব-script-এ 50 Hz-এ gain 0.639, অর্থাৎ hum-এর প্রায় দুই-তৃতীয়াংশ থেকে যায়। ঠিক মুছতে জানালা 20 ms (N = 20) লাগে, যেখানে gain 0. (খ) α = Ts ÷ (τ + Ts) = 0.01 ÷ 0.51 ≈ 0.0196. কাছের shift: 1/64 = 0.0156 (τ = 0.01 × 63 = 0.63 s) বা 1/32 = 0.03125 (τ = 0.31 s). 1/64 নিলে script-এ ধাপের ৯৫%-এ পৌঁছাতে 191 নমুনা = 1.91 s, প্রায় 3τ. (গ) τ = 0.98 × 0.01 ÷ 0.02 = 0.49 s; থিতু ভুল = bias × τ = 0.5 × 0.49 = 0.245°. সব মান lab-এর হিসাব-script-এ মেলানো।

  4. আগে বলুন, তারপর মেলান — ৩টির median: ধারা 20, 21, 95, 22, 23, 90, 91, 24-এ ৩টির জানালার median (তৃতীয় নমুনা থেকে শুরু) কী কী হবে? কোন spike বাদ পড়ে, কোনটি পড়ে না, কেন?

    জানালা আর median: (20, 21, 95) → 21; (21, 95, 22) → 22; (95, 22, 23) → 23; (22, 23, 90) → 23; (23, 90, 91) → 90; (90, 91, 24) → 90. সত্যিকারের run (lab-এর ex.c, ওপরের med3()): task4: 21 22 23 23 90 90. একা 95 পুরো বাদ পড়েছে, কিন্তু পরপর দুটি spike (90, 91) ৩টির জানালায় সংখ্যাগরিষ্ঠ, তাই median নিজেই 90 দিয়েছে। নিয়মটি: N-এর জানালার median পরপর (N − 1)/2টি পর্যন্ত spike সামলায়; ৩-এ একটি, ৫-এ দুটি। লম্বা spike-এর জন্য বড় জানালা, যার দাম বেশি দেরি।

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

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

ক্রমএকটি complementary filter-এর এক নমুনার কাজ সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Timer থেকে আগের নমুনার পরের আসল সময় dt মাপা
  2. IMU থেকে gyro-র বেগ আর accelerometer-এর ত্বরণ পড়া
  3. Gyro-র মাপ থেকে চালুর সময় মাপা bias বিয়োগ করা
  4. Accelerometer-এর মাপ থেকে atan2 দিয়ে কোণ বের করা
  5. আগের কোণে বেগ × dt যোগ করে ভবিষ্যদ্বাণী
  6. A আর (1 − A) ওজনে দুটি মিলিয়ে নতুন কোণ রাখা

প্রতি 10 ms-এ একটি নমুনা নেওয়া হয়, আর output হলো শেষ ৯টি নমুনার moving average. Output বর্তমান থেকে প্রায় কত সময় পিছিয়ে থাকে?

  • 90 ms
  • 10 ms
  • 40 ms
  • শূন্য, কারণ নতুন নমুনাও গড়ে আছে

একটি load cell-এর মাপে মাঝে মাঝে একটি করে বিচ্ছিন্ন, অনেক বড় ভুল মান আসে (spike), বাকি সময় সামান্য noise. Spike যেন output-এ একটুও না ঢোকে, তার জন্য প্রথম ধাপে কোন filter?

  • ৮ নমুনার moving average
  • ৩ বা ৫ নমুনার median
  • α = 1/4-এর EMA
  • ADC-র sampling rate দ্বিগুণ করা

Fixed-point EMA-র নিয়ম y ← y + (x − y) ÷ 8. y আর x দুটিই পূর্ণসংখ্যা, কোনো ভগ্নাংশ বিট নেই, ভাগ শূন্যের দিকে ছাঁটে। x স্থির 1000 আর y শুরুতে 990 হলে y শেষে কোথায় থামবে?

  • ঠিক 1000-এ
  • 990-এই, কখনো নড়বে না
  • 1000 পেরিয়ে দুলতে থাকবে
  • 993-এ আটকে যাবে

একটি complementary filter: θ ← A × (θ + ωgyro × dt) + (1 − A) × θaccel, A = 0.98. এখানে gyro আর accelerometer-এর ভূমিকা কোনটি?

  • Gyro দ্রুত বদলের জন্য (high-pass), accelerometer দীর্ঘ সময়ের সঠিকতার জন্য (low-pass)
  • Accelerometer দ্রুত বদলের জন্য, gyro দীর্ঘ সময়ের জন্য
  • দুটিই সমান ভূমিকা, গড় নেওয়া হচ্ছে
  • Gyro একাই যথেষ্ট, accelerometer শুধু শুরুর মান দেয়

এক-মাত্রার Kalman filter-এ মাপের noise-এর variance r বেশ বড়, আর অনুমানের বর্তমান অনিশ্চয়তা P খুব ছোট। পরের মাপে Kalman gain K = P ÷ (P + r) কেমন হবে, আর তার অর্থ কী?

  • প্রায় 1, নতুন মাপ প্রায় পুরো মেনে নেওয়া হবে
  • 1-এর বেশি, মাপের দিকে আরও বেশি সরানো হবে
  • প্রায় 0, নতুন মাপ অনুমানকে খুব অল্প সরাবে
  • সবসময় ঠিক 0.5

FIR আর IIR filter-এর মধ্যে কোন কথাটি সঠিক?

  • IIR-এ একটি ধাক্কার প্রভাব নির্দিষ্ট সংখ্যক নমুনা পরে পুরো শূন্য হয়
  • FIR সবসময় স্থিতিশীল, IIR সহগ ভুল হলে অস্থির হতে পারে
  • Moving average একটি IIR filter
  • একই তীক্ষ্ণতায় FIR-এ IIR-এর চেয়ে কম হিসাব লাগে

শব্দকোষ

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

মনে রাখুন

  1. Noise চিনে ওষুধ: এলোমেলো noise-এ গড়, hum-এ নমুনার আগে RC আর 20 ms-এর জানালা, spike-এ median, drift-এ calibration বা দ্বিতীয় sensor.
  2. Moving average: ring buffer আর চলমান যোগফল; দেরি (N − 1)/2 নমুনা, ধাপে N নমুনা; fs ÷ N-এর গুণিতকে শূন্য বিন্দু। একটি FIR filter.
  3. EMA: y += α(x − y), α = 1/2k-এ shift; state-এ ভগ্নাংশ বিট রাখুন। τ ≈ Ts(1 − α)/α; α ≈ 2/(N + 1)-এ MA-র সমান মসৃণ, কিন্তু লম্বা লেজ। একটি IIR filter.
  4. Median: spike বাদ দেয় (N-এর জানালায় পরপর (N − 1)/2টি পর্যন্ত), ধাপ ধরে রাখে, কিন্তু noise-এ কম দক্ষ; প্রায়ই median তারপর গড়।
  5. Fusion: complementary filter gyro-র দ্রুত আর accelerometer-এর ধীর অংশ মেলায়, থিতু ভুল bias × τ; এক-মাত্রার Kalman-এর K থিতু হলে সেটি একটি EMA.

পরের পর্বে: পর্ব ৬৯ (PID control — feedback, tuning আর firmware-এ বাস্তবায়ন). মসৃণ মাপ হাতে, এবার তা দিয়ে কিছু নিয়ন্ত্রণ: P, I আর D-এর অর্থ, integral windup, আর filter-এর দেরি কীভাবে একটি control loop-কে দোলাতে পারে।

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

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