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

PWM — duty cycle, frequency, LED-এর আলো আর motor-এর গতি

PWM — Duty Cycle, Frequency, LED Brightness and Motor Speed

Taught in Bangla, this lesson explains PWM period, duty cycle and average voltage, timer-based PWM with ARR and CCR in STM32 PWM mode 1, edge- versus centre-aligned counting, and the resolution-versus-frequency trade-off (3600 steps at 20 kHz from 72 MHz). A software PWM on the course's virtual BG-M3 board is measured from its pin trace: 2399 of 8000 cycles high, ISR cost 2.96%. In-page Python covers gamma and CIE L* brightness steps, servo pulse widths and an RC filter turning PWM into a voltage.

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

  • Duty cycle, frequency আর গড় ভোল্টেজের সম্পর্ক, আর কেন চালু-বন্ধ করা নিয়ন্ত্রণ বিদ্যুৎ বাঁচায়
  • Timer-এর counter, ARR আর CCR থেকে কীভাবে PWM তৈরি হয়; PWM mode 1 আর 2, edge-aligned আর centre-aligned
  • নির্দিষ্ট frequency-র জন্য PSC আর ARR বেছে resolution হিসাব করা
  • Virtual বাজারঘর board-এ SysTick দিয়ে software PWM চালিয়ে LED-এর ধার মেপে duty আর CPU-র খরচ যাচাই
  • LED-এর gamma, cold room-এর buzzer-এর আওয়াজ, motor, servo আর RC filter দিয়ে analog ভোল্টেজে PWM-এর ব্যবহার

১ · PWM কী — দ্রুত চালু-বন্ধ, গড়ে মাঝামাঝি

একটি ঘরের ফ্যানের কথা ভাবুন, যার সুইচ শুধু চালু আর বন্ধ। ফ্যানটি আধা গতিতে চালাতে চাইলে একটি উপায়: প্রতি দুই সেকেন্ডে এক সেকেন্ড চালু, এক সেকেন্ড বন্ধ। পাখার ভারী ব্লেড হঠাৎ থামে না, হঠাৎ পুরো গতিও পায় না; গড়ে মাঝামাঝি একটি গতিতে ঘোরে। এখন এই চালু-বন্ধ সেকেন্ডে হাজারবার করুন: পাখা আর কোনো ঝাঁকুনি টের পায় না, শুধু গড়টি পায়। Microcontroller-এর PWM (pulse-width modulation) ঠিক এই কৌশল। Digital pin শুধু 0 V আর 3.3 V দিতে পারে, মাঝের কিছু নয়; কিন্তু খুব দ্রুত চালু-বন্ধ করে চালু থাকার ভাগ বদলালে যন্ত্রটি মাঝের যেকোনো মান “অনুভব” করে।

দুটি সংখ্যায় একটি PWM সংকেত পুরো বর্ণনা হয়। Frequency (f) মানে সেকেন্ডে কতবার পুরো চালু-বন্ধের চক্র; তার উল্টো period, T = 1 ÷ f. Duty cycle (D) মানে একটি period-এর কত ভাগ সংকেত চালু (high). চালু সময় ton হলে D = ton ÷ T. Pin-এর গড় ভোল্টেজ তখন Vavg = D × VDD. বাজারঘর board-এর 3.3 V-এ 25% duty মানে গড়ে 0.825 V, 50% মানে 1.650 V, 75% মানে 2.475 V; এই সংখ্যাগুলো অংশ ৪-এর block-এ চালিয়ে মেলানো।

কেন গড়টাই কাজের? কারণ বেশিরভাগ যন্ত্রের নিজের একটি “ধীরতা” আছে যা দ্রুত ঝাঁকুনি মুছে দেয়। LED নিজে প্রায় সঙ্গে সঙ্গে জ্বলে-নেভে, কিন্তু আমাদের চোখ দ্রুত জ্বলা-নেভা গড় করে দেখে। Motor-এর coil-এর inductance current-কে হঠাৎ বদলাতে দেয় না, আর rotor-এর ভর গতিকে। Heater-এর তাপ ধীরে বাড়ে-কমে। আর যেখানে যন্ত্র নিজে গড় করে না, সেখানে একটি resistor আর capacitor দিয়ে গড় করে নেওয়া যায় (অংশ ৮)। তাই PWM কার্যত একটি সস্তা “digital থেকে analog”-এর সেতু, যার পূর্ণ রূপ, অর্থাৎ DAC, আসবে পর্ব ৪৮-এ।

লেখার নিয়ম আর lab: এই পর্বে hex লেখা হয় C-র ধাঁচে, যেমন 0x40010810. Board-এর সব সময় আর মান আমার lab-এর আসল build আর run থেকে: firmware C-তে, Clang 22.1.8 দিয়ে compile (PyPI-র ziglang 0.17.1, MIT; LLVM অংশ Apache-2.0 with LLVM exception), চালানো কোর্সের virtual বাজারঘর board BG-M3-এ (Unicorn 2.1.4: binding BSD, engine GPLv2). BG-M3 কোনো আসল পণ্য নয়, আসল Cortex-M3 chip-এর আদলে বানানো শেখার মডেল (পর্ব ০৬; reference lab-এর README, Spec decision 17). Board-এ কোনো hardware PWM timer নেই, শুধু GPIO আর SysTick; তাই hardware PWM শেখানো হয়েছে ST-এর STM32F103-এর reference manual RM0008 থেকে, আর তার আচরণ একটি Python মডেলে, যা ব্রাউজারেই চলে। হাতে কোনো আসল board বা oscilloscope ছিল না।

PWM-এর একটি পুরোনো আত্মীয় আপনি আগেই দেখেছেন। 8253/8254-এর mode 3 একটি square wave বানায়: count N হলে output প্রায় অর্ধেক সময় high, অর্ধেক low (পর্ব ২৫)। এটি duty প্রায় 50%-এ বাঁধা একটি PWM. আজকের microcontroller-এর timer প্রতিটি channel-এ একটি আলাদা compare register রাখে, ফলে duty যেকোনো মানে বসানো যায়, আর একই timer কয়েকটি pin-এ একই frequency-তে আলাদা duty দিতে পারে। PWM-এর সংকেত শেষে একটি GPIO pin দিয়েই বেরোয়, timer-এর হাতে ছাড়া alternate function mode-এ (পর্ব ৪১)।

উপমা — রিকশার প্যাডেল: একজন রিকশাওয়ালা ঢালু রাস্তায় পুরো জোরে প্যাডেল চাপেন না; কয়েক পাক চাপেন, কয়েক পাক ছেড়ে দেন। রিকশার ভর গতিকে মসৃণ রাখে। চাপার পাক আর মোট পাকের অনুপাত হলো duty; প্রতি মিনিটে কতবার এই চাপা-ছাড়ার চক্র, সেটি frequency. চক্র যত দ্রুত, যাত্রী তত কম ঝাঁকুনি টের পান; অনুপাত যত বেশি, রিকশা তত জোরে চলে।

২ · Timer দিয়ে PWM — counter, ARR, CCR আর compare match

Hardware PWM-এর ভেতরে তিনটি জিনিস। একটি counter (CNT), যা প্রতিটি timer tick-এ এক বাড়ে। একটি auto-reload register (ARR), যা বলে counter কত পর্যন্ত গুনে আবার 0-তে ফিরবে। আর প্রতিটি channel-এর একটি capture/compare register (CCR), যার সঙ্গে counter প্রতিটি tick-এ তুলনা হয়। Counter-এর গতি ঠিক করে prescaler (PSC): timer-এর input clock-কে PSC + 1 দিয়ে ভাগ করে counter-এর clock. এসব timer-এর মৌলিক অংশ, যার পূর্ণ হিসাব পর্ব ৪৪-এ (Timer আর counter); এখানে শুধু PWM-এর দিক।

STM32F103-এর general-purpose timer (TIM2 থেকে TIM5)-এর জন্য RM0008-এর §15.3.9 PWM-এর নিয়ম দুটি বাক্যে দেয়। প্রতিটি channel-এর CCMRx register-এর OCxM বিটে 110 লিখলে PWM mode 1, 111 লিখলে PWM mode 2. Upcounting-এ mode 1-এ ভেতরের reference সংকেত OCxREF “high as long as TIMx_CNT < TIMx_CCRx else it becomes low”. Mode 2 ঠিক উল্টো। তাই এক period-এ (ARR + 1 count) চালু থাকে CCR-টি count, আর:

মূল সূত্র (edge-aligned, upcounting)

fPWM = fTIM ÷ ((PSC + 1) × (ARR + 1))  ·  duty = CCR ÷ (ARR + 1)  ·  CCR = 0 হলে সবসময় 0, CCR > ARR হলে সবসময় 1

শেষ দুটি কিনারার নিয়মও RM0008-এ লেখা: CCR “greater than the auto-reload value” হলে OCxREF সবসময় 1, আর CCR 0 হলে সবসময় 0. তাই 0% থেকে 100% পর্যন্ত পুরো পরিসর পাওয়া যায়; 100%-এর জন্য CCR = ARR + 1 লিখতে হয়, ARR নয়। নিচের ছবিতে বাঁ থেকে ডানে সময়; ওপরে counter-এর মান, নিচে output.

ছবি ৪৫.১ — Counter, CCR আর output: edge-aligned আর centre-aligned

ওপরের প্যানেলে counter শুধু ওপরে গোনে, তিনটি period; নিচের প্যানেলে ওপরে-নিচে। দুটিতেই CCR-এর রেখা ARR-এর ৪০%-এ, PWM mode 1

Edge-aligned আর centre-aligned PWM edge-aligned (শুধু ওপরে গোনা) centre-aligned (ওপরে-নিচে) ARR CCR OC1REF CCR OC1REF CNT CNT
ছবি ৪৫.১ — ওপরে: counter 0 থেকে ARR পর্যন্ত উঠে হঠাৎ 0-তে ফেরে (overflow); CNT < CCR থাকা পর্যন্ত output 1, তাই প্রতিটি pulse period-এর শুরুতে ওঠে আর CCR-এ নামে। নিচে: counter ওঠে আর নামে, প্রতিটি পুরো চক্রে 2 × ARR count; output 1 থাকে counter CCR-এর নিচে থাকার সময়, তাই pulse নিচের বিন্দু (CNT = 0) ঘিরে প্রতিসম। একই ARR-এ centre-aligned-এর frequency অর্ধেক। ছবি ধারণা দেখানোর জন্য আঁকা, মাপমতো নয়।

একটি জিনিস এখনো বলা হয়নি: চলতে চলতে duty বদলালে কী হয়? ধরুন counter এখন 5-এ, আর firmware CCR 3 থেকে 7 করল। সেই period-এর output না পুরোনো duty-র, না নতুনের; একটি অনিয়মিত pulse বেরোয়। এর সমাধান preload register: CCMRx-এর OCxPE বিট 1 করলে firmware যা লেখে তা জমা থাকে একটি preload অংশে, আর hardware সেটি আসল (shadow) register-এ নেয় শুধু update event-এ, অর্থাৎ counter overflow হয়ে 0-তে ফেরার মুহূর্তে। RM0008 PWM mode-এ OCxPE চালু করতে বলে, ARR-এর জন্য CR1-এর ARPE ঐচ্ছিক, আর counter চালুর আগে EGR-এর UG বিট লিখে সব register একবার “update” করতে বলে। নিচের stepper-এ একটি period-এর ভেতরে count ধরে ধরে দেখুন; মানগুলো Python-এ মডেল চালিয়ে মেলানো।

