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

DAC — resolution, R-2R ladder আর waveform তৈরি

DAC — Resolution, R-2R Ladder and Waveform Generation

Taught in Bangla, this lesson derives Vout = code × Vref / 2^n, compares binary-weighted and R-2R ladders, and solves a 4-bit ladder by nodal analysis (code 1011 gives 2.26875 V). In-page Python shows a 1% MSB error making an 8-bit ladder non-monotonic and covers DNL, INL, glitches and settling. An integer-built 32-entry sine table runs on the course's virtual BG-M3 board through a 4-bit GPIO ladder, DDS phase accumulators set the frequency, and PWM plus RC filtering is sized for ripple and settling.

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

  • Resolution, LSB আর full scale থেকে যেকোনো code-এর voltage, আর voltage থেকে code হিসাব করা
  • R-2R ladder কেন কাজ করে, Thevenin-এর অর্ধেক হওয়ার যুক্তিতে আর nodal analysis-এ, দুভাবেই দেখানো
  • Monotonicity, DNL, INL, glitch আর settling time চেনা, আর resistor-এর অমিল থেকে তাদের হিসাব করা
  • Fixed-point sine table, sample rate আর DDS দিয়ে নির্দিষ্ট frequency-র waveform বানানো
  • PWM + RC DAC-এর ripple আর settling-এর টানাটানি হিসাব করে বাজারঘরের device-এর জন্য সঠিক DAC বাছাই করা

১ · DAC কী — সংখ্যা থেকে voltage-এর সিঁড়ি

আগের পর্বগুলোতে microcontroller বাইরের জগৎকে শুধু দুই অবস্থায় দেখেছে আর চালিয়েছে: pin 0 বা 1 (পর্ব ৪১). কিন্তু অনেক কাজে মাঝের মান লাগে: একটি speaker-এ সুর, একটি motor driver-এর গতির সংকেত, বা একটি display-এর contrast. যে hardware একটি সংখ্যা নিয়ে তার সমানুপাতিক voltage দেয়, তার নাম DAC (digital-to-analog converter). এটি ADC-র উল্টো পথ: ADC voltage মেপে সংখ্যা দেয় (পর্ব ৪৭, sampling আর quantization সেখানে), DAC সংখ্যা নিয়ে voltage বানায়। এই পর্বে hex লেখা হবে C-ধাঁচে, 0x…, আর binary code লেখা হবে 1011-এর মতো, MSB বাঁয়ে।

উপমা — বাজারের দাঁড়িপাল্লার বাটখারা: দোকানির কাছে 1 kg, 500 g, 250 g আর 125 g-এর চারটি বাটখারা। কোনটি পাল্লায় উঠবে আর কোনটি উঠবে না, এই চার হ্যাঁ-না দিয়ে তিনি 0 থেকে 1875 g পর্যন্ত ১৬টি আলাদা ওজন বানাতে পারেন, প্রতি ধাপে 125 g. DAC ঠিক এভাবে কাজ করে: প্রতিটি বিট একটি “বাটখারা”, MSB সবচেয়ে ভারী (Vref-এর অর্ধেক), পরেরটি তার অর্ধেক, এভাবে LSB পর্যন্ত। ফল একটি মসৃণ ঢাল নয়, একটি সিঁড়ি; সিঁড়ির এক ধাপের উচ্চতাই resolution.

আদর্শ n বিটের DAC-এর তিনটি সূত্র, যা পরীক্ষায় সবচেয়ে বেশি আসে:

মূল সূত্র

১. এক ধাপ: 1 LSB = Vref ÷ 2n
২. Output: Vout = code × Vref ÷ 2n, যেখানে code = 0 … 2n − 1
৩. Full scale (সবচেয়ে বড় code): (2n − 1) × Vref ÷ 2n = Vref − 1 LSB

খেয়াল করুন, হর 2n, 2n − 1 নয়। সবচেয়ে বড় code কখনো ঠিক Vref-এ পৌঁছায় না, এক ধাপ নিচে থামে। STM32F1-এর reference manual RM0008-ও DAC-এর output লেখে VREF+ × DOR ÷ 4096 হিসেবে। কিছু বই আর কিছু chip-এর datasheet 2n − 1 ব্যবহার করে (তখন full scale ঠিক Vref); পরীক্ষায় প্রশ্নের প্রথা দেখে নিন, আর নিজের উত্তরে কোনটি ধরলেন লিখে দিন। নিচের টেবিলের প্রতিটি সংখ্যা Python-এ হিসাব করে মেলানো:

বিট (n)ধাপের সংখ্যা1 LSB (Vref = 3.3 V)Full scaleকোথায় দেখা যায়
416206.25 mV3.09375 Vএই পর্বের GPIO-চালিত R-2R ladder
825612.891 mV3.2871 Vসরল সুর, LED-এর মাত্রা, contrast
1010243.223 mV3.2968 Vঅনেক ছোট MCU-র on-chip DAC
1240960.806 mV3.2992 VSTM32F1-এর high-density অংশের DAC (নিচে)

পরীক্ষার ধাঁচের উদাহরণ: একটি ৮ বিটের DAC, Vref = 5 V. 3.2 V পেতে কোন code লিখবেন, আর আসল output কত ভুল হবে?

  1. 1 LSB = 5 V ÷ 256 = 19.53125 mV.
  2. আদর্শ code = 3.2 V ÷ 19.53125 mV = 163.84; সবচেয়ে কাছের পূর্ণসংখ্যা 164 (0xA4).
  3. আসল output = 164 × 19.53125 mV = 3.203125 V.
  4. ভুল = 3.203125 − 3.2 = 3.125 mV = 0.16 LSB, যা ½ LSB-এর মধ্যে: গোল করলে quantization-এর ভুল কখনো ½ LSB ছাড়ায় না।

বিট বাড়ালে ধাপ ছোট হয়, কিন্তু প্রতিটি বিট অর্ধেক ছোট ধাপ চায়, তাই ভুলের সহনশীলতাও অর্ধেক হয় (অংশ ৩). Resolution আর accuracy তাই এক জিনিস নয়: ১২ বিটের DAC 4096টি code নেয়, কিন্তু তার output প্রতিটি code-এ কতটা সঠিক, তা ঠিক করে resistor-এর মিল, Vref-এর স্থিরতা আর load.

বাজারঘরের device-এ DAC কোথায় লাগে

বাজারঘরের দুটি device-এর মূল কাজ মাপা: scale-এর load cell ADC দিয়ে, cold room-এর তাপমাত্রা I2C দিয়ে। তবু দুটি জায়গায় একটি analog output কাজে আসে। এক, cold room-এর alarm: তাপমাত্রা 8.00 °C-এর ওপরে বা 0.00 °C-এর নিচে তিনবার পরপর গেলে alarm বাজে (README-র নিয়ম)। এখন PA6 শুধু buzzer চালু-বন্ধ করে। DAC থাকলে একটি sine সুর বাজানো যায়, আর তার মাত্রা বদলানো যায়: দিনে জোরে, রাতে আস্তে। দুই, scale-এর display: অনেক character LCD-এর contrast একটি pin-এর ছোট voltage দিয়ে ঠিক হয়, যা সাধারণত একটি potentiometer ঘুরিয়ে দেওয়া হয়; DAC থাকলে firmware নিজেই সেটি ঠিক করতে পারে।

Board-এর সীমা: কোর্সের বাজারঘর board (BG-M3) একটি virtual Cortex-M3, আসল কোনো পণ্য নয় (পর্ব ০৬). এর README-র memory map-এ GPIO, SysTick, UART, ADC, I2C-ধাঁচের bus, EXTI আর watchdog আছে; DAC নেই. তাই এই পর্বে DAC তিনভাবে দেখা হবে: Python-এ মডেল করে (ladder-এর nodal analysis, PWM-এর RC filter), board-এ সত্যিকারের firmware চালিয়ে যা GPIO pin-এ ৪ বিটের code দেয় (বাইরের একটি R-2R ladder ধরে নিয়ে), আর আসল chip-এর reference manual থেকে।

২ · Binary-weighted থেকে R-2R ladder

বাটখারার ধারণা সরাসরি circuit-এ আনলে পাওয়া যায় binary-weighted DAC: প্রতিটি বিটের জন্য একটি resistor, যার মান আগেরটির দ্বিগুণ (R, 2R, 4R, 8R …), সবগুলো একটি op-amp-এর summing node-এ। কাগজে সরল, কিন্তু ৮ বিটে সবচেয়ে বড় resistor সবচেয়ে ছোটটির 27 = 128 গুণ। এত আলাদা মানের resistor একই নির্ভুলতায় বানানো কঠিন, আর MSB-এর resistor-এর ভুল LSB-এর পুরো অবদানকে ছাপিয়ে যায়। ১২ বিটে অনুপাত 2048 গুণ: বাস্তবে প্রায় অচল।

R-2R ladder এই সমস্যার সুন্দর সমাধান: পুরো DAC-এ মাত্র দুই মানের resistor, R আর 2R (2R প্রায়ই দুটি R পাশাপাশি জুড়ে বানানো হয়, তাই আসলে একটিই মান)। নিচের ছবিতে ৪ বিটের voltage-mode ladder: প্রতিটি বিট একটি switch চালায়, 1 হলে তার 2R-কে Vref-এ, 0 হলে ground-এ জোড়ে। আসল microcontroller-এ সেই switch হলো GPIO-র push-pull output (CMOS-এর ভেতরের গঠন Computer Architecture পর্ব ০৮-এ).

ছবি ৪৮.১ — ৪ বিটের R-2R ladder, code 1011

R = 10 kΩ, Vref = 3.3 V; সবুজ switch = বিট 1 (Vref), ধূসর = বিট 0 (ground)

৪ বিটের R-2R ladder, code 1011 N0N1N2N3 RRR 2R2R2R2R2R b0 = 1b1 = 1b2 = 0b3 = 1 3.3 V3.3 V0 V3.3 V Vout LSBMSB 1011 = 11 → 11 ÷ 16 × 3.3 V Vout = 2.26875 V Output resistance সব code-এ R
ছবি ৪৮.১ — বাঁয়ের 2R (ground-এ) ladder-এর শেষ প্রান্তের terminator. প্রতিটি R ডানের node-এ যায়; output MSB-এর node N3 থেকে। Voltage-এর মান অংশ ২-এর nodal analysis থেকে।

