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

Signal conditioning আর calibration — amplifier, filter আর offset

Signal Conditioning and Calibration — Amplifier, Filter and Offset

Taught in Bangla, this lesson bridges a load cell's few millivolts and a 0–3.3 V ADC. It computes a 2 mV/V Wheatstone bridge, an instrumentation amplifier gain near 427 with a reference offset, and an RC anti-aliasing filter with a 15.9 Hz corner and its settling time. On the virtual BG-M3 board a wrong nominal calibration shows 28 g on an empty pan until recalibrating with two button presses fixes it, and a CRC-protected record survives reset; least squares and a lookup table then handle noisy and curved data.

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

  • Wheatstone bridge-এর output, op-amp-এর non-inverting gain আর instrumentation amplifier-এর gain ও REF হিসাব করা
  • Sensor-এর সংকেতকে ADC-র পাল্লায় বসানো: gain, offset আর level shifting-এর নকশা, ধাপে ধাপে
  • ADC-র আগের RC anti-aliasing filter-এর corner, দমন আর settling time হিসাব করা
  • দুই-বিন্দু, বহু-বিন্দু আর least-squares calibration, আর বাঁকা sensor-এর জন্য টেবিল
  • তাপমাত্রার drift-এর হিসাব, আর calibration-এর মান CRC দিয়ে নিরাপদে রাখা, virtual board-এর firmware-এ

১ · Signal conditioning কী — sensor আর ADC-র মাঝের সেতু

গ্রামের হাটে একজন বৃদ্ধ বিক্রেতা খুব আস্তে কথা বলেন। ক্রেতারা শুনতে পান না। তাঁর নাতি পাশে দাঁড়িয়ে কথাগুলো জোরে বলে (amplify), হাটের হট্টগোল বাদ দিয়ে শুধু দামের কথাটুকু বলে (filter), আর দাম বলে টাকায়, “আনা”-য় নয় (একক বদল)। Sensor সেই বৃদ্ধ বিক্রেতা, ADC ক্রেতা, আর মাঝের নাতিটি signal conditioning: sensor-এর দুর্বল, গোলমেলে, ভুল পাল্লার সংকেতকে ADC-র উপযোগী করার বর্তনী।

বাজারঘরের smart scale-এ পথটি এরকম। ভারে load cell-এর ধাতু সামান্য বাঁকে, তার strain gauge-এর রোধ বদলায়, আর একটি bridge বর্তনী কয়েক millivolt দেয়। ADC-র পাল্লা ০ থেকে 3.3 V, এক ধাপ প্রায় 0.806 mV (পর্ব ৪৭)। Amplifier ছাড়া পুরো 5000 g-এর ভার মাত্র আটটি ধাপ নাড়াত! তাই চারটি কাজ লাগে:

১ · Amplification

ছোট সংকেতকে বড় করা, যাতে ADC-র পাল্লার বড় অংশ কাজে লাগে। স্কেলে প্রায় ৪২৭ গুণ।

২ · Offset আর level shifting

সংকেতকে ওপরে-নিচে সরিয়ে পাল্লার ভেতরে বসানো। স্কেলে শূন্য ওজন = 400 count, যাতে শূন্যের নিচের সামান্য টানও চোখে পড়ে।

৩ · Filtering

ADC-র আগে দ্রুত noise আর 50 Hz-এর hum কমানো, যাতে sampling-এ ছদ্মবেশ (aliasing) না ঢোকে।

৪ · Calibration

Firmware-এ count থেকে গ্রামে যাওয়ার দুটি সংখ্যা, zero আর span, জানা বাটখারা দিয়ে মেপে রাখা।

প্রথম তিনটি hardware-এর কাজ, শেষটি firmware-এর। এই পর্বের ঠিকানা আর register-এর মান C-এর ধরনে লেখা হবে, যেমন 0x40012400. বাজারঘরের সব সংখ্যা reference lab-এর README থেকে: খালি পাল্লায় 400 count, 2000 g-এ 1800 count, ধারণক্ষমতা 5000 g, দর 65.50 টাকা/kg. Sensor-এর ধরনগুলো পর্ব ৬৫-এর (sensor interfacing) বিষয়, আর ADC নিজে পর্ব ৪৭-এর। এখানে দুটির মাঝখানটুকু।

বাজারঘরের দ্বিতীয় device, cold-storage monitor, অন্য রকম। তার TMP102-ধাঁচের sensor (README: I2C ঠিকানা 0x48, 0.0625 °C প্রতি LSB) নিজের ভেতরেই amplifier আর ADC রাখে, আর সরাসরি সংখ্যা দেয়; তাই সেখানে analog-এর চারটি কাজ chip-এর নির্মাতা সেরে রেখেছেন। Calibration তবু থাকে, সবচেয়ে সরল রূপে: এক-বিন্দুর offset সংশোধন। ধরুন একটি বিশ্বস্ত reference থার্মোমিটার 4.00 °C দেখাচ্ছে আর sensor 4.25 °C: পার্থক্য 0.25 °C = 4 LSB, তাই firmware প্রতিটি কাঁচা মান থেকে 4 বাদ দেবে। এই পর্বের বাকিটা স্কেলের analog পথ নিয়ে, কারণ সেখানেই সব চারটি কাজ চোখে দেখা যায়।

ছবি ৬৬.১ — বাজারঘরের স্কেলের signal chain

ওপরের সারি analog: bridge আর instrumentation amplifier; নিচের সারি: RC filter, ADC আর firmware-এর calibration

বাজারঘরের স্কেলের signal chain 3.3 V bridge GND + − INA RG = 116 Ω REF 0.322 V ×427 10 kΩ 1 µF ADC ১২ বিট Vref 3.3 V firmware zero, span → গ্রাম, দাম 2000 g রাখলে: bridge 2.64 mV → INA 1.4502 V → ADC 1800 count → 2000 g RC-র corner ≈ 15.9 Hz, ADC ভরে ≈ 5279 g-এ
ছবি ৬৬.১ — Bridge-এর দুই বাহুর voltage দুটিই প্রায় 1.65 V; পার্থক্য মাত্র কয়েক mV. তাই amplifier-কে পার্থক্যটুকু বড় করতে হয়, 1.65 V-কে নয়। এই সংখ্যাগুলো একটি নকশার হিসাব (অংশ ৩-এর block); কোর্সের virtual board এই analog অংশ মডেল করে না, সে সরাসরি README-র সূত্রে count দেয় (Spec decision 25-এর নিয়মে)।

২ · Wheatstone bridge — এক ওহমেরও কম বদল থেকে millivolt

একটি strain gauge আসলে একটি পাতলা ধাতব ফিতার আঁকাবাঁকা পথ। টানলে ফিতা লম্বা আর সরু হয়, রোধ বাড়ে; চাপলে কমে। বদলটি খুবই ছোট: 350 Ω-এর gauge পূর্ণ ভারে বড়জোর এক ওহমের কাছাকাছি বদলায়। এত ছোট বদল সরাসরি মাপা কঠিন, তাই চারটি রোধ হীরার আকারে সাজানো হয়: Wheatstone bridge. দুই পাশে দুটি voltage divider; ভার না থাকলে দুই মাঝবিন্দুর voltage সমান, পার্থক্য শূন্য (“ভারসাম্য”)। ভার এলে পার্থক্য তৈরি হয়, আর সেটিই সংকেত।

মূল সূত্র

Bridge output Vo = Vexc × (R3 ÷ (R3 + R4) − R2 ÷ (R1 + R2)) · চারটি সক্রিয় gauge-এর full bridge-এ (দুটি +ΔR, দুটি −ΔR): Vo = Vexc × ΔR ÷ R · Datasheet-এ লেখা rated output mV/V-এ: পূর্ণ ভারে Vo = rated output × Vexc.

বাজারঘরের নকশায় ধরা যাক 5 kg-এর একটি load cell, rated output 2 mV/V (অনেক load cell-এর datasheet-এ ১ থেকে ৩ mV/V-এর মধ্যে দেখা যায়; নিজের cell-এর মান তার calibration sheet থেকে নিন)। Excitation voltage 3.3 V, আর একই 3.3 V ADC-র Vref, অর্থাৎ ratiometric নকশা। পূর্ণ ভারে output 2 mV/V × 3.3 V = 6.6 mV; 350 Ω-এর gauge-এ এর মানে ΔR = 0.7 Ω. 2000 g-এ তার ৪০%: 2.64 mV. লক্ষ করুন, দুই মাঝবিন্দু তখনো প্রায় 1.65 V-এ: একটি 1.65132 V, অন্যটি 1.64868 V. এই সাধারণ 1.65 V-কে বলে common-mode voltage, আর 2.64 mV-এর পার্থক্যকে differential সংকেত।

Full bridge-এর একটি উপহারও আছে। তাপমাত্রায় চারটি gauge-এর রোধ প্রায় একসঙ্গে বাড়ে-কমে; সব বাহু একই অনুপাতে বদলালে মাঝবিন্দুর voltage বদলায় না। ফলে bridge নিজেই তাপমাত্রার বড় একটি অংশ কেটে দেয়। পুরোটা নয়, কারণ gauge আর ধাতু কখনো হুবহু মেলে না; বাকিটা অংশ ৭-এ।

৩ · Amplifier — op-amp, instrumentation amplifier আর offset

সংকেত বড় করার মূল যন্ত্র op-amp (operational amplifier): দুই input-এর পার্থক্যকে বিপুল (প্রায় লাখ গুণ বা তার বেশি) গুণ করা একটি IC. এত বড় gain সরাসরি কাজে আসে না; output-এর একটি অংশ resistor দিয়ে input-এ ফিরিয়ে (negative feedback) gain-কে resistor-এর অনুপাতে বেঁধে রাখা হয়। সবচেয়ে সরল রূপ non-inverting amplifier:

দুটি gain-এর সূত্র

Non-inverting: G = 1 + Rf ÷ Rg (যেমন Rf = 22 kΩ, Rg = 10 kΩ → G = 3.2; ০–1 V-এর একটি sensor ০–3.2 V হয়, 3.3 V-এর নিচে একটু জায়গা রেখে) · AD620 instrumentation amplifier: G = 1 + 49.4 kΩ ÷ RG (Analog Devices-এর datasheet অনুযায়ী) · Output = REF + G × (V+ − V−).