72 MHz, PSC = 7199 (1 count = 100 µs), ARR = 9, mode 1
সময়
CNT
CCR1 (shadow)
CCR1 (preload)
তুলনা
OC1REF
  1. শুরু। PSC = 7199 মানে 72 MHz ÷ 7200 = 10 kHz, এক count 100 µs; ARR = 9 মানে ১০ count-এ এক period, 1 ms (1 kHz). UG লেখার ফলে shadow-এ CCR1 = 3. CNT = 0 < 3, তাই OC1REF = 1.
  2. Count 1 আর 2. CNT এখনো CCR-এর নিচে, output 1 থাকে। Hardware প্রতিটি count-এ তুলনা করছে, CPU কিছুই করছে না।
  3. Compare match. CNT = 3 = CCR1: এখন আর CNT < CCR নয়, OC1REF 0-তে নামে, 0.3 ms-এ। একই সঙ্গে status-এর CC1IF flag 1 হয়; চাইলে এতে interrupt-ও নেওয়া যায়। Duty = 3 ÷ 10 = 30%.
  4. Firmware নতুন duty লিখল। CNT = 5-এ firmware CCR1 = 7 লিখল। OC1PE চালু, তাই মানটি শুধু preload-এ বসে; shadow এখনো 3, চলতি period অক্ষত থাকে।
  5. Period-এর শেষ count. CNT = 9 = ARR; output 0. পরের tick-এ counter overflow করবে।
  6. Update event. CNT 9 থেকে 0-তে ফিরল, 1.0 ms-এ: preload-এর 7 shadow-এ গেল, UIF flag 1. CNT = 0 < 7, output আবার 1. নতুন duty ঠিক period-এর সীমায় শুরু, কোনো অনিয়মিত pulse নেই।
  7. নতুন compare match. CNT = 7-এ, অর্থাৎ 1.7 ms-এ, output নামে। দ্বিতীয় period-এর duty 7 ÷ 10 = 70%. OC1PE বন্ধ থাকলে firmware-এর লেখা সঙ্গে সঙ্গে কাজ করত, আর লেখার মুহূর্তের ওপর নির্ভর করে সেই period-এর pulse অনিয়মিত হতো।

৩ · Edge-aligned বনাম centre-aligned — মডেলে চালিয়ে দেখা

ছবি ৪৫.১-এর ওপরের প্যানেলটি edge-aligned PWM: counter শুধু ওপরে গোনে, তাই একই timer-এর সব channel-এর pulse period-এর শুরুতে একসাথে ওঠে, আর প্রত্যেকে নিজের CCR-এ নামে। নিচেরটি centre-aligned PWM: STM32-এ CR1-এর CMS বিট 00 ছাড়া অন্য কিছু হলে counter 0 থেকে ARR − 1 পর্যন্ত উঠে ARR থেকে 1 পর্যন্ত নামে (RM0008 §15.3.2). এক পুরো চক্র তখন 2 × ARR count. ওঠার সময় mode 1-এ output 1 যতক্ষণ CNT < CCR, নামার সময় 0 যতক্ষণ CNT > CCR; ফলে pulse প্রতিটি নিচের বিন্দু ঘিরে প্রতিসম, আর duty = CCR ÷ ARR.

নিচের block-টি এই নিয়মগুলোর একটি ছোট মডেল, যা RM0008-এর বাক্যগুলো হুবহু কোডে বসায়। # মানে output 1, _ মানে 0; প্রতিটি অক্ষর একটি count. ARR = 8 নেওয়া হয়েছে, ST-এর reference manual-গুলোর চেনা উদাহরণের মতো। মনে রাখুন, এটি মডেল: আসল silicon-এর কিছু সূক্ষ্ম বিষয়, যেমন centre-aligned-এ কোন দিকের গোনায় flag ওঠে (CMS-এর তিনটি mode), এখানে নেই।

# STM32F1 TIMx-এর একটি PWM channel-এর মডেল (RM0008 §15.3.9 অনুসারে)
def edge(arr, ccr, mode=1, periods=1):
    """Upcounting: CNT 0..ARR; mode 1-এ OCxREF = 1 যতক্ষণ CNT < CCR"""
    out = ""
    for _ in range(periods):
        for cnt in range(arr + 1):
            ref = cnt < ccr                    # CCR > ARR হলে সবসময় 1, CCR = 0 হলে 0
            out += "#" if (ref if mode == 1 else not ref) else "_"
    return out

def centre(arr, ccr):
    """Centre-aligned: ওপরে 0..ARR-1, নিচে ARR..1; একটি period = 2*ARR count"""
    out = ""
    for cnt in range(0, arr):                  # up: active যতক্ষণ CNT < CCR
        out += "#" if cnt < ccr else "_"
    for cnt in range(arr, 0, -1):              # down: inactive যতক্ষণ CNT > CCR
        out += "_" if cnt > ccr else "#"
    return out

ARR = 8
for ccr in (4, 0, 8, 9):
    w = edge(ARR, ccr)
    print(f"edge   mode1 ARR={ARR} CCR={ccr}: {w}  duty {w.count('#')}/{len(w)}")
w = edge(ARR, 4, mode=2)
print(f"edge   mode2 ARR={ARR} CCR=4: {w}  duty {w.count('#')}/{len(w)}")
for ccr in (4, 2):
    w = centre(ARR, ccr)
    print(f"centre mode1 ARR={ARR} CCR={ccr}: {w}  duty {w.count('#')}/{len(w)}")
# দুটি channel: edge-এ দুটোরই ওঠা CNT = 0-তে, centre-এ মাঝখান ঘিরে
print("edge   CH1 CCR=6:", edge(ARR, 6), " CH2 CCR=2:", edge(ARR, 2))
print("centre CH1 CCR=6:", centre(ARR, 6), " CH2 CCR=2:", centre(ARR, 2))

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

edge   mode1 ARR=8 CCR=4: ####_____  duty 4/9
edge   mode1 ARR=8 CCR=0: _________  duty 0/9
edge   mode1 ARR=8 CCR=8: ########_  duty 8/9
edge   mode1 ARR=8 CCR=9: #########  duty 9/9
edge   mode2 ARR=8 CCR=4: ____#####  duty 5/9
centre mode1 ARR=8 CCR=4: ####________####  duty 8/16
centre mode1 ARR=8 CCR=2: ##____________##  duty 4/16
edge   CH1 CCR=6: ######___  CH2 CCR=2: ##_______
centre CH1 CCR=6: ######____######  CH2 CCR=2: ##____________##

প্রথম চার লাইন সূত্রটি প্রমাণ করে: ARR = 8 মানে ৯ count-এর period, duty = CCR ÷ 9. CCR = 8 দিলেও একটি count 0 থাকে; পুরো 100%-এর জন্য CCR = 9 = ARR + 1 লাগে, আর CCR = 0 মানে সম্পূর্ণ 0. Mode 2 একই CCR-এ উল্টো ছবি দেয়: duty 5/9 = 1 − 4/9. Centre-aligned-এ period ১৬ count (2 × ARR), আর CCR = 4 দিলে duty 8/16 = 4/8 = CCR ÷ ARR; pulse-টি period-এর দুই কিনারায় ভাগ হয়ে আছে, কারণ এর কেন্দ্র CNT = 0. শেষ দুই লাইনে দুটি channel: edge-aligned-এ দুটোই প্রথম count-এ একসাথে ওঠে; centre-aligned-এ দুটি pulse একই কেন্দ্র ঘিরে, তাই CH2-এর ধার CH1-এর ধার থেকে দূরে।

এই পার্থক্য কেন গুরুত্বপূর্ণ? Edge-aligned-এ সব channel একসাথে ওঠে মানে একই মুহূর্তে সব load একসাথে current টানতে শুরু করে; power লাইনে একটি বড় ঝাঁকুনি আর শব্দ। Centre-aligned-এ ধারগুলো ছড়িয়ে যায়। Three-phase motor-এর নিয়ন্ত্রণে আরও একটি সুবিধা: pulse-এর কেন্দ্র সবসময় একই জায়গায়, তাই motor-এর current মাপার ADC-কে সেই নির্দিষ্ট মুহূর্তে চালালে switching-এর শব্দ এড়িয়ে নমুনা নেওয়া যায় (অনেক motor-control application note-এ বর্ণিত কৌশল; নির্দিষ্ট chip-এর নথি দেখে নিন)। দাম: একই ARR-এ frequency অর্ধেক, অথবা একই frequency-তে resolution এক বিট কম। LED বা সাধারণ buzzer-এর জন্য edge-aligned যথেষ্ট; বড় motor-এ centre-aligned প্রচলিত।

৪ · Resolution বনাম frequency — একটি অনিবার্য দরকষাকষি

PWM-এর resolution মানে duty-র কতগুলো আলাদা ধাপ সম্ভব। Edge-aligned-এ ধাপের সংখ্যা ARR + 1, তাই বিটে log2(ARR + 1). সমস্যাটা এক লাইনে: timer clock স্থির থাকলে প্রতিটি বাড়তি ধাপ period-কে এক count লম্বা করে। 72 MHz-এ (STM32F103-এর সর্বোচ্চ system clock; timer-এর clock কত, তা RCC-র bus prescaler-এর ওপরও নির্ভর করে, পর্ব ৩৩) 8 বিটের PWM সর্বোচ্চ 281.25 kHz দিতে পারে, কিন্তু 16 বিটের মাত্র 1098.63 Hz. নিচের block-এ duty থেকে গড় ভোল্টেজ, বিট থেকে frequency, আর তিনটি লক্ষ্য frequency-র জন্য PSC আর ARR বেছে নেওয়া হয়েছে।

# PWM: duty -> গড় ভোল্টেজ, আর resolution বনাম frequency (edge-aligned)
import math
VDD = 3.3
for duty in (0.0, 0.25, 0.5, 0.75, 1.0):
    print(f"duty {duty*100:5.1f} %  ->  average {duty*VDD:.3f} V")

F_TIM = 72_000_000            # STM32F103-এর timer clock (72 MHz ধরে)
print("bits  steps   f_pwm (PSC = 0)")
for bits in (8, 10, 12, 16):
    steps = 2 ** bits         # ARR + 1
    print(f"{bits:4}  {steps:6}  {F_TIM / steps:12.2f} Hz")

def psc_arr(f_tim, f_pwm, max_arr=65535):
    """সবচেয়ে বেশি step (ছোট PSC) দিয়ে f_pwm; (PSC+1)(ARR+1) = f_tim / f_pwm"""
    total = round(f_tim / f_pwm)
    for psc in range(0, 65536):
        if total % (psc + 1) == 0 and total // (psc + 1) - 1 <= max_arr:
            arr = total // (psc + 1) - 1
            return psc, arr, f_tim / ((psc + 1) * (arr + 1))
for f in (20_000, 1_000, 50):
    psc, arr, real = psc_arr(F_TIM, f)
    print(f"{f:6} Hz: PSC={psc:3} ARR={arr:5}  steps={arr+1:5} "
          f"({math.log2(arr+1):.2f} bit)  real {real:.2f} Hz")

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

duty   0.0 %  ->  average 0.000 V
duty  25.0 %  ->  average 0.825 V
duty  50.0 %  ->  average 1.650 V
duty  75.0 %  ->  average 2.475 V
duty 100.0 %  ->  average 3.300 V
bits  steps   f_pwm (PSC = 0)
   8     256     281250.00 Hz
  10    1024      70312.50 Hz
  12    4096      17578.12 Hz
  16   65536       1098.63 Hz
 20000 Hz: PSC=  0 ARR= 3599  steps= 3600 (11.81 bit)  real 20000.00 Hz
  1000 Hz: PSC=  1 ARR=35999  steps=36000 (15.14 bit)  real 1000.00 Hz
    50 Hz: PSC= 23 ARR=59999  steps=60000 (15.87 bit)  real 50.00 Hz