কেন কাজ করে — প্রতি node-এ অর্ধেক

যুক্তিটি Thevenin equivalent দিয়ে সবচেয়ে সহজ: যেকোনো voltage উৎস আর resistor-এর জাল বাইরের দিক থেকে একটি voltage আর তার সঙ্গে series-এ একটি resistor-এর সমান। বাঁ প্রান্ত থেকে শুরু করুন। N0-তে দুটি 2R: একটি ground-এ, একটি b0-এর switch-এ। সমান দুই resistor-এর ভাগে voltage অর্ধেক: b0 × Vref ÷ 2, আর দুটি 2R সমান্তরালে = R. এবার N0 থেকে N1-এর দিকে series-এ আরেকটি R: বাঁ দিকটা এখন N1-এর কাছে 2R. N1-এও তাই আবার দুটি 2R-এর ভাগ, আর আবার অর্ধেক। প্রতিটি node-এ নিয়ম একটাই:

R-2R-এর পুনরাবৃত্তি

Vk = (Vk−1 + bk × Vref) ÷ 2, শুরুতে V−1 = 0; প্রতিটি node-এ বাঁ দিকের resistance = R
শেষে: Vout = Vref × (b3/2 + b2/4 + b1/8 + b0/16) = code × Vref ÷ 16

বাঁ দিকের Thevenin equivalent
যে node
এই node-এর বিট
হিসাব
Thevenin voltage
Thevenin resistance
Node-এর আসল voltage
  1. N0, LSB. Terminator-এর 2R ground-এ, b0-এর 2R 3.3 V-এ। সমান দুই resistor-এর ভাগ: 1.65 V, আর দুটি সমান্তরালে R.
  2. N1. বাঁ দিক (1.65 V, R) আর series-এর R মিলে 2R; সঙ্গে b1-এর 2R 3.3 V-এ। আবার সমান ভাগ: (1.65 + 3.3) ÷ 2 = 2.475 V.
  3. N2, বিট 0. b2-এর 2R ground-এ, তাই নতুন কিছু যোগ হয় না, শুধু অর্ধেক: 2.475 ÷ 2 = 1.2375 V. বিট 0 মানে “আগের সবকিছু আবার অর্ধেক”।
  4. N3, MSB আর output. (1.2375 + 3.3) ÷ 2 = 2.26875 V = 11 ÷ 16 × 3.3 V. MSB-এর অবদান একবার অর্ধেক (1.65 V), LSB-এর চারবার (0.20625 V).
  5. পুরো জাল একসাথে। Thevenin-এর মান ছিল “বাঁ দিক আলাদা করলে” voltage. সব জোড়া থাকলে ভেতরের node-এর আসল voltage আলাদা (1.88203, 2.11406, 1.75312 V), কারণ ডান দিক থেকেও current আসে। কিন্তু output খোলা, তাই N3-এ দুটি মিলে যায়: 2.26875 V. নিচের Python solver-এর হিসাব।

এবার একই কথা অন্য পথে যাচাই। Nodal analysis-এ প্রতিটি node-এর জন্য Kirchhoff-এর current নিয়ম লেখা হয় (ঢোকা current = বের হওয়া current), যা একটি রৈখিক সমীকরণের সারি G·V = I দেয়; G-তে resistor-এর conductance, I-তে উৎস থেকে আসা current. নিচের ব্লক এই সারি Gaussian elimination দিয়ে সমাধান করে, কোনো Thevenin-এর কৌশল ছাড়াই। পরের ব্লকও এই function ব্যবহার করে, তাই দুটি একই namespace-এ চলে:

# R-2R ladder: nodal analysis (G·V = I), Gaussian elimination দিয়ে সমাধান
VREF, R = 3.3, 10_000.0
def ladder(code, n=4, rload=None, r2=None):
    r2 = r2 or [2 * R] * n               # প্রতিটি বিটের 2R (অমিল পরীক্ষায় বদলানো যায়)
    G, I = [[0.0] * n for _ in range(n)], [0.0] * n
    def link(a, b, r):                   # a আর b node-এর মাঝে resistor; b=None মানে ground
        G[a][a] += 1 / r
        if b is not None:
            G[b][b] += 1 / r; G[a][b] -= 1 / r; G[b][a] -= 1 / r
    link(0, None, 2 * R)                 # শেষ প্রান্তের 2R, ground-এ
    for k in range(n):
        vb = VREF if code >> k & 1 else 0.0          # বিটের switch: Vref বা 0 V
        G[k][k] += 1 / r2[k]; I[k] += vb / r2[k]
        if k: link(k, k - 1, R)
    if rload: link(n - 1, None, rload)
    for c in range(n):                   # সামনে এগিয়ে মোছা
        for r in range(c + 1, n):
            f = G[r][c] / G[c][c]
            for j in range(c, n):
                G[r][j] -= f * G[c][j]
            I[r] -= f * I[c]
    V = [0.0] * n
    for r in reversed(range(n)):         # পেছন থেকে বসানো
        V[r] = (I[r] - sum(G[r][j] * V[j] for j in range(r + 1, n))) / G[r][r]
    return V

V = ladder(0b1011)
print("code 1011, N0..N3:", " ".join(f"{v:.5f}" for v in V), "V")
print(f"Vout = {V[-1]:.5f} V, সূত্রে 11/16 x 3.3 = {11 / 16 * VREF:.5f} V")
err = max(abs(ladder(c)[-1] - c / 16 * VREF) for c in range(16))
print(f"16টি code-এ সূত্র থেকে সর্বোচ্চ পার্থক্য = {err:.1e} V")
half = {round(ladder(c, rload=R)[-1] / ladder(c)[-1], 6) for c in range(1, 16)}
print("10 kΩ load দিলে Vout কমে হয় (গুণ):", half)

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

code 1011, N0..N3: 1.88203 2.11406 1.75312 2.26875 V
Vout = 2.26875 V, সূত্রে 11/16 x 3.3 = 2.26875 V
16টি code-এ সূত্র থেকে সর্বোচ্চ পার্থক্য = 8.9e-16 V
10 kΩ load দিলে Vout কমে হয় (গুণ): {0.5}

তিনটি জিনিস দেখুন। এক, Thevenin-এর অর্ধেক-অর্ধেক যুক্তি আর পুরো সমীকরণের সমাধান একই 2.26875 V দিয়েছে। দুই, ১৬টি code-এই পার্থক্য 10−15 V-এর ঘরে, যা শুধু float-এর গোল করার ভুল: আদর্শ resistor-এ ladder নিখুঁত। তিন, output-এ R-এর সমান একটি load দিলে প্রতিটি code-এ voltage ঠিক অর্ধেক। অর্থাৎ ladder-এর output resistance code-এর ওপর নির্ভর করে না, সবসময় R. এটি R-2R-এর একটি বড় সুবিধা, কিন্তু একটি সতর্কতাও: 10 kΩ-এর ladder সরাসরি একটি speaker বা কম resistance-এর load চালাতে পারে না। সেজন্য output-এর পরে একটি op-amp-এর buffer লাগে, যা উঁচু input resistance নিয়ে ভাগটা অক্ষত রাখে।

৩ · আসল DAC-এর ভুল — monotonicity, DNL, glitch আর settling

আদর্শ ladder নিখুঁত, কিন্তু আসল resistor-এর মান ১%, ০.১% বা আরও ভালো সহনশীলতায় বানানো হয়। সেই ছোট অমিল কতটা ক্ষতি করে, তা মাপার জন্য কয়েকটি শব্দ:

  • DNL (differential non-linearity): প্রতিটি ধাপের আসল উচ্চতা আদর্শ 1 LSB থেকে কত আলাদা। DNL = (আসল ধাপ ÷ 1 LSB) − 1. DNL = 0 মানে নিখুঁত ধাপ।
  • INL (integral non-linearity): কোনো code-এর আসল output আদর্শ সরলরেখা থেকে কত দূরে, LSB-এর এককে। এটি সব আগের ধাপের ভুলের যোগফল।
  • Monotonicity: code বাড়ালে output কখনো কমে না। DNL সবসময় −1-এর বেশি থাকলে DAC monotonic. Control loop-এ (যেমন পর্ব ৬৯-এর PID) non-monotonic DAC বিপজ্জনক: firmware বেশি চাইলে hardware কম দেয়, আর loop দোলে।

সবচেয়ে খারাপ ধাপ সাধারণত “major carry”-তে: 0111 1111 → 1000 0000, যেখানে সব বিট একসাথে উল্টায়। এখানে MSB একাই নিচের সাতটি বিটের যোগফল + 1 LSB-এর সমান হওয়ার কথা। MSB-এর resistor একটু ভুল হলে এই সমতা ভাঙে। নিচের ব্লক আগের ladder() দিয়ে ৮ বিটের ladder বানিয়ে শুধু MSB-এর 2R বদলায়:

# ৮ বিটের ladder: MSB-এর 2R যদি একটু বেশি হয়, 127 → 128 ধাপে কী ঘটে
N = 8
LSB = VREF / 2 ** N
for pct in (0.0, 0.5, 1.0, 2.0):
    r2 = [2 * R] * N
    r2[N - 1] = 2 * R * (1 + pct / 100)          # শুধু MSB-এর resistor
    v127 = ladder(127, N, r2=r2)[-1]
    v128 = ladder(128, N, r2=r2)[-1]
    step = (v128 - v127) / LSB                   # ধাপ, LSB-এর এককে
    dnl = step - 1 if abs(step - 1) > 5e-4 else 0.0
    print(f"MSB 2R +{pct:3.1f}%: 127 → {v127:.4f} V, 128 → {v128:.4f} V,"
          f" ধাপ = {step:+.3f} LSB, DNL = {dnl:+.3f}")
print(f"1 LSB = {LSB * 1000:.3f} mV")

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

MSB 2R +0.0%: 127 → 1.6371 V, 128 → 1.6500 V, ধাপ = +1.000 LSB, DNL = +0.000
MSB 2R +0.5%: 127 → 1.6412 V, 128 → 1.6459 V, ধাপ = +0.364 LSB, DNL = -0.636
MSB 2R +1.0%: 127 → 1.6453 V, 128 → 1.6418 V, ধাপ = -0.269 LSB, DNL = -1.269
MSB 2R +2.0%: 127 → 1.6533 V, 128 → 1.6337 V, ধাপ = -1.525 LSB, DNL = -2.525
1 LSB = 12.891 mV

