এই পর্বে যা শিখবেন
- যেকোনো Qm.n বিন্যাসের পরিসর আর ধাপ হিসাব করা, আর আসল সংখ্যাকে Q-তে নেওয়া ও ফেরানো
- যোগ, বিয়োগ, গুণ আর ভাগে scaling ঠিক রাখা, rounding দিয়ে ছাঁটাইয়ের পক্ষপাত দূর করা, আর overflow-এ saturation বসানো
- বাজারঘর স্কেলের ADC count থেকে Q16.16-এ গ্রাম আর cold room-এর sensor word থেকে ১/১৬ °C, প্রতিটি সম্ভাব্য ইনপুটে যাচাই করে
- FPU-হীন Cortex-M3-এ soft-float-এর খরচ আসল নির্দেশ-সংখ্যা আর code size দিয়ে মাপা, আর float কোথায় চলে, কোথায় চলে না তা বোঝা
- AI-র লেখা fixed-point কোডের overflow, rounding আর ভুল shift ধরার একটি নিয়মিত পদ্ধতি
১ · দশমিক বিন্দু কোথায় — দাঁড়িপাল্লা, পয়সা আর FPU-হীন CPU
উপমা — দোকানের খাতা: বাজারঘরের দোকানদার খাতায় কখনো “৮১.৮৮ টাকা” লেখেন না, লেখেন “৮১৮৮” আর মনে রাখেন শেষ দুই অঙ্ক পয়সা। যোগ-বিয়োগ তখন সাধারণ পূর্ণসংখ্যার, ভুলের সুযোগ কম, আর দশমিক বিন্দু শুধু ক্রেতাকে বলার সময় বসে। বিন্দুটি সংখ্যার ভেতরে নেই, আছে দোকানদারের মাথায়, আর তার জায়গা কখনো বদলায় না। এই “স্থির বিন্দু”-ই fixed-point.
পর্ব ০৫-এ (এমবেডেড কাজের সংখ্যা) আপনি এর তিনটি রূপ দেখেছেন: দাম পয়সায় (8188 = 81.88 টাকা), দর পয়সা প্রতি kg-তে (6550), আর cold room-এর তাপমাত্রা ১/১৬ °C এককে। সেখানে নামও পেয়েছেন: fixed-point মানে এমন একটি integer, যার দশমিক বিন্দুর জায়গা আগে থেকে ঠিক করা, আর binary বিন্দুর বেলায় তার নাম লেখা হয় Q format-এ। এই পর্বে সেই পরিচয় থেকে পুরো কারিগরিতে যাব: প্রতিটি কাজে বিন্দু কোথায় সরে, কতটা ভুল ঢোকে, কখন সংখ্যা উপচে পড়ে, আর float-এর বদলে এই ঝামেলা কেন নেওয়া হয়।
শেষ প্রশ্নের উত্তর কোর্সের virtual বাজারঘর board-এর CPU-তেই। BG-M3 একটি Cortex-M3 (কোনো আসল পণ্য নয়, আসল ARMv7-M CPU-র চারপাশে Python-এ লেখা STM32-ধাঁচের peripheral; পর্ব ০৬), আর ARM-এর Cortex-M3 Technical Reference Manual অনুযায়ী এই core-এ কোনো FPU নেই। C-তে float লিখলে তাই compiler প্রতিটি গুণ-যোগকে library function-এর ডাকে বদলায়, যার নাম soft-float. অংশ ৮-এ আসল মাপ দেখবেন: একই দামের হিসাব fixed-point-এ ২১টি নির্দেশে, soft-float-এ প্রায় ৩৫৩টিতে। Floating point-এর বিন্যাস (sign, exponent, mantissa) কীভাবে কাজ করে, তা Computer Architecture-এর পর্ব ২৩-এ আছে; এখানে আবার শেখানো হবে না।
এই পর্বে hex লেখা হবে C-এর ধরনে (0x7FFF), কারণ সব কোড Cortex-M-এর। দুটি শব্দ আগে পরিষ্কার করে নিই। Scaling factor হলো integer আর আসল মানের অনুপাত: পয়সায় ১০০, Q15-এ 215 = 32768. আর dynamic range হলো একটি বিন্যাসে রাখা যায় এমন সবচেয়ে বড় আর সবচেয়ে ছোট মানের ব্যবধান। Fixed-point-এর পুরো খেলা এই দুটির দর-কষাকষি: ভগ্নাংশে বেশি বিট দিলে সূক্ষ্মতা বাড়ে, কিন্তু পূর্ণ অংশের জায়গা কমে।
ছবি ৪০.১ — বাজারঘরের চারটি Q বিন্যাস, বিট ধরে
লাল = চিহ্ন-বিট, নীল = পূর্ণ অংশ, হলুদ = ভগ্নাংশ, ধূসর = সবসময় 0; কালো বিন্দু = binary বিন্দু
২ · Qm.n — পরিসর, ধাপ আর রূপান্তরের তিন সূত্র
Qm.n-এ মোট বিট m + n, যার m বিট পূর্ণ অংশ (চিহ্ন-বিটসহ) আর n বিট ভগ্নাংশ। পুরো বিন্যাস তিনটি সূত্রে ধরা যায়:
- ধাপ (resolution): সবচেয়ে ছোট বদল = 2−n. Q15-এ 1/32768 ≈ 0.0000305; t16-এ 1/16 = 0.0625 °C.
- পরিসর: −2m−1 থেকে 2m−1 − 2−n. Q15-এ −1 থেকে 0.99997: +1 নিজে নেই, কারণ two's complement-এ ঋণাত্মক দিকে একটি মান বেশি।
- রূপান্তর: q = round(x × 2n), আর ফেরত x ≈ q ÷ 2n. 0.8 → 0.8 × 32768 = 26214.4 → 26214, যা আসলে 0.79998779; এই 0.0000122-এর ভুল রূপান্তরেই ঢুকে গেছে।
বিন্দুর জায়গা বাছাই মানে আগে থেকে ঠিক করা, সংখ্যাটি সবচেয়ে বড় কত হবে আর সবচেয়ে সূক্ষ্ম কত দরকার। বাজারঘরের দুটি device-এ যত fixed-point মান আছে, সব এক টেবিলে:
| মান | বিন্যাস | Scale | উদাহরণ |
|---|---|---|---|
| দাম | int32_t পয়সা | ১০০ (দশমিক) | 8188 = 81.88 টাকা |
| দর | int32_t পয়সা/kg | ১০০ (দশমিক) | 6550 = 65.50 টাকা/kg |
| Sensor-এর word | Q8.8, ১৬ বিট | 28 = 256 | 0x0980 = 9.50 °C |
| t16 | Q12.4 (int32_t-এ রাখা) | 24 = 16 | 152 = 9.50 °C |
| স্কেলের gain | Q16.16, ৩২ বিট | 216 = 65536 | 93623 ≈ 1.4285736 |
| Filter-এর সহগ (পর্ব ৬৮) | Q15, ১৬ বিট | 215 = 32768 | 26214 ≈ 0.8 |
লক্ষ করুন, প্রথম দুটি দশমিক scale-এর, বাকিগুলো binary. টাকার হিসাব দশমিকেই থাকা উচিত, কারণ 0.01 টাকা binary ভগ্নাংশে কখনো হুবহু হয় না (১/১০০-এর হরে ৫ আছে)। Binary scale-এর সুবিধা হলো ২-এর ঘাত দিয়ে গুণ-ভাগ মানে শুধু shift, যা Cortex-M3-এ এক নির্দেশ। সাধারণ নিয়ম: মানুষকে দেখানো বা আইনগতভাবে হুবহু হতে হবে এমন সংখ্যা দশমিক scale-এ; sensor আর নিয়ন্ত্রণের ভেতরের হিসাব binary scale-এ।
নামের গোলমাল: এই কোর্সে m-এর মধ্যে চিহ্ন-বিট গোনা হয়, তাই ১৬ বিটের Q15 = Q1.15, আর Q16.16 মানে ৩২ বিট। কিছু বই আর DSP-র নথি চিহ্ন-বিট আলাদা রাখে আর একই বিন্যাসকে Q0.15 বা Q15.16 বলে। ARM-এর CMSIS-DSP library শুধু ভগ্নাংশ বিট দিয়ে নাম দেয়: q15_t (১৬ বিট), q31_t (৩২ বিট)। নাম দেখে নয়, মোট বিট আর scale দেখে মেলাবেন।
এবার নিজে চালিয়ে দেখুন। নিচের ছোট সহায়ক চারটি বিন্যাসের পরিসর আর ধাপ ছাপে, তারপর কয়েকটি বাজারঘরের সংখ্যাকে Q-তে নিয়ে আবার ফেরায়, যাতে রূপান্তরের ভুল চোখে পড়ে:
# Qm.n-এর সহায়ক: পরিসর, ধাপ আর রূপান্তর (এই কোর্সের প্রথা: m-এ চিহ্ন-বিটও ধরা)
from math import floor
def info(m, n):
bits = m + n
lo, hi = -(1 << (bits - 1)), (1 << (bits - 1)) - 1
name = f"Q{m}.{n}"
print(f"{name:<6} {bits} bit: {lo / 2**n:g} .. {hi / 2**n:.6f}, step {2**-n:.7f}")
def to_q(x, n): # অর্ধেকে ওপরে গোল (round half up)
return floor(x * (1 << n) + 0.5)
def show(name, x, n):
q = to_q(x, n)
back = q / (1 << n)
print(f"{name:<10} Q.{n:<2} int={q:<8} back={back:.8f} err={back - x:+.2e}")
for m, n in [(1, 15), (8, 8), (12, 4), (16, 16)]:
info(m, n)
print()
show("0.8", 0.8, 15)
show("0.6", 0.6, 15)
show("2000/1400", 2000 / 1400, 16)
show("65.50", 65.50, 16)
show("6.55", 6.55, 16)
for t in (9.50, -0.50): # sensor-এর ১৬ বিটের word = Q8.8
w = to_q(t, 8) & 0xFFFF
print(f"{t:+.2f} C -> word 0x{w:04X}, t16 = {to_q(t, 4)}")আসল আউটপুট (ব্রাউজারের Python):
Q1.15 16 bit: -1 .. 0.999969, step 0.0000305
Q8.8 16 bit: -128 .. 127.996094, step 0.0039062
Q12.4 16 bit: -2048 .. 2047.937500, step 0.0625000
Q16.16 32 bit: -32768 .. 32767.999985, step 0.0000153
0.8 Q.15 int=26214 back=0.79998779 err=-1.22e-05
0.6 Q.15 int=19661 back=0.60000610 err=+6.10e-06
2000/1400 Q.16 int=93623 back=1.42857361 err=+2.18e-06
65.50 Q.16 int=4292608 back=65.50000000 err=+0.00e+00
6.55 Q.16 int=429261 back=6.55000305 err=+3.05e-06
+9.50 C -> word 0x0980, t16 = 152
-0.50 C -> word 0xFF80, t16 = -8
প্রথম চার লাইনে তিন সূত্রের ফল। Q12.4-এর ধাপ 0.0625, অর্থাৎ sensor-এর ১/১৬ °C. নিচের অংশে দেখুন, 65.50 Q16.16-এ হুবহু (65.5 = 131/2, binary-তে সসীম), কিন্তু 6.55 নয়: ভুল 0.00000305. 2000/1400-এর gain 93623-এ ভুল 2.18 × 10−6, যা অংশ ৬-এ গ্রামের হিসাবে কত বড় হয় তা মাপা হবে। শেষ দুই লাইনে sensor-এর word হুবহু README-র মান: −0.50 °C = 0xFF80, আর t16 = −8.
৩ · যোগ, বিয়োগ, overflow আর saturation
একই Q বিন্যাসের দুটি সংখ্যার যোগ-বিয়োগ একদম সাধারণ integer-এর যোগ-বিয়োগ: 0.75 + 0.5-এর Q15 রূপ 24576 + 16384. বিন্দু দুটিরই একই জায়গায়, তাই ফলেও সেখানেই। বিন্যাস আলাদা হলে আগে একটিকে shift করে অন্যটির সমান করতে হয়, যেমন sensor-এর Q8.8 word ৪ বিট ডানে সরিয়ে Q12.4-এর t16. এখানে একটি সূক্ষ্ম কথা: ঋণাত্মক signed সংখ্যা ডানে সরানো C-তে implementation-defined; Clang আর GCC দুটিই arithmetic shift করে (চিহ্ন-বিট কপি হয়), তাই −0.50 °C-এর 0xFF80 থেকে −8 আসে।
সমস্যা হলো ফল সীমার বাইরে গেলে। 24576 + 16384 = 40960, যা ১৬ বিটের signed সীমা 32767 ছাড়িয়ে যায়। C-তে দুটি int16_t-এর যোগ আগেই int-এ উন্নীত হয় (integer promotion, পর্ব ৩৪), তাই 40960 ঠিকঠাক তৈরি হয়; কিন্তু ফলটিকে int16_t-এ ফেরালে two's complement-এর নিয়মে সংখ্যা ঘুরে আসে (wrap-around): 0xA000 = −24576 = −0.75. যোগফল ধনাত্মক থেকে হঠাৎ ঋণাত্মক, অর্থাৎ integer overflow. ছোট type-এ রূপান্তরের এই wrap-ও C-তে implementation-defined; আর int32_t-এর নিজের overflow তো undefined behavior, যার ওপর compiler নির্ভর করতে পারে (C প্রোগ্রামিং পর্ব ৪৮)।
নিয়ন্ত্রণ আর sensor-এর হিসাবে wrap প্রায় সবসময় সবচেয়ে খারাপ উত্তর: মোটরকে “সবচেয়ে জোরে” বলার বদলে “উল্টো দিকে জোরে” বলা। তাই ব্যবহার হয় saturating arithmetic: সীমা ছাড়ালে ফলকে সবচেয়ে বড় বা সবচেয়ে ছোট মানে আটকে দেওয়া। C-তে আগে চওড়া type-এ হিসাব, তারপর clamp:
static int16_t sat16(int32_t x) /* qmath.c */
{
if (x > 32767) return 32767;
if (x < -32768) return -32768;
return (int16_t)x;
}
int16_t q15_add_sat(int16_t a, int16_t b) { return sat16((int32_t)a + b); }
int16_t q15_add_wrap(int16_t a, int16_t b) { return (int16_t)(a + b); }
Clang 22.1.8 (-O2, Cortex-M3) এর কী বানায়, তা আমার lab-এর qmath.c-এর -S output থেকে (directive-এর লাইন বাদ):
q15_add_wrap:
add r0, r1
sxth r0, r0 @ নিচের 16 বিট sign-extend: wrap
bx lr
q15_add_sat:
add r0, r1
ssat r0, #16, r0 @ signed saturate to 16 bits
bx lr
দুটি if-সহ পুরো sat16 একটি নির্দেশ হয়ে গেছে: ssat (signed saturate). ARMv7-M-এর মূল নির্দেশমালায় SSAT আর USAT আছে, তাই Cortex-M3-এও। Saturating যোগের আলাদা নির্দেশ (QADD, QADD16) অবশ্য Cortex-M4-এর DSP instruction-এর অংশ, M3-এ নেই; এখানে compiler যোগ আর clamp দুই নির্দেশে করেছে। নিচের stepper ধাপে ধাপে board-এর run-এর মান দেখায়।
| কাজ | |
| ইনপুট | |
| r0 | |
| আসল মান |
- দুটি সংখ্যা। 0.75 × 32768 = 24576 = 0x6000, আর 0.5 × 32768 = 16384 = 0x4000. দুটিই Q15-এর সীমার মধ্যে।
- যোগ ৩২ বিটে। Cortex-M3-এর register ৩২ বিটের, তাই
add-এর পরে r0 = 40960 = 0xA000, কোনো তথ্য হারায়নি। কিন্তু 40960 > 32767: আসল মান 1.25, Q15-এ রাখা যায় না। - Wrap.
sxthনিচের ১৬ বিট নিয়ে বিট ১৫-কে চিহ্ন ধরে: 0xA000 = −24576 = −0.75. Board-এর log:add 24576+16384: wrap=-24576. ধনাত্মক যোগফল ঋণাত্মক হয়ে গেল। - Saturation.
ssat r0, #16, r0মান −32768 থেকে 32767-এ আটকায়: 32767 = 0x7FFF = 0.99997. Board:sat=32767. ভুল এখন 0.25-এর, কিন্তু দিক ঠিক। - ঋণাত্মক দিক। −24576 + −16384 = −40960. Wrap দেয় +24576 (+0.75), saturation দেয় −32768 (−1.0). Board:
wrap=24576 sat=-32768. - গুণেও overflow. −1 × −1 = +1, কিন্তু Q15-এ +1 নেই। 0x8000 × 0x8000 = 230, ১৫ বিট ডানে 32768; ছাঁটা সংস্করণ (
sbfx) একে ১৬ বিটে wrap করে −32768 দেয়। Board:trunc=-32768: −1 × −1 = −1. - Saturating গুণ।
q15_mulআগে 16384 যোগ করে, তারপর ১৫ বিট সরিয়ে 32768 পায় আর clamp করে 32767-এ। Board:q15_mul(-32768,-32768)=32767. সব 232 জোড়া পরীক্ষায় এটিই একমাত্র জোড়া, যার গুণফল সীমা ছাড়ায়।
সত্যিকারের run (বাজারঘর board BG-M3, Clang 22.1.8 / ziglang 0.17.1, Unicorn 2.1.4; python -B board.py run build/qmath.elf, প্রথম চার লাইন):
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0604 ms] UART: q15_mul(26214,19661)=15729 trunc=15728
[ 0.1201 ms] UART: q15_mul(-32768,-32768)=32767 trunc=-32768
[ 0.1771 ms] UART: add 24576+16384: wrap=-24576 sat=32767
[ 0.2351 ms] UART: add -24576-16384: wrap=24576 sat=-32768
সব সংখ্যা যে কেবল এই কয়েকটি ইনপুটে নয়, সবখানে ঠিক, তা দেখতে আমি host-এ numpy দিয়ে Q15-এর সব 65536 × 65536 = 4,294,967,296টি জোড়া চালিয়েছি: যোগে ঠিক ১/৪ অংশ জোড়া (1,073,741,824টি) সীমা ছাড়ায়, আর rounding-সহ গুণে শুধু (−1, −1). Saturation কতটা জরুরি তা এই সংখ্যাতেই স্পষ্ট: এলোমেলো দুটি Q15 যোগ করলে প্রতি চারবারে একবার overflow.
৪ · গুণ — বিন্দু সরে, আর rounding ফেরায় সঠিকতা
দশমিকে 0.8 × 0.6 করতে আপনি 8 × 6 = 48 করেন, তারপর দুই দশমিক ঘর গুনে 0.48 লেখেন। Binary-তেও তাই: Qa.b × Qc.d-এর ফল Q(a+c).(b+d). Q15 × Q15 তাই Q2.30, ৩২ বিটে ঠিক এঁটে যায় (২ + ৩০ = ৩২)। ফেরত Q15-এ যেতে ১৫ বিট ডানে সরাতে হয়। Q16.16 × Q16.16 হয় Q32.32, যার জন্য ৬৪ বিট লাগে।
ডানে সরানো মানে নিচের বিটগুলো ফেলে দেওয়া। Arithmetic shift সবসময় নিচের দিকে (−∞-এর দিকে) ছাঁটে, তাই গড়ে প্রায় অর্ধেক LSB-এর একটি একমুখী ভুল থাকে। প্রতিকার সহজ: shift-এর আগে অর্ধেক ধাপ যোগ করা, Q15-এ 214 = 16384. এই rounding-এ ফল সবচেয়ে কাছের মানে যায় (ঠিক অর্ধেকে ওপরে)। দামের হিসাবে + 500 করে ১০০০ দিয়ে ভাগ যে কাজ করে, এখানে + (1 << 14) করে >> 15 একই কাজ করে।
int16_t q15_mul(int16_t a, int16_t b) /* qmath.c */
{
int32_t p = (int32_t)a * b; /* Q2.30 */
return sat16((p + (1 << 14)) >> 15); /* round, back to Q1.15 */
}
| নির্দেশ | |
| মান | |
| বিন্যাস | |
| আসল মান |
- a = 0.8. 0.8 × 32768 = 26214.4 → 26214 = 0x6666. রূপান্তরেই ভুল −0.0000122; সত্যিকারের ইনপুট এখন 0.79998779.
- b = 0.6. 0.6 × 32768 = 19660.8 → 19661 = 0x4CCD = 0.60000610. দুটিই r0 আর r1-এ,
int16_tহিসেবে sign-extend হয়ে। - গুণ।
muls: 26214 × 19661 = 515,393,454 = 0x1EB847AE. এখন বিন্দু ৩০ বিটের পরে: 515,393,454 ÷ 230 = 0.47999756. কোনো তথ্য হারায়নি। - অর্ধেক ধাপ যোগ। ফলের LSB হবে 215-এর ঘরে, তার অর্ধেক 214 = 16384. যোগফল 515,409,838 = 0x1EB887AE.
- ১৫ বিট ডানে।
asrs #15: 15729 = 0x3D71. যোগ না করলে 515,393,454 ≫ 15 = 15728. আসল গুণফল ×32768 = 15728.56, তাই 15729-ই কাছের মান। - Saturation পরীক্ষা। Clang শুধু ওপরের সীমা দেখে: 15729 < 32767, তাই ফল অপরিবর্তিত, 0.48001099. নিচের সীমার কোনো পরীক্ষা নেই; কেন, তা অনুশীলন ৪-এ প্রমাণ করবেন। Board:
15729 trunc=15728.
শেষ ধাপের it lt আর asrlt Clang-এর নিজের সাজানো (qmath.c-এর -S, Clang 22.1.8):
q15_mul:
muls r0, r1, r0 @ Q2.30
add.w r1, r0, #16384 @ + half LSB
asrs r2, r1, #15
movw r0, #32767
cmp r2, r0
it lt
asrlt r0, r1, #15 @ fits: use it, else keep 32767
bx lr
q15_mul_trunc:
muls r0, r1, r0
sbfx r0, r0, #15, #16 @ bits 30..15, sign-extended: wraps
bx lr
Rounding কি সব ইনপুটে ঠিক? Host-এ সব 232টি জোড়ায় q15_mul-এর ফল গুণফলের সঠিক “অর্ধেকে ওপরে” গোল করা মানের সঙ্গে মিলেছে, আর saturated জোড়াটি ছাড়া কোথাও ভুল অর্ধেক LSB-এর বেশি নয়। ছাঁটা সংস্করণ 2,147,418,112টি জোড়ায় (প্রায় অর্ধেক) এক LSB কম দিয়েছে, সবসময় একই দিকে। একবারের গুণে এটি নগণ্য, কিন্তু filter বা MAC-এর মতো হাজারবার জমানো হিসাবে এই একমুখী ভুল জমে বড় হয় (ভাবনার প্রশ্ন ৫)।
Q16.16-এর গুণে ৬৪ বিটের গুণফল লাগে। Cortex-M3-এর এর জন্য এক নির্দেশ আছে, SMLAL (৩২ × ৩২ → ৬৪, সঙ্গে যোগ)। আমার lab-এর q16.c-তে (q16_t)(((int64_t)a * b + 0x8000) >> 16) লিখলে Clang বানিয়েছে: mov.w r3, #32768, smlal r3, r2, r1, r0, তারপর দুটি shift আর একটি orr: rounding-এর ধ্রুবকও গুণের সঙ্গে একই নির্দেশে যোগ হয়ে গেছে। Cortex-M0-এর মতো ছোট core-এ ৬৪ বিটের ফলের গুণ নেই, সেখানে একই লাইন library-র ডাক হয়।
৫ · ভাগ — সবচেয়ে দামি কাজ, তাই আগেভাগে সেরে রাখা
Fixed-point-এ ভাগের নিয়ম গুণের উল্টো: Q16.16 ÷ Q16.16 করলে বিন্দু মুছে যায়, তাই ভাজ্যকে আগে ১৬ বিট বাঁয়ে সরিয়ে নিতে হয়: q = (a × 216) ÷ b. সমস্যা হলো a × 216 সাধারণত ৩২ বিটে আঁটে না (a ±0.5-এর বেশি হলেই নয়), তাই ৬৪ বিট লাগে। আর Cortex-M3-এর hardware divider (SDIV, UDIV; পর্ব ২৯) শুধু ৩২ বিটের। ফল দেখুন (q16.c, Clang 22.1.8, -O2):
q16_div: @ (q16_t)(((int64_t)a << 16) / b)
push {r7, lr}
... @ a-কে 64 বিটে তুলে 16 বিট বাঁয়ে
asrs r3, r2, #31
bl __aeabi_ldivmod @ 64-বিটের ভাগ: library function
pop {r7, pc}
একটি C লাইন, অথচ __aeabi_ldivmod নামের একটি runtime library-র function, যা loop-এ বিট ধরে ভাগ করে। আরও একটি ফাঁদ: ঋণাত্মক a-কে << 16 করা C-তে undefined behavior; নিরাপদ লেখা (int64_t)a * 65536, যা compiler একই shift-এ বানায়।
তাই firmware-এর নিয়ম: প্রতিটি reading-এ ভাগ নয়। ভাগটি একবার করে (calibration-এর সময়) একটি গুণক বা scaling factor বানিয়ে রাখুন, তারপর প্রতিবার শুধু গুণ আর shift. ধ্রুবক দিয়ে ভাগ হলে compiler নিজেই কাজটি করে: পর্ব ২৮ (Microcontroller-এর পরিবার) আর ২৯-এ দেখেছেন, ÷1000 Clang-এর হাতে 0x10624DD3 দিয়ে umull আর shift হয়ে যায়, যা এক ধরনের strength reduction. কিন্তু calibration-এর সংখ্যা compile-এর সময় জানা না থাকলে (দোকানে নতুন করে মাপা হলে) এই কৌশল আপনাকেই করতে হবে।
স্কেলের ক্ষেত্রে সেটি এমন (আমার lab-এর cal.c): calibration-এর দুটি মাপ থেকে একবার গোল করা ভাগে gain, তারপর প্রতিটি reading-এ গুণ। এখানে 2000 × 216 = 131,072,000, যা ৩২ বিটে আঁটে, তাই ভাগটি M3-এর hardware SDIV-এই হয়, library লাগে না।
typedef struct { int32_t zero_raw; int32_t gain_q16; } cal_t;
static cal_t cal_make(int32_t zero_raw, int32_t span_raw, int32_t span_g)
{
int32_t counts = span_raw - zero_raw; /* 1400 */
cal_t c = { zero_raw, ((span_g << 16) + counts / 2) / counts }; /* rounded */
return c;
}
সত্যিকারের run-এ (build/cal.elf) প্রথম লাইন gain_q16=93623: (131,072,000 + 700) ÷ 1400 = 93623.36 → 93623, compile-time-এর হিসাবের সঙ্গে হুবহু এক। ছেঁটে ভাগ করলে আসত 93622; host-এ পরীক্ষায় এই gain-ও 0–4095 সব count-এ সঠিক গ্রাম দেয়, কারণ পরের অংশে দেখবেন ভুলের জন্য যথেষ্ট জায়গা আছে। তবু গোল করে ভাগ করা ভালো অভ্যাস: অন্য calibration-এ ভুলের এত জায়গা না-ও থাকতে পারে, আর তখন gain-এর এক LSB-ই কয়েকটি count-এ এক গ্রামের পার্থক্য গড়ে।
৬ · স্মার্ট স্কেল — ADC count থেকে গ্রাম, Q16.16-এ
README-র “বাজারঘর devices” অনুযায়ী স্কেলের ১২ বিটের ADC খালি প্ল্যাটফর্মে 400 count দেখায় আর 2000 g-এর বাটখারায় 1800 count. দুই-বিন্দুর এই calibration-এর সূত্র: gram = round((raw − 400) × 2000 ÷ 1400), যা reference firmware scale.c ভাগ দিয়েই করে (div_round নামের function-এ)। Fixed-point-এ একই কাজ: gain = 2000 ÷ 1400 = 1.4285714, Q16.16-এ 93623. প্রতিটি reading-এ (raw − 400) × 93623, তারপর অর্ধেক ধাপ 32768 যোগ করে ১৬ বিট ডানে।
প্রথম প্রশ্ন সবসময় overflow: সবচেয়ে বড় গুণফল কি int32_t-এ আঁটে? ADC-র সর্বোচ্চ 4095, তাই (4095 − 400) × 93623 = 345,936,985; সীমা 2,147,483,647, প্রায় ছয় গুণ জায়গা বাকি। সবচেয়ে ছোট (raw = 0) −37,449,200, সেটিও নিরাপদ। এই হিসাব কাগজে করে কোডের পাশে মন্তব্যে লিখে রাখুন।
| ধাপ | |
| মান | |
| অর্থ |
- ADC-র সংখ্যা। README-র run-এ 1400 g রাখার পরে চারটি conversion-এর গড় raw = 1380. এটি একটি সাধারণ integer, কোনো একক নেই।
- Zero বাদ। 1380 − 400 = 980 count, অর্থাৎ শুধু বোঝার জন্য কতটা উঠেছে।
- Gain. 2000 ÷ 1400 × 65536 = 93622.86 → 93623 = 0x00016DB7. ওপরের ১৬ বিট 0x0001 = 1, নিচের 0x6DB7 = 0.42857; মোট 1.42857361, আসল মানের চেয়ে 0.0000022 বেশি।
- গুণ। 980 × 93623 = 91,750,540 = 0x0578008C. এটি Q16.16-এ গ্রাম: ওপরের অর্ধেক 0x0578 = 1400, নিচের 0x008C = 140 ÷ 65536 = 0.0021 g. Gain-এর সেই ক্ষুদ্র বাড়তিটুকুই এই ভগ্নাংশ।
- গোল করে পূর্ণ গ্রাম। 91,750,540 + 32768 = 91,783,308 = 0x0578808C, ১৬ বিট ডানে 0x0578 = 1400 g. README-র ভাগের ফলও 1400, board-এর run-এও
raw=1380 q16=91750540 g=1400 ref=1400. - Tare আর দাম। আগে tare করা 150 g-এর ঝুড়ি বাদ দিলে net 1250 g; দাম (1250 × 6550 + 500) ÷ 1000 = 8188 পয়সা = 81.88 টাকা, README-র run-এর
price=81.88 Tk. - ভগ্নাংশওয়ালা একটি count. raw 1000: 600 × 93623 = 56,173,800 = 0x035924E8; পূর্ণ 0x0359 = 857, ভগ্নাংশ 0x24E8 = 0.1442. আসল মান 857.142857; গোল করে 857 g, ভাগের ফলও 857.
বাস্তব firmware-এ দামের পুরো function Clang কেমন বানায়, দেখুন (cost_fixed.c, -O2; অংশ ৮-এ এর খরচ মাপা হবে):
price_paisa: @ raw -> paisa
movw r1, #4624
movw r2, #28087
movt r1, #64965 @ r1 = 0xFDC51210 = 32768 - 400*93623
movt r2, #1 @ r2 = 0x00016DB7 = 93623
mla r0, r0, r2, r1 @ raw*93623 + r1 (multiply-accumulate)
movw r1, #6550
asrs r0, r0, #16 @ grams
muls r1, r0, r1
... @ +500, umull 0x10624DD3, lsr #6 = /1000
bx lr
Compiler দুটি জিনিস নিজে করেছে: −400 × 93623 আর +32768 একটি ধ্রুবক 0xFDC51210-এ জুড়ে দিয়েছে, যাতে বিয়োগ, গুণ, rounding তিনটিই একটি mla (multiply-accumulate) নির্দেশে হয়; আর ১০০০-এর ভাগকে পর্ব ২৯-এর magic number-এর গুণে বদলেছে। পুরো রূপান্তর আর দামে কোনো ভাগের নির্দেশ নেই।
৪০৯৬টি count-এর মধ্যে মাত্র কয়েকটি দেখে সন্তুষ্ট হওয়া ঠিক নয়। নিচের ব্লক সব count-এ Q-gain-এর ফলকে README-র ভাগের সঙ্গে মেলায়, আর দেখায় কত ভগ্নাংশ বিট কম দিলে কী হয়:
# Load cell: raw 0..4095 -> grams. ভাগ (div_round) বনাম Q-gain দিয়ে গুণ + shift
from fractions import Fraction
def div_round(n, d): # README-র নিয়ম: অর্ধেকে শূন্য থেকে দূরে
return (n + d // 2) // d if n >= 0 else -((-n + d // 2) // d)
ref = [div_round((r - 400) * 2000, 1400) for r in range(4096)]
def grams_q(r, gain, n): # firmware: ((raw-400)*gain + half) >> n
return ((r - 400) * gain + (1 << (n - 1))) >> n
for n in (8, 10, 12, 13, 16):
gain = round(Fraction(2000, 1400) * 2**n) # ধ্রুবক, compile-time-এ
bad = [r for r in range(4096) if grams_q(r, gain, n) != ref[r]]
worst = max((abs(grams_q(r, gain, n) - ref[r]) for r in range(4096)))
big = 3695 * gain # raw 4095-এ গুণফল
print(f"Q.{n:<2} gain={gain:<6} mismatches={len(bad):<4} worst={worst} g"
f" max product={big:,}")
g16 = round(Fraction(2000, 1400) * 2**16)
for r in (505, 1380, 855, 3970, 395, 1000):
p = (r - 400) * g16
print(f"raw={r:<4} product={p:>11,} /65536={p / 65536:9.4f}"
f" -> {grams_q(r, g16, 16)} g (ref {ref[r]})")আসল আউটপুট (ব্রাউজারের Python):
Q.8 gain=366 mismatches=3339 worst=5 g max product=1,352,370
Q.10 gain=1463 mismatches=943 worst=1 g max product=5,405,785
Q.12 gain=5851 mismatches=706 worst=1 g max product=21,619,445
Q.13 gain=11703 mismatches=0 worst=0 g max product=43,242,585
Q.16 gain=93623 mismatches=0 worst=0 g max product=345,936,985
raw=505 product= 9,830,415 /65536= 150.0002 -> 150 g (ref 150)
raw=1380 product= 91,750,540 /65536=1400.0021 -> 1400 g (ref 1400)
raw=855 product= 42,598,465 /65536= 650.0010 -> 650 g (ref 650)
raw=3970 product=334,234,110 /65536=5100.0078 -> 5100 g (ref 5100)
raw=395 product= -468,115 /65536= -7.1429 -> -7 g (ref -7)
raw=1000 product= 56,173,800 /65536= 857.1442 -> 857 g (ref 857)
Q16.16-এ ০টি অমিল, আর board-এর firmware-ও একই কথা বলেছে: raw 0..4095: Q16.16 mismatches=0 Q8 mismatches=3339 worst=5 g. কেন ১৩ বিটেই যথেষ্ট? আসল গ্রাম (raw − 400) × 10 ÷ 7, তাই ভগ্নাংশ সবসময় ১/৭-এর গুণিতক; অর্ধেকের সবচেয়ে কাছে 3/7 আর 4/7, অর্থাৎ ভুলের জন্য 0.071 g-এর জায়গা আছে। Q16.16-এর সবচেয়ে বড় ভুল 3695 count-এ 0.008 g, ঢের কম; Q.8-এর gain 366-এ (আসল 365.71) ভুল জমে ৪–৫ g পর্যন্ত যায়। অর্থাৎ ভগ্নাংশ বিটের সংখ্যা অনুমান নয়, ভুলের বাজেট থেকে হিসাব করা যায়।
উল্টো দিকের ফাঁদও আছে। “আরও নিখুঁত হবে” ভেবে কেউ gain রাখলেন Q8.24-এ: 23,967,451. তখন (raw − 400) × gain ৩২ বিটে আঁটে শুধু raw ≤ 489 পর্যন্ত (231 ÷ 23,967,451 ≈ 89.6 count, অর্থাৎ প্রায় ১২৮ গ্রাম পর্যন্ত)। সত্যিকারের run (cal.c-এর শেষ অংশ; signed overflow C-তে undefined, তাই এখানে গুণ unsigned-এ করে wrap দেখানো):
[ 8.5160 ms] UART: Q8.24 raw=489 product=2133103139 g=127
[ 8.5851 ms] UART: Q8.24 raw=490 product=-2137896706 g=-127
[ 8.6542 ms] UART: Q8.24 raw=505 product=-1778384941 g=-106
[ 8.7246 ms] UART: Q8.24 raw=1380 product=2013265500 g=120
১২৮ g পর্যন্ত সব ঠিক, ১৩০ g থেকে ঋণাত্মক, আর 1400 g-এর আলু দেখায় 120 g. ক্রেতা খুশি, দোকানদার দেউলিয়া। বেশি ভগ্নাংশ বিট মানে কম পূর্ণ অংশ, তাই সূক্ষ্মতা আর পরিসর সবসময় একসাথে হিসাব করতে হয়।
৭ · Cold room — তাপমাত্রা পুরোটাই integer-এ
Cold-storage monitor-এর sensor (README: I2C-ধাঁচের, ঠিকানা 0x48, TMP102-এর মতো) ১২ বিটের two's complement মান দেয়, প্রতি LSB 0.0625 °C, ১৬ বিটের word-এ বাঁ-ঘেঁষা। অর্থাৎ word-টি নিজেই Q8.8, যার নিচের ৪ বিট সবসময় 0 (ছবি ৪০.১)। Firmware (coldroom.c) এক লাইনে একে ১/১৬ °C-এর t16-এ আনে:
*t16 = (int32_t)(int16_t)I2C1->DATA >> 4; /* Q8.8 word -> Q12.4 */
প্রথম cast (int16_t) বিট ১৫-কে চিহ্ন বানায়, দ্বিতীয় (int32_t) sign extension করে ৩২ বিটে তোলে, তারপর arithmetic shift. 0xFF80 → −128 → −8 = −0.50 °C. সীমাগুলোও একই এককে integer: ৮.০০ °C = 128, ০.০০ °C = 0, hysteresis ০.৫০ °C = 8. তাই alarm-এর সব সিদ্ধান্ত সাধারণ integer তুলনা: t16 > 128 মানে HIGH-এর গণনা, t16 < 0 মানে LOW, আর 8 থেকে 120-এর মধ্যে (০.৫০–৭.৫০ °C) “ঠিক আছে”-র গণনা। কোথাও float নেই, তবু 8.0625 °C আর 8.00 °C-এর পার্থক্য নির্ভুলভাবে ধরা পড়ে।
Display-এর জন্য README দুই দশমিকের মান বানায়: hundredths = t16 × 25 ÷ 4 (কারণ 1/16 °C = 6.25 hundredths, অর্থাৎ সাড়ে ছয় শতাংশ ডিগ্রি)। এটি 0.25 °C-এর গুণিতকে হুবহু, বাকিগুলোতে শূন্যের দিকে ছাঁটে। কতটা ছাঁটে? Sensor-এর সব ৪০৯৬টি code পরীক্ষা করুন:
# Cold room: sensor-এর ১৬ বিটের word (Q8.8) -> t16 (১/১৬ °C) -> সীমা আর display
HIGH, LOW, HYST = 8 * 16, 0, 8 # 8.00 °C, 0.00 °C, 0.50 °C (t16 একক)
def t16_of(word): # C: (int32_t)(int16_t)word >> 4
s = word - 0x10000 if word & 0x8000 else word
return s >> 4 # Python-এর >> সবসময় arithmetic
def centi(t): # C: t16 * 25 / 4 (শূন্যের দিকে ছাঁটা)
v = abs(t) * 25 // 4
return v if t >= 0 else -v
exact = worst = 0
for code in range(-2048, 2048): # 12-বিটের সব 4096 code
t = t16_of((code << 4) & 0xFFFF)
err = abs(t * 6.25 - centi(t)) # আসল মান 6.25 hundredths প্রতি LSB
exact += err == 0
worst = max(worst, err)
print(f"codes=4096 exact={exact} truncated={4096 - exact} worst={worst} hundredths")
for word in (0x0800, 0x0810, 0x0780, 0x0790, 0xFFF0, 0xFF80, 0x0980):
t = t16_of(word)
if t > HIGH:
zone = "HIGH count"
elif t < LOW:
zone = "LOW count"
elif LOW + HYST <= t <= HIGH - HYST:
zone = "ok count"
else:
zone = "hysteresis band"
c = centi(t)
print(f"0x{word:04X} t16={t:>4} -> {c / 100:+.2f} C ({t / 16:+.4f}) {zone}")আসল আউটপুট (ব্রাউজারের Python):
codes=4096 exact=1024 truncated=3072 worst=0.75 hundredths
0x0800 t16= 128 -> +8.00 C (+8.0000) hysteresis band
0x0810 t16= 129 -> +8.06 C (+8.0625) HIGH count
0x0780 t16= 120 -> +7.50 C (+7.5000) ok count
0x0790 t16= 121 -> +7.56 C (+7.5625) hysteresis band
0xFFF0 t16= -1 -> -0.06 C (-0.0625) LOW count
0xFF80 t16= -8 -> -0.50 C (-0.5000) LOW count
0x0980 t16= 152 -> +9.50 C (+9.5000) HIGH count
৪০৯৬টির ১০২৪টি হুবহু (0.25 °C-এর গুণিতক), ৩০৭২টিতে ছাঁটা, কিন্তু সবচেয়ে বড় ভুল 0.75 hundredths, অর্থাৎ 0.0075 °C: display-এর শেষ অঙ্কে বড়জোর এক। সিদ্ধান্ত কিন্তু t16-এ হয়, display-এর মানে নয়, তাই এই ছাঁটাই alarm-কে কখনো প্রভাবিত করে না। 0x0800 (ঠিক 8.00 °C) HIGH নয়, কারণ শর্ত “8.00-এর বেশি”; আর 7.5625 °C hysteresis-এর ফাঁকে পড়ে, README-র 7.75 °C-এর মতো, যা কোনো গণনাতেই যোগ হয় না।
README-র cold-room run-এ এর ফল সরাসরি দেখা যায়: 8.25, 9.00 আর 9.50 °C (t16 = 132, 144, 152) পরপর তিনটি reading 128-এর বেশি, তাই [ 7000.0387 ms] GPIO PA6 ALARM ON. Firmware-এর ভেতরে একটিও float নেই, অথচ সিদ্ধান্ত ১/১৬ °C পর্যন্ত নিখুঁত।
৮ · Float বনাম fixed — Cortex-M3-এ soft-float-এর আসল দাম
এবার সরাসরি তুলনা। একই কাজ, raw count থেকে পয়সায় দাম, দুইভাবে লেখা: cost_fixed.c-এ অংশ ৬-এর integer হিসাব, cost_float.c-এ float দিয়ে:
int32_t price_paisa(int32_t raw) /* cost_float.c */
{
float g = (float)(raw - 400) * (2000.0f / 1400.0f);
if (g <= 0.0f)
return 0;
float taka = g / 1000.0f * 65.50f;
return (int32_t)(taka * 100.0f + 0.5f);
}
প্রথম চমক build-এর সময়ই। Board-এর build -nostdlib দিয়ে link করে (কোনো library নেই), তাই সত্যিকারের ফল (ld.lld 22.1.8, লাইন ছোট করা):
ld.lld: error: undefined symbol: __aeabi_i2f
ld.lld: error: undefined symbol: __aeabi_fmul
ld.lld: error: undefined symbol: __aeabi_fdiv
ld.lld: error: undefined symbol: __aeabi_fadd
ld.lld: error: undefined symbol: __aeabi_f2iz
ld.lld: error: undefined symbol: __aeabi_fcmple
প্রতিটি float কাজ একটি ARM EABI-র নামের function: int থেকে float (i2f), গুণ, ভাগ, যোগ, float থেকে int (f2iz), তুলনা। এগুলো না পেলে linker-এর এই undefined reference. সাধারণ toolchain এগুলো libgcc বা compiler-rt থেকে চুপচাপ জুড়ে দেয়, তাই অনেকে টেরই পান না; Cortex-M0-এর ভাগের helper নিয়ে একই ঘটনা দেখেছেন পর্ব ৩৭-এ। আমি Zig-এর নিজের compiler_rt Cortex-M3-এর জন্য build করে (ReleaseSmall) link করেছি, তারপর দুটি firmware board-এ চালিয়েছি। price_paisa-র আগে আর পরে SysTick-এর VAL পড়ে নির্দেশ গোনা হয়েছে (মাপার নিজের খরচ বাদ দিয়ে):
[ 0.0649 ms] UART: fixed raw=505 price=9.83 Tk instructions=21
[ 0.1306 ms] UART: fixed raw=1275 price=81.88 Tk instructions=21
[ 0.1939 ms] UART: fixed raw=750 price=32.75 Tk instructions=21
[ 0.2546 ms] UART: fixed raw=400 price=0.00 Tk instructions=18
...
[ 0.1085 ms] UART: float raw=505 price=9.83 Tk instructions=353
[ 0.2177 ms] UART: float raw=1275 price=81.88 Tk instructions=352
[ 0.3247 ms] UART: float raw=750 price=32.75 Tk instructions=354
[ 0.4095 ms] UART: float raw=400 price=0.00 Tk instructions=193
| মাপ (Clang 22.1.8, -O2) | fixed | float (soft) |
|---|---|---|
| প্রতি ডাকে নির্দেশ | ২১ (খালি পাল্লায় ১৮) | ৩৫২–৩৫৪ (খালি পাল্লায় ১৯৩) |
price_paisa-র নিজের আকার | 56 byte | 88 byte |
| Link হওয়া library | 0 byte | 1330 byte (ভাগ 404, যোগ 344, গুণ 288, তুলনা 108, i2f 100, f2iz 84, বাকি 2) |
পুরো firmware-এর .text | 1908 byte | 3312 byte |
এই সংখ্যাগুলো পড়ার নিয়ম দুটি। এক, board এক নির্দেশ = এক cycle ধরে (README, Spec decision 17); আসল Cortex-M3-এ গুণ, ভাগ, branch আর memory-র নির্দেশে cycle আলাদা, তাই এগুলো নির্দেশের সংখ্যা, সময় নয়। দুই, soft-float-এর খরচ library-নির্ভর: GCC-র libgcc বা কোনো vendor-এর হাতে-লেখা assembly library-তে সংখ্যা অন্য হবে। তবু ক্রমটি একই থাকে: প্রতিটি float কাজ কয়েক ডজন integer নির্দেশ, আর FPU-হীন chip-এ এই পার্থক্য প্রায় ১৭ গুণ।
আর সঠিকতা? দামের দুই লেখাই ওপরের চারটি ওজনে একই উত্তর দিয়েছে, কিন্তু 0 থেকে 5000 g-এর প্রতিটি ওজনে একই float সূত্র (g ÷ 1000 × 65.50) চালালে board-এর firmware floatsweep.c বলেছে:
[ 1.6785 ms] UART: g=30 int=197 float=196
[ 7.0766 ms] UART: g=130 int=852 float=851
[ 11.4111 ms] UART: g=210 int=1376 float=1375
[ 268.0562 ms] UART: 0..5000 g: g/1000*65.50 mismatches=56, g*6.55 mismatches=0
৩০ g-এর আসল দাম 196.5 পয়সা, যা README-র নিয়মে 197. কিন্তু 30 ÷ 1000 = 0.03 float-এ হুবহু হয় না, একটু কম থাকে, আর সেই কম অর্ধেকের ঠিক নিচে নামিয়ে দেয়। মজার কথা, g × 6.55f লিখলে ৫০০১টিতেই মিলেছে, কারণ 6.55f ঘটনাক্রমে 6.55-এর একটু ওপরে (6.5500001907) রাখা থাকে। ভাগ্যে মিলে যাওয়া নকশা নয়। নিচের ব্লকটি একই পরীক্ষা আপনার জন্য একটি আসল C compiler-এ (x86-64-এর IEEE float, board-এর soft-float-এর মতোই single precision) চালায়:
#include <stdio.h>
#include <stdint.h>
/* integer: paisa, round half up (README formula) */
static int32_t price_int(int32_t g) { return (g * 6550 + 500) / 1000; }
/* float: taka = g / 1000 * 65.50, then to paisa */
static int32_t price_float(int32_t g)
{
float taka = (float)g / 1000.0f * 65.50f;
return (int32_t)(taka * 100.0f + 0.5f);
}
int main(void)
{
int bad = 0;
for (int32_t g = 0; g <= 5000; g++) {
int32_t i = price_int(g), f = price_float(g);
if (i != f && ++bad <= 3)
printf("g=%4d int=%5d paisa float=%5d paisa\n", g, i, f);
}
printf("0..5000 g: %d of 5001 prices differ\n", bad);
printf("30 g in taka as float: %.9f (exact 1.965)\n", 30 / 1000.0f * 65.50f);
printf("float 16777216 + 1 = %.1f\n", 16777216.0f + 1.0f);
return 0;
}আসল আউটপুট (Wandbox-এর GCC):
g= 30 int= 197 paisa float= 196 paisa
g= 130 int= 852 paisa float= 851 paisa
g= 210 int= 1376 paisa float= 1375 paisa
0..5000 g: 56 of 5001 prices differ
30 g in taka as float: 1.964999914 (exact 1.965)
float 16777216 + 1 = 16777216.0
Host-এর float আর board-এর soft-float একই ৫৬টি ওজনে, একই তিনটি প্রথম উদাহরণে ভুল করেছে: দুটিই IEEE 754 single precision, দুটিই প্রতিটি কাজ সঠিকভাবে গোল করে, তাই ফলও এক। ভুলটা hardware-এর নয়, সূত্রের: দশমিক টাকাকে binary ভগ্নাংশে রাখার। শেষ লাইন float-এর আরেক সীমা: 24 বিটের mantissa বলে 16,777,216 (224)-এর পরে এক যোগ করা যায় না। একটি ৩২ বিটের integer পয়সার counter সেখানে নির্বিঘ্নে চলত।
তাহলে float কি নিষিদ্ধ? না। Cortex-M4F আর M7-এর মতো FPU-ওয়ালা core-এ single precision-এর গুণ-যোগ hardware-এ হয় (M4F-এ double তবু software-এ)। যেখানে মানের পরিসর বিশাল আর আগে থেকে জানা নেই, যেমন পদার্থবিদ্যার মডেল বা বড় ম্যাট্রিক্স, সেখানে float সহজ আর নিরাপদ। কিন্তু টাকা কখনো float-এ নয়; FPU-হীন chip-এ ঘন ঘন চলা হিসাব (ADC-র প্রতিটি sample, filter, PID) fixed-point-এ; আর ISR-এ float এড়িয়ে চলুন, কারণ soft-float-এ সময় লম্বা আর ইনপুটভেদে বদলায় (ওপরে ১৯৩ বনাম ৩৫৪)।
আরও গভীরে: 8086-এর নিজের কোনো float নির্দেশ ছিল না; Intel ১৯৮০ সালের দিকে আলাদা chip 8087 coprocessor এনেছিল, যা পাশে বসে float হিসাব করত। বিভিন্ন কোম্পানির float-এর ফল তখন আলাদা হতো, যে বিশৃঙ্খলা থেকে William Kahan-এর নেতৃত্বে IEEE 754 standard আসে (১৯৮৫)। একই সময়ে, ১৯৮০-এর দশকের শুরুতে, TI-এর TMS320 পরিবারের মতো fixed-point DSP chip এসেছিল, আর Q-নোটেশন সেই DSP-র জগৎ থেকেই ছড়িয়েছে বলে ধরা হয়। আজ ARM Cortex-M4-এর DSP নির্দেশ (QADD, SMLAD: দুটি Q15 গুণ একসাথে যোগ) আর CMSIS-DSP library-র q15_t/q31_t function সেই ঐতিহ্যই বহন করে।
পরীক্ষা ও ইন্টারভিউতে: (১) “Q15-এ 0x4000 মানে কত?” → 16384 ÷ 32768 = 0.5. (২) “দুটি Q15 গুণ করলে ফল কোন বিন্যাসে, আর কী করতে হয়?” → Q2.30; অর্ধেক ধাপ (16384) যোগ করে ১৫ বিট ডানে, তারপর saturate. (৩) “Saturation আর wrap-এর পার্থক্য?” → wrap সীমা ছাড়িয়ে উল্টো প্রান্তে ঘোরে, saturation প্রান্তে আটকে থাকে; Cortex-M3-এ SSAT. (৪) “FPU না থাকলে float কীভাবে চলে?” → compiler __aeabi_fmul-এর মতো soft-float function ডাকে; ধীর, বড়, সময় ইনপুটভেদে আলাদা। (৫) “টাকা কেন float-এ নয়?” → 0.01 binary-তে হুবহু হয় না; পয়সায় integer রাখুন।
৯ · AI-এর যুগে fixed-point যাচাই
Fixed-point কোড AI assistant খুব আত্মবিশ্বাসের সঙ্গে লেখে, আর সাধারণ কয়েকটি মানে তা ঠিকও চলে। ভুলগুলো লুকিয়ে থাকে প্রান্তে: সবচেয়ে বড় ইনপুটে, ঋণাত্মক সংখ্যায়, আর হাজারবার জমানো হিসাবে। সবচেয়ে চেনা ভুল আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
| গুণের মাঝের ফল ৩২ বিটে রাখে, যা overflow করে (অংশ ৬-এর Q8.24) | সবচেয়ে বড় ইনপুট × সবচেয়ে বড় গুণক হাতে হিসাব; সব সম্ভাব্য ইনপুটে host-এ চালানো |
| গুণের পরে ভুল সংখ্যক বিট সরায়, বা rounding বাদ দেয় | Qa.b × Qc.d = Q(a+c).(b+d) লিখে মেলানো; ছাঁটা আর গোল করা ফল তুলনা |
Saturation ছাড়া (int16_t) cast, বা −1 × −1-এর ক্ষেত্র ভুলে যায় | (−32768, −32768) আর সীমার দুই প্রান্ত দিয়ে পরীক্ষা |
| ঋণাত্মক সংখ্যা বাঁয়ে shift করে (UB), বা ডানে shift-কে ভাগ ভাবে | -fsanitize=undefined দিয়ে host-এ চালানো; −1 ≫ 1 = −1, কিন্তু −1 ÷ 2 = 0 |
Cortex-M3-এ FPU, QADD বা -mfloat-abi=hard আছে বলে ধরে নেয় | Core-এর Technical Reference Manual; Clang-এর -S-এ bl __aeabi_ খোঁজা |
টাকার হিসাবে float বা double দেয় | সব ওজনে integer সূত্রের সঙ্গে মেলানো (অংশ ৮-এর ৫৬টি অমিল) |
AI-কে কাজে লাগাতে বিন্যাস, সীমা আর যাচাইয়ের শর্ত শুরুতেই দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১8086-এর পাশে আলাদা 8087 chip থেকে আজকের Cortex-M4F পর্যন্ত FPU কেন এখনো অনেক microcontroller-এ ঐচ্ছিক? আর FPU সস্তা হলে fixed-point কি অপ্রয়োজনীয় হয়ে যাবে?
১৯৮০-এর দশকের শুরুতে 8086 বা 8088-এর PC-তে float হিসাব দরকার হলে আলাদা একটি chip, 8087 coprocessor, মাদারবোর্ডের খালি সকেটে বসাতে হতো। ঐচ্ছিক রাখার কারণ ছিল দাম আর জায়গা: বেশিরভাগ ব্যবহারকারী লেখালেখি আর হিসাবের খাতায় integer-ই চালাতেন, তাদের ওপর float-এর বোঝা চাপানোর মানে ছিল না। পরে transistor সস্তা হলে 80486-এর মতো CPU-তে FPU ভেতরেই চলে আসে।
Microcontroller-এর জগতে হিসাবটি আরেকটু জটিল। এখানে silicon-এর প্রতিটি বর্গমিলিমিটার আর প্রতিটি microampere-এর দাম আছে, কারণ chip লাখে লাখে বিক্রি হয় আর অনেকগুলো বছরের পর বছর ব্যাটারিতে চলে। ARM তাই Cortex-M-এ ধাপ রেখেছে: M0 আর M0+-এ hardware ভাগও নেই, M3-এ ভাগ আছে কিন্তু FPU নেই, M4-এ FPU ঐচ্ছিক (single precision), M7-এ single বা double. Chip নির্মাতা নিজের বাজার দেখে বেছে নেন। একটি টর্চলাইট বা দরজার সেন্সরের chip-এ FPU মানে শুধু বাড়তি leakage current আর দাম।
FPU থাকলেও fixed-point হারিয়ে যাচ্ছে না, তিনটি কারণে। প্রথমত, টাকার মতো দশমিক হিসাব float-এ কখনোই নিরাপদ নয়, FPU থাক বা না থাক; এই পর্বের ৫৬টি এক-পয়সার ভুল hardware FPU-তেও একই আসত। দ্বিতীয়ত, sensor আর ADC-র ডেটা মূলত integer, আর তার পরিসর আগে থেকেই জানা: ১২ বিটের ADC কখনো 4095-এর বেশি দেবে না। এমন ডেটায় float-এর বিশাল পরিসর অপ্রয়োজনীয়, আর ১৬ বিটের Q15 অর্ধেক memory-তে একই কাজ করে, DSP নির্দেশে একসাথে দুটি। তৃতীয়ত, FPU-ওয়ালা core-এও interrupt-এর সময় FPU-র register বাঁচাতে বাড়তি কাজ লাগে, যা latency বাড়াতে পারে।
উল্টো দিকে, যেখানে পরিসর অজানা বা বিশাল, যেমন নেভিগেশনের হিসাব বা ছোট neural network-এর training, সেখানে FPU সময় আর মাথাব্যথা দুটিই বাঁচায়। TinyML-এ (পর্ব ৭৮) দেখবেন, inference-এর জন্য উল্টো ৮ বিটের integer-এ নামানো হয়, যা আসলে fixed-point-এরই আরেক রূপ।
মূল উপলব্ধি: FPU একটি নকশার সিদ্ধান্ত, অগ্রগতির মাপকাঠি নয়; জানা পরিসরের, দশমিক বা দ্রুত-পুনরাবৃত্ত হিসাবে fixed-point সবসময় প্রাসঙ্গিক থাকবে।
প্র ০২টাকার হিসাব কেন কখনো binary float-এ নয়? ব্যাংক আর দোকানের software দশমিক সংখ্যা কীভাবে সামলায়?
মূল সমস্যা গণিতের, hardware-এর নয়। Binary ভগ্নাংশে শুধু সেই সংখ্যাগুলো হুবহু রাখা যায়, যাদের হর ২-এর ঘাত: 0.5, 0.25, 0.375. এক পয়সা মানে 1/100, আর ১০০ = ২² × ৫², তাই ৫-এর গুণনীয়কটি binary-তে কখনো শেষ হয় না, ঠিক যেমন ১/৩ দশমিকে 0.333… চলতেই থাকে। ফলে 0.01, 0.03, 0.15 সবই float-এ সামান্য কম বা বেশি। এই পর্বে দেখা গেল, 30 ÷ 1000 ভাগটির float ফল 0.03-এর একটু নিচে, আর দামের সূত্রে সেই নিচে থাকা 196.5 পয়সাকে 196-এ নামিয়েছে। ৫০০১টি ওজনে ৫৬ বার। প্রতিটি মাত্র এক পয়সা, কিন্তু হিসাবের খাতা আর ক্রেতার রসিদ মিলবে না, আর অডিটে এমন অমিলই সবচেয়ে বড় মাথাব্যথা।
পুরোনো দিনের সমাধান ছিল দশমিক অঙ্ক সরাসরি রাখা: BCD (পর্ব ০৫ আর ১১-এ 8085-এর DAA), আর ব্যবসায়িক mainframe-এর COBOL ভাষায় packed decimal type, যেখানে প্রতি অঙ্কে চার বিট। আধুনিক সমাধান সাধারণত এই পর্বেরই: ক্ষুদ্রতম একককে (পয়সা) integer ধরা, আর গুণ-ভাগের সময় নির্দিষ্ট নিয়মে গোল করা। বাজারঘরের দামের সূত্র (net_g × 6550 + 500) ÷ 1000 সেই ধরনের: rounding-এর নিয়ম (অর্ধেকে ওপরে) কোডে স্পষ্ট লেখা, তাই যে কেউ খাতা-কলমে মিলিয়ে দেখতে পারেন।
IEEE 754-এর ২০০৮ সালের সংশোধনে দশমিক floating-point বিন্যাসও যোগ হয়েছে (decimal64, decimal128), আর কিছু ডেটাবেস ও ভাষায় দশমিক type আছে (যেমন SQL-এর DECIMAL ধরন)। এগুলো দশমিক ভগ্নাংশ হুবহু রাখে, কিন্তু microcontroller-এ সাধারণত hardware সমর্থন নেই, আর software-এ ধীর। ছোট firmware-এর জন্য তাই পয়সায় integer-ই সবচেয়ে সরল আর যাচাইযোগ্য।
একটি সূক্ষ্ম বিষয় মনে রাখার মতো: পয়সায় integer রাখলেও ভাগ আর rounding-এর নিয়মটি ব্যবসার নিয়ম, programmer-এর খেয়াল নয়। কোথাও “অর্ধেকে ওপরে”, কোথাও “অর্ধেকে জোড়ের দিকে” (banker's rounding), কোথাও সবসময় ক্রেতার পক্ষে নিচে। সেই নিয়ম আগে লিখিত হওয়া দরকার, তারপর কোড।
মূল উপলব্ধি: দশমিক মুদ্রা binary ভগ্নাংশে হুবহু হয় না; ক্ষুদ্রতম একককে integer ধরে লিখিত rounding-এর নিয়ম মানাই নিরাপদ ও যাচাইযোগ্য পথ।
প্র ০৩Saturation সবসময় ভালো, আর wrap সবসময় খারাপ — কথাটি কি ঠিক? কোন হিসাবে wrap-ই সঠিক আচরণ?
Sensor, অডিও আর নিয়ন্ত্রণের মানে saturation প্রায় সবসময় ঠিক, কারণ এগুলো কোনো ভৌত পরিমাণের প্রতিনিধি। তাপমাত্রা খুব বেশি হলে “সবচেয়ে বেশি” বলা ভুলের পরিমাণ সীমিত রাখে; wrap করে “খুব ঠান্ডা” বলা বিপদ ডেকে আনে। অডিওতে saturation শোনায় একটু কর্কশ clipping-এর মতো, wrap শোনায় বিকট শব্দের মতো। PID নিয়ন্ত্রণে (পর্ব ৬৯) motor-এর PWM-এর আদেশ সীমায় আটকানো স্বাভাবিক, আর integrator-কেও আটকাতে হয়, নইলে “windup” হয়।
কিন্তু কিছু হিসাবের অর্থই হলো wrap. SysTick-এর মতো counter বা ms-এর timestamp ৩২ বিটে প্রায় ৪৯.৭ দিন পরে শূন্যে ফেরে; দুটি সময়ের পার্থক্য now - start unsigned-এ বিয়োগ করলে wrap-এর পরেও ঠিক ফল আসে, ঠিক এই modular গণিতের জন্যই। এখানে saturation দিলে counter একদিন থেমে যেত আর সব timeout ভেঙে পড়ত। CRC আর checksum-এর গণনা, ring buffer-এর index, hash: সবই ইচ্ছাকৃতভাবে modular. একইভাবে, কোণ (phase) রাখতে Q-বিন্যাসে wrap চমৎকার: 359° থেকে এক ডিগ্রি বাড়লে 0°-এ ফেরাই ঠিক।
দ্বিতীয় সূক্ষ্মতা: saturation ভুলকে লুকায়। একটি ফিল্টারের ভেতরে যদি বারবার saturate হয়, ফল দেখতে স্বাভাবিক কিন্তু আসলে সংকেত নষ্ট। ভালো নকশায় তাই saturation-এর সঙ্গে একটি খবরও রাখা হয়। ARM-এর SSAT আর DSP-র QADD নির্দেশ APSR-এর Q flag (sticky) set করে, যা পরে পড়ে জানা যায় কোথাও saturate হয়েছিল কি না; firmware নিজেও একটি গণনা রাখতে পারে। বাজারঘর স্কেলের OVERLOAD বার্তা এরই একটি রূপ: 5000 g-এর বেশি হলে চুপচাপ 5000 দেখানো নয়, ক্রেতাকে স্পষ্ট জানানো।
তৃতীয় দিক C ভাষার: unsigned-এর wrap C-তে সংজ্ঞায়িত, signed-এর overflow undefined. তাই wrap চাইলে unsigned type-এ লিখুন, saturation চাইলে চওড়া type-এ হিসাব করে clamp; signed overflow-এর ওপর কখনো ভরসা নয়, কারণ optimizer ধরে নেয় তা ঘটেই না আর পরীক্ষাটি মুছে দিতে পারে।
মূল উপলব্ধি: ভৌত পরিমাণে saturation (সঙ্গে সতর্ক-সংকেত), সময়, index আর checksum-এর মতো modular পরিমাণে unsigned wrap; প্রশ্নটি “কোনটি ভালো” নয়, “এই সংখ্যার অর্থ কী”।
প্র ০৪কতটি ভগ্নাংশ বিট যথেষ্ট, তা অনুমানে না করে কীভাবে হিসাব করবেন? বাজারঘর স্কেলে ১৩ বিট কেন যথেষ্ট, আর ADC বদলালে কী বদলাবে?
পদ্ধতিটি একটি “ভুলের বাজেট”। প্রথমে ঠিক করুন ফল কতটা নির্ভুল হতে হবে: স্কেলের বেলায় ভাগের সূত্রের সঙ্গে প্রতিটি গ্রাম হুবহু মিলতে হবে। তারপর দেখুন, আসল ফলের ভগ্নাংশ “অর্ধেক”-এর কত কাছে আসতে পারে, কারণ সেখানেই সামান্য ভুল গোল করাকে উল্টে দেয়। এখানে গ্রাম = (raw − 400) × 10 ÷ 7, তাই ভগ্নাংশ সবসময় ০, ১/৭, ২/৭ … ৬/৭; অর্ধেকের সবচেয়ে কাছে 3/7 = 0.4286 আর 4/7 = 0.5714, দূরত্ব 0.0714 g. অর্থাৎ gain-এর ভুল × সবচেয়ে বড় count যতক্ষণ 0.0714 g-এর কম, কোনো অমিল হবে না।
n বিটে gain-এর ভুল সর্বোচ্চ অর্ধেক ধাপ, 2−(n+1), আর সবচেয়ে বড় count 3695 (raw 4095). শর্ত 3695 × 2−(n+1) < 0.0714, অর্থাৎ 2n > প্রায় ২৫,৯০০, n ≥ ১৫ নিশ্চিতভাবে যথেষ্ট। বাস্তবে gain-এর ভুল প্রায়ই অর্ধেক ধাপের চেয়ে কম হয়, তাই পরীক্ষায় ১৩ বিটেই ০টি অমিল এসেছে (gain 11703, আসল 11702.86, ভুল মাত্র ০.১৪ ধাপ)। এই কারণেই হাতের হিসাব “নিশ্চিত সীমা” দেয়, আর সব ইনপুটে পরীক্ষা দেয় “আসল সীমা”; দুটোই দরকার। Q16.16 নেওয়া হয়েছে কারণ এটি ১৫-এর বেশি, ৩২ বিটের অর্ধাঅর্ধি সুবিধাজনক, আর overflow থেকেও ছয় গুণ দূরে।
এবার উল্টো দিকের বাজেট: overflow. সবচেয়ে বড় গুণফল = সবচেয়ে বড় count × gain × 2n, যাকে 231-এর নিচে থাকতে হবে। ১২ বিটের ADC-তে 3695 × 1.43 × 2n < 231 মানে n ≤ ১৮. তাই বাজারঘর স্কেলে n-এর নিরাপদ জানালা ১৩ থেকে ১৮; ২৪ বিটের Q8.24 যে ভাঙল, তা এই হিসাবেই আগে বোঝা যেত।
ADC বদলালে দুটি বাজেটই সরে যায়। ধরুন ভবিষ্যতে load cell-এর জন্য ২৪ বিটের একটি ADC বসানো হলো, যার count কয়েক মিলিয়ন পর্যন্ত যায়। তখন ৩২ বিটের গুণফলে Q16.16 আর আঁটবে না; হয় gain-কে কম বিটে নিতে হবে, নয়তো ৬৪ বিটের গুণ (SMULL, Cortex-M3-এ এক নির্দেশ) ব্যবহার করতে হবে। আবার ADC-র নিজের quantization error আর noise (পর্ব ৪৭ আর ৬৬) প্রায়ই gain-এর ভুলের চেয়ে অনেক বড়; তখন অতিরিক্ত ভগ্নাংশ বিট আসলে কিছুই যোগ করে না।
মূল উপলব্ধি: ভগ্নাংশ বিটের নিচের সীমা আসে নির্ভুলতার বাজেট থেকে, ওপরের সীমা overflow-এর বাজেট থেকে; দুটি হাতে হিসাব করে সব ইনপুটে পরীক্ষায় নিশ্চিত হোন।
প্র ০৫একবারের গুণে ছাঁটাইয়ের ভুল অর্ধেক LSB-এর মতো নগণ্য। তবু DSP আর filter-এর নকশাকারীরা rounding-এর পদ্ধতি নিয়ে এত সতর্ক কেন?
কারণ ছাঁটাইয়ের ভুল এলোমেলো নয়, একমুখী। Arithmetic shift সবসময় −∞-এর দিকে ছাঁটে, তাই প্রতিটি গুণে ফল গড়ে প্রায় অর্ধেক LSB কম। এই পর্বের সব 232 জোড়ার পরীক্ষায় প্রায় অর্ধেক জোড়ায় ছাঁটা ফল গোল করা ফলের চেয়ে এক কম, কখনো বেশি নয়। একবারে কিছু নয়, কিন্তু একটি filter প্রতি sample-এ এমন গুণ করে আর ফল আবার পরের ধাপে ফেরত দেয়। একমুখী ভুল তখন জমতে থাকে, যেমন প্রতিদিন দুই পয়সা কম ধরলে মাস শেষে হিসাব মেলে না।
একটি সাধারণ উদাহরণ exponential moving average: y = y + α × (x − y), যেখানে α ছোট, যেমন 1/16 (৪ বিট ডানে সরানো)। Cold room-এর t16-এ x = 100 (6.25 °C) স্থির রেখে আমি Python-এ ২০০ ধাপ চালিয়েছি। ছাঁটাইসহ y শূন্য থেকে উঠে 85-এ আটকে যায় (5.31 °C, প্রায় এক ডিগ্রি কম), কারণ পার্থক্য ১৬-এর নিচে নামলেই তার ১/১৬ ছেঁটে শূন্য; অথচ ওপর থেকে নামলে ঠিক 100-এ পৌঁছায়। একমুখী ভুল তাই দিকভেদে আলাদা ফল দেয়। অর্ধেক ধাপ যোগ করলে আটকে যাওয়ার জায়গা হয় 93 আর 108: ফাঁক অর্ধেক আর দুই দিকে সমান, কিন্তু শূন্য নয়। পুরো সমাধান হলো y-কে বেশি ভগ্নাংশ বিটে রাখা: আরও ৮ বিট দিলে y = 99.97, গোল করে ঠিক 100. এমন filter-এর বিস্তারিত পর্ব ৬৮-এ।
দ্বিতীয় প্রশ্ন, ঠিক অর্ধেকে কী হবে। “অর্ধেকে ওপরে” (এই পর্বের পদ্ধতি) সহজ আর এক নির্দেশে হয়, কিন্তু ঠিক-অর্ধেক মানগুলোয় সামান্য ওপরমুখী পক্ষপাত রাখে। IEEE 754-এর ডিফল্ট “অর্ধেকে জোড়ের দিকে” (ties to even): অর্ধেক মানের অর্ধেক ওপরে, অর্ধেক নিচে যায়, তাই দীর্ঘ হিসাবে পক্ষপাত শূন্য। অনেক DSP-তে একে convergent rounding বলা হয়, আর hardware-এ এর বিশেষ ব্যবস্থাও থাকে। Q15-এর ক্ষেত্রে আরেকটি অসমতা আছে: −1 আছে কিন্তু +1 নেই, তাই −1 × −1-এর মতো এক-আধটি ক্ষেত্রে saturation দরকার, যা এই পর্বে দেখা গেল।
শেষ কথা: নকশাকারীরা প্রায়ই accumulator-কে চওড়া রাখেন। Q15-এর গুণফল Q2.30-এ রেখে অনেকগুলো যোগ করেন (Cortex-M3-এরও SMLAL ৬৪ বিটে জমায়, M4-এর SMLALD একসাথে দুটি Q15 গুণ), আর একেবারে শেষে একবার rounding আর saturation করেন। এতে ভুল ঢোকে একবার, প্রতি ধাপে নয়।
মূল উপলব্ধি: ছাঁটাইয়ের ভুল একমুখী বলে বারবার করা হিসাবে জমে; অর্ধেক ধাপ যোগ করা, চওড়া accumulator আর শেষে একবার গোল করাই fixed-point-এর নির্ভুলতার মূল কৌশল।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি firmware-এর উত্তর কোর্সের virtual বাজারঘর board-এ build করে চালিয়ে আর প্রতিটি হিসাব চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — দোকানে নতুন calibration: দোকানদার খালি পাল্লায় একবার আর 2000 g-এর বাটখারায় একবার button চাপেন; firmware তখন দুটি raw মান পায়।
cal_grams(const cal_t *c, int32_t raw)লিখুন, যা প্রতিটি reading-এ কোনো ভাগ ছাড়া Q16.16-এ গ্রাম দেয়, গোল করে, আর কখনো wrap করে না। Gain কীভাবে, কখন হিসাব হবে? 400/1800 দিয়ে 505, 1380, 855, 3970, 395 count-এ ফল কী, আর 0–4095-এ কয়টি অমিল?Gain calibration-এর মুহূর্তে একবারই:
((span_g << 16) + counts / 2) / counts, অংশ ৫-এরcal_make(2000 × 65536 = 131,072,000 ৩২ বিটে আঁটে, তাই M3-এরSDIVনির্দেশেই হয়)। প্রতিটি reading:static int32_t cal_grams(const cal_t *c, int32_t raw) { int32_t g = ((raw - c->zero_raw) * c->gain_q16 + 32768) >> 16; if (g > 32767) g = 32767; /* never wraps */ return g; }সত্যিকারের run (
build/cal.elf):gain_q16=93623, তারপরraw=505 g=150,raw=1380 g=1400,raw=855 g=650,raw=3970 g=5100,raw=395 g=-7, আরmismatches 0..4095=0. ১২ বিটের ADC-তে গুণফল সর্বোচ্চ 345,936,985, তাই gain যতক্ষণ প্রায় 581,000-এর নিচে, ভেতরের গুণ নিরাপদ; ৩২৭৬৭-এর clamp বাড়তি সাবধানতা, যদি ভবিষ্যতে ভুল calibration-এ gain বিশাল হয়ে যায়। খেয়াল করুন, −7 g (tare-এর পরে প্ল্যাটফর্ম থেকে মাল তুললে) ঠিকই ঋণাত্মক এসেছে, কারণ arithmetic shift আর +32768 মিলে অর্ধেকে ওপরে গোল করে: −7.14 → −7. -
ভুল খুঁজুন — “আরও নিখুঁত” কোড: একজন লিখলেন:
#define GAIN_Q24 23967451(2000/1400 × 224),int32_t grams(int32_t raw) { return ((raw - 400) * GAIN_Q24 + (1 << 23)) >> 24; }আরint16_t q15_mul(int16_t a, int16_t b) { return (int16_t)((a * b) >> 15); }. দুটিতে কী ভুল, কোন ইনপুট থেকে ভাঙে, আর ঠিক রূপ কী?প্রথমটি: (raw − 400) × 23,967,451 ৩২ বিটে আঁটে শুধু raw ≤ 489 পর্যন্ত; 490-এ গুণফল 2,157,070,590 > 2,147,483,647. C-তে signed overflow undefined behavior, আর board-এ wrap দেখালে (
cal.c) ফল:raw=489 g=127,raw=490 g=-127,raw=505 g=-106,raw=1380 g=120. অর্থাৎ ১২৮ g-এর ওপরে সব ভুল। ঠিক রূপ: Q16.16 gain 93623 (৬৪ বিট ছাড়াই নিরাপদ), অথবা Q8.24 রাখতে চাইলে(int64_t)-এ গুণ (SMULL) করতে হবে। কিন্তু অংশ ৬-এর হিসাবে বাড়তি ভগ্নাংশ বিট কিছুই দেয় না, তাই সরল সমাধানই ভালো।দ্বিতীয়টি: rounding নেই, তাই 0.8 × 0.6 দেয় 15728 (গোল করে 15729), আর প্রায় অর্ধেক জোড়ায় এক LSB কম। বড় ভুল saturation না থাকা: −32768 × −32768 = 230, ≫ 15 = 32768,
(int16_t)-এ wrap করে −32768. Board-এ ছাঁটা সংস্করণ সত্যিইtrunc=-32768দিয়েছে: −1 × −1 = −1. ঠিক রূপ অংশ ৪-এরq15_mul:sat16((p + (1 << 14)) >> 15). -
হিসাব — আগে বলুন, তারপর মেলান: Cold room-এর sensor পরপর তিনটি word দিল: 0x0810, 0x0790, 0xFFF0. প্রতিটির t16, README-র সূত্রে display-এর মান (t16 × 25 ÷ 4, শূন্যের দিকে ছাঁটা), আর কোন গণনা (HIGH, LOW, ok, বা কোনোটিই নয়) বাড়বে? তারপর Q15-এ 0x2000 × 0xC000 (rounding-সহ
q15_mul) কত, hex আর আসল মানে?0x0810: t16 = 0x0810 ≫ 4 = 129 = 8.0625 °C; 129 × 25 ÷ 4 = 806.25 → 806, display
+8.06; 129 > 128, তাই HIGH-এর গণনা বাড়ে। 0x0790: t16 = 121 = 7.5625 °C; 3025 ÷ 4 = 756.25 → 756,+7.56; 121 > 120, তাই ok-এর গণনায় পড়ে না, আবার 128-এর বেশিও নয়: hysteresis-এর ফাঁক: কোনো গণনা বাড়ে না, বরং firmware-এর নিয়মে তিনটি গণনাই শূন্যে ফেরে। 0xFFF0:(int16_t)−16, ≫ 4 = −1 = −0.0625 °C; −25 ÷ 4 = −6.25 → শূন্যের দিকে −6,-0.06; −1 < 0, তাই LOW-এর গণনা। তিনটিই অংশ ৭-এর ব্লকের আউটপুটের সঙ্গে মেলে।Q15: 0x2000 = 8192 = 0.25, 0xC000 = −16384 = −0.5. গুণফল −134,217,728 (Q2.30), + 16384 = −134,201,344, ≫ 15 (arithmetic, নিচের দিকে) = −4095.5 থেকে −4096 = 0xF000 = −0.125. আসল 0.25 × −0.5 = −0.125, তাই হুবহু; Python-এ
(8192 * -16384 + 16384) >> 15চালিয়েও −4096. -
প্রমাণ — Clang নিচের সীমা কেন বাদ দিল: অংশ ৪-এর
q15_mul-এ C কোড দুই দিকেই clamp করে, অথচ Clang-এর assembly শুধু 32767-এর সঙ্গে তুলনা করে। প্রমাণ করুন যে দুটিint16_tইনপুটে (p + 214) ≫ 15 কখনো −32768-এর নিচে নামে না, আর 32767 ছাড়ায় শুধু একটি জোড়ায়।a, b দুটিই −32768 থেকে 32767-এর মধ্যে, তাই গুণফল p-এর সীমা: সবচেয়ে ছোট p আসে বিপরীত চিহ্নের দুই প্রান্তে, −32768 × 32767 = −1,073,709,056 = −230 + 215. তখন (p + 214) ÷ 215 = −215 + 1 + 0.5 = −32766.5; floor (arithmetic shift) = −32767, যা −32768-এর ওপরে। অর্থাৎ নিচের clamp কখনো কাজে আসে না, আর Clang-এর value-range বিশ্লেষণ এটি ধরে ফেলে পরীক্ষাটি মুছে দিয়েছে।
ওপরের দিকে, সবচেয়ে বড় p = (−32768) × (−32768) = 230, তখন (230 + 214) ≫ 15 = 32768 > 32767: saturation লাগে। পরের সবচেয়ে বড় p হলো 32767 × 32767 = 230 − 216 + 1 বা −32768 × −32767 = 230 − 215; দ্বিতীয়টিতে (230 − 215 + 214) ÷ 215 = 32767.5, floor 32767, সীমার মধ্যে। তাই সীমা ছাড়ায় ঠিক একটি জোড়া, (−32768, −32768) জোড়াটি। Host-এ সব 4,294,967,296 জোড়ার numpy পরীক্ষাও বলেছে: saturation 1 বার, rounding-এর অমিল 0.
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রম১২ বিটের ADC-র একটি স্কেলে (খালি 400 count, 2000 g-এ 1800 count) প্রতিটি reading-এ ভাগ ছাড়া গ্রাম বের করার নকশার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Calibration থেকে আসল gain বের করা: 2000 g ÷ 1400 count
- ভগ্নাংশ বিট বেছে gain-কে 2n দিয়ে গুণ করে গোল করা (Q16.16-এ 93623)
- সবচেয়ে বড় গুণফল (3695 × 93623)
int32_t-এ আঁটে কি না যাচাই করা - প্রতিটি reading-এ (raw − 400) × gain হিসাব করা
- অর্ধেক ধাপ (32768) যোগ করে ১৬ বিট ডানে সরানো
Q15 বিন্যাসে (১৬ বিট, ১৫টি ভগ্নাংশ বিট) রাখা 0x4000-এর আসল মান কত?
- 16384
- 0.5
- 0.25
- 1.0
দুটি Q15 সংখ্যা ৩২ বিটের int32_t-এ গুণ করলে গুণফল কোন বিন্যাসে থাকে, আর Q15-এ ফেরাতে কী করতে হয়?
- Q1.15; কিছুই করতে হয় না
- Q16.16; ১৬ বিট ডানে সরানো
- Q2.30; 2^14 যোগ করে ১৫ বিট ডানে সরানো
- Q2.30; ১৫ বিট বাঁয়ে সরানো
Q15-এ 0x6000 + 0x4000 (0.75 + 0.5) হিসাব করা হলো saturating যোগ দিয়ে। ফল কত?
- 0xA000 (−0.75)
- 0x8000 (−1.0)
- 0x14000 (1.25)
- 0x7FFF (≈ 0.99997)
Q15 গুণে (p + (1 << 14)) >> 15 লেখা হয়, শুধু p >> 15 নয়। এই 214 যোগের কাজ কী?
- ছাঁটাইয়ের বদলে কাছের মানে গোল করা
- Overflow ঠেকানো
- ঋণাত্মক সংখ্যার চিহ্ন রক্ষা করা
- ফলকে Q2.30 থেকে Q1.15-এ নেওয়া
একটি স্কেলে ১২ বিটের ADC, খালি অবস্থায় 400 count, আর গ্রাম = ((raw − 400) × gain + অর্ধেক ধাপ) ≫ n, সব হিসাব int32_t-এ। আসল gain 2000 ÷ 1400 ≈ 1.4286. কোন পছন্দে raw 4095-এর আগেই গুণফল overflow করবে?
- Q.8, gain 366
- Q16.16, gain 93623
- Q8.24, gain 23,967,451
- Q.13, gain 11703
FPU নেই এমন Cortex-M3-এর firmware-এ float g = x * 1.4285715f; লেখা হলো, আর compile হলো Clang-এ -mfloat-abi=soft দিয়ে। Compiler গুণটি কীভাবে করে?
- VMUL.F32-এর মতো FPU নির্দেশ দিয়ে
- __aeabi_fmul-এর মতো runtime library function ডেকে
- স্বয়ংক্রিয়ভাবে Q16.16-এ বদলে
- একটি integer গুণ আর shift দিয়ে
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Qm.n: ধাপ 2−n, পরিসর −2m−1 থেকে 2m−1 − 2−n; q = round(x × 2n). টাকা দশমিক scale-এ (পয়সা), sensor আর নিয়ন্ত্রণ binary scale-এ।
- গুণ: Qa.b × Qc.d = Q(a+c).(b+d); অর্ধেক ধাপ যোগ করে n বিট ডানে, তারপর saturate. Q15-এ শুধু −1 × −1 সীমা ছাড়ায়।
- ভাগ: ভাজ্যকে আগে 2n দিয়ে গুণ; Q16.16-এ ৬৪ বিট লাগে, যা
__aeabi_ldivmodনামের library-র ডাক হয়ে যায়। ভাগ একবার calibration-এ, প্রতি reading-এ শুধু গুণ। - বাজেট: ভগ্নাংশ বিটের নিচের সীমা নির্ভুলতা থেকে (স্কেলে ১৩), ওপরের সীমা overflow থেকে (স্কেলে ১৮); সব ইনপুটে পরীক্ষা করে নিশ্চিত হোন।
- Float-এর দাম: FPU-হীন M3-এ soft-float প্রায় ১৭ গুণ বেশি নির্দেশ আর ১৩৩০ byte library; টাকা কখনো float-এ নয় (৫৬টি এক-পয়সার ভুল)।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ০৫ · এমবেডেড কাজের সংখ্যাভিত্তিTwo's complement, carry বনাম overflow আর fixed-point-এর প্রথম পরিচয়।
- পর্ব ২৯ · ARM Cortex-M-এর গঠনতুলনার জন্যHardware ভাগ,
UMULLআর ÷1000-এর magic number. - C প্রোগ্রামিং পর্ব ০৮ · Type conversionপাশের ট্র্যাকInteger promotion আর ছোট type-এ রূপান্তরের নিয়ম।
- C প্রোগ্রামিং পর্ব ৫৪ · এমবেডেড Cপাশের ট্র্যাকFixed-width type আর hardware-এর কাছের C.