দ্বিতীয় সারণিতে প্রতি দুই বিট বাড়লে frequency চার ভাগের এক ভাগ। তৃতীয় অংশে psc_arr সবচেয়ে ছোট PSC খোঁজে, কারণ PSC যত ছোট, ARR তত বড়, ধাপ তত বেশি। 20 kHz-এ গুণফল (PSC + 1)(ARR + 1) = 3600, যা ARR-এর ১৬ বিটের সীমায় (65535) ধরে, তাই PSC = 0. 1 kHz-এ গুণফল 72000, ১৬ বিটে ধরে না, তাই PSC = 1 লাগে। বাস্তবে অনেকে সুবিধার জন্য PSC = 71 নেন (এক count = 1 µs), তখন 1 kHz-এ ARR = 999, ঠিক 1000 ধাপ, শতাংশে লেখা সহজ, কিন্তু resolution কম। দুটোই সঠিক; কোনটি ভালো, তা নির্ভর করে কতটা সূক্ষ্ম duty দরকার তার ওপর।

নিচের stepper একই হিসাব একটি নকশার প্রশ্নের মতো ধাপে ধাপে করে: একটি motor-এর জন্য 20 kHz (মানুষের শোনার সীমার কাছে বা ওপরে, তাই motor-এর গুনগুন শব্দ কম শোনা যায়; মানুষভেদে সীমা আলাদা), আর শেষে কোর্সের board-এর software PWM কেন মাত্র ১০ ধাপ, তার উত্তর।

fTIM = 72 MHz (STM32F103), শেষ ধাপে board 8 MHz
প্রশ্ন
হিসাব
ফল
  1. লক্ষ্য থেকে গুণফল। 72 MHz ÷ 20 kHz = 3600: এক period-এ timer clock-এর 3600টি tick. এই 3600-কে PSC + 1 আর ARR + 1-এর গুণফলে ভাঙতে হবে।
  2. Resolution সর্বোচ্চ। PSC = 0 নিলে সব tick counter-এর ধাপ হয়: ARR = 3599, ধাপ 3600, log2 3600 ≈ 11.81 বিট. এক ধাপ 1 ÷ 72 MHz ≈ 13.9 ns; duty-কে এর চেয়ে সূক্ষ্মভাবে বদলানো যায় না।
  3. 8 বিটে বাঁধা থাকলে। ARR = 255 (256 ধাপ) আর PSC = 0 দিলে f = 72 MHz ÷ 256 = 281.25 kHz. দ্রুত, কিন্তু অনেক MOSFET-driver আর motor-এর জন্য এত দ্রুত switching-এ ক্ষতি বেশি (দ্রুততর ধারে প্রতিবার কিছু শক্তি গরম হয়ে যায়)।
  4. 8 বিট রেখে 20 kHz-এর কাছে। 281250 ÷ 20000 = 14.06, পূর্ণসংখ্যা নয়। PSC + 1 = 14 নিলে f = 72 MHz ÷ (14 × 256) ≈ 20089.29 Hz: ঠিক 20 kHz নয়, কিন্তু motor-এর জন্য সাধারণত যথেষ্ট কাছে।
  5. পূর্ণ 16 বিট। ARR = 65535, PSC = 0: f = 72 MHz ÷ 65536 ≈ 1098.63 Hz. LED বা ধীর heater-এর জন্য চলে, motor-এর জন্য খুব ধীর আর শ্রবণসীমার ভেতরে।
  6. 1 kHz. 72 MHz ÷ 1 kHz = 72000, যা 65536-এর চেয়ে বড়, তাই PSC কমপক্ষে 1: PSC = 1, ARR = 35999, ধাপ 36000 ≈ 15.14 বিট. সুবিধার জন্য PSC = 71, ARR = 999 নিলে ধাপ ঠিক 1000.
  7. Board-এর software PWM. Board-এ timer hardware নেই, প্রতিটি ধাপ একটি SysTick interrupt. 1 kHz-এ 256 ধাপ চাইলে tick 256 kHz, অর্থাৎ 8 MHz-এ প্রতি tick মাত্র 31.25 cycle; অথচ অংশ ৬-এ মাপা ISR একাই 21 থেকে 42টি নির্দেশ। তাই board-এ ১০ ধাপ (3.32 বিট), tick 100 µs.

৫ · STM32F103-এ hardware PWM — register ধরে ধরে

এখন একটি আসল chip-এ সব একসাথে বসানো যাক। বাজারঘরের cold-storage monitor-এর alarm বসে PA6-এ। STM32F103-এর datasheet-এর pin সারণি অনুযায়ী PA6-এর default alternate function-এর মধ্যে TIM3-এর channel 1 (TIM3_CH1) আছে; অর্থাৎ PA6-এর buzzer-কে timer সরাসরি চালাতে পারে (আপনার chip-এর package-এর সারণিতে মিলিয়ে নিন)। মজার ব্যাপার, PA5-এর সবুজ LED-এর জন্য F103-এ remap ছাড়া কোনো timer channel নেই; সেখানে PWM লাগলে হয় অন্য pin, নয় software PWM. নিচের কোড buzzer-কে 2 kHz-এ 50% duty দেয়।

/* STM32F103, CMSIS device header; RM0008 §15. hardware-এ চালানো হয়নি */
void buzzer_pwm_init(void)
{
    RCC->APB2ENR |= 1u << 2;                    /* IOPAEN: GPIOA-র clock */
    RCC->APB1ENR |= 1u << 1;                    /* TIM3EN */
    GPIOA->CRL = (GPIOA->CRL & ~(0xFu << 24))
               | (0xAu << 24);                   /* PA6: AF push-pull, 2 MHz */
    TIM3->PSC  = 71;                            /* 72 MHz / 72 = 1 MHz, 1 us */
    TIM3->ARR  = 499;                           /* 500 us = 2 kHz */
    TIM3->CCR1 = 250;                           /* 50 % */
    TIM3->CCMR1 = (6u << 4) | (1u << 3);        /* OC1M = 110 (PWM 1), OC1PE */
    TIM3->CCER |= 1u << 0;                      /* CC1E: pin-এ output */
    TIM3->CR1  |= 1u << 7;                      /* ARPE: ARR-ও preload */
    TIM3->EGR   = 1u << 0;                      /* UG: সব shadow লোড */
    TIM3->CR1  |= 1u << 0;                      /* CEN: counter চালু */
}
void buzzer_volume(uint16_t ccr) { TIM3->CCR1 = ccr; }   /* 0..500 */

এটি একটি উদাহরণ: হাতে STM32F103 নেই, তাই কোনো board-এ চালানো হয়নি। বিট আর মান RM0008-এর বিবরণ থেকে, আর frequency ও duty ওপরের Python সূত্রে মেলানো: 1 MHz ÷ 500 = 2000 Hz, 250 ÷ 500 = 50%. প্রতিটি লাইনের পেছনে একটি কারণ আছে। প্রথমত দুটি clock: GPIO-র (APB2) আর TIM3-এর (APB1); কোনোটি ভুললে কোনো error ছাড়াই কিছু হয় না। দ্বিতীয়ত pin-এর nibble 0xA = CNF 10 (alternate function push-pull) আর MODE 10 (2 MHz); সাধারণ push-pull (0x2) দিলে pin ODR-এর কথা শোনে, timer-এর নয় (পর্ব ৪১-এর alternate function অংশ)। তৃতীয়ত CCER-এর CC1E, যা না দিলে timer ঠিকই গোনে, কিন্তু pin-এ কিছু যায় না। চতুর্থত UG: PSC নিজেও preload-যুক্ত, UG ছাড়া নতুন PSC কাজ করে প্রথম overflow-এর পরে।

একটি লক্ষণীয় বিষয়: CCMR1 = … পুরো register-এ সরাসরি লেখা, কারণ startup-এ বাকি বিট তখনো reset-এর মান 0-তে থাকে। চলতি সিস্টেমে channel 2-এর সেটিংও একই register-এ থাকে, তখন read-modify-write করে শুধু নিজের field বদলাতে হবে (পর্ব ৩৫)। আর buzzer_volume শুধু একটি store: preload-এর কারণে পরের period থেকে নতুন duty, কোনো interrupt বন্ধ করার দরকার নেই। Hardware PWM-এর এটিই বড় সুবিধা: একবার সাজালে CPU-র কোনো কাজ নেই, CPU ঘুমালেও (কিছু sleep mode-এ) pin চলতে থাকে।

৬ · বাজারঘর board-এ software PWM — আসল run

কোর্সের board-এ timer peripheral নেই, আছে শুধু Cortex-M-এর নিজস্ব SysTick (Spec decision 22: period = LOAD + 1 cycle, সবসময় 8 MHz core clock ধরে গোনা)। তাই এখানে software PWM: SysTick প্রতি 100 µs-এ একটি interrupt দেয়, আর ISR নিজে একটি phase counter চালিয়ে ঠিক সময়ে PA5 চালু-বন্ধ করে। এটি আসলে hardware PWM-এর counter আর compare unit-কে কোডে লেখা: phase হলো CNT, STEPS হলো ARR + 1, duty হলো CCR, আর next_duty হলো preload, যা শুধু period-এর শুরুতে নেওয়া হয়। আমার lab-এর swpwm.c-এর মূল অংশ (reference lab-এর bazarghar.h ব্যবহার করে):

#define STEPS 10u
static volatile uint32_t next_duty;     /* main লেখে, ISR পড়ে */
static volatile uint32_t ticks;         /* 100 us-এর tick */
static uint32_t phase, duty;            /* শুধু ISR-এর ভেতরে */

void SysTick_Handler(void)
{
    if (phase == 0u) {
        duty = next_duty;                           /* period-এর শুরুতে latch */
        if (duty > 0u) GPIOA->BSRR = 1u << LED_PIN; /* শুধু set */
        else           GPIOA->BRR  = 1u << LED_PIN;
    }
    if (phase == duty && duty < STEPS)
        GPIOA->BRR = 1u << LED_PIN;                 /* compare match: off */
    if (++phase == STEPS)
        phase = 0u;
    ticks++;
}
/* main: LOAD = 8 000 000 / 10 000 - 1 = 799; duty 3, 7, 0, 10, 1 (প্রতিটি 3 period) */

দুটি নকশার সিদ্ধান্ত লক্ষ করুন। প্রথমত, LED চালু করতে শুধু BSRR আর বন্ধ করতে শুধু BRR: কোনো read-modify-write নেই, আর একই store-এ set আর reset দুটোই কখনো নয় (দুটো একসাথে হলে ST-এর chip আর board দুটোতেই set জেতে, পর্ব ৪১, তবু সেই নিয়মের ওপর ভর না করাই নিরাপদ). দ্বিতীয়ত, next_duty আর ticks volatile, কারণ একজন main-এ আর অন্যজন ISR-এ বদলায় (পর্ব ৩৪); ৩২ বিটের একটি aligned word-এর একক লেখা Cortex-M3-এ একটি str, তাই মাঝপথে ভাঙা মান ISR দেখে না। Main শুধু next_duty বদলায়, তারপর WFI-তে ঘুমায়। Build আর run:

সত্যিকারের run · Clang 22.1.8 (ziglang 0.17.1), Unicorn 2.1.4, বাজারঘর board BG-M3
$ python -B bd.py build fw/swpwm.c -o build/swpwm.elf
built build/swpwm.elf
$ python -B bd.py run build/swpwm.elf
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0205 ms] UART: duty 3/10
[     0.1086 ms] GPIO PA5 LED ON
[     0.4085 ms] GPIO PA5 LED OFF
[     1.1086 ms] GPIO PA5 LED ON
[     1.4085 ms] GPIO PA5 LED OFF
[     2.1086 ms] GPIO PA5 LED ON
[     2.4085 ms] GPIO PA5 LED OFF
[     3.0235 ms] UART: duty 7/10
[     3.1086 ms] GPIO PA5 LED ON
[     3.8085 ms] GPIO PA5 LED OFF
[     4.1086 ms] GPIO PA5 LED ON
[     4.8085 ms] GPIO PA5 LED OFF
[     5.1086 ms] GPIO PA5 LED ON
[     5.8085 ms] GPIO PA5 LED OFF
[     6.0236 ms] UART: duty 0/10
[     9.0258 ms] UART: duty 10/10
[     9.1086 ms] GPIO PA5 LED ON
[    12.0236 ms] UART: duty 1/10
[    12.2085 ms] GPIO PA5 LED OFF
[    13.1086 ms] GPIO PA5 LED ON
[    13.2085 ms] GPIO PA5 LED OFF
[    14.1086 ms] GPIO PA5 LED ON
[    14.2085 ms] GPIO PA5 LED OFF
[    15.0099 ms] exit(0) after 120079 cycles