Bridge-এর জন্য একটি non-inverting amplifier কেন চলে না? কারণ তার একটি মাত্র input মাটির সাপেক্ষে মাপে। Bridge-এর এক বাহুর 1.65 V-কে ৪২৭ গুণ করতে গেলে output সঙ্গে সঙ্গে সরবরাহের সীমায় আটকে যাবে, আর 2.64 mV-এর আসল খবর হারাবে। দরকার এমন amplifier যে শুধু দুই input-এর পার্থক্য বড় করে আর সাধারণ অংশ উপেক্ষা করে: instrumentation amplifier (INA). সাধারণ অংশ কতটা উপেক্ষা করে, তার মাপ CMRR (common-mode rejection ratio), dB-তে। ধরুন সরবরাহে 10 mV-এর 50 Hz hum দুই বাহুতে সমানভাবে এল, আর CMRR 100 dB (অর্থাৎ ১০৫ গুণ দমন): input-এর হিসাবে তা 0.1 µV, ৪২৭ গুণে মাত্র প্রায় 0.05 count. প্রকৃত CMRR প্রতিটি chip-এর datasheet-এ gain আর frequency অনুযায়ী আলাদা টেবিলে থাকে।

INA-র তৃতীয় একটি pin খুব কাজের: REF. Output = REF + G × পার্থক্য, তাই REF-এ যে voltage দেবেন, শূন্য ভারে output সেখানে থাকবে। এটিই level shifting: সংকেতকে ওপরে তুলে ADC-র পাল্লার ভেতরে বসানো। বাজারঘরের স্কেলে শূন্য ভারে 400 count চাই, অর্থাৎ REF ≈ 400 × 0.806 mV = 0.322 V. কেন শূন্যে নয়? কারণ একক সরবরাহের amplifier-এর output সাধারণত মাটির একদম কাছে পৌঁছাতে পারে না, আর শূন্যের নিচের সামান্য উল্টো টান (খালি পাল্লা তুলে ধরা, বা offset-এর ভুল) তখন 0-তে আটকে লুকাত। 400 count-এর এই জায়গা সেই খবর রাখে। নিচের block পুরো নকশাটি README-র দুটি সংখ্যা থেকে উল্টো দিকে হিসাব করে।

# Load cell bridge → instrumentation amplifier → ADC: বাজারঘর স্কেলের পথ
VEXC = 3.3            # bridge excitation, ADC-র Vref-ও এটাই (ratiometric)
SENS = 2.0e-3         # rated output 2 mV/V at full scale (উদাহরণ মান)
CAP_G = 5000          # load cell-এর পূর্ণ মাপ
VREF, BITS = 3.3, 12
LSB = VREF / 2 ** BITS

def bridge(r1, r2, r3, r4, v=VEXC):     # দুই বাহুর মাঝের voltage-এর পার্থক্য
    return v * (r3 / (r3 + r4) - r2 / (r1 + r2))

R, dR = 350.0, 0.7                      # 350 Ω gauge, পূর্ণ ভারে ΔR = 0.7 Ω
print(f"bridge, 0 g   : {bridge(R, R, R, R) * 1e3:.4f} mV")
print(f"bridge, 5000 g: {bridge(R + dR, R - dR, R + dR, R - dR) * 1e3:.4f} mV")

# README চায়: zero = 400 count, ঢাল 0.7 count/g
gain = 0.7 * CAP_G * LSB / (SENS * VEXC)
v_ref = 400 * LSB                       # INA-র REF pin-এ level shift
rg = 49.4e3 / (gain - 1)                # AD620-ধাঁচ: G = 1 + 49.4 kΩ / RG
print(f"gain = {gain:.1f}, REF = {v_ref:.4f} V, RG = {rg:.1f} Ω")

for g in (0, 150, 2000, 5000, 5300):
    vb = SENS * VEXC * g / CAP_G        # bridge-এর output
    vo = v_ref + gain * vb              # amplifier-এর output
    code = max(0, min(2 ** BITS - 1, int(vo / LSB + 0.5)))
    print(f"{g:5d} g: bridge {vb * 1e3:6.3f} mV -> {vo:6.4f} V -> code {code}")
print(f"ADC ভরে যায় {(4095 - 400) / 0.7:.0f} g-এ")

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

bridge, 0 g   : 0.0000 mV
bridge, 5000 g: 6.6000 mV
gain = 427.2, REF = 0.3223 V, RG = 115.9 Ω
    0 g: bridge  0.000 mV -> 0.3223 V -> code 400
  150 g: bridge  0.198 mV -> 0.4069 V -> code 505
 2000 g: bridge  2.640 mV -> 1.4502 V -> code 1800
 5000 g: bridge  6.600 mV -> 3.1421 V -> code 3900
 5300 g: bridge  6.996 mV -> 3.3113 V -> code 4095
ADC ভরে যায় 5279 g-এ

প্রথম দুই লাইন bridge-এর সূত্র যাচাই: চারটি সমান রোধে 0 mV, আর ±0.7 Ω-এ ঠিক 6.6 mV, অর্থাৎ 2 mV/V × 3.3 V. তৃতীয় লাইন নকশার উত্তর: gain প্রায় ৪২৭, REF 0.3223 V, আর AD620-ধাঁচের chip-এ RG প্রায় 115.9 Ω (বাজারে পাওয়া কাছাকাছি মান, যেমন 115 Ω বা 118 Ω, নিলে gain একটু বদলাবে; সেই পার্থক্য calibration মুছে দেয়)। তারপরের সারিগুলো README-র সংখ্যার সঙ্গে হুবহু মেলে: 150 g → 505, 2000 g → 1800, 5000 g → 3900. শেষ দুই লাইন সতর্কতা: 5300 g-এ ADC 4095-এ আটকে গেছে। Firmware-এর OVERLOAD সীমা 5000 g, ADC-র ছাদ প্রায় 5279 g-এ; মাঝের এই জায়গা ইচ্ছাকৃত। আর আসল amplifier-এর output প্রায়ই সরবরাহের একদম কিনারায় পৌঁছায় না (“rail-to-rail” কিনা datasheet দেখুন), তাই বাস্তবে ছাদ আরও নিচে হতে পারে।

পরীক্ষার ধাঁচে একটি হিসাব — দুই দিকের সংকেত ADC-তে

প্রশ্ন: একটি sensor −1 V থেকে +1 V দেয়। ১২ বিটের ADC-র পাল্লা ০ থেকে 3.3 V. Gain আর offset কত হবে, আর −0.5 V-এ code কত?

  1. Input-এর পাল্লা 2 V (−1 থেকে +1), ADC-র পাল্লা 3.3 V. তাই gain = 3.3 ÷ 2 = 1.65.
  2. −1 V-কে 0 V-এ আনতে হবে: Vout = 1.65 × Vin + offset, আর 0 = 1.65 × (−1) + offset, তাই offset = 1.65 V. অর্থাৎ Vout = 1.65 × Vin + 1.65 V.
  3. −0.5 V-এ Vout = −0.825 + 1.65 = 0.825 V.
  4. Code = 0.825 V ÷ (3.3 V ÷ 4096) = 1024. একইভাবে 0 V → 2048, +0.25 V → 2560, আর +1 V → 4096, যা ১২ বিটে আঁটে না, তাই 4095-এ আটকায়।
  5. উল্টো পথ: code 2867 থেকে Vin = (2867 × 0.80566 mV − 1.65) ÷ 1.65 ≈ 0.400 V.

বাস্তবে gain একটু কম রাখা হয় (যেমন 1.6), যাতে দুই প্রান্তে কয়েক count জায়গা থাকে আর পাল্লার বাইরে যাওয়া চেনা যায়।

Signal chain-এর প্রতিটি বিন্দু
পাল্লায়
দুই বাহু
পার্থক্য
INA output
ADC
  1. ভারসাম্য। খালি পাল্লায় চারটি gauge-ই 350 Ω; দুই বাহুর মাঝবিন্দু 1.65 V, পার্থক্য 0 mV.
  2. 2000 g. প্রতিটি gauge-এ ΔR = 0.28 Ω; এক বাহু 1.65132 V, অন্যটি 1.64868 V. পার্থক্য 3.3 × 0.28 ÷ 350 = 2.64 mV.
  3. Gain. INA শুধু পার্থক্য বড় করে: 427.25 × 2.64 mV = 1.1279 V. দুই বাহুর সাধারণ 1.65 V (common-mode) প্রায় পুরো বাদ পড়ে।
  4. REF যোগ। REF pin-এ 0.3223 V (400 count-এর voltage), তাই output 1.4502 V.
  5. RC filter. 0 g থেকে হঠাৎ 2000 g হলে ADC-র pin-এর voltage এক লাফে ওঠে না: 10 ms-এ 1.0353 V, 90 ms-এ 1.4501 V (অংশ ৪-এর block-এর হিসাব)।
  6. ADC. থিতু voltage 1.4502 V ÷ 0.80566 mV = 1800 count, ঠিক README-র 2000 g-এর calibration বিন্দু।

৪ · Anti-aliasing RC filter — corner, দমন আর থিতু হওয়ার সময়

ADC-র আগে একটি resistor আর একটি capacitor-এর low-pass filter বসানো প্রায় নিয়ম। কাজ দুটি: দ্রুত noise কমানো, আর sampling rate-এর অর্ধেকের ওপরের frequency কমিয়ে aliasing ঠেকানো (anti-aliasing filter; aliasing-এর তত্ত্ব পর্ব ৪৭-এ)। একটি এক-ধাপের (single-pole) RC filter-এর তিনটি সংখ্যা মনে রাখলেই নকশা হয়:

RC filter-এর তিন সূত্র

τ = R × C · Corner frequency fc = 1 ÷ (2π × R × C), যেখানে দমন −3 dB (0.707 গুণ) · f-এ gain |H| = 1 ÷ √(1 + (f ÷ fc)2) · n বিটের ½ LSB-এ settling time ≈ τ × ln(2n+1), ১২ বিটে প্রায় 9.01 τ.

শেষ সূত্রটি প্রায়ই ভুলে যাওয়া হয়। Filter যত শক্ত, সংকেত তত ধীরে নতুন মানে পৌঁছায়। ঢাকার যানজটে বড় বাস যেমন হঠাৎ থামে না, হঠাৎ চলেও না। ওজনের স্কেলে ধীর হওয়া সমস্যা নয়, কিন্তু কতটা ধীর তা জানা চাই, নইলে firmware থিতু হওয়ার আগেই মেপে ভুল দাম দেখাবে। নিচের block বাজারঘরের জন্য একটি প্রস্তাব যাচাই করে: R = 10 kΩ, C = 1 µF.

# ADC-র আগের RC low-pass filter: corner, 50 Hz-এ দমন আর settling time
import math

R, C = 10e3, 1e-6                       # 10 kΩ, 1 µF
tau = R * C
fc = 1 / (2 * math.pi * tau)
print(f"tau = {tau * 1e3:.1f} ms, fc = {fc:.2f} Hz")

def gain(f):                            # এক-pole RC-র |H(f)|
    return 1 / math.sqrt(1 + (f / fc) ** 2)