মাত্র ১% বেশি resistor-এ ধাপ −0.269 LSB: code 127 থেকে 128-এ গেলে voltage কমে গেছে, DAC আর monotonic নয়। খেয়াল করুন, 127-এর মানও বদলেছে, কারণ MSB-এর বিট 0 থাকলেও তার 2R ground-এ জোড়া থেকে ladder-এর ভাগ বদলায়। একটি সহজ নিয়ম: n বিটের DAC-এ MSB-এর ভুল ½ LSB-এর কম রাখতে হলে আপেক্ষিক ভুল 1 ÷ 2n-এর ঘরে লাগে, ৮ বিটে প্রায় ০.৪%, ১২ বিটে প্রায় ০.০২%. এজন্য সস্তা ১% resistor দিয়ে হাতে বানানো ladder ৬–৭ বিটের বেশি সাধারণত বিশ্বাসযোগ্য নয়, আর আসল ১২–১৬ বিটের DAC chip-এ resistor একই silicon-এ মিলিয়ে বানানো আর trim করা হয়।

Glitch আর settling time

Code বদলালে output এক লাফে নতুন মানে পৌঁছায় না। প্রথমত, প্রতিটি switch একই মুহূর্তে উল্টায় না। 0111 থেকে 1000-এ যাওয়ার সময় যদি MSB আগে চালু হয় আর নিচের তিনটি একটু পরে বন্ধ হয়, এক মুহূর্তের জন্য code 1111, অর্থাৎ প্রায় full scale; উল্টো হলে 0000. এই ক্ষণিকের ভুল লাফের নাম glitch, আর এটি সবচেয়ে বড় হয় major carry-তে। দ্বিতীয়ত, switch উল্টানোর পরেও output-এর capacitance আর buffer-এর গতির কারণে voltage ধীরে নতুন মানে থিতু হয়; নতুন মানের ±½ LSB-এর (বা datasheet-এর বলা সীমার) মধ্যে আসতে যে সময় লাগে, তা settling time. পরের sample এর আগে এলে আগের মান পুরো পৌঁছায়নি।

Firmware-এর দিক থেকে প্রথম সমস্যার একটি অংশ আপনার হাতে। GPIO দিয়ে ladder চালালে সব বিট একটি register write-এ বদলাতে হবে। STM32-ধাঁচের BSRR-এ একই write-এ কিছু pin set আর কিছু reset করা যায় (পর্ব ৩৫). দুটি আলাদা write (আগে সব মুছে পরে নতুনগুলো বসানো) প্রতিটি sample-এ ইচ্ছা করে একটি glitch বানায়; অনুশীলন ২-এ সেটিই খুঁজবেন।

আসল chip — STM32F1-এর DAC

STM32F1 পরিবারের reference manual RM0008-এর DAC অধ্যায় অনুযায়ী (আপনার revision মিলিয়ে নিন): DAC আছে শুধু connectivity line (STM32F105/107) আর high-density ও XL-density STM32F101/103-এ; জনপ্রিয় medium-density অংশে (যেমন STM32F103C8) DAC নেই। যেখানে আছে, সেখানে দুটি channel, প্রতিটি ১২ বিটের (৮ বিট mode-ও আছে), output PA4 আর PA5-এ। ১২ বিটের right-aligned মান লেখা হয় DAC_DHR12R1 register-এ; hardware trigger ছাড়া এক APB1 clock পরে তা output register DOR-এ যায়, trigger থাকলে trigger-এর তিন APB1 clock পরে। Trigger হতে পারে কয়েকটি timer-এর TRGO, EXTI line 9 বা software, আর প্রতিটি channel DMA চাইতে পারে। একটি output buffer (BOFF বিট) বাইরের load চালাতে সাহায্য করে; hardware নিজেই triangle আর noise (LFSR) waveform বানাতে পারে। Settling time নিয়ে RM0008 শুধু বলে এটি supply voltage আর load-এর ওপর নির্ভর করে; STM32F103xC/D/E-এর datasheet-এর টেবিলে 50 pF আর 5 kΩ load-এ settling time-এর সর্বোচ্চ মান 4 µs আর update rate 1 MS/s দেখানো আছে (datasheet-এর নিজের revision দেখে নিশ্চিত হোন)।

৪ · Waveform তৈরি — sine table, sample rate আর DDS

DAC দিয়ে একটি সুর বাজানোর সরল পথ: একটি period-এর sine আগে থেকে হিসাব করে একটি lookup table-এ রাখা, তারপর একটি নির্দিষ্ট হারে, প্রতি timer tick-এ, পরের ঘরের মান DAC-এ লেখা (timer-এর reload-এর হিসাব পর্ব ৪৪-এ)। এই হারই sampling rate fs. Table-এ N ঘর আর প্রতি tick-এ এক ঘর এগোলে output-এর frequency:

Table-এর সুর

fout = fs ÷ N. উদাহরণ: fs = 32 kHz (প্রতি 31.25 µs-এ একটি sample), N = 32 → fout = 1 kHz.
১২ বিটের মাঝখান-ভিত্তিক sine: code[i] = 2048 + round(2047 × sin(2π i ÷ N))

মাঝখান 2048 কারণ DAC-এর output শুধু 0 থেকে Vref, ঋণাত্মক নয়; তাই sine-কে অর্ধেক Vref-এর চারপাশে দোলানো হয় (পরে একটি capacitor সেই DC অংশ সরিয়ে দিতে পারে)। Amplitude 2047, 2048 নয়, যাতে চূড়া 4095-এ আঁটে। নিচের ব্লক table বানায় আর গোল করার ভুল মাপে, তারপর DDS-এর কৌশল দেখায়, যার কথা নিচে:

# ৩২ ঘরের sine table (12 বিট, মাঝখান 2048) আর DDS phase accumulator
import math
N, BITS = 32, 12
MID, AMP = 2048, 2047
table = [math.floor(MID + AMP * math.sin(2 * math.pi * i / N) + 0.5) for i in range(N)]
for i in range(0, N, 8):
    print(f"sine[{i:2}..]:", *table[i:i + 8])
err = max(abs(table[i] - (MID + AMP * math.sin(2 * math.pi * i / N))) for i in range(N))
print(f"গোল করার সর্বোচ্চ ভুল = {err:.3f} LSB")

FS = 32_000                              # প্রতি সেকেন্ডে 32000টি sample
for f_out in (1000, 1250, 2000):
    M = round(f_out * 2 ** 32 / FS)      # tuning word
    acc, idx = 0, []
    for _ in range(8):
        idx.append(acc >> 27)            # ওপরের ৫ বিট = table-এর ঘর (0..31)
        acc = (acc + M) & 0xFFFFFFFF
    print(f"{f_out} Hz: M = {M}, প্রথম ৮টি ঘর {idx}")
print(f"সবচেয়ে ছোট ধাপ = {FS / 2 ** 32 * 1e6:.2f} µHz")

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

sine[ 0..]: 2048 2447 2831 3185 3495 3750 3939 4056
sine[ 8..]: 4095 4056 3939 3750 3495 3185 2831 2447
sine[16..]: 2048 1649 1265 911 601 346 157 40
sine[24..]: 1 40 157 346 601 911 1265 1649
গোল করার সর্বোচ্চ ভুল = 0.448 LSB
1000 Hz: M = 134217728, প্রথম ৮টি ঘর [0, 1, 2, 3, 4, 5, 6, 7]
1250 Hz: M = 167772160, প্রথম ৮টি ঘর [0, 1, 2, 3, 5, 6, 7, 8]
2000 Hz: M = 268435456, প্রথম ৮টি ঘর [0, 2, 4, 6, 8, 10, 12, 14]
সবচেয়ে ছোট ধাপ = 7.45 µHz

Table-এর গোল করার ভুল ½ LSB-এর নিচে (0.448), যেমন হওয়ার কথা। খেয়াল করুন চূড়া 4095 আর তলা 1, প্রতিসম। দ্বিতীয় অংশ DDS (direct digital synthesis): একটি ৩২ বিটের phase accumulator প্রতি sample-এ tuning word M যোগ করে, আর তার ওপরের ৫ বিট table-এর ঘর বাছে। M = 227 হলে প্রতি sample-এ ঠিক এক ঘর, 1 kHz; দ্বিগুণ M হলে প্রতি sample-এ দুই ঘর, 2 kHz. 1250 Hz-এ ঘর এগোয় সোয়া এক করে, তাই মাঝে মাঝে একটি ঘর বাদ পড়ে (4-এর ঘর নেই), কিন্তু গড় হার ঠিক থাকে। Frequency-র সবচেয়ে ছোট ধাপ fs ÷ 232 = 7.45 µHz, অর্থাৎ timer না বদলেই কার্যত যেকোনো সুর।

Board-এ সত্যিকারের run — integer-এ বানানো table আর একটি ৪ বিটের ladder

Cortex-M3-এ FPU নেই, আর sin() soft-float-এ ধীর (পর্ব ৪০-এ মাপা). আমার lab-এর dac_sine.c table বানায় পুরোপুরি integer-এ: কোণ Q30-এ (230 = 1.0), sin x-এর Taylor ধারা Horner রূপে, x9 পর্যন্ত, শুধু 0 থেকে π/2-এর ৯টি বিন্দুতে; বাকি তিন চতুর্থাংশ প্রতিসাম্য থেকে। x2 π/2-এ প্রায় 2.47, যা Q30-এর ৩২ বিটের সীমা (প্রায় 2.0) ছাড়ায়, তাই গুণ ৬৪ বিটে। প্রথম চেষ্টায় আমি সেটি ৩২ বিটে রেখেছিলাম, আর চূড়ার ঘরে 4095-এর বদলে এসেছিল 63498: fixed-point-এর overflow ঠিক যেমন পর্ব ৪০ সাবধান করে।

#define ONE    (1 << 30)               /* 1.0 in Q30 */
#define HALFPI 1686629713              /* pi/2 * 2^30 */
static int64_t mulq(int64_t a, int64_t b) { return (a * b) >> 30; }