bd.py হলো reference lab-এর board.py-এর একটি ছোট wrapper, যা শুধু Zig-এর cache আর compiler-এর temp folder আমার lab-এর ভেতরে রাখে; board-এর কোড অপরিবর্তিত। Log-এর প্রতিটি সময় = cycle ÷ 8000 (Spec decision 31), তাই ধারগুলোকে cycle-এ ফিরিয়ে মাপা যায়। আমার lab-এর analyze.py প্রতিটি ON থেকে পরের OFF আর পরের ON পর্যন্ত cycle গোনে:

সত্যিকারের run · Python 3.13.5
$ python -B analyze.py swpwm.out
edges: 18
ON at 0.1086 ms: high 2399 cycles = 299.9 us, period 8000 cycles = 1000.0 us, duty 29.99 %
ON at 1.1086 ms: high 2399 cycles = 299.9 us, period 8000 cycles = 1000.0 us, duty 29.99 %
ON at 2.1086 ms: high 2399 cycles = 299.9 us, period 8000 cycles = 1000.0 us, duty 29.99 %
ON at 3.1086 ms: high 5599 cycles = 699.9 us, period 8000 cycles = 1000.0 us, duty 69.99 %
ON at 4.1086 ms: high 5599 cycles = 699.9 us, period 8000 cycles = 1000.0 us, duty 69.99 %
ON at 5.1086 ms: OFF at 5.8085 ms, no ON edge 1 ms later
ON at 9.1086 ms: OFF at 12.2085 ms, no ON edge 1 ms later
ON at 13.1086 ms: high 799 cycles = 99.9 us, period 8000 cycles = 1000.0 us, duty 9.99 %
ON at 14.1086 ms: OFF at 14.2085 ms, no ON edge 1 ms later

পাঁচটি শিক্ষা বেরোয়।

  1. Period নিখুঁত, high সময় এক cycle কম। প্রতিটি পুরো period ঠিক 8000 cycle = 1 ms, কারণ SysTick-এর ছন্দ hardware-এর (LOAD = 799). কিন্তু 30%-এ high 2399 cycle, 2400 নয়: ON-এর store ISR-এর শুরু থেকে যত নির্দেশ পরে আসে, OFF-এর store তার চেয়ে এক নির্দেশ আগে আসে। Software PWM-এর ধার ISR-এর পথের দৈর্ঘ্যের ওপর নির্ভর করে; hardware PWM-এ ধার আসে compare unit থেকে, কোডের পথ থেকে নয়।
  2. নতুন duty শুধু period-এর সীমায়। Main 3.0235 ms-এ 7 লিখল, কিন্তু LED 3.1086-এ নতুন period-এর শুরুতেই প্রথম 70%-এর pulse দিল। ঠিক preload-এর মতো আচরণ।
  3. 0% আর 100%-এ কোনো ধার নেই। 0/10-এর তিন period (6.1 থেকে 9.1 ms) log-এ একটিও লাইন নেই, LED পুরো নেভা। 10/10-এ 9.1086 থেকে LED টানা জ্বলে; ১০/১০ থেকে ১/১০-এ যাওয়ার পরে প্রথম OFF আসে 12.2085-এ, নতুন period শুরুর এক tick পরে। Analyzer তাই ওই তিনটি সারিতে “no ON edge” লেখে, কোনো ভুল নয়।
  4. সবচেয়ে ছোট pulse এক tick. 1/10-এ high 799 cycle ≈ 100 µs. এর চেয়ে সূক্ষ্ম duty এই নকশায় অসম্ভব, অংশ ৪-এর stepper-এর শেষ ধাপের কারণে।
  5. CPU-র খরচ মাপা যায়। --trace 3000 দিয়ে প্রতিটি নির্দেশ ছাপিয়ে ISR-এর নির্দেশ গোনা হয়েছে: একটি 30%-এর period-এর দশটি tick-এ 33, 22, 22, 29, 22, 22, 22, 22, 22, 21, মোট 237; 0%-এর period-এ প্রথম tick 42, মোট 239. 8000 cycle-এর মধ্যে 237 মানে 2.96%. কিন্তু Spec decision 17 মনে রাখুন: board-এ এক নির্দেশ = এক cycle আর exception-এ ঢোকা-বেরোনোর খরচ শূন্য; আসল Cortex-M3-এ entry আর exit-এ আরও প্রায় এক ডজন করে cycle আর flash-এর wait state যোগ হয়, তাই আসল খরচ বেশি।

ISR-এর ওই ভিন্ন দৈর্ঘ্য কোথা থেকে, তা compiler-এর output-এই দেখা যায়। clang -S --target=thumbv7m-none-eabi -mcpu=cortex-m3 -O2 (Clang 22.1.8) ISR-এর প্রথম অংশ বানিয়েছে branch ছাড়াই BSRR আর BRR-এর মধ্যে বাছাই করে (directive-এর লাইন বাদ):

	movw	r3, #2068         @ 0x0814 -> BRR
	movt	r3, #16385        @ 0x4001
	str	r2, [r1]          @ duty = next_duty
	subs	r3, #4            @ 0x40010810 -> BSRR
	cmp	r2, #0
	mov.w	r2, #32           @ 1u << 5
	itt	eq
	movweq	r3, #2068         @ duty == 0 হলে আবার BRR
	movteq	r3, #16385
	str	r2, [r3]          @ একটি store: set বা reset

if/else-এর দুটি শাখা Clang একটি ঠিকানার বাছাইয়ে নামিয়েছে: আগে BRR-এর ঠিকানা, তা থেকে 4 বাদ দিয়ে BSRR, আর duty শূন্য হলে itt eq দিয়ে আবার BRR. শেষে একটি str. এই ধরনের কোড পড়তে পারলে ISR-এর সময় নিজে গুনে নেওয়া যায়, compiler-এর ওপর অন্ধ ভরসা ছাড়াই (Compilers কোর্সে ARM-এর register-এর নিয়ম)।

SysTick 100 µs, STEPS = 10, PA5 LED
ISR শুরু
phase (ঢোকার সময়)
duty
store
LED (log)
ISR-এর নির্দেশ
  1. Tick ১, phase 0. ISR প্রায় 0.1065 ms-এ শুরু (trace থেকে)। Period-এর শুরু, তাই duty = next_duty = 3, আর duty > 0 বলে BSRR-এ 0x20: log-এ 0.1086 ms-এ LED ON. এই tick-এ ISR-এ 33টি নির্দেশ।
  2. Tick ২, phase 1. phase ≠ 0, phase ≠ duty: কোনো store নেই, শুধু phase আর ticks বাড়ে। 22টি নির্দেশ, LED জ্বলেই থাকে।
  3. Tick ৩, phase 2. একই সংক্ষিপ্ত পথ, 22টি নির্দেশ। Hardware PWM-এর count 1 আর 2-এর মতো, শুধু এখানে CPU-কেই প্রতিবার জাগতে হয়।
  4. Tick ৪, phase 3 = duty. Software-এর “compare match”: BRR-এ 0x20, log-এ 0.4085 ms-এ LED OFF. ON থেকে OFF 2399 cycle; এই পথে 29টি নির্দেশ।
  5. Tick ৫ থেকে ১০. phase 4 থেকে 9, LED নেভা; প্রতিটিতে 22টি নির্দেশ, শেষটিতে 21, আর phase আবার 0-তে ফেরে।
  6. Tick ১১, নতুন period. 1.1065 ms-এ phase 0: আবার BSRR, 1.1086-এ ON. দুই ON-এর ব্যবধান ঠিক 8000 cycle = 1 ms. দশটি tick-এ মোট 237টি নির্দেশ, board-এর মডেলে CPU-র 2.96%.
  7. Duty বদল। Main 3.0235 ms-এ next_duty = 7 লিখেছে; চলতি period শেষ হওয়া পর্যন্ত কিছু বদলায় না। 3.1065-এর tick-এ phase 0-তে 7 latch, 3.1086-এ ON, 3.8085-এ OFF: high 5599 cycle, 70%-এর থেকে আবার এক cycle কম।

সাবধান — software PWM-এর jitter: এই run-এ অন্য কোনো interrupt ছিল না, তাই প্রতিটি ধার নিখুঁত জায়গায়। আসল firmware-এ UART, ADC বা বোতামের ISR একই সময়ে চললে SysTick অপেক্ষা করতে পারে (interrupt latency), আর LED-এর ধার কয়েক µs সরে যায়। LED-এর চোখে এটি অদৃশ্য, কিন্তু servo বা motor-এ এই কাঁপুনি সমস্যা করে। Priority আর latency-র পুরো আলোচনা পর্ব ৪৩-এ; নিয়ম হলো, যেখানে ধারের সময় জরুরি, সেখানে hardware PWM.

৭ · LED-এর আলো আর buzzer-এর আওয়াজ — চোখ আর কান সরলরেখায় চলে না

বাজারঘরের smart scale-এর display-এর পেছনে একটি backlight, যার উজ্জ্বলতা দোকানের আলো অনুযায়ী আট ধাপে বদলাতে চাই। সরল সমাধান: duty 0, 12.5, 25 … 100%. কিন্তু ব্যবহার করলে দেখা যায়, প্রথম কয়েক ধাপে উজ্জ্বলতা অনেক বাড়ে, শেষের কয়েক ধাপে প্রায় কিছুই বদলায় না। কারণ চোখ আলোর পরিমাণকে সরলরেখায় দেখে না; অন্ধকারে ছোট বদল বেশি চোখে পড়ে, উজ্জ্বলে কম। একে সামলাতে duty-কে একটি বাঁকা সূত্রে বসানো হয়, যাকে gamma correction বলে। দুটি প্রচলিত সূত্র: duty = x2.2 (পর্দার gamma-র ধারণা থেকে নেওয়া একটি সাধারণ আনুমানিক মান), আর CIE 1976-এর L* (lightness) সূত্র উল্টে নেওয়া। কোনোটিই “একমাত্র সঠিক” নয়; মানুষের দেখা পরিবেশ, LED আর আলোর মাত্রার ওপর নির্ভর করে, তাই নকশায় চোখে পরখ করে নেওয়া ভালো।

Cold room-এর alarm-এর buzzer-এও একই প্রশ্ন: রাতে আওয়াজ কম, দিনে বেশি। একটি passive buzzer (যার ভেতরে নিজের oscillator নেই) একটি square wave দিয়ে চালানো হয়; frequency ঠিক করে সুর, আর তার জোর অনেকটা নির্ভর করে সংকেতের মূল (fundamental) উপাদানের ওপর। একটি pulse-এর ধারার মূল উপাদানের মাপ duty D-এর সঙ্গে sin(πD)-এর অনুপাতে বদলায় (Fourier series-এর একটি সাধারণ ফল), যা 50%-এ সর্বোচ্চ। তাই duty কমিয়ে আওয়াজ কমানো যায়। আসল জোর buzzer-এর গঠন, resonance আর driver-এর ওপর নির্ভর করে, তাই নিচের dB শুধু সংকেতের হিসাব, কানের মাপ নয়।

# Backlight-এর ধাপ (CIE L* আর gamma 2.2) আর buzzer-এর মূল সুরের জোর
import math

def cie_lstar_to_y(L):          # CIE 1976 L* (0..100) -> আপেক্ষিক luminance Y (0..1)
    return ((L + 16) / 116) ** 3 if L > 8 else L / 903.3