for f in (1, 5, fc, 50, 500):
    g = gain(f)
    print(f"f = {f:6.2f} Hz: |H| = {g:.3f} ({20 * math.log10(g):6.1f} dB)")

hum = 20                                # amplifier-এর পরে 50 Hz hum, count p-p
print(f"50 Hz hum: {hum} -> {hum * gain(50):.1f} count p-p")

t_half = tau * math.log(2 ** 13)        # ১২ বিটের ½ LSB-এ থিতু হতে
print(f"½ LSB (12 bit) পর্যন্ত থিতু: {t_half * 1e3:.1f} ms = {math.log(2 ** 13):.2f} tau")

v, dt = 0.3223, 1e-3                    # 0 g থেকে 2000 g: 0.3223 -> 1.4502 V
target = 1.4502
for k in range(1, 101):                 # 1 ms ধাপে সংখ্যায় সমাধান
    v += (target - v) * (1 - math.exp(-dt / tau))
    if k in (10, 30, 50, 90, 100):
        code = int(v / (3.3 / 4096) + 0.5)
        print(f"t = {k:3d} ms: {v:.4f} V, code {code}")

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

tau = 10.0 ms, fc = 15.92 Hz
f =   1.00 Hz: |H| = 0.998 (  -0.0 dB)
f =   5.00 Hz: |H| = 0.954 (  -0.4 dB)
f =  15.92 Hz: |H| = 0.707 (  -3.0 dB)
f =  50.00 Hz: |H| = 0.303 ( -10.4 dB)
f = 500.00 Hz: |H| = 0.032 ( -29.9 dB)
50 Hz hum: 20 -> 6.1 count p-p
½ LSB (12 bit) পর্যন্ত থিতু: 90.1 ms = 9.01 tau
t =  10 ms: 1.0353 V, code 1285
t =  30 ms: 1.3940 V, code 1730
t =  50 ms: 1.4426 V, code 1791
t =  90 ms: 1.4501 V, code 1800
t = 100 ms: 1.4501 V, code 1800

Corner 15.92 Hz. ওজনের আসল বদল (কেউ আলু ঢালছেন) কয়েক Hz-এর মধ্যে, তাই 1 Hz আর 5 Hz প্রায় অক্ষত: 0.998 আর 0.954. 50 Hz-এর hum 0.303 গুণে নামে: 20 count থেকে প্রায় 6 count. এক-ধাপের filter দশকে মাত্র 20 dB কাটে (500 Hz-এ −29.9 dB), তাই বাকি কাজ firmware-এর গড়ের: ঠিক 20 ms-এর গুণিতকে গড় নিলে hum মুছে যায় (পর্ব ৪৭), আর moving average-এর মতো digital filter পর্ব ৬৮-এর বিষয়। শেষ পাঁচ লাইন সবচেয়ে কাজের: 0 থেকে 2000 g-এর লাফে 10 ms পরে code মাত্র 1285, 50 ms পরেও 1791, আর ½ LSB-এর মধ্যে 1800 আসতে লাগে প্রায় 90 ms. স্কেল প্রতি 100 ms-এ মাপে, তাই ঠিক সীমার ভেতরে; কিন্তু C = 2.2 µF নিলে আর থাকত না।

একটি বাস্তব সতর্কতা: এখানে 1 µF-এর capacitor ADC-র pin-এর একদম কাছে বসে, তাই এটি ADC-র ভেতরের sampling capacitor-কে চার্জ জোগানোর “ট্যাংক”-এর কাজও করে; কিন্তু 10 kΩ-এর উৎস-রোধ ADC-র sampling time-এর হিসাবে বড়। একটির পর একটি দ্রুত conversion-এ ভুল আসে কিনা, তা chip-এর datasheet-এর সর্বোচ্চ উৎস-রোধের টেবিল আর পর্ব ৪৭-এর sampling time-এর হিসাব দিয়ে মিলিয়ে নিতে হয়।

৫ · দুই-বিন্দুর calibration — virtual board-এ স্কেল নতুন করে মাপা

অংশ ৩-এর নকশা কাগজে নিখুঁত, কিন্তু আসল resistor-এর tolerance আছে, load cell-এর rated output-এর নিজস্ব ছড়ানো আছে, আর amplifier-এর নিজের offset আছে। তাই দুটি স্কেল কখনো হুবহু একই count দেয় না। ভুলগুলো দুই ভাগে পড়ে: offset error (শূন্যে count সরে যাওয়া) আর gain error (ঢাল একটু বেশি বা কম)। সরলরেখার এই দুই ভুল দুটি জানা বিন্দু দিয়ে মোছা যায়: two-point calibration. পাড়ার দোকানে দাঁড়িপাল্লার কাঁটা খালি অবস্থায় শূন্যে আনা, তারপর সরকারি ছাপ দেওয়া বাটখারা চাপিয়ে মেলানো, ঠিক এই দুই ধাপ।

দুই-বিন্দুর calibration

খালি পাল্লায় zero = raw0 · জানা বাটখারা Wref-এ span = rawref − raw0 · ঢাল = Wref ÷ span (g প্রতি count) · grams = round((raw − zero) × Wref ÷ span), integer-এ আগে গুণ, পরে ভাগ।

এই পর্বের firmware recal.c reference lab-এর scale.c থেকে বানানো, আর এতে তিনটি নতুন জিনিস: (১) boot-এর সময় SRAM-এর .noinit অংশের একটি calibration record পড়ে, যদি তার CRC-32 মেলে; না মিললে nominal মান (zero 380, span 1450 count প্রতি 2000 g, অর্থাৎ কল্পিত একটি “কারখানার গড়” মান)। (২) প্রথম button চাপে খালি পাল্লার ১৬টি conversion-এর গড় zero হিসেবে, দ্বিতীয় চাপে 1000 g-এর বাটখারায় span হিসেবে নেয়; span 200 count-এর কম হলে প্রত্যাখ্যান। (৩) নতুন মান CRC-সহ .noinit-এ রাখে, তারপর একটি software reset ঘটিয়ে দেখায় যে record টেকে। Calibration-এর মূল অংশ:

typedef struct { int32_t zero, span, ref_g; uint32_t crc; } cal_t;
__attribute__((section(".noinit"))) static volatile cal_t nv;

/* main loop: button press 1 = empty platform, press 2 = reference */
if (seen == 1) {
    cal_zero = adc_avg(16);                     /* 16 conversions */
} else if (seen == 2) {
    int32_t s = adc_avg(16) - cal_zero;
    if (s < MIN_SPAN) {                         /* 200 counts */
        uart_puts("... too small: rejected, old values kept\r\n");
    } else {
        zero = cal_zero; span = s; ref = REF_G; /* REF_G = 1000 g */
        nv.zero = zero; nv.span = span; nv.ref_g = ref;
        nv.crc = crc32(&nv, offsetof(cal_t, crc));
    }
}
/* every 100 ms: average of 4, then grams and price in paisa */
int32_t raw = adc_avg(4);
int32_t g = div_round((raw - zero) * ref, span);
int32_t p = g > 0 ? (g * RATE + 500) / 1000 : 0;   /* RATE = 6550 */

Record-টি volatile, কারণ এটি reset পেরিয়ে আসা মেমরি, যা compiler-এর চোখে “কেউ লেখেনি”; আর CRC হিসাব হয় crc ঘরটি বাদ দিয়ে, offsetof দিয়ে মেপে। CRC-32 আর দুই কপির কৌশল পর্ব ৬৩-এ (নির্ভরযোগ্যতা আর safety) বিস্তারিত; এখানে শুধু ব্যবহার। Script: খালি পাল্লা, 1000 g, আবার খালি, button, 1000 g বাটখারা, button, তারপর 150 g, 1400 g, 5000 g, reset-এর পরে 650 g.

$ python -B board.py run build/recal.elf --script recal.json
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0000 ms] > load on the scale: 0 g
[     0.0198 ms] UART: boot: power-on
[     0.1396 ms] UART: no valid record, nominal: zero=380 span=1450 counts per 2000 g
[   100.2010 ms] UART: raw=400 grams=28 price=1.83 Tk
[   150.0000 ms] > load on the scale: 1000 g
[   200.2081 ms] UART: raw=1100 grams=993 price=65.04 Tk
[   250.0000 ms] > load on the scale: 0 g
[   300.0000 ms] > button pressed
[   300.2010 ms] UART: raw=400 grams=28 price=1.83 Tk
[   307.1991 ms] UART: CAL 1: empty platform, zero=400 counts
[   350.0000 ms] > button released
[   400.0000 ms] > load on the scale: 1000 g
[   400.2081 ms] UART: raw=1100 grams=993 price=65.04 Tk
[   450.0000 ms] > button pressed
[   457.2685 ms] UART: CAL 2: saved zero=400 span=700 counts per 1000 g
[   500.0000 ms] > button released
[   500.2108 ms] UART: raw=1100 grams=1000 price=65.50 Tk
[   550.0000 ms] > load on the scale: 150 g
[   600.2033 ms] UART: raw=505 grams=150 price=9.83 Tk
[   650.0000 ms] > load on the scale: 1400 g
[   700.2109 ms] UART: raw=1380 grams=1400 price=91.70 Tk
[   750.0000 ms] > load on the scale: 5000 g
[   800.2131 ms] UART: raw=3900 grams=5000 price=327.50 Tk
[   900.1762 ms] UART: software reset (record stays in SRAM)
[   900.1772 ms] RESET (software, AIRCR.SYSRESETREQ)
[   900.2014 ms] UART: boot: software reset
[   900.3120 ms] UART: CRC ok, loaded: zero=400 span=700 counts per 1000 g
[   950.0000 ms] > load on the scale: 650 g
[  1000.3777 ms] UART: raw=855 grams=650 price=42.58 Tk
[  1200.3190 ms] exit(0) after 9602552 cycles

সত্যিকারের run (বাজারঘর board BG-M3, Clang 22.1.8 / ziglang 0.17.1, Unicorn 2.1.4; firmware আমার lab-এ build করা)। Board-এর load-cell মডেল README-র raw = 400 + 0.7 × grams (Spec decision 25); software reset-এ SRAM টিকে থাকে আর RCC-র SFTRSTF বসে (Spec decision 18 আর 28 অনুযায়ী)। নিচের stepper লাইনগুলো ধাপে ধাপে মেলায়।