static int32_t sin_q30(uint32_t k)      /* sin(k * pi/16), k = 0..8 */
{
    int64_t x = ((int64_t)HALFPI * k) / 8;  /* angle in Q30 */
    int64_t x2 = mulq(x, x), t = ONE;       /* x^2 up to 2.47: needs 64 bits */
    t = ONE - mulq(x2, t) / 72;        /* Horner: 1 - x^2/(8*9) ... */
    t = ONE - mulq(x2, t) / 42;
    t = ONE - mulq(x2, t) / 20;
    t = ONE - mulq(x2, t) / 6;
    return (int32_t)mulq(x, t);
}
void SysTick_Handler(void)             /* প্রতি 31.25 us (LOAD = 249) */
{
    if (idx >= N) return;
    uint32_t c4 = sine[idx] >> 8;                    /* ওপরের ৪ বিট */
    GPIOA->BSRR = (c4 << 8) | ((~c4 & 0xFu) << 24);  /* PA8..PA11, এক write */
    idx++;
}

main প্রথমে table বানিয়ে UART-এ ছাপে, তারপর PA8–PA11-কে output করে SysTick চালু করে। প্রতি tick-এ ISR table-এর ১২ বিটের মানের ওপরের ৪ বিট একটি BSRR write-এ চার pin-এ বসায়; বাইরে একটি ৪ বিটের R-2R ladder ধরা হলে সেটিই DAC. ঠিক ৩২টি sample, একটি period, তারপর থামা:

সত্যিকারের run — board.py run build/dac_sine.elf (BG-M3, Clang 22.1.8 -O2)
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.3503 ms] UART: sine[0..]: 2048 2447 2831 3185 3495 3750 3939 4056
[     0.4784 ms] UART: sine[8..]: 4095 4056 3939 3750 3495 3185 2831 2447
[     0.5934 ms] UART: sine[16..]: 2048 1649 1265 911 601 346 157 40
[     0.7015 ms] UART: sine[24..]: 1 40 157 346 601 911 1265 1649
[     0.7372 ms] GPIO PA11 = 1
[     0.7685 ms] GPIO PA8 = 1
[     0.7997 ms] GPIO PA9 = 1
[     0.8310 ms] GPIO PA8 = 0
[     0.8310 ms] GPIO PA9 = 0
[     0.8310 ms] GPIO PA10 = 1
...  (মোট ৩৮টি GPIO লাইন)
[     1.7060 ms] GPIO PA9 = 1
[     1.7289 ms] UART: one period sent: 32 samples
[     1.7296 ms] exit(0) after 13837 cycles

Board-এর integer table Python-এর float table-এর সঙ্গে ৩২টি ঘরেই হুবহু মিলেছে (০ code পার্থক্য)। GPIO লাইনগুলো থেকে আমার lab-এর parse_run.py প্রতি tick-এর ৪ বিটের code আবার জোড়া দিয়েছে আর আগের nodal solver দিয়ে ladder-এর voltage হিসাব করেছে (Vref = 3.3 V); voltage-গুলো board-এর নয়, মডেলের, কারণ board-এ analog অংশ নেই। কয়েকটি মুহূর্ত:

Tick-এর পরে
Sample (সময়)
Table (১২ বিট)
ওপরের ৪ বিট
Board-এর GPIO লাইন
Ladder-এর Vout
  1. প্রথম sample, মাঝখান। 2048 >> 8 = 8 = 1000: শুধু MSB, PA11. Ladder-এ 8 ÷ 16 × 3.3 = 1.65 V, ঠিক অর্ধেক Vref.
  2. k = 2. 2831 >> 8 = 11 = 1011, ছবি ৪৮.১-এর সেই code: 2.26875 V. আগের sample-এ ছিল 1001, তাই শুধু PA9 বদলেছে।
  3. তিন pin একসাথে। 1011 → 1100: তিনটি বিট উল্টায়। Board তিনটি লাইন ছাপে, কিন্তু একই সময়ে (0.8310 ms), কারণ ISR একটিই BSRR write করেছে। দুটি write হলে মাঝে একটি ভুল code দেখা দিত: glitch.
  4. চূড়ায় চ্যাপ্টা। 3939 থেকে 4095 পর্যন্ত পাঁচটি মানের ওপরের ৪ বিট একই 15, তাই পাঁচ tick কোনো GPIO লাইন নেই। ৪ বিটে মাত্র ১৬টি ধাপ, তাই sine-এর চূড়া একটি সমতল তাক: quantization-এর ফল।
  5. মাঝখান পেরোনো। k = 16-এ 1000, k = 17-এ 1649 >> 8 = 6 = 0110: তিনটি বিট একসাথে উল্টায়, আর ৭ (0111) বাদ পড়ে যায়, কারণ 2048 − 399 = 1649 এক লাফে দুই ধাপ নামে।
  6. তলায় পাঁচ tick শূন্য। 157 থেকে 1 পর্যন্ত সব 0000. লক্ষ্য করুন চূড়ায় 15 (3.09375 V), তলায় 0: ওপরের ৪ বিট নেওয়া মানে truncate করা, আর ৩২টি code-এর গড় 7.53, আদর্শ 8.0 নয়। গোল করে নিলে (code + 128) >> 8, 15-এ আটকে, গড় 7.91 হয়। পুরো ৩২ sample 1 ms-এ: 1 kHz-এর সুর।

ISR কত ছোট, তাও দেখা দরকার, কারণ প্রতি 31.25 µs-এ, প্রতি সেকেন্ডে ৩২,০০০ বার এটি চলে। Clang 22.1.8-এর -O2 -S output-এ পুরো handler ২১টি Thumb নির্দেশ: index পড়া, সীমা দেখা, table থেকে একটি ldrb (১৬ বিটের মানের ওপরের byte, যা compiler নিজেই >> 8-এর বদলে বেছেছে, কারণ মান 4095-এর বেশি নয়), bfi আর eor দিয়ে set আর reset বিট, তারপর একটি str ঠিকানা 0x40010810-এ, যা board-এর GPIOA BSRR. আসল chip-এ এমন ঘন ISR-এর বদলে timer-এর trigger আর DMA ব্যবহার করা হয় (অংশ ৬ আর ভাবনার প্রশ্ন ৫); পর্ব ৪৩-এর latency আর jitter এখানে সরাসরি সুরের বিকৃতি।

Table কোথায় থাকবে, সেটিও একটি নকশার পছন্দ। dac_sine.c table চালু হওয়ার সময় হিসাব করে SRAM-এ রাখে: ৩২ × ২ = ৬৪ byte RAM, আর boot-এ অল্প কিছু হিসাবের সময়। বিকল্প হলো host-এ Python দিয়ে মানগুলো বানিয়ে static const uint16_t হিসেবে flash-এ রাখা: RAM লাগে না, boot-এ কোনো হিসাব নেই, কিন্তু table বদলাতে আবার build. ছোট table-এ দুটিই চলে; ১০২৪ ঘরের table-এ (২ KiB) flash প্রায় সবসময় ভালো, কারণ ছোট MCU-তে RAM বেশি দামি সম্পদ (পর্ব ৩৯).

৫ · PWM + RC filter — DAC ছাড়া DAC

বেশিরভাগ microcontroller-এ DAC নেই, কিন্তু প্রায় সবগুলোতে timer-এর PWM আছে। একটি pin খুব দ্রুত চালু-বন্ধ করলে তার গড় voltage = duty cycle × VDD. একটি RC low-pass filter সেই গড়টুকু রেখে দ্রুত ওঠানামা প্রায় মুছে দেয়। PWM-এর timer, duty আর LED-এর উদাহরণ পর্ব ৪৫-এ; এখানে প্রশ্নটি DAC হিসেবে: কত বিট, কত ripple, কত দ্রুত।

প্রথম টানাটানি resolution আর frequency-র মধ্যে। n বিটের PWM মানে timer-এর counter 2n ঘর গোনে এক period-এ, তাই fPWM = fclk ÷ 2n. বাজারঘর board-এর 8 MHz clock-এ ৮ বিটে 31.25 kHz, ১২ বিটে মাত্র 1953 Hz. দ্বিতীয় টানাটানি filter-এর মধ্যে: বড় time constant τ = RC ripple কমায়, কিন্তু নতুন মানে পৌঁছাতে দেরি করায়। এক ধাপের RC-তে duty D হলে steady-state ripple-এর সূত্র, আর T ≪ τ হলে তার সহজ রূপ:

PWM DAC-এর হিসাব

Ripple (p-p) = VDD (1 − e−DT/τ)(1 − e−(1−D)T/τ) ÷ (1 − e−T/τ) ≈ VDD × D(1 − D) × T ÷ τ; সবচেয়ে বেশি D = 0.5-এ
½ LSB-এর মধ্যে থিতু হওয়ার সময়: t ≈ τ × ln(2n+1)

# PWM + RC filter = সস্তা DAC: ripple আর settling-এর টানাটানি
import math
VDD, CLK = 3.3, 8_000_000                 # বাজারঘর board-এর 8 MHz
def ripple(D, T, tau):                    # একক RC-র steady-state ripple (p-p)
    a, b = math.exp(-D * T / tau), math.exp(-(1 - D) * T / tau)
    return VDD * (1 - a) * (1 - b) / (1 - math.exp(-T / tau))

R, C = 10_000, 100e-9                     # τ = 1 ms
tau = R * C
for bits in (8, 12):
    f = CLK / 2 ** bits                   # counter-এর এক পাক = এক period
    T = 1 / f
    lsb = VDD / 2 ** bits
    rp = ripple(0.5, T, tau)
    print(f"{bits} বিট: f_pwm = {f:.1f} Hz, 1 LSB = {lsb * 1000:.3f} mV,"
          f" ripple = {rp * 1000:.3f} mV = {rp / lsb:.2f} LSB")
    need = VDD * 0.25 * T / (lsb / 2)     # ripple ≤ ½ LSB হতে কত τ লাগে
    print(f"   settle (½ LSB): {tau * math.log(2 ** (bits + 1)) * 1000:.2f} ms;"
          f" ripple ½ LSB-এ নামাতে τ ≥ {need * 1000:.1f} ms")

# সময় ধরে ছোট ধাপে simulation: 8 বিট, duty 128/256, 0 V থেকে শুরু
T, steps, v = 1 / 31_250, 256, 0.0
dt = T / steps
for p in range(1, 301):
    lo, hi = 9.0, -9.0
    for n in range(steps):
        pin = VDD if n < 128 else 0.0
        v += (pin - v) * dt / tau
        lo, hi = min(lo, v), max(hi, v)
    if p in (1, 31, 62, 195, 300):
        print(f"period {p:3}: শেষে {v:.4f} V, ripple {1000 * (hi - lo):.3f} mV")

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