ARR = 999                       # 1000 step-এর PWM (CCR 0..1000)
print("step  linear  gamma2.2  CIE-L*")
for step in range(0, 9):
    x = step / 8                # মানুষের চোখে সমান ধাপ চাই
    lin = round(x * (ARR + 1))
    gam = round(x ** 2.2 * (ARR + 1))
    cie = round(cie_lstar_to_y(x * 100) * (ARR + 1))
    print(f"{step:4}  {lin:6}  {gam:8}  {cie:6}")

# পাতলা pulse-এ buzzer: square wave-এর মূল (fundamental) উপাদান ∝ sin(pi * D)
print("duty   fundamental   level")
for d in (0.5, 0.25, 0.10, 0.05):
    a = math.sin(math.pi * d)
    print(f"{d*100:4.0f} %   {a:6.3f}      {20*math.log10(a):6.1f} dB")

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

step  linear  gamma2.2  CIE-L*
   0       0         0       0
   1     125        10      15
   2     250        47      44
   3     375       116      98
   4     500       218     184
   5     625       356     310
   6     750       531     483
   7     875       745     710
   8    1000      1000    1000
duty   fundamental   level
  50 %    1.000         0.0 dB
  25 %    0.707        -3.0 dB
  10 %    0.309       -10.2 dB
   5 %    0.156       -16.1 dB

Linear সারিতে ধাপ ১ মানে CCR = 125 (12.5%), কিন্তু gamma 2.2-এ মাত্র 10 আর CIE-তে 15: চোখে “প্রথম ধাপ” আসলে খুব কম আলো। মাঝের ধাপ ৪-এ linear 500, বাঁকা দুটি সূত্রে প্রায় 200; দুটি বাঁকা সূত্র কাছাকাছি, কিন্তু অন্ধকারের দিকে CIE একটু বেশি দেয়। ধাপ ১-এর 10 বা 15-এর মতো ছোট মান ঠিকঠাক বসাতে PWM-এর resolution লাগে: 8 বিটে (256 ধাপ) ধাপ ১ হতো মাত্র 3 বা 4, তাই অন্ধকারের দিকের মসৃণতার জন্য 10 বিট বা তার বেশি প্রচলিত। Buzzer-এর সারিতে 25% duty মূল সুরকে −3.0 dB, 10% duty −10.2 dB নামায়: রাতের জন্য একটি সহজ “আস্তে” সেটিং, সুর না বদলেই।

LED-এর PWM-এর frequency-ও গুরুত্বপূর্ণ। খুব কম হলে আলো কাঁপতে দেখা যায় (flicker); তার চেয়ে বেশি হলেও দ্রুত চোখ ঘোরালে বা মোবাইলের ক্যামেরায় দাগ দেখা যেতে পারে। তাই display-এর backlight-এ কয়েক শ Hz থেকে কয়েক kHz প্রচলিত; নির্দিষ্ট মান LED driver-এর datasheet আর আলোর নিয়ম দেখে ঠিক করতে হয়। LED-এর current নিজেই সীমিত রাখতে হবে current-limiting resistor বা driver দিয়ে: PWM শুধু গড় কমায়, প্রতিটি pulse-এর ভেতরে current পুরো মানে চলে।

৮ · Motor, servo আর PWM থেকে analog ভোল্টেজ

DC motor. PWM-এর সবচেয়ে বড় ব্যবহার motor-এর গতি। Motor-এর coil-এর inductance current-কে মসৃণ করে, তাই গড় ভোল্টেজের সঙ্গে গতি মোটামুটি বাড়ে। কিন্তু motor কখনো সরাসরি GPIO pin থেকে নয়: একটি pin কয়েক mA দেয়, motor চায় শত শত mA থেকে কয়েক A. মাঝে একটি MOSFET বা একটি H-bridge driver লাগে, যা দুই দিকেই ঘোরাতে পারে। Switch বন্ধের মুহূর্তে coil-এর জমানো শক্তি উচ্চ ভোল্টেজের ঝটকা তোলে; তাকে নিরাপদ পথ দেয় একটি flyback diode. H-bridge-এর একই দিকের ওপর-নিচের দুটি transistor একসাথে চালু হলে সরাসরি short (shoot-through), তাই বদলের সময় দুটোকেই কিছুক্ষণ বন্ধ রাখা হয়, যাকে dead time বলে; STM32-এর advanced timer TIM1-এ complementary output আর dead-time-এর hardware আছে। এসবের পুরো আলোচনা পর্ব ৬৭-এ (Motor নিয়ন্ত্রণ)। Motor, বড় ব্যাটারি আর driver-এর circuit-এ কাজের সময় fuse আর current-সীমিত power supply রাখুন, আর mains-এর কোনো circuit-এ নিজে কাজ করবেন না।

Servo. একটি hobby servo-র ভেতরে motor, gear আর নিজের feedback; বাইরে থেকে শুধু বলে দিতে হয় কোন কোণে যাবে। প্রচলিত ধরন: প্রায় 20 ms অন্তর (50 Hz) একটি pulse, যার প্রস্থ মোটামুটি 1 ms থেকে 2 ms, আর 1.5 ms মাঝখান। এটি একটি প্রচলিত রীতি, কোনো একক মানদণ্ড নয়: অনেক servo 0.5 থেকে 2.5 ms গ্রহণ করে, আর পরিসরের বাইরে গেলে gear-এ চাপ পড়ে, তাই নির্দিষ্ট servo-র datasheet দেখে নিন। লক্ষ করুন, এখানে তথ্য বহন করে pulse-এর প্রস্থ, duty নয়; 50 Hz-এ 1–2 ms মানে duty মাত্র 5–10%. তাই timer-এর এক count 1 µs রাখলে CCR সরাসরি µs-এ লেখা যায়।

PWM থেকে analog. একটি resistor আর একটি capacitor-এর low-pass filter PWM-এর দ্রুত ওঠানামা মুছে গড়টি রেখে দেয়। দুটি দাম আছে: স্থির হতে সময় লাগে (প্রায় ৫ τ, যেখানে τ = RC), আর তার পরেও একটি ছোট ripple থেকে যায়। RC যত বড়, ripple তত কম কিন্তু সাড়া তত ধীর; PWM-এর frequency যত বেশি, একই RC-তে ripple তত কম। নিচের block-এ servo-র CCR আর একটি RC filter-এর সময় ধরে ধাপে ধাপে simulation, যার ripple একটি আনুমানিক সূত্রের সঙ্গে মেলানো (RC period-এর চেয়ে অনেক বড় হলে ripplep-p ≈ VDD × D × (1 − D) × T ÷ RC). এই কৌশলের পূর্ণ রূপ, R-2R ladder আর আসল DAC, পর্ব ৪৮-এ।

# Servo-র pulse আর PWM-কে RC filter দিয়ে ভোল্টেজ বানানো
import math
TICK_US = 1                      # PSC = 71: 72 MHz / 72 = 1 MHz, এক count = 1 us
ARR = 19999                      # 20000 count = 20 ms = 50 Hz
for us in (1000, 1500, 2000):    # প্রচলিত ১–২ ms (servo-ভেদে আলাদা)
    ccr = us // TICK_US
    print(f"pulse {us} us -> CCR1 = {ccr}, duty {100*ccr/(ARR+1):.1f} %")

# 3.3 V, 20 kHz PWM, duty 40 %, R = 10 kOhm, C = 1 uF: সময় ধরে ধাপে ধাপে
VDD, F, D, R, C = 3.3, 20_000, 0.40, 10_000, 1e-6
N = 50                           # প্রতি period-এ ৫০টি ছোট ধাপ
dt = 1 / F / N
v = 0.0
print(f"tau = {R*C*1000:.0f} ms, f_c = {1/(2*math.pi*R*C):.1f} Hz")
for p in range(1, 2001):         # 2000 period = 100 ms = 10 tau
    lo = hi = v
    for n in range(N):
        pin = VDD if n < D * N else 0.0
        v += (pin - v) * dt / (R * C)
        lo, hi = min(lo, v), max(hi, v)
    if p in (200, 400, 1000, 2000):
        print(f"t = {p/20:5.1f} ms: v = {v:.4f} V, ripple p-p {1000*(hi-lo):.2f} mV")
print(f"target {D*VDD:.2f} V, formula ripple {1000*VDD*D*(1-D)/F/(R*C):.2f} mV")

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

pulse 1000 us -> CCR1 = 1000, duty 5.0 %
pulse 1500 us -> CCR1 = 1500, duty 7.5 %
pulse 2000 us -> CCR1 = 2000, duty 10.0 %
tau = 10 ms, f_c = 15.9 Hz
t =  10.0 ms: v = 0.8332 V, ripple p-p 4.93 mV
t =  20.0 ms: v = 1.1397 V, ripple p-p 4.32 mV
t =  50.0 ms: v = 1.3091 V, ripple p-p 3.98 mV
t = 100.0 ms: v = 1.3180 V, ripple p-p 3.96 mV
target 1.32 V, formula ripple 3.96 mV

Servo-র তিনটি সারিতে CCR আর µs এক সংখ্যা, কারণ PSC = 71-এ এক count 1 µs; duty মাত্র 5 থেকে 10%. RC অংশে τ = 10 kΩ × 1 µF = 10 ms. 10 ms-এ (১ τ) ভোল্টেজ লক্ষ্যের প্রায় ৬৩%, 50 ms-এ (৫ τ) প্রায় পৌঁছে গেছে, 100 ms-এ 1.3180 V, লক্ষ্য 0.40 × 3.3 = 1.32 V-এর খুব কাছে। Ripple শুরুতে বেশি (capacitor তখন দ্রুত চার্জ হচ্ছে), স্থির হলে 3.96 mV, আনুমানিক সূত্রের সঙ্গে হুবহু। এই সংখ্যাগুলো আদর্শ উপাদানের মডেল: আসল circuit-এ pin-এর resistance, load-এর current আর capacitor-এর leakage ফল কিছুটা বদলায়।

আরও গভীরে: একটি নির্দিষ্ট timer clock-এ ধাপের সংখ্যা বাড়ানোর একটি চতুর কৌশল “dithering”: পরপর কয়েকটি period-এ CCR-কে n আর n + 1-এর মধ্যে পালা করে বসালে গড় duty দুই ধাপের মাঝামাঝি হয়, যেমন চারটি period-এর একটিতে n + 1 দিলে গড় n + 0.25. কিছু নতুন MCU-র timer-এ এমন dithering hardware-এই আছে, আর কিছু chip উচ্চ-resolution timer দিয়ে এক clock-এর চেয়েও সূক্ষ্ম ধার দেয় (নির্দিষ্ট chip-এর reference manual দেখে নিন)। আর STM32-এর timer DMA দিয়ে প্রতিটি update event-এ CCR-এ নতুন মান লিখতে পারে, ফলে CPU ছাড়াই PWM দিয়ে একটি পুরো waveform বা LED-এর একটি নকশা চালানো যায়; DMA-র ভিত্তি পর্ব ৪৬-এ।

পরীক্ষা ও ইন্টারভিউতে: (১) “72 MHz-এ PSC = 71, ARR = 999, CCR = 250 হলে frequency আর duty?” → 1 MHz ÷ 1000 = 1 kHz, 250 ÷ 1000 = 25%. (২) “PWM-এর resolution আর frequency-র সম্পর্ক?” → f = fTIM ÷ (ধাপের সংখ্যা); নির্দিষ্ট clock-এ এক বিট বেশি মানে frequency অর্ধেক। (৩) “Edge- আর centre-aligned-এর পার্থক্য?” → centre-aligned-এ counter ওঠে-নামে, pulse প্রতিসম, ধার ছড়ানো, একই ARR-এ frequency অর্ধেক; motor-এ প্রচলিত। (৪) “CCR-এর preload কেন?” → period-এর মাঝে লেখা নতুন মান পরের update event-এ নেওয়া হয়, তাই অনিয়মিত pulse হয় না। (৫) “Software PWM-এর সমস্যা?” → প্রতি ধাপে interrupt, CPU খরচ, কম resolution আর অন্য interrupt থেকে jitter.

৯ · AI-এর যুগে PWM-এর কোড যাচাই