Firmware-এর calibration আর ফল
zero, span
পাল্লায়, raw
হিসাব
দেখায়
  1. পুরোনো মান। Record নেই, তাই nominal zero 380. খালি পাল্লায় raw 400, যা 20 count বেশি: স্কেল 28 g দেখায় আর খালি পাল্লার দাম 1.83 টাকা! এটি offset error.
  2. Gain-ও ভুল। 1000 g-এ raw 1100, কিন্তু nominal ঢালে 993 g. ক্রেতা ৭ গ্রামের দাম কম দেন; আসলে ক্ষতি দোকানের।
  3. CAL 1. খালি পাল্লায় button. ১৬টি conversion-এর গড় 400: এটিই নতুন zero.
  4. CAL 2. 1000 g বাটখারা, button. গড় 1100, span 700 count, যা 200-এর সীমার অনেক ওপরে, তাই গ্রহণ; record আর CRC-32 .noinit-এ।
  5. যাচাই, 150 g. (505 − 400) × 1000 ÷ 700 = 150 g, দাম (150 × 6550 + 500) ÷ 1000 = 983 paisa = 9.83 টাকা, README-র সংখ্যা।
  6. 1400 g. 980 × 1000 ÷ 700 = 1400 g, দাম 91.70 টাকা. 5000 g-এও ঠিক 5000. ভিন্ন বাটখারা (1000 g) দিয়েও ঢাল একই, 1.4286 g প্রতি count.
  7. Reset-এর পরে। Software reset. SRAM টিকেছে, CRC মিলেছে, তাই 400 আর 700 ফিরে এল; 650 g-এ raw 855 → 650 g, দাম 42.58 টাকা.

একই firmware আরও দুটি script-এ চালানো হলো। adc_noise_counts: 8 দিলে (Spec decision 25-এর seed দেওয়া noise) calibration নিজেও noisy মাপে দাঁড়ায়: CAL 2: saved zero=399 span=702 counts per 1000 g, আর তারপর 5000 g-এ raw=3898 grams=4984. Span-এ মাত্র ২ count-এর ভুল (০.২৯%) পূর্ণ ভারে প্রায় ১৪ গ্রাম, আর zero-র এক count ও মাপের মুহূর্তের noise মিলে মোট −16 g. শিক্ষা: calibration-এর বিন্দুতে অনেক বেশি নমুনার গড় নিন, আর বাটখারা যত ভারী (পূর্ণ মাপের কাছে), তত ভালো। আরেকটি script-এ কারিগর দ্বিতীয় button চাপার আগে বাটখারা রাখতে ভুলে গেলেন: CAL 2: span=0 counts too small: rejected, old values kept. এই একটি if না থাকলে span = 0, আর পরের প্রতিটি ভাগ শূন্য দিয়ে।

৬ · বহু-বিন্দুর calibration — least squares আর টেবিল

দুটি বিন্দু দিয়ে একটি রেখা টানা যায়, কিন্তু প্রতিটি বিন্দুর নিজের noise রেখায় ঢুকে যায়। বেশি বিন্দু নিলে কী হয়? Virtual board-এ points.c প্রতি 100 ms-এ একটি মাত্র conversion নেয় (গড় ছাড়া), ±8 count noise-এ, আর script পাল্লায় 0, 1000 … 5000 g রাখে:

$ python -B board.py run build/points.elf --script points.json
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[    50.0000 ms] > load on the scale: 0 g
[   100.0355 ms] UART: point 1: raw=406
[   150.0000 ms] > load on the scale: 1000 g
[   200.0381 ms] UART: point 2: raw=1101
[   250.0000 ms] > load on the scale: 2000 g
[   300.0381 ms] UART: point 3: raw=1792
[   350.0000 ms] > load on the scale: 3000 g
[   400.0381 ms] UART: point 4: raw=2505
[   450.0000 ms] > load on the scale: 4000 g
[   500.0381 ms] UART: point 5: raw=3204
[   550.0000 ms] > load on the scale: 5000 g
[   600.0381 ms] UART: point 6: raw=3906
[   600.0394 ms] exit(0) after 4800315 cycles

সত্যিকারের run (একই সংস্করণ)। আসল মডেল 400, 1100 … 3900; প্রতিটি বিন্দু কয়েক count সরে আছে, 2000 g-এ পুরো ৮ count. এই ছয়টি বিন্দুর মধ্য দিয়ে এমন একটি রেখা খোঁজা হয়, যার থেকে বিন্দুগুলোর উল্লম্ব দূরত্ব (residual)-এর বর্গের যোগফল সবচেয়ে কম: least squares. মাপ নেওয়া হয় জানা ওজনকে x আর count-কে y ধরে, কারণ বাটখারার ভুল count-এর noise-এর তুলনায় নগণ্য; তারপর রেখাটি উল্টে count থেকে গ্রাম। তত্ত্ব আর জ্যামিতি Machine Learning পর্ব ০৭-এ; এখানে শুধু দুটি সূত্র।

# ছয় বিন্দুর calibration: least-squares রেখা বনাম দুই প্রান্তের রেখা
# data: virtual board-এর সত্যিকারের run (±8 count noise, গড় ছাড়া)
G = [0, 1000, 2000, 3000, 4000, 5000]          # জানা বাটখারা, g
RAW = [406, 1101, 1792, 2505, 3204, 3906]      # ADC count

n = len(G)
sx, sy = sum(G), sum(RAW)
sxy = sum(g * r for g, r in zip(G, RAW))
sxx = sum(g * g for g in G)
b = (n * sxy - sx * sy) / (n * sxx - sx * sx)  # ঢাল, count প্রতি g
a = (sy - b * sx) / n                          # শূন্য-বিন্দু, count
print(f"Σx={sx} Σy={sy} Σxy={sxy} Σx²={sxx}")
print(f"least squares: raw = {a:.2f} + {b:.5f} × g")

b2 = (RAW[-1] - RAW[0]) / (G[-1] - G[0])       # শুধু দুই প্রান্ত
a2 = RAW[0]
print(f"two-point    : raw = {a2:.2f} + {b2:.5f} × g")

def show(name, a, b):
    errs = []
    for g, r in zip(G, RAW):
        est = (r - a) / b                      # count থেকে গ্রামে ফেরা
        errs.append(est - g)
    print(name, " ".join(f"{e:+6.1f}" for e in errs),
          f"| সর্বোচ্চ {max(abs(e) for e in errs):.1f} g")

show("LSQ ভুল (g):", a, b)
show("2-pt ভুল (g):", a2, b2)
for name, aa, bb in (("LSQ", a, b), ("2-pt", a2, b2)):
    worst = max(abs((aa + bb * g) - (400 + 0.7 * g)) / 0.7 for g in (0, 5000))
    print(f"{name}: আসল রেখা (400 + 0.7 × g) থেকে সর্বোচ্চ দূরত্ব {worst:.1f} g")

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

Σx=15000 Σy=12914 Σxy=44546000 Σx²=55000000
least squares: raw = 400.76 + 0.70063 × g
two-point    : raw = 406.00 + 0.70000 × g
LSQ ভুল (g):   +7.5   -0.6  -14.3   +3.4   +1.0   +3.0 | সর্বোচ্চ 14.3 g
2-pt ভুল (g):   +0.0   -7.1  -20.0   -1.4   -2.9   +0.0 | সর্বোচ্চ 20.0 g
LSQ: আসল রেখা (400 + 0.7 × g) থেকে সর্বোচ্চ দূরত্ব 5.6 g
2-pt: আসল রেখা (400 + 0.7 × g) থেকে সর্বোচ্চ দূরত্ব 8.6 g

Least-squares রেখা 400.76 + 0.70063 × g, আসল 400 + 0.7 × g-এর খুব কাছে। দুই প্রান্তের রেখা প্রথম বিন্দুর +6 count-এর noise পুরোটাই শূন্য-বিন্দুতে নিয়ে নিয়েছে: 406. “ভুল” লাইন দুটি প্রতিটি noisy বিন্দু ফিরে পড়লে কত গ্রাম আসে: দুই প্রান্তের রেখা নিজের দুই বিন্দুতে নিখুঁত (+0.0) দেখায়, কিন্তু সেটি আত্মপ্রতারণা; বাকি বিন্দুতে 20 g পর্যন্ত ভুল। আসল প্রশ্ন শেষ দুই লাইনে: আসল রেখা থেকে দূরত্ব। Least squares 5.6 g, দুই প্রান্ত 8.6 g. ছয়টির জায়গায় প্রতিটি বিন্দুতে ১৬টির গড় নিলে দুটিই আরও অনেক ভালো হতো; least squares গড়ের বিকল্প নয়, সঙ্গী।

হিসাবের অবস্থা
ধাপ
মান
  1. Data. ছয়টি জানা ওজন (x) আর board-এর একক conversion (y), ±8 count noise-সহ।
  2. চারটি যোগফল। Σx, Σy, Σxy আর Σx²; পুরো হিসাব এই চার সংখ্যা থেকে। Firmware-এ এগুলো integer-এ জমানো যায়। এখানে সবচেয়ে বড় গুণফল 6 × 55000000 = 330000000, int32_t-এ আঁটে; কিন্তু বেশি বিন্দু বা বড় সংখ্যায় এগুলো দ্রুত ২৩১ ছাড়ায়, তাই int64_t নিরাপদ।
  3. ঢাল। b = (nΣxy − ΣxΣy) ÷ (nΣx² − (Σx)²) = 0.70063 count প্রতি g. আসল 0.7.
  4. শূন্য। a = (Σy − bΣx) ÷ n = 400.76 count. আসল 400.
  5. Residual. প্রতিটি বিন্দু থেকে রেখার দূরত্ব: সবচেয়ে বড় 2000 g-এ −10.02 count. যোগফল প্রায় শূন্য, least squares-এর একটি নিশ্চিত বৈশিষ্ট্য।
  6. রায়। আসল রেখা থেকে least-squares রেখা সর্বোচ্চ 5.6 g দূরে, দুই প্রান্তের রেখা 8.6 g. বেশি বিন্দু noise-কে গড় করেছে।

Firmware-এ least squares চালাতে হয় কি? সাধারণত না। কারখানার calibration station (একটি PC) বিন্দুগুলো সংগ্রহ করে, রেখা বের করে, আর microcontroller-এ শুধু দুটি সংখ্যা পাঠায়, zero আর ঢাল, integer-এ (যেমন ঢালকে ১০০০ বা ৬৫৫৩৬ দিয়ে গুণ করে; পর্ব ৪০-এর fixed-point কৌশল)। মাঠে, দোকানে, firmware-এ যদি নিজেই করতে হয়, চারটি যোগফল জমিয়ে শেষে দুটি ভাগই যথেষ্ট; শুধু খেয়াল রাখতে হয় Σxy আর Σx²-এর মতো গুণফল যেন ৩২ বিট না ছাড়ায়।

