অ্যানালগ-টু-ডিজিটাল কনভার্সন (ADC)

১ · ADC কী এবং কেন লাগে

বাস্তব জগতের বেশিরভাগ সিগন্যাল — তাপমাত্রা, আলো, শব্দ, ভোল্টেজ — অ্যানালগ: এরা যেকোনো মান নিতে পারে, ধারাবাহিকভাবে বদলায়। কিন্তু মাইক্রোকন্ট্রোলারের CPU শুধু ডিজিটাল বাইনারি সংখ্যা নিয়ে কাজ করতে পারে। এই ফাঁক পূরণ করে ADCAnalog-to-Digital Converterএকটি পেরিফেরাল যা একটি অ্যানালগ ভোল্টেজকে পরিমাপ করে নিকটতম প্রতিনিধিত্বকারী ডিজিটাল সংখ্যায় (কোড) রূপান্তর করে। — একটি পেরিফেরাল যা একটি পিনে আসা অ্যানালগ ভোল্টেজ মেপে তার সবচেয়ে কাছাকাছি ডিজিটাল প্রতিনিধিত্ব (একটি $n$-বিট পূর্ণসংখ্যা কোড) বের করে দেয়।

২ · কোয়ান্টাইজেশনের সূত্র

একটি $n$-বিট ADC মোট $2^n$টি আলাদা কোড দিতে পারে ($0$ থেকে $2^n - 1$)। এই কোডগুলো পুরো রেফারেন্স রেঞ্জ ($0$ থেকে $V_{ref}$) জুড়ে সমান দূরত্বে ছড়ানো থাকে — প্রতিটি ধাপের আকার (স্টেপ সাইজ বা রেজোলিউশন):

$$ \Delta = \dfrac{V_{ref}}{2^{n}} $$

একটি ইনপুট ভোল্টেজ $V_{in}$-কে নিকটতম কোডে রূপান্তর করা হয় রাউন্ড করে:

$$ D = \mathrm{round}\!\left(\dfrac{V_{in}}{\Delta}\right), \qquad V_{quantized} = D \times \Delta $$

যেহেতু $D$ একটি পূর্ণসংখ্যা আর $V_{in}$ প্রায় সবসময়ই একটি ঠিক স্টেপ বাউন্ডারিতে পড়ে না, তাই একটি ছোট কোয়ান্টাইজেশন এরর সবসময় থেকে যায়:

$$ E_{quant} = V_{quantized} - V_{in} $$

৩ · সিমুলেশন — কয়েকটি ভোল্টেজকে কোডে রূপান্তর

নিচের কোড সেলে একটি quantize() ফাংশন উপরের সূত্র সত্যিই প্রয়োগ করে কয়েকটি অ্যানালগ ভোল্টেজকে একটি ১০-বিট ADC-এর কোডে রূপান্তর করছে এবং প্রতিটির কোয়ান্টাইজেশন এরর গণনা করে দেখাচ্ছে।

def quantize(voltage, vref, bits):
    step_size = vref / (2 ** bits)
    max_code = (2 ** bits) - 1
    code = round(voltage / step_size)
    code = max(0, min(code, max_code))  # রেঞ্জের বাইরে গেলে ক্ল্যাম্প করা
    quantized_voltage = code * step_size
    error = quantized_voltage - voltage
    return step_size, code, quantized_voltage, error


vref = 3.3
bits = 10
test_voltages = [0.837, 1.650, 3.000]

step_size = vref / (2 ** bits)
print(f"{bits}-bit ADC, Vref={vref}V -> স্টেপ সাইজ (Δ) = {step_size:.6f} V")
print()

for v in test_voltages:
    step_size, code, qv, err = quantize(v, vref, bits)
    print(f"ইনপুট = {v:.3f}V  ->  code = {code:4d}  ->  কোয়ান্টাইজড = {qv:.6f}V  "
          f"->  এরর = {err:+.6f}V")

৪ · রেজোলিউশন বাড়ালে এরর কমে — সত্যিকারের তুলনা

একটি গুরুত্বপূর্ণ, সহজেই ভুল বোঝা সম্ভাবনাযুক্ত ধারণা হলো — বেশি বিট মানেই কম এরর, এবং এটি শুধু দাবি নয়, গাণিতিকভাবে নিশ্চিত: যেহেতু $V_{ref}$ প্রতিবার ২-এর গুণিতক দিয়ে ভাগ হয়, একটি নিম্ন-রেজোলিউশন গ্রিডের প্রতিটি কোড-পয়েন্ট একটি উচ্চ-রেজোলিউশন গ্রিডেও ঠিক উপস্থিত থাকে — তাই সূক্ষ্ম গ্রিডে নিকটতম পয়েন্ট কখনও মোটা গ্রিডের চেয়ে দূরে হতে পারে না। নিচের কোড সেলে এই দাবিটি একই ইনপুট ভোল্টেজে ৮-বিট, ১০-বিট ও ১২-বিট ADC-এর জন্য সত্যিই গণনা করে দেখানো হয়েছে।

def quantize(voltage, vref, bits):
    step_size = vref / (2 ** bits)
    max_code = (2 ** bits) - 1
    code = round(voltage / step_size)
    code = max(0, min(code, max_code))
    quantized_voltage = code * step_size
    error = quantized_voltage - voltage
    return step_size, code, quantized_voltage, error


vref = 3.3
target_voltage = 2.017  # একই ইনপুট, বিভিন্ন রেজোলিউশনে টেস্ট করা হচ্ছে

print(f"ইনপুট ভোল্টেজ = {target_voltage}V (Vref={vref}V) -- একই ইনপুট, ভিন্ন রেজোলিউশন:\n")

prev_abs_error = None
for bits in (8, 10, 12):
    step_size, code, qv, err = quantize(target_voltage, vref, bits)
    abs_err = abs(err)
    trend = ""
    if prev_abs_error is not None:
        trend = "  (আগের চেয়ে কম বা সমান এরর)" if abs_err <= prev_abs_error else "  (আগের চেয়ে বেশি এরর!)"
    print(f"{bits:2d}-bit  ->  Δ={step_size:.6f}V  code={code:4d}  "
          f"কোয়ান্টাইজড={qv:.6f}V  |এরর|={abs_err:.6f}V{trend}")
    prev_abs_error = abs_err