“STM32-এ PWM-এর কোড দিন” লিখলে AI assistant দ্রুত কোড দেয়, আর প্রায়ই তা compile-ও হয়। কিন্তু PWM-এর ভুল সাধারণত compile-এ ধরা পড়ে না: frequency এক count ভুল, pin-এ কিছুই বেরোয় না, বা motor-এর জন্য বিপজ্জনক পরামর্শ। সবচেয়ে চেনা ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
ARR = 1000 লিখে 1 kHz দাবি করে (আসলে 1001 count), বা PSC-এর “+ 1” ভোলেf = fTIM ÷ ((PSC + 1)(ARR + 1)) নিজে হিসাব করুন; ওপরের Python block-এ মান বসিয়ে দেখুন
F4-এর MODER/AFR দিয়ে F1-এর pin সাজায়, বা F1-এ pin-কে সাধারণ push-pull রাখেনির্দিষ্ট chip-এর reference manual (F1: RM0008) আর datasheet-এর pin সারণি মেলান; AF-এর nibble দেখুন
CCER-এর CCxE, OCxPE বা UG ভোলে; timer-এর clock (APB1/APB2) গুলিয়ে ফেলেRM0008-এর PWM mode অংশের ধাপের তালিকা ধরে প্রতিটি register মিলিয়ে নিন
Timer-এর clock ভুল ধরে (APB prescaler-এর প্রভাব না জেনে)Clock tree থেকে timer-এর আসল clock বের করুন (পর্ব ৩৩); সম্ভব হলে debugger-এ register পড়ুন
Software PWM-এর ISR-এ ODR ^= দিয়ে RMW করে, volatile ভোলে, বা ISR-এ printf/delay রাখেBSRR/BRR ব্যবহার আর shared চলকে volatile আছে কি না দেখুন; Clang-এর -S পড়ুন, board-এ ধার মেপে নিন
Motor সরাসরি GPIO pin-এ বা flyback diode আর dead time ছাড়া; servo-র pulse-এর পরিসর নিশ্চিত বলে দেয়Driver-এর datasheet, H-bridge-এর dead time আর servo-র নিজের datasheet মিলিয়ে নিন

AI-কে কাজে লাগাতে chip, clock আর লক্ষ্য শুরুতেই স্পষ্ট বলুন, আর যাচাইয়ের শর্ত দিন:

আমি STM32F103-এর জন্য bare-metal C লিখছি (CMSIS header, HAL ছাড়া)। Reference manual RM0008. System clock 72 MHz, APB1 = 36 MHz. ১. TIM3-এর channel 1 (PA6) দিয়ে একটি passive buzzer-এ 2 kHz-এর PWM দাও, duty 0 থেকে 50% পর্যন্ত বদলানো যাবে। TIM3-এর input clock কত, আর কেন, আগে ব্যাখ্যা করবে। ২. PSC, ARR আর CCR1-এর মান সূত্রসহ দেখাবে: সূত্র f = f_TIM / ((PSC+1)(ARR+1)) ধরে। ৩. PA6-এর CRL nibble binary-তে বলবে; CCMR1-এর OC1M, OC1PE, CCER-এর CC1E, CR1-এর ARPE আর EGR-এর UG কেন লাগে, প্রতিটির এক লাইনের কারণ দেবে। ৪. কোনো register-এর নাম, বিট বা pin-এর alternate function নিয়ে নিশ্চিত না হলে "নিশ্চিত নই, RM0008 বা datasheet দেখুন" লিখবে; F4-এর MODER বা AFR ব্যবহার করবে না।

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

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

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

প্র ০১একটি motor-এর গতি কমাতে series-এ একটি resistor বা transistor দিয়ে ভোল্টেজ “ঝরিয়ে” ফেলা যায়। তবু power electronics প্রায় সবখানে PWM-এর মতো switching বেছে নিয়েছে কেন? এর দাম কী?

Linear পদ্ধতিতে, অর্থাৎ series-এ একটি resistor বা আংশিক চালু transistor রেখে, load-এর ভোল্টেজ কমানো যায়, কিন্তু বাড়তি ভোল্টেজ তাপ হয়ে হারায়। হিসাবটি সরল: 12 V-এর সরবরাহ থেকে একটি motor-কে 6 V-এ 1 A দিতে চাইলে বাকি 6 V নিয়ন্ত্রক transistor-এর ওপর পড়ে, আর সেখানে 6 V × 1 A = 6 W তাপ, motor যতটুকু পায় ঠিক ততটুকু। দক্ষতা ৫০%, আর transistor-এর জন্য বড় heat sink. Switching-এ transistor হয় পুরো চালু, যেখানে তার ওপর ভোল্টেজ প্রায় শূন্য, নয় পুরো বন্ধ, যেখানে current প্রায় শূন্য। দুই অবস্থাতেই ভোল্টেজ × current ছোট। তাই আদর্শ switch-এ ক্ষতি প্রায় শূন্য, আর বাস্তবে ক্ষতি আসে শুধু চালু অবস্থার ছোট resistance আর বদলের মুহূর্ত থেকে।

এই নীতিই আধুনিক power electronics-এর ভিত্তি। মোবাইল চার্জার আর ল্যাপটপের adapter-এর switching power supply, ইনভার্টার, বৈদ্যুতিক গাড়ি আর রেলের motor drive, class-D audio amplifier, সবখানে একই ধারণা: দ্রুত চালু-বন্ধ, তারপর inductance বা capacitor দিয়ে গড় করা। Power semiconductor, বিশেষ করে MOSFET আর IGBT, যত দ্রুত আর দক্ষ হয়েছে, এই পদ্ধতি তত ছড়িয়েছে; বিংশ শতাব্দীর শেষ কয়েক দশকে এটি linear পদ্ধতিকে বেশিরভাগ বড় power-এর কাজ থেকে সরিয়ে দিয়েছে বলে ধরা হয়।

দাম তিনটি। প্রথমত switching loss: প্রতিটি ধারে transistor কিছু সময় আধা চালু থাকে, তখন ভোল্টেজ আর current দুটোই বড়, তাই frequency বাড়লে এই ক্ষতি বাড়ে। এ কারণেই অংশ ৪-এর 281 kHz motor-এর জন্য সাধারণত অপ্রয়োজনীয়। দ্বিতীয়ত electromagnetic শব্দ: খাড়া ধার রেডিও-তরঙ্গ ছড়ায় আর পাশের analog circuit-কে বিরক্ত করে, যেমন smart scale-এর load cell-এর amplifier-কে, যেখানে কয়েক count-এর কাঁপুনি মানে কয়েক গ্রামের ভুল (প্রতি count প্রায় 1.43 g, README-র calibration অনুযায়ী)। তৃতীয়ত নকশার জটিলতা: flyback diode, dead time, filter আর layout-এর যত্ন। Linear পদ্ধতি এখনো টিকে আছে কম power আর কম শব্দের জায়গায়, যেমন সংবেদনশীল analog অংশের জন্য ছোট linear regulator.

মূল উপলব্ধি: Switch পুরো চালু বা পুরো বন্ধ থাকলে তার ওপর তাপ প্রায় শূন্য, তাই PWM দিয়ে গড় নিয়ন্ত্রণ linear পদ্ধতির চেয়ে অনেক দক্ষ; দাম হলো ধারের ক্ষতি, শব্দ আর সাবধানী নকশা।

প্র ০২8253/8254-এর mode 3 একটি square wave দিত। আজকের microcontroller-এর timer-এ প্রতিটি channel-এর compare register আর PWM mode কী নতুন সম্ভাবনা এনেছে, আর পুরোনো chip দিয়ে PWM কেন কষ্টকর ছিল?

Intel-এর 8253 আর তার উন্নত রূপ 8254 ১৯৭০ আর ১৯৮০-এর দশকের microprocessor সিস্টেমের সাধারণ timer chip ছিল; IBM PC-তেও এই পরিবারের একটি timer system tick আর speaker-এর সুর দিত বলে বহুল বর্ণিত। এর প্রতিটি counter নিচে গোনে আর ছয়টি mode-এর একটিতে চলে। Mode 3 square wave: count N জোড় হলে output N ÷ 2 count high আর N ÷ 2 low; বিজোড় হলে high (N + 1) ÷ 2 আর low (N − 1) ÷ 2 (পর্ব ২৫)। অর্থাৎ frequency ইচ্ছেমতো, কিন্তু duty প্রায় 50%-এ বাঁধা।

যেকোনো duty পেতে পুরোনো সিস্টেমকে কৌশল করতে হতো। একটি উপায় mode 1, অর্থাৎ hardware-triggered one-shot: একটি counter নির্দিষ্ট প্রস্থের একটি pulse দেয়, আর তার gate-এ আরেকটি counter-এর square wave দিয়ে প্রতিটি period-এ pulse চালু করা হয়। এতে দুটি counter, বাইরের তার, আর প্রতিবার duty বদলাতে একটি নতুন count লেখা লাগত। আরেক উপায় পুরো software: CPU একটি loop বা interrupt-এ port-এর বিট চালু-বন্ধ করে, যা এই পর্বের board-এর software PWM-এর পূর্বপুরুষ। তখনকার CPU কয়েক MHz-এ চলত আর প্রতিটি নির্দেশে অনেক T-state লাগত, তাই software PWM-এর resolution আর frequency দুটোই খুব কম থাকত।

আজকের timer-এ পার্থক্য মৌলিক। একটি counter-এর সঙ্গে কয়েকটি compare channel, প্রতিটির নিজের CCR আর output mode. ফলে একটি timer একই frequency-তে চারটি pin-এ চারটি আলাদা duty দেয়, CPU-র কোনো কাজ ছাড়া। Preload register duty বদলকে period-এর সীমায় বাঁধে; centre-aligned mode, complementary output আর dead time motor-control-কে hardware-এ নিয়ে আসে; আর DMA দিয়ে CCR-এ পরপর মান লিখে পুরো waveform বানানো যায়। ধারণাগত দিক থেকে compare unit হলো একটি তুলনাকারী (comparator) যা প্রতিটি count-এ “CNT < CCR?” প্রশ্ন করে; এই একটি ছোট hardware যোগ PWM-কে “কৌশল” থেকে “একটি register লেখা”-তে নামিয়ে এনেছে।

পরীক্ষার দিক থেকেও এটি জানা দরকার: 8253-এর mode 3-এর হিসাব আর আধুনিক timer-এর PSC/ARR/CCR-এর হিসাব একই মূল ধারণা, একটি clock ভাগ করে গোনা; শুধু আধুনিক timer গোনার মাঝে একটি তুলনার বিন্দু যোগ করেছে।

মূল উপলব্ধি: পুরোনো timer frequency দিত, duty-র জন্য বাড়তি counter বা CPU-র শ্রম লাগত; প্রতিটি channel-এ একটি compare register আর PWM mode duty-কে একটি register-এর মানে পরিণত করেছে, আর CPU-কে মুক্তি দিয়েছে।

প্র ০৩PWM দিয়ে জ্বলা LED আসলে প্রতি period-এ পুরো জ্বলে আর পুরো নেভে। তাহলে আমরা মাঝামাঝি উজ্জ্বলতা দেখি কেন, আর সেই দেখার নিয়ম কি PWM-এর frequency আর ধাপের নকশা ঠিক করে দেয়?

চোখ একটি ধীর যন্ত্র। একটি আলো যথেষ্ট দ্রুত জ্বলা-নেভা করলে আমরা আর কাঁপুনি দেখি না, একটি স্থির আলো দেখি; যে frequency-র ওপরে এমন হয়, তাকে critical flicker fusion বলা হয়, যা আলোর মাত্রা, রং, চোখের কোন অংশে পড়ছে আর মানুষভেদে বদলায়, সাধারণত কয়েক দশ Hz-এর ঘরে। আর সেই স্থির আলো কতটা উজ্জ্বল দেখায়, তার পুরোনো একটি নিয়ম Talbot–Plateau-র নিয়ম নামে পরিচিত, যা উনিশ শতকের প্রথম ভাগের গবেষণা থেকে এসেছে বলে বর্ণিত: fusion-এর ওপরে কাঁপা আলোর দেখা উজ্জ্বলতা তার সময়-গড়ের সমান। PWM-এর ভাষায়, চোখ duty × পূর্ণ উজ্জ্বলতা “দেখে”।