সব sensor সরলরেখায় চলে না। Thermistor খুব বাঁকা, আর ভালো load cell-ও সামান্য বাঁকে (nonlinearity, datasheet-এ rated output-এর শতাংশে)। তখন রেখা যত ভালোই হোক, মাঝখানে ভুল থেকে যায়। সমাধান multi-point calibration: কয়েকটি জানা বিন্দু একটি টেবিলে, আর মাঝখানে দুই প্রতিবেশী বিন্দুর মধ্যে সরলরেখা, অর্থাৎ piecewise linear interpolation. নিচের C program একটি কল্পিত বাঁকা sensor-এর পাঁচটি পরীক্ষার count নেয় (মডেলটি মাঝখানে 12 count নিচে বাঁকা; count-গুলো lab-এ সেই সূত্রে হিসাব করা), আর পাঁচ বিন্দুর টেবিল দিয়ে, firmware-এর মতো শুধু integer-এ, গ্রাম বের করে।

/* বাঁকা sensor: ৫ বিন্দুর টেবিল বনাম দুই প্রান্ত, শুধু integer */
#include <stdio.h>
static const int RAW[5] = {400, 1266, 2138, 3016, 3900};    /* মাপা count */
static const int GR[5]  = {0, 1250, 2500, 3750, 5000};       /* জানা g */
static int div_round(int n, int d) { return n >= 0 ? (n + d / 2) / d : -((-n + d / 2) / d); }
static int table(int raw) {                     /* খণ্ডে খণ্ডে সরলরেখা */
    int i = 0;
    while (i < 3 && raw > RAW[i + 1]) i++;      /* কোন খণ্ড? */
    return GR[i] + div_round((raw - RAW[i]) * (GR[i + 1] - GR[i]), RAW[i + 1] - RAW[i]);
}
int main(void) {   /* মডেল: raw = 400 + 0.7g - 48x(1-x), x = g/5000, গোল করে */
    int g[5] = {625, 1875, 2500, 3125, 4375}, raw[5] = {832, 1701, 2138, 2576, 3457};
    for (int k = 0; k < 5; k++) {
        int two = div_round((raw[k] - 400) * 5000, 3500), tab = table(raw[k]);
        printf("%4d g: raw=%4d  two-point=%4d g (%+3d)  table=%4d g (%+d)\n",
               g[k], raw[k], two, two - g[k], tab, tab - g[k]);
    }
    return 0;
}

আসল আউটপুট (Wandbox-এর C compiler):

 625 g: raw= 832  two-point= 617 g ( -8)  table= 624 g (-1)
1875 g: raw=1701  two-point=1859 g (-16)  table=1874 g (-1)
2500 g: raw=2138  two-point=2483 g (-17)  table=2500 g (+0)
3125 g: raw=2576  two-point=3109 g (-16)  table=3124 g (-1)
4375 g: raw=3457  two-point=4367 g ( -8)  table=4374 g (-1)

পরীক্ষার ওজনগুলো ইচ্ছা করে টেবিলের বিন্দুর মাঝখানে। দুই প্রান্তের রেখা মাঝখানে সবচেয়ে খারাপ: 2500 g-এ −17 g, কারণ বাঁক সেখানেই সবচেয়ে গভীর। টেবিল ভুলকে 1 g-এ নামিয়েছে; যেটুকু বাকি, তা খণ্ডের ভেতরের ছোট বাঁক আর integer-এর গোল করা। বিন্দু যত ঘন, ভুল তত কম, কিন্তু প্রতিটি বিন্দুর জন্য একবার জানা বাটখারা চাপাতে হয়। বিকল্প হলো least squares দিয়ে একটি দ্বিঘাত বহুপদী (a + bx + cx²) বসানো; কোনটি ভালো, তা sensor-এর বাঁকের আকার আর firmware-এর সময়ের বাজেটের ওপর নির্ভর করে। Program-টি একটি কল্পিত মডেল; কোনো নির্দিষ্ট load cell-এর বাঁক নয়।

৭ · তাপমাত্রা, drift আর calibration-এর মান সংরক্ষণ

Calibration একবার করলেই চিরকাল চলে না। গ্রীষ্মে দোকানের ভেতর ২০ °C থেকে ৪০ °C-এ ওঠে, আর তিনটি জিনিস সরে যায়। এই ধীর সরে যাওয়ার নাম drift. সংখ্যাগুলো একটি উদাহরণ datasheet ধরে (আসল নকশায় নিজের অংশগুলোর datasheet থেকে নিন):

উৎসউদাহরণ spec২০ °C বাড়লে (হিসাব)
Load cell-এর zerorated output-এর 0.02% প্রতি 10 °C3500 × 0.0002 × 2 = 1.4 count ≈ 2.0 g
Load cell-এর spanreading-এর 0.02% প্রতি 10 °C5000 g-এ 0.04% = 2.0 g
Amplifier-এর input offset drift1 µV/°C20 µV × 427.25 = 8.54 mV ≈ 10.6 count ≈ 15.2 g

শেষ সারিটি অবাক করে: amplifier-এর মাত্র কয়েক মাইক্রোভোল্টের সরণ সবচেয়ে বড় ভুল, কারণ সেটি সংকেতের সঙ্গে ৪২৭ গুণ হয়। ছোট সংকেত মানে প্রতিটি µV দামি। তিনটি প্রতিকার, সস্তা থেকে দামি:

  • Zero-র drift-এ tare আর auto-zero: স্কেল চালুর সময় আর খালি পাল্লায় স্থির থাকলে zero আবার মাপা। Offset-এর drift (সারি ১ আর ৩) এতেই প্রায় মোছে। বাণিজ্যিক স্কেলে এই “zero tracking” কতটুকু অনুমোদিত, তা আইনি মাপের নিয়মে বাঁধা (যেমন আন্তর্জাতিক সুপারিশ OIML R 76; নিজের দেশের নিয়ম দেখুন)।
  • Span-এর জন্য temperature compensation: একটি তাপমাত্রার sensor রেখে দুই তাপমাত্রায় calibration, তারপর firmware-এ grams × (1 − k × (T − Tcal)) ধরনের সংশোধন। k কারখানায় মেপে record-এ রাখা হয়।
  • ভালো অংশ: কম drift-এর “zero-drift” বা chopper ধরনের amplifier, বা load cell-এর জন্যই বানানো ADC. যেমন HX711: ২৪ বিটের ADC, ভেতরে gain 128 বা 64 (channel A), নমুনার হার 10 বা 80 প্রতি সেকেন্ড (Avia Semiconductor-এর datasheet অনুযায়ী)।

Auto-zero firmware-এ কেমন দেখায়? একটি সাধারণ নিয়ম: পরপর কয়েকটি মাপ (ধরা যাক ১০টি, প্রতি 100 ms-এ, অর্থাৎ এক সেকেন্ড) যদি সবই বর্তমান zero-র খুব কাছে থাকে (ধরা যাক ±২ count-এর মধ্যে) আর একে অপরের থেকে প্রায় না নড়ে, তবে তাদের গড়কে নতুন zero ধরা। সীমাটি ছোট রাখা জরুরি: নইলে কেউ খুব ধীরে একটি হালকা জিনিস রাখলে firmware সেটিকে “drift” ভেবে মুছে দেবে, আর স্কেল চিরকাল শূন্য দেখাবে। তাই zero tracking-এর পরিসর আর হার দুটিই সীমিত, আর মোট কতটা সরানো গেছে তারও একটি সীমা, যার বাইরে গেলে পূর্ণ calibration চাই।

শেষ প্রশ্ন: calibration-এর সংখ্যাগুলো কোথায় থাকবে? Board-এর .noinit SRAM শুধু reset পেরোয়, বিদ্যুৎ গেলে নয়; আসল স্কেলে মানগুলো যায় flash-এর একটি আলাদা পাতায় বা EEPROM-এ। Record-এ রাখা ভালো: zero, span, বাটখারার ওজন, calibration-এর তাপমাত্রা, একটি সংস্করণ নম্বর আর CRC. CRC না মিললে firmware চুপচাপ পুরোনো মান চালাবে না; “CAL ERROR” দেখিয়ে বিক্রি থামাবে, কারণ ভুল ওজনে দাম নেওয়া নীরব প্রতারণা। দুই কপি, CRC আর fail-safe-এর বিস্তারিত পর্ব ৬৩-এ।

আরও গভীরে: তিন op-amp-এর ক্লাসিক instrumentation amplifier-এ প্রথম ধাপের দুটি op-amp দুই input-কে উচ্চ impedance-এ ধরে আর একটি মাত্র RG দিয়ে পার্থক্য বড় করে; তৃতীয়টি একটি difference amplifier, যার resistor-গুলোর মিল (laser-trim করা) CMRR ঠিক করে। এ কারণেই একই কাজ চারটি আলাদা resistor-এর op-amp দিয়ে করলে CMRR প্রায়ই অনেক খারাপ হয়: 0.1%-এর resistor-এর অমিলই common-mode-এর একটি অংশকে differential বানিয়ে দেয়। আর SAR ADC-র জায়গায় load cell-এর জন্য প্রায়ই sigma-delta ADC বেছে নেওয়া হয়, যার ভেতরের digital filter একইসঙ্গে anti-aliasing-এর বড় অংশ সামলায়, আর কোনো কোনো chip-এ 50 Hz আর 60 Hz-এ গভীর notch থাকে।

পরীক্ষা ও ইন্টারভিউতে: (১) “2 mV/V-এর load cell, 5 V excitation, পূর্ণ ভারে output?” → 10 mV. (২) “Non-inverting amplifier, Rf = 47 kΩ, Rg = 10 kΩ, gain?” → 1 + 4.7 = 5.7. (৩) “10 kΩ আর 1 µF-এর RC-র corner?” → 1 ÷ (2π × 0.01 s) ≈ 15.9 Hz. (৪) “দুই-বিন্দুর calibration-এ zero 400, 1000 g-এ 1100; raw 1380 কত গ্রাম?” → 980 × 1000 ÷ 700 = 1400 g. (৫) “Bridge-এর জন্য instrumentation amplifier কেন?” → সংকেত differential আর বড় common-mode-এর ওপর বসে; INA শুধু পার্থক্য বড় করে, CMRR উঁচু, input impedance বেশি।

৮ · AI-এর যুগে signal conditioning আর calibration যাচাই