8 বিট: f_pwm = 31250.0 Hz, 1 LSB = 12.891 mV, ripple = 26.399 mV = 2.05 LSB
   settle (½ LSB): 6.24 ms; ripple ½ LSB-এ নামাতে τ ≥ 4.1 ms
12 বিট: f_pwm = 1953.1 Hz, 1 LSB = 0.806 mV, ripple = 420.108 mV = 521.44 LSB
   settle (½ LSB): 9.01 ms; ripple ½ LSB-এ নামাতে τ ≥ 1048.6 ms
period   1: শেষে 0.0516 V, ripple 51.971 mV
period  31: শেষে 1.0299 V, ripple 36.063 mV
period  62: শেষে 1.4117 V, ripple 29.853 mV
period 195: শেষে 1.6336 V, ripple 26.350 mV
period 300: শেষে 1.6367 V, ripple 26.399 mV

৮ বিটে 10 kΩ আর 100 nF-এ ripple 26.4 mV, প্রায় দুই LSB: ৮ বিটের দাবি পুরো রাখা যায়নি। Ripple ½ LSB-এ নামাতে τ ≥ 4.1 ms লাগে, তখন থিতু হতে প্রায় 4.1 × ln 512 ≈ 25.6 ms. ১২ বিটে ছবিটি আরও খারাপ: PWM ধীর বলে একই filter-এ ripple 420 mV, আর ½ LSB-এর জন্য τ প্রায় এক সেকেন্ড, থিতু হতে প্রায় ৯.৪৫ সেকেন্ড। ধাপে ধাপে simulation-এ ripple-এর মান সূত্রের সঙ্গে মিলেছে (26.399 mV). শেষের voltage 1.6367 V, 1.65 নয়, কারণ প্রতিটি period-এর শেষে, অর্থাৎ নিচু অংশের শেষে মাপা হয়েছে: গড় 1.65 V, তার নিচে ripple-এর অর্ধেক।

Period-এর শেষে
Period (সময়)
সময় ÷ τ
Capacitor-এর voltage
এই period-এর ripple
অবস্থা
  1. প্রথম period. Capacitor খালি, pin 16 µs উঁচু, 16 µs নিচু। প্রায় সরলরেখায় ওঠে: শেষে মাত্র 0.0516 V. এ সময়ে ripple বড় (52 mV), কারণ capacitor-এর voltage নিচে থাকায় চার্জের current বেশি।
  2. এক τ পরে। ৩১টি period = 0.992 ms. গড় voltage লক্ষ্যের প্রায় ৬৩%-এ, যা RC-র পরিচিত নিয়ম (পর্ব ৪২-এর RC debounce-এ একই τ).
  3. দুই τ পরে। প্রায় ৮৬%. Ripple কমছে, কারণ capacitor-এর voltage মাঝখানের কাছে এলে উঁচু আর নিচু অংশের current সমান হতে থাকে।
  4. ৬.২৪ τ, ½ LSB. τ × ln 512 = 6.24 ms: স্থির মানের ½ LSB (6.45 mV)-এর মধ্যে। ৮ বিটের DAC-এর নতুন মান “পৌঁছেছে” বলার এটিই সময়।
  5. স্থির অবস্থা। Ripple 26.399 mV, সূত্রের সঙ্গে হুবহু, আর 2.05 LSB. অর্থাৎ settling 6 ms-এর বেশি, তবু ripple ৮ বিটের এক ধাপের দ্বিগুণ: একক RC-তে দুটি একসাথে ভালো হয় না।

নকশার উদাহরণ — contrast-এর PWM DAC: বাজারঘরের BG-M3-এ ৮ বিটের PWM (31.25 kHz), R = 10 kΩ. Ripple ½ LSB-এর মধ্যে রাখতে C কত?

  1. ½ LSB = 3.3 V ÷ 256 ÷ 2 = 6.445 mV.
  2. সবচেয়ে খারাপ D = 0.5-এ ripple ≈ 3.3 × 0.25 × 32 µs ÷ τ ≤ 6.445 mV, তাই τ ≥ 4.1 ms, C ≥ 410 nF.
  3. প্রচলিত মান 470 nF নিলে τ = 4.7 ms, ripple = 5.62 mV (সূত্রের নির্ভুল রূপেও 5.62 mV).
  4. থিতু হওয়া ≈ 4.7 ms × ln 512 = 29.3 ms. Contrast-এর বোতাম চাপার পরে ৩০ ms-এর দেরি চোখে পড়ে না: নকশা চলবে।

সমাধানের পথ কয়েকটি। PWM-এর frequency বাড়ানো (দ্রুত timer clock; অনেক STM32-এ timer 72 MHz-এ চলতে পারে). দুই ধাপের RC বা একটি op-amp-এর active filter, যা ripple অনেক দ্রুত কমায় কিন্তু settling তত ধীর করে না। আর বুদ্ধির কৌশল: দুটি PWM pin, একটি ওপরের বিটের জন্য আর একটি নিচের বিটের জন্য, বাইরে 1 : 256 অনুপাতের resistor দিয়ে যোগ। তবু PWM DAC মূলত ধীরে বদলানো মানের জন্য: একটি contrast voltage, একটি LED-এর মাত্রা, একটি set-point. 1 kHz-এর সুরের মতো দ্রুত বদলানো সংকেতে (অংশ ৪) ৮ বিটের 31.25 kHz PWM কোনোমতে চলে, কারণ filter-কে একই সঙ্গে 1 kHz পার হতে দিতে আর 31.25 kHz আটকাতে হয়।

৬ · বাজারঘরে DAC — alarm-এর সুরের মাত্রা আর display contrast

এবার দুটি কাজ নকশা করুন, একটি কাল্পনিক উন্নত বাজারঘর board-এর জন্য যার একটি ১২ বিটের DAC আছে (STM32F1 high-density-এর মতো), আর একটি আজকের BG-M3-এর জন্য।

Alarm-এর সুরের মাত্রা। Cold room-এর alarm চালু হলে 1 kHz-এর sine বাজবে, আর মাত্রা তিন স্তরে: L = 4 (পুরো), 2 (অর্ধেক), 1 (এক চতুর্থাংশ). Table একটিই; প্রতিটি sample-এ মাঝখান থেকে দূরত্ব L ÷ 4 দিয়ে গুণ: code = 2048 + (table[i] − 2048) × L ÷ 4, signed integer-এ। L = 2-এ চূড়া 2048 + 2047 × 2 ÷ 4 = 2048 + 1023 = 3071, তলা 1025 (C-এর ভাগ শূন্যের দিকে কাটে, তাই দুই দিক প্রতিসম)। Amplitude অর্ধেক মানে শব্দের চাপ অর্ধেক, প্রায় 6 dB কম। মাত্রা বদলাতে হলে period-এর শুরুতে, অর্থাৎ code 2048-এর ঘরে বদলানো ভালো, তাহলে হঠাৎ লাফে “ক্লিক” শব্দ হয় না। Speaker বা piezo buzzer সরাসরি DAC pin-এ নয়: একটি amplifier লাগবে, কারণ DAC-এর buffer কয়েক kΩ-এর load-এর জন্য বানানো।

Display contrast. ধরা যাক scale-এর LCD মডিউলের contrast pin-এ প্রায় 0.9 V দরকার (মান মডিউল-ভেদে আলাদা; মডিউলের datasheet দেখুন)। ১২ বিট আর Vref = 3.3 V-এ code = round(0.9 ÷ 3.3 × 4096) = round(1117.09) = 1117, যা দেয় 1117 × 3.3 ÷ 4096 = 0.89993 V. দোকানে আলো বদলালে firmware একটি বোতামে contrast এক ধাপ করে বদলাতে পারে, potentiometer ছাড়াই। Contrast খুব ধীরে বদলায়, তাই এখানে PWM + RC যথেষ্ট, এমনকি BG-M3-এর মতো DAC-হীন chip-এও।

পদ্ধতিভালোদুর্বলতাবাজারঘরে
On-chip DAC (যেমন STM32F1 high-density)১২ বিট, কয়েক µs-এ থিতু, timer trigger আর DMAসব chip-এ নেই; buffer-এর load সীমিতAlarm-এর sine সুর
GPIO + R-2R ladderযেকোনো MCU-তে, দ্রুত, সরলঅনেক pin; resistor-এর মিলে ৬–৮ বিটের সীমাশেখার জন্য, কম বিটের সুর
PWM + RCএকটি pin, প্রায় বিনা খরচেRipple আর settling-এর টানাটানি, ধীরDisplay contrast
বাইরের I2C/SPI DAC chipউঁচু resolution, নিজের VrefBus-এর সময় (পর্ব ৫০, ৫১), আরেকটি অংশনির্ভুল set-point দরকার হলে

আরও গভীরে: উচ্চ-গতির DAC-এ glitch কমাতে ওপরের কয়েকটি বিট প্রায়ই binary নয়, “thermometer” code-এ চালানো হয়: ওপরের ৩ বিটের জন্য ৭টি সমান current উৎস, যার মধ্যে code অনুযায়ী তত সংখ্যক চালু। তখন major carry-তে একটি উৎস যোগ হয়, সব উল্টায় না; এই মিশ্র নকশার নাম segmented DAC. আরেকটি পরিবার resistor string (Kelvin divider) DAC: 2nটি সমান resistor-এর একটি সারি আর একটি switch দিয়ে বেছে নেওয়া tap, যা গঠনগতভাবেই monotonic, কারণ সারির ওপরের tap কখনো নিচেরটির চেয়ে কম হতে পারে না। অডিওর বহু DAC আবার delta-sigma: খুব দ্রুত ১ বা কয়েক বিটের ধারা, পরে filter, যা PWM DAC-এর ধারণার উন্নত রূপ।