কিন্তু “দেখা উজ্জ্বলতা” আর “আমাদের অনুভূতি” এক নয়। চোখ আলোর পরিমাণের অনুপাত বোঝে, পার্থক্য নয়: অন্ধকার ঘরে একটি মোমবাতি অনেক, দুপুরে প্রায় কিছুই না। তাই সমান ধাপে duty বাড়ালে নিচের দিকের ধাপ বড় আর ওপরের দিকে প্রায় অদৃশ্য লাগে। ১৯৭৬ সালে CIE (আন্তর্জাতিক আলোক কমিশন) যে L* (lightness) মাপকাঠি দিয়েছিল, তা এই অনুভূতিকে একটি প্রায় ঘনমূলের বক্ররেখায় ধরে; আর কম্পিউটারের পর্দার জগৎ থেকে আসা “gamma 2.2” একটি কাছাকাছি সরল ঘাত। অংশ ৭-এর block-এ দুটির মান পাশাপাশি দেখা গেছে: মাঝের ধাপে linear 500, বাঁকা সূত্রে প্রায় 200.

এ থেকে নকশার দুটি নিয়ম বেরোয়। প্রথমত resolution: অন্ধকারের দিকে মসৃণ ধাপের জন্য খুব ছোট duty লাগে, যেমন 1000 ধাপের মধ্যে 10 বা 15, যা 8 বিটের PWM-এ ঠিকমতো বসে না। তাই ভালো LED dimmer-এ 10 থেকে 16 বিট দেখা যায়। দ্বিতীয়ত frequency: fusion-এর সামান্য ওপরে থাকলেই কাজ শেষ নয়। দ্রুত চোখ ঘোরালে বা চলন্ত জিনিসের ওপর আলো পড়লে PWM-এর আলো দাগ বা ভাঙা রেখার মতো দেখায় (stroboscopic effect), আর ক্যামেরার rolling shutter-এ ডোরা দেখা যায়। IEEE 1789-2015 নামের একটি recommended practice LED-এর flicker-এর ঝুঁকি কমাতে frequency আর modulation-এর গভীরতার মধ্যে সম্পর্কের নির্দেশনা দেয়; সংখ্যার জন্য মূল নথি দেখুন। ব্যবহারিক ফল: display-এর backlight-এ কয়েক শ Hz থেকে kHz-এর ঘর প্রচলিত।

বাজারঘরের smart scale-এর backlight-এর জন্য তাই সিদ্ধান্ত দাঁড়ায়: অন্তত 10 বিটের PWM, উজ্জ্বলতার আট ধাপ একটি lookup table থেকে, যা CIE L* বা gamma সূত্রে আগে হিসাব করা, আর frequency কয়েক kHz-এর আশেপাশে, যা LED driver-এর সীমার ভেতরে।

মূল উপলব্ধি: চোখ দ্রুত কাঁপা আলোকে সময়-গড় হিসেবে দেখে, কিন্তু সেই গড়কে অনুপাতে অনুভব করে; তাই PWM-এর frequency ঠিক হয় flicker এড়াতে, আর ধাপগুলো ঠিক হয় gamma বা CIE-এর মতো বাঁকা সূত্রে, যার জন্য বাড়তি resolution লাগে।

প্র ০৪একটি DC motor-এর PWM-এর frequency কীভাবে বাছবেন? খুব কম আর খুব বেশি, দুই দিকেই কী সমস্যা, আর centre-aligned PWM ও dead time এখানে কী ভূমিকা রাখে?

নিচের দিকের সীমা আসে motor-এর নিজের সময়-ধ্রুবক থেকে। Coil-এর inductance L আর resistance R মিলে একটি L ÷ R সময়-ধ্রুবক, যা current কত দ্রুত বদলাতে পারে তা ঠিক করে। PWM-এর period এর চেয়ে অনেক ছোট হলে প্রতিটি “চালু” অংশে current সামান্য বাড়ে, “বন্ধ” অংশে সামান্য কমে, আর গড় current মসৃণ থাকে। Period বড় হলে current প্রতিবার অনেক ওঠানামা করে: torque কাঁপে, motor গরম হয় বেশি (একই গড়ে বেশি ওঠানামা মানে বেশি তাপ), আর motor-এর কাঠামো সেই frequency-তে কাঁপে। কয়েক kHz-এর PWM-এ এই কাঁপুনি মানুষের কানে স্পষ্ট শোনা যায়, একটি তীক্ষ্ণ গুনগুন। তাই অনেক motor drive 20 kHz-এর আশেপাশে বা ওপরে চলে, যা বেশিরভাগ প্রাপ্তবয়স্কের শোনার সীমার কাছে বা বাইরে।

ওপরের দিকের সীমা আসে switching loss থেকে। প্রতিটি ধারে MOSFET কিছু সময় আধা চালু থাকে, আর সেই সময় ভোল্টেজ আর current দুটোই বড়; প্রতিবার কিছু শক্তি তাপ হয়। Frequency দ্বিগুণ মানে এই ক্ষতি মোটামুটি দ্বিগুণ। তার ওপর gate driver-কে প্রতিবার MOSFET-এর gate-এর capacitance চার্জ আর ডিসচার্জ করতে হয়। আর অংশ ৪-এর হিসাবে, নির্দিষ্ট timer clock-এ frequency বাড়ালে duty-র resolution কমে: 72 MHz-এ 20 kHz-এ 3600 ধাপ, 281 kHz-এ মাত্র 256. তাই frequency একটি সমঝোতা: যথেষ্ট বেশি যাতে current মসৃণ আর শব্দ শোনা না যায়, যথেষ্ট কম যাতে তাপ আর resolution ঠিক থাকে।

H-bridge-এ আরও একটি বিপদ আছে। একই পায়ের ওপরের আর নিচের transistor একসাথে চালু হলে সরবরাহ সরাসরি মাটিতে short হয়, যাকে shoot-through বলে; transistor বন্ধ হতে সময় লাগে বলে একটি বন্ধ আর অন্যটি চালুর মাঝে একটু বিরতি দিতে হয়, এই dead time. STM32-এর advanced timer (TIM1) complementary output জোড়া আর hardware dead-time generator দেয়, যাতে firmware-এর ভুলে shoot-through না হয়। Centre-aligned PWM এখানে দুটি সাহায্য করে: তিনটি phase-এর ধার একসাথে না পড়ে ছড়িয়ে যায়, আর pulse-এর কেন্দ্র নির্দিষ্ট থাকায় current মাপার ADC-কে switching-এর শব্দ থেকে দূরের মুহূর্তে চালানো যায়। এর পুরো নকশা পর্ব ৬৭-এ (Motor নিয়ন্ত্রণ); তবে সব সময় মনে রাখুন, motor-এর circuit-এ বড় current, তাই fuse, সঠিক driver আর ব্যাটারির নিরাপত্তা জরুরি।

মূল উপলব্ধি: Motor-এর PWM-এর frequency নিচে বাঁধা current-এর মসৃণতা আর শব্দে, ওপরে বাঁধা switching loss আর resolution-এ; H-bridge-এ dead time shoot-through ঠেকায়, আর centre-aligned PWM ধার ছড়ায় আর মাপার সময় দেয়।

প্র ০৫এই পর্বের board-এ software PWM ২.৯৬% CPU নিয়েছে। আসল প্রকল্পে কখন software PWM গ্রহণযোগ্য, কখন hardware PWM ছাড়া চলবে না, আর আধুনিক chip-গুলো এই প্রশ্নের কী উত্তর দিয়েছে?

প্রথমে সংখ্যাটির সীমা বুঝে নেওয়া দরকার। 2.96% এসেছে board থেকে, যেখানে এক নির্দেশ = এক cycle আর exception-এ ঢোকা-বেরোনো বিনামূল্যে (Spec decision 17 অনুযায়ী)। আসল Cortex-M3-এ প্রতিটি interrupt-এ entry আর exit-এ আরও প্রায় এক ডজন করে cycle, আর flash-এর wait state থাকলে নির্দেশও ধীর। তাই একই নকশা আসল chip-এ কয়েক গুণ বেশি খরচ করতে পারে; সঠিক সংখ্যা জানতে আসল chip-এ মাপতে হবে, যেমন একটি pin ISR-এর শুরুতে চালু আর শেষে বন্ধ করে logic analyzer-এ দেখা। তবু মূল প্রবণতা ঠিক: খরচ বাড়ে tick-এর হারের সঙ্গে, অর্থাৎ frequency × ধাপের সংখ্যা।

Software PWM গ্রহণযোগ্য যখন তিনটি শর্ত মেলে: frequency আর resolution কম (একটি status LED-এর মৃদু আলো, ধীর heater), ধারের ছোট কাঁপুনি ক্ষতিকর নয়, আর hardware channel ফুরিয়ে গেছে বা pin-টিতে কোনো timer নেই, যেমন STM32F103-এর PA5. সুবিধাও আছে: যেকোনো pin, যতগুলো চাই, আর একটি ISR-এ অনেকগুলো LED একসাথে। কিন্তু অন্য interrupt এলে ধার সরে যায়, CPU ঘুমাতে পারে না (প্রতি tick-এ জাগতে হয়, যা low-power নকশার বিপরীত, পর্ব ৬০), আর resolution বাড়ানো কার্যত অসম্ভব। Servo, motor বা সুর বাজানো buzzer-এর মতো কাজে, যেখানে pulse-এর প্রস্থ বা frequency-ই তথ্য, hardware PWM-ই সঠিক পথ।

আধুনিক chip-গুলো এই সমস্যার উত্তর দিয়েছে PWM channel-এর সংখ্যা বাড়িয়ে আর pin-এর সঙ্গে timer-এর যোগ নমনীয় করে। নতুন STM32 পরিবারে প্রতিটি pin-এর alternate function সংখ্যা দিয়ে বাছা যায়, ফলে একটি timer channel অনেক pin-এ যেতে পারে। Raspberry Pi-র RP2040-এর datasheet অনুযায়ী তাতে আটটি PWM slice, প্রতিটিতে দুটি output, আর প্রায় সব GPIO কোনো না কোনো PWM output পায়; তার PIO block দিয়ে নিজের মতো সময়-নির্ভর সংকেতও বানানো যায়। ESP32-এ LED-এর জন্য আলাদা একটি PWM peripheral (LEDC নামে পরিচিত) অনেক channel দেয়। এসব তথ্য নির্দিষ্ট chip-এর বর্তমান datasheet-এ মিলিয়ে নেবেন।

এই কোর্সে software PWM-এর আসল run-এর মূল্য অন্য জায়গায়: hardware-এর counter, compare আর preload কী করে, তা কোডে লিখলে একেবারে স্পষ্ট হয়, আর ধার মেপে duty যাচাইয়ের অভ্যাস তৈরি হয়, যা আসল hardware-এ logic analyzer দিয়ে একইভাবে করতে হয়।