“HX711 দিয়ে load cell-এর calibration code দিন” লিখলে AI assistant সঙ্গে সঙ্গে কোড দেয়, আর বেশিরভাগ সময় তা চলেও। কিন্তু এখানকার ভুলগুলো নীরব: স্কেল সংখ্যা দেখায়, শুধু কয়েক গ্রাম ভুল, বা গরমে ভুল। চেনা ফাঁদ আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
Bridge-এর জন্য একটি সাধারণ non-inverting op-amp বলে, common-mode ভুলে যায়দুই বাহুর voltage আলাদা হিসাব করুন (1.65 V-এর ওপর কয়েক mV); INA-র input range datasheet-এ মিলিয়ে নিন
INA-র gain সূত্র এক chip থেকে আরেকটিতে মিশিয়ে ফেলে (49.4 kΩ, 100 kΩ, ভিন্ন রূপ)নিজের chip-এর datasheet-এর gain সমীকরণ দেখে RG হিসাব; তারপর calibration তো আছেই
RC filter দেয়, কিন্তু settling time বা ADC-র উৎস-রোধের সীমা ভাবে নাτ × ln(2n+1) হাতে হিসাব; মাপার সময়ের সঙ্গে মেলানো
Calibration-এ integer ভাগ আগে করে ((raw - zero) / span * ref), বা float ছাড়া গোল করা ভুলে যায়Host-এ বা কোর্সের board-এ ছোট ওজনে চালান: 150 g যদি 0 g দেখায়, ভাগ আগে হয়েছে (অনুশীলন ২)
Calibration record-এ কোনো CRC বা সীমা-পরীক্ষা রাখে না, span শূন্য হলেও মেনে নেয়বাটখারা ছাড়া দ্বিতীয় ধাপ চালিয়ে দেখুন; record নষ্ট করে reset করে দেখুন
Drift বা নির্দিষ্ট chip-এর spec-এর সংখ্যা বানিয়ে বলেপ্রতিটি সংখ্যার উৎস (datasheet-এর টেবিল আর শর্ত) চেয়ে নিন, নিজে মিলিয়ে নিন

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

আমি একটি load cell (5 kg, 2 mV/V, excitation 3.3 V) থেকে একটি ARM Cortex-M3 microcontroller-এর ১২ বিটের ADC-তে (Vref 3.3 V) ওজন মাপছি। চাই: শূন্য ভারে 400 count, 5000 g-এ 3900 count. ১. Instrumentation amplifier-এর gain আর REF voltage হিসাব করো, সূত্রসহ। কোনো নির্দিষ্ট chip-এর gain সমীকরণ ব্যবহার করলে chip-এর নাম আর datasheet-এর সূত্রটি লিখবে। ২. ADC-র আগে একটি RC filter প্রস্তাব করো: corner, 50 Hz-এ দমন, আর ১২ বিটের ½ LSB-এ settling time হিসাব করবে। ৩. দুই-বিন্দুর calibration-এর একটি C function লেখো: শুধু integer, আগে গুণ পরে ভাগ, গোল করে; span খুব ছোট হলে প্রত্যাখ্যান; record-এ CRC-32. ৪. কোনো drift বা CMRR-এর সংখ্যা নিয়ে নিশ্চিত না হলে বলো "নিশ্চিত নই, datasheet দেখুন"; মান বানিয়ে বলবে না।

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

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

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

প্র ০১Wheatstone bridge প্রায় দুশো বছর পুরোনো একটি বর্তনী। আধুনিক ২৪ বিটের ADC-র যুগেও load cell আর strain gauge কেন প্রায় সবসময় bridge-এ সাজানো হয়?

বর্তনীটি প্রথম বর্ণনা করেন Samuel Hunter Christie, ১৮৩৩ সালে; Charles Wheatstone ১৮৪৩ সালে এটিকে জনপ্রিয় করেন অজানা রোধ মাপার পদ্ধতি হিসেবে, আর নামটি তাঁর সঙ্গেই জুড়ে যায়। মূল ধারণা: দুটি voltage divider পাশাপাশি, আর মাপা হয় তাদের মাঝবিন্দুর পার্থক্য। আসল মানের বদলে পার্থক্য মাপার সুবিধা আজও তিনটি জায়গায় বিশাল।

প্রথমত, শূন্যের চারপাশে মাপা। একটি 350 Ω-এর gauge-কে সরাসরি একটি divider-এ রাখলে 1.65 V-এর ওপর কয়েক mV-এর বদল খুঁজতে হতো, অর্থাৎ ADC-র পুরো পাল্লার প্রায় সবটাই খরচ হতো একটি স্থির মান বয়ে নিতে। Bridge সেই বড় স্থির অংশ নিজেই বাদ দেয়, ফলে পরের amplifier শুধু খবরটুকু বড় করতে পারে, ৪০০ গুণের বেশি, সরবরাহের সীমায় না আটকে। ২৪ বিটের ADC-ও এর থেকে মুক্ত নয়: HX711-এর মতো chip-এর input-এ তাই ভেতরেই উঁচু gain-এর amplifier থাকে, আর পূর্ণ মাপের input মাত্র কয়েক দশ mV.

দ্বিতীয়ত, তাপমাত্রা। চারটি সক্রিয় gauge একই ধাতুর ওপর একই তাপে থাকে; তাদের রোধ একই অনুপাতে বাড়লে দুই divider-এর অনুপাত বদলায় না। এভাবে একটি বড় ভুল বর্তনীর গঠনেই কাটে, firmware-এর আগে।

তৃতীয়ত, ratiometric মাপ। Output সরাসরি excitation-এর সমানুপাতিক (mV/V), তাই একই excitation যদি ADC-র reference হয়, সরবরাহের ওঠানামা প্রায় পুরো মুছে যায়। লোডশেডিং-এর পরে generator বা IPS-এ চলা দোকানেও তাই ওজন স্থির থাকে। Bridge-এর সীমাও আছে: চার তারের লম্বা cable-এর রোধ excitation কমায়, তাই নির্ভুল load cell-এ আলাদা “sense” তার দিয়ে load cell-এর গায়ের আসল excitation মাপা হয় (ছয় তারের সংযোগ)। আর bridge-এর output এত ছোট যে PCB-র নকশা, ভালো ground আর shielding ছাড়া noise সহজেই সংকেতকে ছাপিয়ে যায়।

মূল উপলব্ধি: Bridge আসল মান নয়, পার্থক্য মাপে; এতে বড় স্থির অংশ, তাপমাত্রার একটি বড় অংশ আর সরবরাহের ওঠানামা বর্তনীর গঠনেই কাটে, যা কোনো ADC-র বিট-সংখ্যা একা দিতে পারে না।

প্র ০২একজন প্রকৌশলী বললেন, “একটি op-amp আর চারটি resistor দিয়েই তো difference amplifier হয়, instrumentation amplifier-এর দরকার কী?” আরেকজন বললেন, “HX711-এর মতো একটি load-cell ADC নিলেই সব ঝামেলা শেষ।” দুজনের কথার কোথায় সত্য, কোথায় ফাঁক?

প্রথম কথাটি নীতিতে সত্য: চারটি resistor-এর একটি difference amplifier দুই input-এর পার্থক্যই বড় করে। সমস্যা দুটি। এক, তার input impedance resistor-এর মানের সমান, তাই bridge-এর 350 Ω-এর বাহুর ওপর সে ভার চাপায় আর bridge-এর ভারসাম্য বদলায়। দুই, তার CMRR সম্পূর্ণ নির্ভর করে চারটি resistor-এর অনুপাত কতটা হুবহু মেলে তার ওপর। 0.1%-এর resistor-এর সাধারণ অমিলে common-mode-এর একটি অংশ differential হয়ে যায়; bridge-এর 1.65 V-এর ওপর 2.64 mV-এর মতো সংকেতে এটি বড় ভুল। Instrumentation amplifier-এ সামনে দুটি buffer op-amp উঁচু input impedance দেয়, একটি মাত্র RG gain ঠিক করে, আর ভেতরের মিলে-যাওয়া (প্রায়ই laser-trim করা) resistor-এর জন্য CMRR অনেক উঁচু, datasheet-এ gain অনুযায়ী টেবিলে দেওয়া।

ইতিহাস মনে করিয়ে দেয় কেন এই একীকরণ গুরুত্বপূর্ণ। ১৯৬০-এর দশকে Fairchild-এর μA709 (Bob Widlar-এর নকশা, প্রায় ১৯৬৫) আর পরে μA741 (প্রায় ১৯৬৮) op-amp-কে সস্তা, সাধারণ IC বানিয়েছিল। তার পরেও নির্ভুল মাপে আলাদা op-amp আর resistor মিলিয়ে CMRR পাওয়া কষ্টকর ছিল; এক chip-এ মিলে-যাওয়া অংশসহ INA সেই সমস্যার সমাধান।

দ্বিতীয় কথাটিও অনেকটা সত্য। HX711 (Avia Semiconductor) একটি chip-এ উঁচু gain-এর amplifier (128 বা 64) আর ২৪ বিটের ADC রাখে, নমুনার হার 10 বা 80 প্রতি সেকেন্ড। সাধারণ রান্নাঘরের স্কেলের জন্য এটি সহজ আর ভালো। ফাঁক হলো: ঝামেলা শেষ হয় না, সরে যায়। নমুনার হার কম, তাই দ্রুত মাপ লাগলে চলবে না; ২৪ বিট মানে ২৪ বিটের নির্ভুলতা নয়, কার্যকর বিট noise ঠিক করে; আর offset, gain, nonlinearity আর তাপমাত্রার drift তখনো আছে, তাই calibration আর tare সেই একই কাজ। Microcontroller-এর ADC আর আলাদা INA-র পথে নকশাকারীর হাতে বেশি নিয়ন্ত্রণ থাকে (gain, filter, নমুনার হার), দামে আর জটিলতায় তার মূল্য দিতে হয়।

মূল উপলব্ধি: INA উঁচু input impedance আর মিলে-যাওয়া resistor-এর CMRR একসঙ্গে দেয়; বিশেষ load-cell ADC নকশা সহজ করে, কিন্তু offset, gain, drift আর calibration-এর দায় কখনো সরায় না।

প্র ০৩দুই-বিন্দুর calibration সহজ, least squares বেশি বিন্দু চায়। Board-এর noisy run-এ 1000 g-এর বাটখারায় span 702 এল আর 5000 g-এ ভুল −16 g. বাটখারা কত ভারী হওয়া উচিত, কয়টি বিন্দু নেওয়া উচিত, আর least squares-এর বিপদ কোথায়?

শুরু span-এর ভুল থেকে। Calibration-এর বিন্দুর noise ঢাল-এ ঢোকে, আর ঢালের ভুল ওজনের সমানুপাতিক। 1000 g-এর বাটখারায় span-এ এক count-এর ভুল মানে 1 ÷ 700 ≈ 0.14%, যা 5000 g-এ প্রায় 7.1 g; 2000 g-এর বাটখারায় একই এক count 1 ÷ 1400, অর্থাৎ 5000 g-এ প্রায় 3.6 g. Noisy run-এ span-এ দুই count (702) আর zero-তে এক count মিলে 5000 g-এ −16 g. তাই নিয়ম: বাটখারা যত ভারী, যতটা সম্ভব পূর্ণ মাপের কাছে, তত ভালো; আর প্রতিটি calibration বিন্দুতে বহু নমুনার গড়, কারণ calibration একবার হয়, তার ভুল বিক্রির প্রতিটি মাপে বসে থাকে।