পরীক্ষা ও ইন্টারভিউতে: “৮ বিটের DAC, Vref = 5 V, resolution কত?” → 5 ÷ 256 = 19.53 mV. “R-2R-এর সুবিধা?” → মাত্র দুই মানের resistor, output resistance সব code-এ R, যত বিট দরকার সহজে বাড়ানো যায়। “Binary-weighted DAC-এর সমস্যা?” → resistor-এর পরিসর 2n−1 গুণ, মেলানো কঠিন। “Monotonic মানে?” → code বাড়লে output কখনো কমে না; DNL > −1 LSB. “৩২ ঘরের table, 32 kHz sample rate, output frequency?” → 32000 ÷ 32 = 1 kHz.

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

AI assistant-এর কাছে STM32-এ DAC দিয়ে sine সুর বাজানোর কোড চাইলে সাধারণত চলনসই কোড আসে, কিন্তু DAC-এর ভুলগুলো কম্পাইলে ধরা পড়ে না: ভুল chip-এ DAC ধরে নেওয়া, ভুল সূত্র, বা সময় ভুল। পরিচিত ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
DAC নেই এমন chip-এর জন্য DAC-এর register আর pin দেয় (যেমন medium-density STM32F103)Chip-এর datasheet-এর peripheral তালিকা আর reference manual-এর অধ্যায়ের “কোন device-এ প্রযোজ্য” লাইন
Vref ÷ 2n আর Vref ÷ (2n − 1) মিশিয়ে ফেলে, বা code 4096 লেখেRM-এর সূত্র দেখা; full scale-এ হাতে হিসাব; code-এ clamp
Sample-এর ISR-এ sin(), printf বা float হিসাবTable আগে থেকে; ISR-এর নির্দেশ -S-এ গোনা; timer trigger আর DMA
GPIO ladder দুটি write-এ বদলায়, বা index volatile ছাড়াএকটি BSRR write; ISR আর main-এর ভাগ করা variable-এর তালিকা (পর্ব ৩৪, ৪৩)
PWM DAC-এর RC উৎস ছাড়া বেছে দেয়, ripple আর settling না দেখেএই পর্বের সূত্র বা simulation-এ ripple LSB-এ মাপা
Settling time, DNL বা update rate-এর সংখ্যা উৎস ছাড়া দেয়Datasheet-এর electrical characteristics টেবিল, শর্তসহ (load, supply)

প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:

আমি একটি Cortex-M3 chip-এ (FPU নেই) bare-metal C-তে একটি 1 kHz sine সুর বানাতে চাই, ১২ বিটের DAC আর 32 kHz sample rate দিয়ে। ১. প্রথমে বলো, আমি যে chip-এর নাম দেব তাতে আসলে DAC আছে কি না, আর reference manual-এর কোন অধ্যায়ে তা লেখা। নিশ্চিত না হলে স্পষ্ট বলো। ২. ৩২ ঘরের sine table integer বা fixed-point-এ বানাও, runtime-এ float ছাড়া; মাঝখান 2048, চূড়া 4095-এর বেশি নয়। Table-এর মান Python-এ যাচাই করার একটি ছোট script-ও দাও। ৩. Sample লেখা timer trigger আর DMA দিয়ে করো; ISR ব্যবহার করলে তাতে কোনো sin(), printf বা অপেক্ষা রাখবে না। ৪. মাত্রা কয়েক স্তরে বদলানোর কোড দাও, period-এর শুরুতে বদল যাতে ক্লিক না হয়। ৫. যেকোনো register-এর নাম, ঠিকানা, settling time বা update rate দিলে উৎস (datasheet বা reference manual-এর টেবিল) বলো।

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

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

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

প্র ০১R-2R ladder-এ মাত্র দুই মানের resistor, তবু ১৬ বিটের নির্ভুল DAC বানানো কঠিন কেন? Chip-এর ভেতরে নির্মাতারা কী করেন?

R-2R-এর সৌন্দর্য হলো এর নিয়ম শুধু অনুপাতের ওপর নির্ভর করে: প্রতিটি 2R ঠিক দুটি R-এর সমান হলেই প্রতিটি node-এ ঠিক অর্ধেক হয়। কোনো resistor-এর পরম মান (10 kΩ না 12 kΩ) ভুল হলে ক্ষতি নেই, যদি সব একসাথে ভুল হয়। এজন্য একই silicon-এ, একই উপাদানে, পাশাপাশি বানানো resistor-এর অনুপাত তাদের পরম মানের চেয়ে অনেক ভালো মেলে। কিন্তু অনুপাতের প্রয়োজনও বিট-প্রতি দ্বিগুণ কঠিন হয়। অংশ ৩-এর হিসাবে ৮ বিটে MSB-এর resistor-এ ১% ভুলেই DAC non-monotonic হয়েছে; ½ LSB-এর মধ্যে থাকতে MSB-এর আপেক্ষিক ভুল 1 ÷ 2n-এর ঘরে লাগে। ১৬ বিটে তা 1 ÷ 65536, প্রায় ০.০০১৫%: সাধারণ উৎপাদনে কোনো resistor এত মেলে না।

নির্মাতারা তাই কয়েকটি কৌশল মেশান। এক, trimming: উৎপাদনের পরে পরীক্ষা করে laser দিয়ে thin-film resistor-এর একটু অংশ কেটে মান ঠিক করা, বা chip-এর ভেতরের fuse বা memory-তে সংশোধনের মান লেখা। দুই, segmentation (আরও গভীরে বাক্সে): ওপরের বিটগুলো thermometer code-এ সমান উৎস দিয়ে, যাতে বড় ধাপগুলো একক বড় resistor-এর ওপর নির্ভর না করে। তিন, পুরো ভিন্ন পথ: delta-sigma, যেখানে নির্ভুলতা আসে সময় থেকে, resistor থেকে নয়। একটি ১ বিটের output শুধু দুটি মান নেয়, তাই তা গঠনগতভাবেই linear, আর resolution আসে খুব দ্রুত sampling আর digital filter থেকে।

এমবেডেড প্রকৌশলীর জন্য শিক্ষাটি ব্যবহারিক: datasheet-এ “16-bit” লেখা মানে 65536টি code নেয়, কিন্তু INL, DNL, offset আর gain error-এর টেবিলই বলে কতটা সঠিক। আর পুরো ব্যবস্থার নির্ভুলতা DAC-এর একার নয়: Vref-এর তাপমাত্রায় বদল, PCB-র ground-এর noise আর output-এর load মিলেই ঠিক করে আপনি কত বিট আসলে পাচ্ছেন। বাজারঘরের alarm-এর সুরে ৮ বিটই যথেষ্ট; একটি ওষুধ মেশানোর যন্ত্রের set-point-এ হয়তো ১৬ বিট লাগে, আর তখন DAC বাছাইয়ের সঙ্গে Vref আর layout-ও সমান জরুরি।

মূল উপলব্ধি: R-2R অনুপাতের ওপর দাঁড়ায়, আর প্রতি বিটে অনুপাতের দাবি দ্বিগুণ কঠিন; উঁচু resolution-এ নির্ভুলতা আসে trimming, segmentation বা সময়-ভিত্তিক delta-sigma থেকে।

প্র ০২Compact Disc-এর যুগে অডিও DAC কীভাবে বদলেছে, আর PWM + RC DAC-এর সঙ্গে সেই ইতিহাসের সম্পর্ক কী?

Compact Disc ১৯৮২ সালে বাজারে আসে, Philips আর Sony-র যৌথ মানে: ১৬ বিটের sample, প্রতি সেকেন্ডে 44100টি। প্রতিটি sample বাজাতে একটি DAC লাগে, আর ১৬ বিটের নির্ভুল ladder তখন খুব কঠিন ছিল (প্রশ্ন ১-এর কারণে)। প্রচলিত বর্ণনা অনুযায়ী Philips-এর প্রথম দিকের player-এ একটি ১৪ বিটের DAC ব্যবহার হতো, আর চার গুণ oversampling-এর একটি digital filter দিয়ে বাড়তি resolution আদায় করা হতো: sample-গুলোর মাঝে digital-ভাবে নতুন sample বসিয়ে দ্রুত হারে বাজানো, যাতে quantization-এর noise বড় frequency পরিসরে ছড়িয়ে যায় আর শোনার পরিসরে কম থাকে। পরে ১৯৮০-র দশকের শেষ দিক থেকে ১ বিটের বা কয়েক বিটের delta-sigma ধরনের DAC অডিওতে ছড়ায়, যেখানে খুব দ্রুত হারের একটি সরু ধারা পরে analog filter-এ মসৃণ হয়।

এই পর্বের PWM + RC DAC একই নীতির সবচেয়ে সরল রূপ: amplitude-এর resolution-এর বদলে সময়ের resolution. একটি pin শুধু 0 আর 3.3 V জানে, কিন্তু কতক্ষণ উঁচু থাকবে তা খুব সূক্ষ্মভাবে ঠিক করা যায়, আর RC filter সেই সময়কে voltage-এ বদলায়। পার্থক্য হলো noise কোথায় যায়। সাধারণ PWM-এ সব ripple PWM-এর frequency আর তার গুণিতকে জমা হয়, তাই 31.25 kHz-এর ৮ বিটের PWM-এ filter-কে একসাথে সুর পার হতে দিতে আর ripple আটকাতে হয় (অংশ ৫-এর টানাটানি)। Delta-sigma modulator noise-কে বুদ্ধি করে উঁচু frequency-তে ঠেলে দেয় (noise shaping), যাতে সরল filter-ও অনেক বিটের সমান ফল দেয়।

Microcontroller-এর জগতেও এর ছায়া আছে। কিছু MCU-র ভেতরের DAC আসলে delta-sigma বা PWM-ভিত্তিক, আর অনেক সস্তা অডিও প্রকল্প PWM pin থেকে সুর বাজায়। কোনটি বেছে নেবেন তা ঠিক করে প্রয়োজন: একটি alarm-এর সুরে কান খুব ক্ষমাশীল, সঙ্গীতে নয়। সংখ্যা দিয়ে ভাবুন: কত বিট দরকার, কোন frequency পরিসরে, আর সেই পরিসরে ripple বা noise কত, তারপর পদ্ধতি বাছুন।

মূল উপলব্ধি: নির্ভুল resistor-এর বদলে দ্রুত সময় ব্যবহার করা, oversampling আর delta-sigma-র মূল ধারণা; PWM + RC DAC তার সরল চাচাতো ভাই, আর দুই জগতেই filter আর noise কোথায় যায়, তা-ই আসল প্রশ্ন।