মূল উপলব্ধি: Software PWM ধীর, কম-resolution আর কাঁপুনি-সহনশীল কাজে চলে, কিন্তু CPU আর ঘুম খায়; যেখানে ধারের সময়ই তথ্য, সেখানে hardware PWM, আর আধুনিক chip প্রায় প্রতিটি pin-এ PWM দিয়ে এই সিদ্ধান্ত সহজ করেছে।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — cold room-এর buzzer-এর তিন মাত্রার আওয়াজ: STM32F103, timer clock 72 MHz. PA6-এর TIM3_CH1 দিয়ে passive buzzer-এ 2 kHz-এর PWM চাই, তিনটি মাত্রা: জোরে (50%), মাঝারি (25%), আস্তে (10%) রাখতে হবে। PSC, ARR আর তিনটি CCR1 বের করুন, প্রতিটি মাত্রায় মূল সুর কত dB কমে বলুন, আর একটি alarm_level(int level) function লিখুন।

    PSC = 71 নিলে counter 1 MHz (এক count 1 µs); 2 kHz-এর period 500 µs, তাই ARR = 499. CCR1 = 250 (50%), 125 (25%), 50 (10%) হবে। মূল সুর sin(πD) অনুপাতে: 0.0 dB, −3.0 dB, −10.2 dB (অংশ ৭-এর block-এর মান)। যাচাই: 72 000 000 ÷ (72 × 500) = 2000 Hz.

    static const uint16_t level_ccr[3] = {50u, 125u, 250u}; /* আস্তে, মাঝারি, জোরে */
    
    void alarm_level(int level)              /* -1 = বন্ধ, 0..2 */
    {
        if (level < 0)       TIM3->CCR1 = 0u;   /* CCR = 0: OC1REF সবসময় 0 */
        else if (level > 2)  TIM3->CCR1 = level_ccr[2];
        else                 TIM3->CCR1 = level_ccr[level];
    }   /* init: অংশ ৫-এর buzzer_pwm_init(), OC1PE চালু তাই পরের period থেকে কার্যকর */

    এটি উদাহরণ, hardware-এ চালানো নয়; মানগুলো অংশ ৪-এর সূত্রে মেলানো। বন্ধ করতে CCR1 = 0 দেওয়া নিরাপদ, কারণ RM0008 অনুযায়ী তখন output স্থায়ীভাবে 0; timer চালু রেখেও buzzer চুপ। আসল আওয়াজ buzzer-এর resonance-এর ওপর নির্ভর করে, তাই 2 kHz না হয়ে buzzer-এর datasheet-এর resonant frequency নেওয়াই ভালো।

  2. ভুল খুঁজুন — 1 kHz-এর LED dimmer: একজন STM32F103-এ PB6-এর TIM4_CH1 দিয়ে 1 kHz, 25% চাইলেন (timer clock 72 MHz, PB6-এর nibble CRL-এর বিট ২৭–২৪): RCC->APB2ENR |= 1u << 3; RCC->APB1ENR |= 1u << 2; GPIOB->CRL = (GPIOB->CRL & ~(0xFu << 24)) | (0x2u << 24); TIM4->PSC = 71; TIM4->ARR = 1000; TIM4->CCR1 = 250; TIM4->CCMR1 = (6u << 4) | (1u << 3); TIM4->EGR = 1u; TIM4->CR1 |= 1u; LED একটুও জ্বলে না। তিনটি ভুল খুঁজুন।

    ১. Pin-এর mode: nibble 0x2 = CNF 00 (সাধারণ push-pull), তাই PB6 ODR-এর কথা শোনে, timer-এর নয়; ODR-এর বিট 0, তাই LED নেভা। Alternate function push-pull 2 MHz = CNF 10, MODE 10 = 0xA. ২. CCER-এর CC1E নেই: timer ঠিকই গোনে আর OC1REF তৈরি হয়, কিন্তু output-এর পথ বন্ধ; TIM4->CCER |= 1u; লাগবে। এই দুটির যেকোনো একটিতেই LED জ্বলত না। ৩. ARR-এর এক বেশি: ARR = 1000 মানে 1001 count, তাই f = 1 MHz ÷ 1001 ≈ 999.00 Hz আর duty 250 ÷ 1001 ≈ 24.98%, ঠিক 1 kHz আর 25% নয়; ARR = 999 হবে। বাকিগুলো ঠিক: IOPBEN APB2ENR-এর বিট ৩, TIM4EN APB1ENR-এর বিট ২ (RM0008-এর RCC অধ্যায়ে মিলিয়ে নিন), OC1M = 110 আর OC1PE আছে, UG আর CEN-ও আছে। হিসাব Python-এ চালিয়ে মেলানো: 999.000999 Hz, 24.975 %.

  3. আগে বলুন, তারপর মেলান — board-এর software PWM: অংশ ৬-এর firmware (SysTick 100 µs, ১০ ধাপ, duty শুধু period-এর শুরুতে latch, LED চালু BSRR আর বন্ধ BRR দিয়ে)। Period-গুলোর শুরুর ধার প্রায় x.1086 ms-এ। (ক) Duty 0/10-এ তিনটি period-এ log-এ কতগুলো GPIO লাইন আসবে? (খ) Main 9.0258 ms-এ duty 10/10 লিখলে LED কখন জ্বলবে? (গ) এরপর 12.0236 ms-এ 1/10 লিখলে প্রথম OFF কখন? (ঘ) 70%-এ মাপা high সময় কত cycle হবে, আর কেন 5600 নয়?

    (ক) শূন্য: LED আগে থেকেই নেভা, BRR-এর প্রতিটি লেখা কিছু বদলায় না, আর board শুধু অবস্থা বদলালে GPIO লাইন ছাপে (আসল run-এ 6.0236 থেকে 9.0258-এর মধ্যে একটিও লাইন নেই)। (খ) পরের period-এর শুরুতে, 9.1086 ms-এ, লেখার মুহূর্তে নয়। (গ) 12.1065-এর tick-এ duty 1 latch; সেই tick-এ phase 0, LED তো আগেই জ্বলছে (BSRR-এ কোনো বদল নেই), আর phase 1 = duty-তে, অর্থাৎ পরের tick-এ BRR: 12.2085 ms. (ঘ) 5599 cycle (3.1086 থেকে 3.8085): OFF-এর store ISR-এর শুরু থেকে যত নির্দেশ পরে আসে, ON-এর store তার চেয়ে এক নির্দেশ পরে আসে, তাই high অংশ এক cycle ছোট; period তবু ঠিক 8000, কারণ পরপর দুটি ON একই পথে। সব মান আমার lab-এর আসল run আর analyze.py-এর output থেকে।

  4. হিসাব — edge বনাম centre: Timer clock 72 MHz, PSC = 0. (ক) Edge-aligned, ARR = 1799, CCR1 = 450: frequency, duty, resolution (বিট) আর 3.3 V-এ গড় ভোল্টেজ কত? (খ) একই PSC-তে centre-aligned, ARR = 1800, CCR1 = 450: frequency আর duty? (গ) (ক)-এর PWM-কে 10 kΩ আর 1 µF-এর RC filter দিলে স্থির অবস্থায় আনুমানিক ripple কত?

    (ক) f = 72 MHz ÷ 1800 = 40 kHz; duty = 450 ÷ 1800 = 25%; resolution log2 1800 ≈ 10.81 বিট; গড় = 0.25 × 3.3 = 0.825 V. (খ) Centre-aligned-এ এক চক্র 2 × ARR = 3600 count, f = 72 MHz ÷ 3600 = 20 kHz; duty = CCR ÷ ARR = 450 ÷ 1800 = 25%. একই duty, অর্ধেক frequency; 20 kHz-এ edge-aligned-এর 3600 ধাপের তুলনায় এখানে 1800 ধাপ, অর্থাৎ এক বিট কম। (গ) ripple ≈ 3.3 × 0.25 × 0.75 × 25 µs ÷ 10 ms ≈ 1.55 mV. সব মান Python-এ সূত্র আর অংশ ৩-এর মডেলের মতো একটি ছোট সংস্করণে চালিয়ে মেলানো: 40000.0 Hz, 10.81 bit, 20000.0 Hz, 1.55 mV.

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

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

ক্রমSTM32F103-এ TIM3_CH1 (PA6) দিয়ে PWM চালুর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. RCC-তে GPIOA আর TIM3-এর clock চালু করা
  2. PA6-কে alternate function push-pull mode-এ সাজানো
  3. PSC, ARR আর CCR1-এ frequency আর duty-র মান লেখা
  4. CCMR1-এ OC1M = 110 (PWM mode 1) আর OC1PE, তারপর CCER-এ CC1E
  5. EGR-এ UG লিখে সব shadow register লোড করা
  6. CR1-এ CEN দিয়ে counter চালু করা

একটি timer-এর clock 72 MHz, PSC = 71, ARR = 999, PWM mode 1, edge-aligned, CCR = 250. PWM-এর frequency আর duty কত?

  • 72 kHz, 25%
  • 1 kHz, 25%
  • 1 kHz, 75%
  • 1.014 MHz, 25%

একটি 16 MHz timer clock-এ (PSC = 0) একটি edge-aligned PWM-এ ঠিক 8 বিট resolution (256 ধাপ) চাই। সর্বোচ্চ PWM frequency কত?

  • 2 MHz
  • 244 Hz
  • 62.5 kHz
  • 62.7 kHz

একই timer clock, PSC আর ARR রেখে একটি PWM-কে edge-aligned থেকে centre-aligned mode-এ নিলে frequency-তে কী হয়?

  • প্রায় অর্ধেক হয়
  • দ্বিগুণ হয়
  • বদলায় না, শুধু pulse মাঝখানে সরে
  • PWM বন্ধ হয়ে যায়

একটি motor-এর PWM চলাকালীন firmware যখন-তখন CCR-এ নতুন duty লেখে। মাঝে মাঝে motor-এ একটি অস্বাভাবিক ঝাঁকুনি আসে। STM32-এর timer-এর কোন সেটিং এই সমস্যা কমায়?

  • ARR-এর মান বাড়ানো
  • PWM mode 1 থেকে mode 2-এ যাওয়া
  • PSC বাড়ানো
  • CCMRx-এ OCxPE দিয়ে CCR-এর preload চালু করা

STM32-এর edge-aligned PWM mode 1-এ ARR = 499. Output-কে সারাক্ষণ 1 (100% duty) রাখতে CCR-এ কোন মান দেবেন?

  • 0
  • 499
  • 500
  • 250

একটি 3.3 V-এর PWM, duty 40%, frequency 20 kHz, একটি RC low-pass filter (R = 10 kΩ, C = 1 µF)-এর মধ্য দিয়ে গেল। কয়েক শ ms পরে capacitor-এর ভোল্টেজ প্রায় কত, আর তাতে কী থাকে?

  • প্রায় 3.3 V, কোনো ওঠানামা ছাড়া
  • প্রায় 1.32 V, ওপরে কয়েক mV-এর ripple
  • প্রায় 0 V
  • 0 থেকে 3.3 V-এর পুরো square wave

শব্দকোষ

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

মনে রাখুন

  1. PWM: period T = 1 ÷ f, duty D = ton ÷ T, গড় = D × VDD; যন্ত্র বা filter দ্রুত ওঠানামা গড় করে দেয়।
  2. Timer: f = fTIM ÷ ((PSC + 1)(ARR + 1)), duty = CCR ÷ (ARR + 1); mode 1-এ CNT < CCR হলে 1; CCR = 0 মানে 0%, CCR > ARR মানে 100%; centre-aligned-এ চক্র 2 × ARR.
  3. Resolution বনাম frequency: নির্দিষ্ট clock-এ এক বিট বেশি মানে frequency অর্ধেক; 72 MHz-এ 20 kHz মানে 3600 ধাপ।
  4. STM32F103: দুটি clock, pin AF push-pull, OC1M = 110 আর OC1PE, CC1E, UG, তারপর CEN; preload duty বদলকে period-এর সীমায় বাঁধে।
  5. Board-এর আসল run: software PWM-এ period নিখুঁত 8000 cycle, high সময় 2399 (ISR-এর পথের পার্থক্য), CPU 2.96% (board-এর মডেলে); LED-এ gamma, buzzer-এ duty দিয়ে আওয়াজ, servo-তে pulse-এর প্রস্থ।

পরের পর্বে: পর্ব ৪৬ (DMA). CPU ছাড়া data সরানো, ADC থেকে buffer-এ circular DMA, half আর full transfer-এর interrupt আর double buffering; সঙ্গে পুরোনো 8237-এর সঙ্গে তুলনা।

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

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