Least squares-এর ইতিহাস মনে রাখার মতো। Adrien-Marie Legendre ১৮০৫ সালে পদ্ধতিটি প্রকাশ করেন ধূমকেতুর কক্ষপথের হিসাবে; Carl Friedrich Gauss ১৮০৯ সালে লেখেন যে তিনি বহু আগে থেকে এটি ব্যবহার করছেন, আর অগ্রাধিকার নিয়ে বিতর্ক হয়েছিল। মূল ধারণা: অনেক অসম্পূর্ণ মাপ থেকে সবচেয়ে সম্ভাব্য রেখা, বর্গ-অমিলের যোগফল কমিয়ে। Board-এর ছয় বিন্দুতে এটি আসল রেখা থেকে দূরত্ব 8.6 g থেকে 5.6 g-এ নামিয়েছে।

বিপদ দুটি। প্রথম, বর্গ নেওয়ায় একটি বড় ভুল বিন্দু (কেউ বাটখারা রাখার সময় পাল্লায় হাত রেখেছিলেন) রেখাকে জোরে টানে। তাই residual দেখে অস্বাভাবিক বিন্দু খোঁজা, আর দরকারে robust পদ্ধতি (Machine Learning পর্ব ২৪-এর বিষয়)। দ্বিতীয়, least squares মডেলের আকার বদলায় না: সরলরেখা বসালে বাঁকা sensor-এর বাঁক residual-এ নকশা হয়ে থেকে যায় (মাঝখানে একদিকে, প্রান্তে অন্যদিকে)। Residual-এ এমন নিয়মিত আকার দেখলে বুঝবেন মডেল ভুল; তখন টেবিল বা বহুপদী।

বাণিজ্যিক স্কেলে সিদ্ধান্তগুলো শুধু প্রকৌশলের নয়: কোন শ্রেণির স্কেলে কত ভুল চলবে আর কীভাবে যাচাই হবে, তা আইনি মাপবিদ্যার নিয়মে (যেমন OIML R 76-এর মতো সুপারিশ আর দেশের নিজস্ব আইন) ঠিক হয়, আর calibration-এর পরে অনেক সময় সিল করা হয়, যাতে কেউ চুপিচুপি বদলাতে না পারে।

মূল উপলব্ধি: Calibration-এর ভুল প্রতিটি মাপে বসে থাকে; ভারী বাটখারা, বহু নমুনার গড় আর বেশি বিন্দু তা কমায়, কিন্তু least squares-এর residual দেখে বাজে বিন্দু আর ভুল মডেল চিনে নিতে হয়।

প্র ০৪হিসাবে দেখা গেল amplifier-এর মাত্র 1 µV/°C offset drift ২০ °C-এ স্কেলে প্রায় 15 g ভুল আনে, অথচ load cell-এর নিজের zero drift মাত্র 2 g. কেন এমন হয়, আর বাস্তব স্কেল কীভাবে গরম-ঠান্ডায় নির্ভুল থাকে?

কারণ সংকেত খুব ছোট। পুরো 5000 g-এর খবর মাত্র 6.6 mV-এ; এক গ্রাম মানে প্রায় 1.3 µV. Amplifier-এর input-এ যে কোনো সরণ সংকেতের সঙ্গে একই gain-এ বড় হয়, তাই input-এর 20 µV-এর সরণ ঠিক 20 µV-এর সংকেতের মতো দেখায়: প্রায় ১৫ গ্রাম। Load cell-এর zero drift, উল্টো দিকে, তার rated output-এর শতাংশে বলা, তাই সংকেতের মাপেই ছোট। সাধারণ নিয়ম: signal chain-এর প্রথম ধাপ, যেখানে সংকেত সবচেয়ে ছোট, সেখানকার ভুলই সবচেয়ে দামি। এ জন্যই নির্ভুল মাপে প্রথম amplifier বেছে নেওয়া হয় offset, drift আর noise দেখে, gain দেখে নয়।

প্রতিকার কয়েক স্তরে। প্রথম স্তর hardware: “zero-drift” amplifier, যারা ভেতরে chopping বা auto-zero কৌশলে নিজের offset বারবার মেপে বাদ দেয়; এদের drift সাধারণ amplifier-এর চেয়ে অনেক কম বলে datasheet-এ দেখা যায় (নির্দিষ্ট মান chip ধরে)। দ্বিতীয় স্তর firmware: চালুর সময় tare আর খালি পাল্লায় ধীরে zero অনুসরণ। Offset-এর drift ধীর, ঘণ্টায় কয়েক ডিগ্রি; প্রতিবার খালি অবস্থায় zero নতুন করে নিলে এর প্রায় সবটাই মোছে। এটি গ্রামের পুরোনো দাঁড়িপাল্লার কাঁটা প্রতিবার মাপার আগে শূন্যে আনার আধুনিক রূপ।

তৃতীয় স্তর span-এর জন্য, যা tare দিয়ে মোছে না: তাপমাত্রা মেপে সংশোধন। কারখানায় স্কেলকে দুই বা তিন তাপমাত্রায় রেখে span মাপা হয়, একটি সহগ record-এ রাখা হয়, আর firmware চলার সময় board-এর তাপমাত্রার sensor পড়ে ওজন সংশোধন করে। বাজারঘরের cold-storage monitor-এর TMP102-ধাঁচের sensor-ই এমন কাজে ব্যবহার করা যেত। চতুর্থ স্তর নকশার: load cell, amplifier আর reference একই তাপে রাখা, গরম voltage regulator থেকে দূরে, যাতে তাপমাত্রার পার্থক্য না জন্মায়।

শেষে মনে রাখার মতো: এই পর্বের drift-এর সংখ্যাগুলো একটি উদাহরণ datasheet ধরে; আসল নকশায় প্রতিটি অংশের datasheet থেকে মান নিয়ে একই টেবিল বানাতে হয়, আর গরম ঘরে বা ফ্রিজের পাশে সত্যিকারের পরীক্ষাই শেষ কথা।

মূল উপলব্ধি: সবচেয়ে ছোট সংকেতের ধাপে সবচেয়ে ছোট ভুলও gain-এ বড় হয়; offset-এর drift tare আর zero-drift amplifier মোছে, span-এর drift তাপমাত্রা মেপে সংশোধন লাগে।

প্র ০৫বাজারঘরের firmware calibration রাখল SRAM-এর .noinit-এ, CRC-সহ। আসল একটি স্কেলে calibration-এর মান কোথায়, কী আকারে আর কোন নিরাপত্তায় রাখা উচিত? Record হারালে স্কেলের কী করা উচিত?

Board-এর .noinit শুধু reset পেরোয় (Spec decision 18), বিদ্যুৎ গেলে নয়; আর board-এর flash-এ লেখা fault ঘটায়, তাই কোর্সের run-এ এটিই ছিল সহজ বিকল্প। আসল স্কেলে মান যায় স্থায়ী মেমরিতে: আলাদা EEPROM chip, microcontroller-এর ভেতরের data EEPROM, বা flash-এর একটি আলাদা পাতা। Flash-এ লেখার আগে পুরো পাতা মুছতে হয় আর মোছার সংখ্যা সীমিত (সংখ্যা chip-এর datasheet-এ), তাই calibration-এর মতো কালেভদ্রে বদলানো data-র জন্য এটি ঠিক আছে, কিন্তু প্রতি মিনিটে লেখা চলবে না।

Record-এর আকার: zero, span, বাটখারার ওজন, calibration-এর তাপমাত্রা আর সহগ, তারিখ বা গণনা নম্বর, একটি format-সংস্করণ, আর শেষে CRC. সংস্করণ নম্বর জরুরি: firmware update-এর পরে record-এর গঠন বদলালে পুরোনো record-কে নতুন বলে পড়া ঠেকায়। লেখার সময় বিদ্যুৎ গেলে record অর্ধেক লেখা থাকতে পারে; এ জন্য দুই কপি রাখা হয়, একটি লিখে CRC যাচাই করে তবে অন্যটি (পর্ব ৬৩-এর কৌশল)। মনে রাখবেন, CRC দুর্ঘটনার ভুল ধরে, ইচ্ছাকৃত বদল নয়: বাণিজ্যিক স্কেলে calibration-এ ঢোকার পথ সিল বা পাসওয়ার্ডে বাঁধা, আর আরও কঠোর নকশায় record-এ cryptographic signature (পর্ব ৭৭-এর বিষয়)।

Record হারালে কী হবে, সেটি নকশার সবচেয়ে গুরুত্বপূর্ণ প্রশ্ন। কোর্সের firmware nominal মানে চলে গেল, আর run-এ দেখা গেল খালি পাল্লা 28 g দেখায়। শিক্ষার জন্য ঠিক আছে, দোকানে নয়। বিক্রির স্কেলে নিরাপদ আচরণ হলো ভুল মানে চুপচাপ চলা নয়, বরং পরিষ্কার “CAL ERROR” দেখিয়ে দাম দেওয়া বন্ধ রাখা, যতক্ষণ না কেউ নতুন calibration করেন। এই “fail-safe” ভাবনা আর record নষ্ট হলে দুই কপির কোনটি নেবেন, তার বাস্তব run পর্ব ৬৩-এ।

আরেকটি ব্যবহারিক কথা: কারখানার calibration আর মাঠের calibration আলাদা রাখা ভালো। কারখানার মান (তাপমাত্রার সহগ, nonlinearity টেবিল) কখনো মাঠে বদলায় না; মাঠে শুধু zero আর span নতুন করে নেওয়া হয়। এতে দোকানে কেউ ভুল বাটখারা দিয়ে calibration করলেও কারখানার সূক্ষ্ম কাজ নষ্ট হয় না।