প্র ০৩৩২টি sample-এর সিঁড়িকে আমরা “sine” বলছি। Output-এ আসলে কোন কোন frequency আছে, আর একটি reconstruction filter কেন লাগে?

DAC প্রতিটি sample-এর মান পরের sample পর্যন্ত ধরে রাখে, তাই output একটি সিঁড়ি; এর নাম zero-order hold. সিঁড়ির ধারালো কিনারায় উঁচু frequency থাকে। Sampling-এর তত্ত্ব (Nyquist-এর ১৯২৮ সালের কাজ আর Shannon-এর ১৯৪৯ সালের প্রবন্ধের সঙ্গে সাধারণত যুক্ত) বলে, fs হারে বানানো একটি fout সুরের output-এ মূল সুর ছাড়াও fs − fout, fs + fout, 2fs ± fout … frequency-তে প্রতিচ্ছবি (image) থাকে। এই পর্বের উদাহরণে 32 kHz আর 1 kHz: প্রথম প্রতিচ্ছবি 31 kHz আর 33 kHz. মানুষের কান সাধারণত প্রায় 20 kHz-এর ওপরে শোনে না, আর piezo buzzer-ও হয়তো সাড়া দেয় না, তাই এখানে ক্ষতি কম; কিন্তু অন্য যন্ত্রে এই প্রতিচ্ছবি সমস্যা করে।

ADC-র দিকে একই তত্ত্ব aliasing হিসেবে আসে (পর্ব ৪৭): fs-এর অর্ধেকের ওপরের সংকেত নিচে ভাঁজ হয়ে মিশে যায়। DAC-এর দিকে তাই একটি নিয়ম: fout fs ÷ 2-এর নিচে, এখানে 16 kHz-এর নিচে, আর বাস্তবে আরও অনেক নিচে, কারণ মূল সুর আর প্রথম প্রতিচ্ছবির মাঝে filter-এর জায়গা লাগে। DDS-এ M বাড়িয়ে 15 kHz চাইলে table-এর ঘর প্রতি sample-এ প্রায় ১৫টি করে লাফাবে, আর output প্রায় চিনতে পারা যাবে না, যদিও গণিতে তথ্য সব আছে।

Reconstruction filter হলো DAC-এর পরের low-pass filter, যা প্রতিচ্ছবিগুলো কমিয়ে সিঁড়িকে মসৃণ করে। একটি সূক্ষ্ম কথা: zero-order hold নিজেও মূল সুরকে একটু দুর্বল করে, fs-এর কাছে গেলে বেশি (sinc আকারের droop); উচ্চ-মানের যন্ত্রে digital filter আগেভাগে এটি পুষিয়ে দেয়। বাজারঘরের alarm-এ সরল পথ: table-এর ঘর বাড়ানো বা sample rate বাড়ানো, যাতে প্রতিচ্ছবি অনেক দূরে সরে যায়, আর একটি RC বা amplifier-এর নিজের সীমিত bandwidth বাকিটা সামলায়।

মূল উপলব্ধি: DAC-এর সিঁড়িতে মূল সুরের সঙ্গে fs-এর চারপাশে প্রতিচ্ছবি থাকে; fout-কে fs ÷ 2-এর অনেক নিচে রাখা আর একটি reconstruction filter, এই দুইয়ে পরিষ্কার waveform.

প্র ০৪DDS-এর phase accumulator কেন এত জনপ্রিয়? বাজারঘরের alarm-এ উঠানামা করা সাইরেনের মতো সুর বানাতে এটি কী সুবিধা দেয়?

Direct digital synthesis-এর ধারণা সাধারণত ১৯৭১ সালের Tierney, Rader আর Gold-এর “A Digital Frequency Synthesizer” প্রবন্ধের সঙ্গে যুক্ত বলে বর্ণনা করা হয়। মূল যন্ত্র তিনটি: একটি phase accumulator (একটি বড় counter যা প্রতি clock-এ M যোগ করে আর স্বাভাবিকভাবে wrap করে), একটি phase-থেকে-amplitude table, আর একটি DAC. আজ এটি signal generator, radio-র synthesizer আর অনেক বিশেষ chip-এ ব্যবহার হয়।

এর তিনটি সুবিধা এই পর্বের সংখ্যায় দেখা যায়। এক, সূক্ষ্মতা: ৩২ বিটের accumulator আর 32 kHz-এ frequency-র ধাপ 7.45 µHz; timer-এর reload বদলে frequency বদলালে ধাপ হতো মোটা আর অসমান। দুই, phase-এর ধারাবাহিকতা: M বদলালে accumulator যেখানে ছিল সেখান থেকেই চলতে থাকে, তাই waveform-এ কোনো লাফ বা ক্লিক নেই। সাইরেনের সুর, 800 Hz থেকে 1600 Hz পর্যন্ত মসৃণভাবে উঠে আবার নামা, শুধু প্রতি কয়েক ms-এ M একটু বদলেই হয়। তিন, একই table আর একই sample rate-এ যেকোনো frequency: 1250 Hz-এর মতো “অসুবিধাজনক” মানেও, যেখানে table-এর ঘর মাঝে মাঝে বাদ পড়ে কিন্তু গড় হার নিখুঁত।

দাম আছে। ঘর বাদ পড়া বা পুনরাবৃত্তি মানে phase-এর একটি ছোট truncation ভুল, যা output-এ অবাঞ্ছিত spur দেয়; বড় table বা দুই ঘরের মাঝে interpolation এটি কমায়। প্রতি sample-এ একটি যোগ, একটি shift আর একটি table পড়া: Cortex-M3-এ কয়েকটি নির্দেশ, ISR-এ বা DMA-র double buffer ভরাতে (পর্ব ৪৬) সহজে আঁটে। আর একটি নিরাপত্তার দিক: alarm-এর সুর নিজেই জীবন-রক্ষাকারী বার্তা, তাই সুর বানানোর কোড এমন হতে হবে যা কখনো আটকে না যায়; সুরের পাশাপাশি PA6-এর সাধারণ on/off alarm রাখা একটি ভালো ব্যাকআপ।

মূল উপলব্ধি: DDS frequency-কে একটি যোগের সংখ্যা বানিয়ে দেয়: সূক্ষ্ম ধাপ, লাফহীন বদল আর একই table-এ যেকোনো সুর, সবই কয়েকটি integer নির্দেশে।

প্র ০৫Sample-গুলো ISR দিয়ে DAC-এ লিখলে আর timer trigger ও DMA দিয়ে লিখলে, সুরের মানে কী পার্থক্য হয়? Jitter-কে এখানে কীভাবে ভাববেন?

Waveform-এর প্রতিটি sample একটি নির্দিষ্ট মুহূর্তের জন্য। ISR দিয়ে লিখলে আসল লেখার মুহূর্ত = timer-এর tick + interrupt latency, আর পর্ব ৪৩-এ দেখেছেন latency স্থির নয়: অন্য সমান বা বেশি জরুরি ISR চললে বা critical section থাকলে দেরি বাড়ে। এই ওঠানামা, jitter, sample-কে ভুল সময়ে বসায়, যা মূল সুরের ওপর noise আর অবাঞ্ছিত frequency হিসেবে আসে। সুর যত দ্রুত বদলায় (উঁচু frequency, বড় amplitude), সময়ের একই ভুলে voltage-এর ভুল তত বড়, কারণ ভুল ≈ ঢাল × সময়ের ভুল।

আসল chip-এর DAC এই সমস্যার জন্য নকশা করা। RM0008 অনুযায়ী STM32F1-এর DAC-কে একটি timer-এর TRGO দিয়ে trigger করা যায়: firmware আগেভাগে DHR register-এ পরের মান লিখে রাখে, আর hardware trigger-এর তিন APB1 clock পরে মানটি output-এ নেয়। Software-এর দেরি যাই হোক, output বদলের মুহূর্ত ঠিক করে timer, তাই jitter প্রায় শুধু clock-এর। DMA যুক্ত করলে CPU-র কাজই থাকে না: DMA প্রতি trigger-এ table থেকে পরের মান DHR-এ এনে দেয়, circular mode-এ table-এর শেষে আবার শুরু (পর্ব ৪৬). একটি সতর্কতাও RM-এ আছে: DAC-এর DMA request queue হয় না; আগেরটি স্বীকার হওয়ার আগে নতুন trigger এলে সেটি নীরবে বাদ পড়ে, তাই DMA-র bus অন্য কাজে খুব ব্যস্ত থাকলে sample হারাতে পারে (STM32-এর কিছু অংশে এর জন্য underrun flag আছে বলে বর্ণনা পাওয়া যায়; আপনার chip-এর manual দেখুন)।

কোর্সের board-এ এই পার্থক্য পুরো দেখা যায় না: এখানে প্রতিটি নির্দেশ এক cycle আর exception-এ প্রবেশ শূন্য cycle (Spec decision 17), আর ISR নিজের tick-এর সঙ্গে সঙ্গে চলেছে। তবু board-এর run একটি জিনিস দেখিয়েছে: পুরো sample ISR ২১টি নির্দেশ, তাই 31.25 µs-এর মধ্যে প্রচুর সময় বাকি। নকশার নিয়ম তাই: শেখার আর কম চাহিদার কাজে ছোট ISR চলে, কিন্তু সুরের মান জরুরি হলে hardware trigger, আর CPU-কে মুক্ত রাখতে DMA.