মূল উপলব্ধি: Calibration record একটি ছোট কিন্তু অমূল্য data: স্থায়ী মেমরিতে, সংস্করণ আর CRC-সহ, দুই কপিতে, আর হারালে স্কেল চুপচাপ নয়, স্পষ্টভাবে থামবে।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — 10 kg-এর স্কেল: বাজারঘর একটি বড় স্কেল চায়: 10 kg-এর load cell, rated output 3 mV/V, excitation আর Vref 3.3 V, ১২ বিটের ADC. শূন্য ভারে 200 count আর 10 000 g-এ 3800 count চাই। (ক) পূর্ণ ভারে bridge-এর output, INA-র gain, REF voltage আর AD620-ধাঁচের RG কত? (খ) Firmware-এর int32_t raw_to_grams(int32_t raw) লিখুন (integer, গোল করে)। (গ) এক count কত গ্রাম?

    (ক) Bridge: 3 mV/V × 3.3 V = 9.9 mV. 3600 count-এর voltage = 3600 × 3.3 ÷ 4096 = 2.9004 V, তাই gain = 2.9004 ÷ 0.0099 ≈ 292.97. REF = 200 × 0.80566 mV ≈ 0.1611 V. RG = 49.4 kΩ ÷ (292.97 − 1) ≈ 169.2 Ω.

    static int32_t raw_to_grams(int32_t raw)
    {
        /* 200 counts = 0 g, 3800 counts = 10000 g: span 3600 */
        return div_round((raw - 200) * 10000, 3600);
    }

    (গ) 10 000 ÷ 3600 ≈ 2.78 g প্রতি count. গুণফল সর্বোচ্চ (4095 − 200) × 10 000 = 38 950 000, int32_t-এ আঁটে। Lab-এর হিসাব-script: raw 200 → 0 g, 254 → 150 g, 2000 → 5000 g, 3800 → 10 000 g. বাস্তবে RG কাছাকাছি মানের হবে আর gain একটু সরবে; এ জন্যই 200/3800 সংখ্যা দুটি firmware-এ calibration থেকে আসবে, কাগজের হিসাব থেকে নয়।

  2. ভুল খুঁজুন — calibration-এর দুটি লাইন: recal.c-এর একটি সংস্করণে দুটি লাইন বদলানো:
    int32_t g = (raw - zero) / span * ref;          /* grams */
    nv.crc = crc32(&nv, sizeof(cal_t));             /* save  */
    if (crc32(&nv, sizeof(cal_t)) == nv.crc) { ... } /* boot  */
    calibration-এর পরে zero 400, span 700, ref 1000 g. 150 g (raw 505), 1400 g (raw 1380) আর 5000 g (raw 3900)-এ স্কেল কী দেখাবে? Software reset-এর পরে কী হবে? আগে হিসাব করুন, তারপর উত্তর খুলুন।

    ভুল ১, ভাগ আগে: integer-এ 105 ÷ 700 = 0, তাই 150 g → 0 g; 980 ÷ 700 = 1, তাই 1400 g → 1000 g; 3500 ÷ 700 = 5 → 5000 g (ঠিক, কাকতালীয়ভাবে)। স্কেল শুধু 1000 g-এর ধাপে মাপে। ভুল ২, CRC-তে নিজের ঘর: sizeof(cal_t) CRC-এর ঘরটিও ঢোকায়; লেখার সময় সেখানে পুরোনো মান ছিল, আর পরে নতুন CRC বসায় হিসাবের data বদলে যায়, তাই boot-এ কখনো মেলে না। সত্যিকারের run (lab-এর recal_bug.c, একই script): raw=505 grams=0 price=0.00 Tk, raw=1380 grams=1000 price=65.50 Tk, raw=3900 grams=5000, আর reset-এর পরে no valid record, nominal: zero=380 span=1450 counts per 2000 g আর 650 g-এ grams=0. সংশোধন: div_round((raw - zero) * ref, span) আর offsetof(cal_t, crc). শিক্ষা: শুধু পূর্ণ ভারে (5000 g) পরীক্ষা করলে দুটি ভুলই লুকাত।

  3. হিসাব — আরেকটি RC filter: R = 4.7 kΩ, C = 2.2 µF. (ক) τ আর corner frequency কত? (খ) 50 Hz-এ gain কত, dB-তে কত? (গ) ১২ বিটের ½ LSB-এ থিতু হতে কত সময়? (ঘ) স্কেল প্রতি 100 ms-এ মাপলে এই filter চলবে কি?

    (ক) τ = 4700 × 2.2 × 10−6 = 10.34 ms; fc = 1 ÷ (2π × 0.01034) ≈ 15.39 Hz. (খ) |H| = 1 ÷ √(1 + (50 ÷ 15.39)2) ≈ 0.294, অর্থাৎ প্রায় −10.6 dB. (গ) 9.01 × 10.34 ms ≈ 93.2 ms. (ঘ) চলবে, কিন্তু সীমার খুব কাছে: ওজন বদলের পরের প্রথম মাপ (100 ms-এর মধ্যে যেকোনো সময় আসতে পারে) পুরো থিতু নাও হতে পারে। দুটি পরপর মাপ মিললে তবেই দাম দেখানো একটি ভালো নিয়ম। মানগুলো lab-এর হিসাব-script (অংশ ৪-এর block-এ R আর C বদলে) থেকে।

  4. আগে বলুন, তারপর মেলান — noisy calibration: Noise-সহ calibration-এ firmware রেখেছে zero = 399, span = 702 count প্রতি 1000 g. দুই-বিন্দুর সূত্রে (div_round) raw 3898 আর raw 1382 কত গ্রাম দেখাবে? 5000 g-এর ভুল 1400 g-এর ভুলের চেয়ে বড় কেন?

    raw 3898: (3898 − 399) × 1000 ÷ 702 = 3 499 000 ÷ 702 ≈ 4984.3 → 4984 g. raw 1382: 983 000 ÷ 702 ≈ 1400.3 → 1400 g. সত্যিকারের run (recal.elf, adc_noise_counts: 8) ঠিক এই দুটি লাইন দিয়েছে: raw=3898 grams=4984 price=326.45 Tk আর raw=1382 grams=1400 price=91.70 Tk. কারণ: span-এর ভুল (702 বনাম 700, প্রায় 0.29%) একটি ঢালের ভুল, যা ওজনের সমানুপাতে বাড়ে: 5000 g-এ প্রায় 14 g, আর zero-র এক count আর সেই মুহূর্তের noise মিলে −16 g. 1400 g-এ একই ঢালের ভুল মাত্র প্রায় 4 g, আর এই মাপে noise উল্টো দিকে পড়ে প্রায় কাটাকাটি হয়েছে। তাই ভারী বাটখারা আর calibration-এ বেশি নমুনার গড়।

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

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

ক্রমএকটি ওজনের স্কেলের দুই-বিন্দুর calibration-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. স্কেল চালু রেখে তাপে থিতু হতে দেওয়া, পাল্লা খালি আর স্থির রাখা
  2. খালি পাল্লায় বহু নমুনার গড় নিয়ে zero রাখা
  3. জানা, যতটা সম্ভব ভারী বাটখারা চাপিয়ে আবার বহু নমুনার গড় নেওয়া
  4. span যুক্তিসংগত সীমার ভেতরে কিনা পরীক্ষা করা
  5. zero, span আর বাটখারার মান CRC-সহ স্থায়ী মেমরিতে রাখা
  6. অন্য একটি জানা ওজনে মেপে calibration যাচাই করা

একটি full-bridge load cell-এর rated output 2 mV/V, excitation 5 V. পূর্ণ ভারে bridge-এর output কত?

  • 2 mV
  • 2.5 V
  • 10 mV
  • 0.4 mV

একটি instrumentation amplifier-এর gain সমীকরণ G = 1 + 49.4 kΩ ÷ RG. RG = 499 Ω হলে gain প্রায় কত?

  • ৯৯
  • ১০০
  • ১০
  • ৪৯.৪

ADC-র আগে R = 10 kΩ আর C = 1 µF-এর একটি single-pole RC low-pass filter. Corner frequency প্রায় কত, আর ১২ বিটের ½ LSB-এ থিতু হতে প্রায় কত সময় লাগে?

  • 100 Hz, 10 ms
  • 15.9 Hz, 10 ms
  • 1.59 kHz, 0.9 ms
  • 15.9 Hz, প্রায় 90 ms

একটি স্কেলের calibration: খালি পাল্লায় 400 count, 1000 g-এর বাটখারায় 1100 count. Integer firmware-এ grams = (raw − zero) × 1000 ÷ span. raw = 1380 হলে কত গ্রাম?

  • 1400 g
  • 1000 g
  • 1255 g
  • 980 g

Least-squares calibration রেখা কোন রাশিকে সবচেয়ে ছোট করে বেছে নেওয়া হয়?

  • দুই প্রান্তের বিন্দুতে ভুল
  • Residual-এর সাধারণ যোগফল
  • Residual-এর বর্গের যোগফল
  • সবচেয়ে বড় একক residual

3.3 V-এ চলা একটি load-cell bridge-এর দুই বাহু প্রায় 1.65 V-এ, আর তাদের পার্থক্য কয়েক mV. এটি বড় করতে একটি সাধারণ non-inverting op-amp-এর বদলে instrumentation amplifier কেন?

  • Non-inverting amplifier ১০ গুণের বেশি gain দিতে পারে না
  • সংকেতটি differential; INA common-mode বাদ দিয়ে শুধু পার্থক্য বড় করে
  • ADC সরাসরি mV মাপতে পারে না বলে
  • INA-র কোনো noise নেই

শব্দকোষ

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

মনে রাখুন

  1. Bridge: output = rated output × excitation; 2 mV/V × 3.3 V = 6.6 mV পূর্ণ ভারে, 1.65 V-এর common-mode-এর ওপর। Ratiometric নকশায় excitation-ই ADC-র Vref.
  2. Amplifier: non-inverting G = 1 + Rf ÷ Rg; bridge-এর জন্য INA (AD620-এ G = 1 + 49.4 kΩ ÷ RG), output = REF + G × পার্থক্য. স্কেলে G ≈ 427, REF ≈ 0.322 V → 400 count থেকে শুরু।
  3. RC filter: fc = 1 ÷ 2πRC; 10 kΩ আর 1 µF-এ 15.9 Hz, 50 Hz-এ 0.303 গুণ, ১২ বিটে থিতু হতে ≈ 9 τ = 90 ms.
  4. Calibration: zero আর span দুটি জানা বিন্দু থেকে; আগে গুণ, পরে ভাগ, গোল করে; span-এর সীমা পরীক্ষা; ভারী বাটখারা আর বহু নমুনার গড়। বেশি বিন্দুতে least squares, বাঁকা sensor-এ টেবিল।
  5. Drift আর সংরক্ষণ: প্রথম ধাপের µV-ও gain-এ বড় হয়; offset-এ tare আর auto-zero, span-এ তাপমাত্রা দিয়ে সংশোধন। Record স্থায়ী মেমরিতে, সংস্করণ আর CRC-সহ; না মিললে স্কেল থামবে।

পরের পর্বে: পর্ব ৬৭ (Motor নিয়ন্ত্রণ — DC, servo আর stepper motor, H-bridge). এবার উল্টো দিক, actuator: H-bridge-এর চারটি switch, PWM দিয়ে গতি, stepper-এর ধাপের ক্রম আর encoder দিয়ে ঘোরা গোনা।

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

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