মূল উপলব্ধি: Waveform-এ সময়ও data; output বদলের মুহূর্ত software-এর latency থেকে মুক্ত করতে timer trigger, আর CPU-কে মুক্ত করতে DMA.

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর Python-এ, Clang-এ বা কোর্সের virtual board-এ চালিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — millivolt থেকে DAC code: ১২ বিটের একটি DAC, Vref = 3300 mV. একটি uint32_t dac_code_mv(uint32_t mv) লিখুন যা float ছাড়া সবচেয়ে কাছের code দেয়, আর 4095-এর বেশি কখনো নয়। তারপর বাজারঘরের LCD-র contrast-এর জন্য 900 mV-এর code আর তার আসল voltage বের করুন। 3300 mV দিলে কী হওয়া উচিত?
    #define VREF_MV 3300u
    uint32_t dac_code_mv(uint32_t mv)
    {
        if (mv >= VREF_MV) return 4095u;               /* full scale-এর ওপরে নয় */
        return (mv * 4096u + VREF_MV / 2u) / VREF_MV;  /* round half up */
    }

    900 mV: (900 × 4096 + 1650) ÷ 3300 = 3688050 ÷ 3300 = 1117 (integer ভাগ), যা round(1117.09)-এর সমান। আসল voltage 1117 × 3.3 ÷ 4096 = 0.89993 V. 3300 mV-এ সূত্র দিত 4096, যা ১২ বিটে আঁটে না (register-এ লিখলে ওপরের বিট কেটে 0 হয়ে যেতে পারে, সবচেয়ে খারাপ ভুল), তাই আগেই 4095-এ আটকানো। Overflow-এর হিসাবও দেখুন: mv < 3300 হলে mv × 4096 সর্বোচ্চ প্রায় 1.35 কোটি, ৩২ বিটে সহজে আঁটে। সংখ্যাগুলো Python-এ মেলানো।

  2. ভুল খুঁজুন — glitch-ভরা ladder: একজন বাজারঘরের alarm-এর জন্য PA8–PA11-এর R-2R ladder চালাতে ISR-এ লিখেছেন:
    void SysTick_Handler(void)
    {
        uint32_t c4 = sine[idx] >> 8;
        GPIOA->BRR  = 0xFu << 8;       /* আগে চার pin মোছা */
        GPIOA->BSRR = c4 << 8;         /* তারপর নতুন বিট বসানো */
        idx = (idx + 1u) % 32u;
    }
    সুর বাজে, কিন্তু একটি অদ্ভুত কর্কশ শব্দ মিশে থাকে। কোথায় ভুল, আর ঠিক রূপ কী?

    দুটি write-এর মাঝে চার pin সবগুলো 0: ladder-এর output প্রতিটি sample-এ এক মুহূর্তের জন্য 0 V-এ নামে, তারপর নতুন মানে ওঠে। মাঝখানের কাছে (1.65 V) প্রতি 31.25 µs-এ 1.65 V-এর একটি সরু নিচের দিকের কাঁটা: এটি software-এর বানানো glitch, যা 32 kHz আর তার গুণিতকে শক্তি যোগ করে, আর amplifier-এ বিকৃতি আনে। ঠিক রূপ একটি write, যেখানে set আর reset বিট একসাথে:

        GPIOA->BSRR = (c4 << 8) | ((~c4 & 0xFu) << 24);

    এটিই এই পর্বের dac_sine.c; board-এর run-এ k = 3-এ তিনটি pin-এর লাইন একই সময়ে (0.8310 ms) এসেছে, মাঝের কোনো অবস্থা ছাড়া। ODR-এ read-modify-write করলেও একটি write হয়, কিন্তু main আর ISR দুজনে একই port-এর অন্য pin বদলালে বদল হারাতে পারে (পর্ব ৩৫), তাই BSRR ভালো। আর একটি ছোট কথা: idx শুধু ISR-এ ব্যবহার হলে volatile লাগে না, main পড়লে লাগে।

  3. হিসাব — ১০ বিট আর ladder: (ক) একটি ১০ বিটের DAC, Vref = 2.5 V: 1 LSB, code 0x2A5-এর voltage আর full scale কত? (খ) ৪ বিটের R-2R ladder, Vref = 3.3 V, code 0110: প্রতি node-এ Thevenin voltage ধাপে ধাপে লিখুন।

    (ক) 1 LSB = 2.5 ÷ 1024 = 2.441 mV. 0x2A5 = 2 × 256 + 10 × 16 + 5 = 677, তাই Vout = 677 × 2.5 ÷ 1024 = 1.65283 V. Full scale = 1023 × 2.5 ÷ 1024 = 2.49756 V, অর্থাৎ Vref − 1 LSB. (খ) 0110 মানে b0 = 0, b1 = 1, b2 = 1, b3 = 0. N0: (0 + 0) ÷ 2 = 0 V. N1: (0 + 3.3) ÷ 2 = 1.65 V. N2: (1.65 + 3.3) ÷ 2 = 2.475 V. N3: (2.475 + 0) ÷ 2 = 1.2375 V = 6 ÷ 16 × 3.3 V. এটি board-এর run-এর k = 17-এর মান; অংশ ২-এর nodal solver-এ ladder(0b0110)-ও একই 1.2375 V দেয়।

  4. আগে বলুন — DDS আর মাত্রা: ৩২ ঘরের table (১২ বিট, অংশ ৪-এর মান), fs = 32 kHz, ৩২ বিটের accumulator, ঘর = acc >> 27. (ক) 500 Hz-এর জন্য M কত, আর প্রথম আটটি sample কোন ঘর পড়বে? (খ) মাত্রা L = 2 (code = 2048 + (table − 2048) × 2 ÷ 4, signed) হলে ঘর 8 আর ঘর 24-এর code কত? (গ) সবচেয়ে বেশি কোন frequency-তে নেওয়া চলে না, আর কেন?

    (ক) M = 500 × 232 ÷ 32000 = 67108864 = 226; প্রতি sample-এ আধা ঘর, তাই ঘর 0, 0, 1, 1, 2, 2, 3, 3: প্রতিটি মান দুবার, একটি period-এ ৬৪টি sample, 64 × 31.25 µs = 2 ms = 500 Hz. (খ) ঘর 8 = 4095: 2048 + 2047 × 2 ÷ 4 = 2048 + 1023 = 3071. ঘর 24 = 1: 2048 + (−2047) × 2 ÷ 4 = 2048 − 1023 = 1025 (C-এর ভাগ শূন্যের দিকে কাটে, তাই দুই দিকে সমান 1023). (গ) fs ÷ 2 = 16 kHz বা তার ওপরে নয়: সেখানে প্রতি period-এ দুটির কম sample, আর output-এ মূল সুর আর প্রতিচ্ছবি (fs − f) আলাদা করা যায় না; বাস্তবে filter-এর জায়গার জন্য আরও অনেক নিচে। সব সংখ্যা Python-এ চালিয়ে মেলানো।

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

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

ক্রমএকটি microcontroller DAC আর timer দিয়ে একটি sine সুর বাজাবে। নকশা আর চলার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. সুরের frequency আর table-এর ঘর থেকে sample rate ঠিক করা (fs = N × fout)
  2. Integer বা fixed-point-এ sine table বানিয়ে host-এ যাচাই করা
  3. Timer-এর reload মান সেট করে sample rate-এ trigger চালু করা
  4. প্রতি trigger-এ table-এর পরের মান DAC-এর data register-এ যাওয়া
  5. Table-এর শেষে index আবার শূন্যে ফেরা
  6. DAC-এর সিঁড়ি reconstruction filter আর amplifier হয়ে speaker-এ যাওয়া

একটি ১২ বিটের DAC, Vref = 3.3 V, আর output-এর সূত্র Vref × code ÷ 4096. Code 2048 লিখলে output কত?

  • 1.6504 V
  • 1.65 V
  • 3.3 V
  • 0.806 mV

Binary-weighted resistor DAC-এর তুলনায় R-2R ladder-এর মূল সুবিধা কোনটি?

  • R-2R-এর output resistance শূন্য, তাই buffer লাগে না
  • R-2R-এ কখনো glitch হয় না
  • মাত্র দুই মানের resistor লাগে, বিট যত বেশিই হোক
  • R-2R সবসময় monotonic, resistor যত ভুলই হোক

৪ বিটের একটি voltage-mode R-2R ladder, Vref = 3.3 V, output খোলা। Code 1011 (MSB বাঁয়ে) হলে output কত?

  • 2.26875 V
  • 2.0625 V
  • 2.42 V
  • 1.2375 V

8 MHz clock-এর একটি timer দিয়ে PWM DAC: counter ৮ বিট থেকে ১২ বিট করা হলো, RC filter একই। কী ঘটবে?

  • PWM-এর frequency ১৬ গুণ বাড়বে
  • Ripple ১৬ গুণ কমবে, কারণ ধাপ ছোট
  • Settling time ১৬ গুণ কমবে
  • PWM 31.25 kHz থেকে 1953 Hz-এ নামবে, আর ripple অনেক বাড়বে

একটি ৮ বিটের DAC-এ code 127 থেকে 128-এ গেলে output 1.6453 V থেকে 1.6418 V-এ নামে (1 LSB = 12.891 mV). কোন কথাটি ঠিক?

  • এটি settling time-এর সমস্যা, অপেক্ষা করলে ঠিক হবে
  • DAC এখানে non-monotonic, DNL −1 LSB-এর চেয়ে কম
  • এটি glitch, যা কয়েক ns-এ চলে যায়
  • এটি শুধু full scale-এর gain error

একটি DDS: ৩২ বিটের phase accumulator, sample rate 32 kHz, ৩২ ঘরের table (ঘর = accumulator-এর ওপরের ৫ বিট)। 1 kHz-এর জন্য tuning word M কত?

  • 1
  • 32
  • 134217728 (227)
  • 4294967296 (232)

শব্দকোষ

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

মনে রাখুন

  1. সূত্র তিনটি: 1 LSB = Vref ÷ 2n, Vout = code × 1 LSB, full scale = Vref − 1 LSB. Resolution আর accuracy আলাদা।
  2. R-2R: প্রতি node-এ (আগের + বিট × Vref) ÷ 2; দুই মানের resistor, output resistance সব code-এ R, ভারী load-এ buffer.
  3. ভুলের মাপ: DNL, INL, monotonicity; major carry-তে MSB-এর অমিল সবচেয়ে ক্ষতিকর, glitch-ও সেখানে বড়। GPIO ladder একটি BSRR write-এ।
  4. Waveform: fout = fs ÷ N; table আগে থেকে, integer-এ; DDS-এ M = fout × 232 ÷ fs; fout fs ÷ 2-এর অনেক নিচে।
  5. PWM + RC: fPWM = fclk ÷ 2n; ripple ≈ VDD D(1 − D) T ÷ τ, settling ≈ τ ln 2n+1: ধীর মানের জন্য (contrast), দ্রুত সুরের জন্য নয়।

পরের পর্বে: পর্ব ৪৯ (UART — baud rate, frame, parity আর ring buffer). Start, data, parity আর stop বিটের frame, baud rate-এর divisor আর ভুলের শতাংশ, আর smart scale-এর দামের লাইন UART-এ পাঠানো।

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

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