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

Motor নিয়ন্ত্রণ — DC, servo আর stepper motor, H-bridge

Motor Control — DC, Servo and Stepper Motors, H-Bridge

Taught in Bangla, this lesson explains back-EMF and why a modelled 12 V motor draws 3.00 A at stall but 0.50 A loaded, and how an H-bridge drives both directions without shoot-through by adding dead time. It reads the DRV8833 truth table, then runs real C firmware on the virtual BG-M3 board, where the code coasts 2 ms before reversing and each half step changes exactly one pin with a single BSRR store. Step angles, servo pulses, 4x quadrature decoding with a lookup table, flyback diodes and motor noise complete it.

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

  • DC motor-এর back-EMF, torque আর গতির সম্পর্ক, stall current আর চালুর মুহূর্তের current-এর হিসাব
  • H-bridge-এর চারটি অবস্থা (সামনে, পেছনে, coast, brake), shoot-through, dead time আর driver IC-এর truth table
  • Virtual বাজারঘর board-এ H-bridge আর stepper-এর pin sequence চালিয়ে আসল log পড়া, আর compiler-এর output যাচাই
  • Stepper motor-এর wave, full আর half step, step angle আর conveyor-এর হিসাব; servo-র মূল নিয়ম
  • Quadrature encoder decode করে দিক, অবস্থান আর rpm বের করা, আর motor-এর circuit-এর নিরাপত্তার নিয়ম

১ · Motor কেন আলাদা — pin থেকে ঘূর্ণন পর্যন্ত

এখন পর্যন্ত কোর্সের firmware বেশিরভাগ সময় “শুনেছে”: ADC থেকে ওজন, I2C থেকে তাপমাত্রা। এই পর্বে firmware “কাজ করবে”: কিছু ঘোরাবে, সরাবে, ঠেলবে। যে যন্ত্র বৈদ্যুতিক সংকেতকে চলনে বদলায়, তাকে actuator বলে; motor সবচেয়ে প্রচলিত actuator. তিন ধরনের motor এখানে আসবে: সাধারণ DC motor (খেলনা গাড়ি, ফ্যান, পাম্প), servo (নির্দিষ্ট কোণে যাওয়া), আর stepper motor (ঠিক মাপের ধাপে ঘোরা, যেমন printer-এর কাগজ টানা)।

প্রথম শিক্ষা: motor কখনো সরাসরি microcontroller-এর pin-এ নয়। একটি GPIO pin সাধারণত কয়েক থেকে কুড়ি-পঁচিশ mA দিতে পারে (নির্দিষ্ট chip-এর datasheet-এ “absolute maximum” দেখুন), আর একটি ছোট motor চালুর মুহূর্তে কয়েক শ mA থেকে কয়েক A টানে। তার ওপর motor-এর coil একটি inductance: current হঠাৎ বন্ধ করলে সে উচ্চ ভোল্টেজের ঝটকা তোলে, যা pin আর chip দুটোই নষ্ট করতে পারে। তাই মাঝে সবসময় একটি motor driver থাকে: একটি transistor, একটি H-bridge বা একটি তৈরি driver IC. MCU শুধু driver-এর input-এ logic সংকেত দেয়, আর motor-এর বড় current আসে আলাদা সরবরাহ থেকে।

উপমা — রিকশা আর মালিক: একটি রিকশার মালিক নিজে প্যাডেল চাপেন না; তিনি শুধু বলেন “বাঁয়ে”, “থামুন”, “জোরে”। আসল শক্তি দেন রিকশাওয়ালা। MCU হলো মালিক: কয়েক mA-এর সংকেত দেয়। Driver হলো রিকশাওয়ালা: ব্যাটারি থেকে কয়েক A টেনে motor ঘোরায়। মালিক নিজে প্যাডেলে পা দিলে, অর্থাৎ pin সরাসরি motor-এ জুড়লে, দুজনেরই ক্ষতি।

বাজারঘরের দুটি device-এর সঙ্গে এই পর্বের একটি কাল্পনিক সংযোজন ধরে নিই (README-র device-এর সংখ্যাগুলো বদলায় না): cold room-এর evaporator-এর একটি DC fan, যার গতি PWM দিয়ে বদলানো যায়, আর smart scale-এর পাশে একটি ছোট conveyor, যা একটি stepper দিয়ে পণ্যের থলে নির্দিষ্ট দূরত্ব সরায়। দুটিই শুধু শেখার উদাহরণ।

লেখার নিয়ম আর 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-এ কোনো motor, driver, encoder বা PWM timer নেই; আছে GPIO আর SysTick. তাই board-এর run দেখায় শুধু firmware কোন pin কখন বদলায়। Motor-এর আচরণ এসেছে ব্রাউজারে চলা Python মডেল থেকে, যার মানগুলো অনুমিত, আর driver IC-এর তথ্য নির্মাতার datasheet থেকে। হাতে কোনো আসল motor বা oscilloscope ছিল না।

২ · DC motor — back-EMF, torque আর গতি

একটি brushed DC motor-এর ভেতরে চুম্বকের মাঝে একটি ঘূর্ণমান coil (armature), আর একটি commutator ও brush, যা প্রতি আধা পাকে coil-এর current-এর দিক উল্টে দেয়, যাতে ঘোরার টান একই দিকে থাকে। Firmware-এর জন্য ভেতরের গঠনের চেয়ে তিনটি সূত্র বেশি দরকারি। Coil-এর resistance R, inductance L, আর motor-এর একটি ধ্রুবক k ধরলে:

DC motor-এর তিন সূত্র (আদর্শ মডেল)

back-EMF E = k × ω  ·  torque T = k × I  ·  V = I × R + L × dI/dt + k × ω

স্থির অবস্থায়: I = (V − k ω) ÷ R,   stall current = V ÷ R,   no-load গতি ≈ V ÷ k

ω হলো কৌণিক গতি (rad/s; rpm = ω × 60 ÷ 2π)। প্রথম সূত্রটিই মূল রহস্য: ঘোরা coil চুম্বকের মধ্যে একটি ভোল্টেজ বানায়, যা সরবরাহের উল্টো দিকে। একে back-EMF বলে। Motor যত জোরে ঘোরে, back-EMF তত বড়, আর coil-এর ওপর আসল চাপ (V − E) তত ছোট; তাই current কমে। থেমে থাকা motor-এ E = 0, তাই current শুধু R দিয়ে সীমিত: এটি stall current, চালুর মুহূর্তের প্রায় সর্বোচ্চ current. দ্বিতীয় সূত্র বলে torque current-এর সমানুপাতিক। দুটি মেলালে একটি সরলরেখা পাওয়া যায়: শূন্য গতিতে সবচেয়ে বেশি torque (stall torque), আর torque শূন্য হলে সবচেয়ে বেশি গতি। এই রেখাকে torque–speed curve বলে। SI একক ব্যবহার করলে back-EMF-এর k (V·s/rad) আর torque-এর k (N·m/A) একই সংখ্যা।

নিচের block-এ একটি অনুমিত 12 V motor (R = 4 Ω, L = 2 mH, k = 0.02, rotor-এর জড়তা J = 2 × 10−6 kg·m², load 10 mN·m) দুইভাবে দেখা হয়েছে: প্রথমে স্থির অবস্থার সূত্র, তারপর সময় ধরে ছোট ছোট ধাপে (2.5 µs) simulation, 20 kHz PWM-সহ। PWM-এর off অংশে motor-এর দুই প্রান্ত মাটিতে জোড়া ধরা হয়েছে (slow decay, অংশ ৩)। মানগুলো কোনো আসল motor-এর নয়; আসল motor-এর R, k আর J তার datasheet থেকে নিতে হয়।

# একটি ছোট 12 V DC motor-এর মডেল (মানগুলো অনুমিত, কোনো আসল motor-এর নয়)
R, L, K = 4.0, 2e-3, 0.02     # ohm, henry, V·s/rad (= N·m/A)
J, TL = 2e-6, 0.01            # kg·m², load torque N·m
VS = 12.0
RPM = 60 / (2 * 3.141592653589793)

print(f"stall current {VS/R:.2f} A, stall torque {K*VS/R*1000:.0f} mN·m")
print(f"no-load {VS/K*RPM:.0f} rpm, tau_e {L/R*1000:.2f} ms, tau_m {J*R/K**2*1000:.0f} ms")
for v in (12.0, 6.0):         # গড় ভোল্টেজ: 100% আর 50% duty
    i = TL / K                # স্থির অবস্থায় K·I = load torque
    print(f"V = {v:4.1f} V -> I = {i:.2f} A, speed {(v - i*R)/K*RPM:.0f} rpm")

def run(duty, f_pwm=20_000, dt=2.5e-6):
    i = w = peak = 0.0
    per = round(1 / f_pwm / dt)              # এক PWM period-এ ২০ ধাপ
    speeds, lo, hi = [], 9.0, 0.0
    for n in range(1, 40_001):               # 100 ms
        v = VS if (n % per) < round(duty * per) else 0.0   # off = slow decay
        i += (v - R*i - K*w) / L * dt
        torque = K*i - TL
        if w > 0 or torque > 0:              # load-এর চেয়ে কম torque-এ স্থির
            w += torque / J * dt
        peak = max(peak, i)
        if n % 4000 == 0:                    # প্রতি 10 ms
            speeds.append(round(w * RPM))
        if n > 40_000 - per:                 # শেষ period-এর ripple
            lo, hi = min(lo, i), max(hi, i)
    return peak, speeds, lo, hi

for duty in (1.0, 0.5):
    peak, s, lo, hi = run(duty)
    print(f"duty {duty:.0%}: peak {peak:.2f} A, rpm at 10/20/40/100 ms: "
          f"{s[0]}, {s[1]}, {s[3]}, {s[9]}; last period I {lo:.2f}..{hi:.2f} A")

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

stall current 3.00 A, stall torque 60 mN·m
no-load 5730 rpm, tau_e 0.50 ms, tau_m 20 ms
V = 12.0 V -> I = 0.50 A, speed 4775 rpm
V =  6.0 V -> I = 0.50 A, speed 1910 rpm
duty 100%: peak 2.83 A, rpm at 10/20/40/100 ms: 1826, 3009, 4142, 4746; last period I 0.52..0.52 A
duty 50%: peak 1.47 A, rpm at 10/20/40/100 ms: 724, 1200, 1656, 1898; last period I 0.47..0.54 A

প্রথম লাইন: থেমে থাকা অবস্থায় 12 V ÷ 4 Ω = 3.00 A, torque 0.02 × 3 = 60 mN·m. দ্বিতীয় লাইনে no-load গতি 12 ÷ 0.02 = 600 rad/s ≈ 5730 rpm; electrical সময়-ধ্রুবক L ÷ R = 0.50 ms, আর mechanical সময়-ধ্রুবক J R ÷ k² = 20 ms, অর্থাৎ current গতির চেয়ে প্রায় চল্লিশ গুণ দ্রুত বদলায়। স্থির অবস্থায় load-এর 10 mN·m-এর জন্য current সবসময় 10 ÷ 0.02 = 0.50 A, ভোল্টেজ যা-ই হোক; ভোল্টেজ শুধু গতি ঠিক করে: 12 V-এ 4775 rpm, 6 V-এ 1910 rpm. গতি অর্ধেকের কম হলো, কারণ 0.5 A × 4 Ω = 2 V দুই ক্ষেত্রেই coil-এ হারায়। Simulation সূত্রের সঙ্গে মেলে: 100 ms-এ (৫ τ) 4746 আর 1898 rpm, লক্ষ্যের ৯৯%-এর বেশি। চালুর মুহূর্তের peak 100%-এ 2.83 A, প্রায় stall current, আর 50% duty-তে 1.47 A. শেষ period-এ 50%-এর current 0.47 থেকে 0.54 A-এর মধ্যে ওঠানামা করে; এই ripple আনুমানিক V × D (1 − D) ÷ (L f) = 12 × 0.25 ÷ (0.002 × 20 000) = 0.075 A.

শেষ পর্যবেক্ষণটি নকশায় কাজে লাগে: PWM-এর frequency যত বেশি আর coil-এর L যত বড়, current তত মসৃণ। Frequency বাছাইয়ের পুরো দরকষাকষি (শব্দ, switching loss, resolution) পর্ব ৪৫-এ (PWM); এখানে ধরে নিচ্ছি timer-এর একটি PWM channel driver-এর input-এ যায়। নিচের stepper-এ একই মডেলে 12 V হঠাৎ দিলে কী হয়, সময় ধরে দেখুন।

12 V, R = 4 Ω, k = 0.02, load 10 mN·m
সময়
current I
back-EMF k ω
torque k I
গতি
  1. সুইচ চালু। Motor থেমে, current শূন্য। Coil-এর inductance current-কে হঠাৎ লাফাতে দেয় না।
  2. 0.10 ms. Current 0.55 A, torque 10.9 mN·m, load-এর 10 mN·m-কে সবে ছাড়িয়েছে; rotor এখনো প্রায় স্থির, তাই back-EMF শূন্য।
  3. 0.50 ms (এক electrical τ). Current 1.90 A, বাড়ছে L ÷ R = 0.5 ms সময়-ধ্রুবকে। Rotor ঘুরতে শুরু করেছে: 31 rpm.
  4. 2.0 ms, peak. Current 2.83 A, stall current 3.00 A-এর খুব কাছে। এখানে 12 − 2.83 × 4 − 0.70 ≈ 0 V, তাই current আর বাড়ে না। Driver আর power supply-কে এই peak সামলাতে হয়।
  5. 10 ms. গতি 1826 rpm, back-EMF 3.82 V. Coil-এর ওপর চাপ কমেছে, তাই current নেমে 2.08 A.
  6. 20 ms (এক mechanical τ). 3009 rpm, চূড়ান্ত গতি 4775-এর প্রায় ৬৩%. Current 1.45 A.
  7. 40 ms. 4142 rpm, back-EMF 8.68 V, current 0.84 A. বাড়তি torque কমছে, তাই গতি বাড়ার হারও কমছে।
  8. 100 ms. প্রায় স্থির: 4746 rpm, back-EMF 9.94 V, current 0.52 A, torque প্রায় load-এর সমান। চালুর peak-এর তুলনায় current প্রায় সাড়ে পাঁচ ভাগের এক ভাগ।

সাবধান — stall current: Motor আটকে গেলে (conveyor-এ থলে জ্যাম, fan-এ কিছু ঢুকে গেলে) back-EMF শূন্য থাকে, আর current টানা stall-এর মানে থাকে। এতে coil, driver আর তার গরম হয়, আর ব্যাটারি দ্রুত খালি হয়। তাই নকশায় তিনটি সুরক্ষা রাখুন: driver-এর current limit (অনেক driver IC-এ একটি sense resistor দিয়ে ঠিক করা যায়), firmware-এ encoder বা current দেখে “চালু অথচ ঘুরছে না” ধরলে বন্ধ করা, আর সরবরাহে fuse. বড় ব্যাটারি, বিশেষ করে Li-ion, শর্ট হলে আগুন ধরাতে পারে; কাজের সময় current-সীমিত bench supply ব্যবহার করুন, আর mains-এর কোনো circuit-এ নিজে কাজ করবেন না।

৩ · H-bridge — চারটি switch, চারটি অবস্থা

একটি transistor দিয়ে motor চালু-বন্ধ আর PWM-এ গতি বদলানো যায়, কিন্তু শুধু এক দিকে। দিক বদলাতে motor-এর দুই প্রান্তের ভোল্টেজ উল্টাতে হয়। সমাধান চারটি switch, সাধারণত MOSFET, যা ছবিতে “H” অক্ষরের মতো সাজানো: দুটি খাড়া “পা”, প্রতিটিতে ওপরে একটি (supply-এর দিকে, high-side) আর নিচে একটি (মাটির দিকে, low-side), আর মাঝের আড়াআড়ি দাগে motor. S1 আর S4 চালু হলে current বাঁ থেকে ডানে যায়; S3 আর S2 চালু হলে ডান থেকে বাঁয়ে। প্রতিটি switch-এর পাশে একটি diode, যা ছবিতে দেখানো।

ছবি ৬৭.১ — H-bridge, সামনে ঘোরার পথ

S1 আর S4 চালু: current-এর পথ সবুজে। প্রতিটি switch-এর পাশে flyback diode (MOSFET-এ এটি তার body diode-ও হতে পারে)

H-bridge আর সামনে ঘোরার current-এর পথ VM (motor-এর সরবরাহ) GND S1S2 S3S4 M OUT1OUT2 সামনে: S1 + S4 নিষিদ্ধ: S1 + S2
ছবি ৬৭.১ — সামনে ঘোরার সময় S1 (ওপর-বাঁ) আর S4 (নিচে-ডান) চালু, তাই OUT1 ≈ VM আর OUT2 ≈ 0 V. পেছনে ঘুরতে S3 আর S2. একই পায়ের S1 আর S2 (বা S3 আর S4) একসাথে চালু হলে VM সরাসরি GND-তে short. Diode-গুলো স্বাভাবিক অবস্থায় বন্ধ থাকে; switch বন্ধ হলে coil-এর current-কে ফেরার পথ দেয়। ছবি ধারণার জন্য, মাপমতো নয়।

চারটি switch-এর ষোলোটি সমন্বয়ের মধ্যে কাজের অবস্থা চারটি, আর কয়েকটি বিপজ্জনক:

অবস্থাচালু switchMotor-এর ওপরফল
সামনে (forward)S1, S4+VMএক দিকে ঘোরে
পেছনে (reverse)S3, S2−VMউল্টো দিকে ঘোরে
Coastকোনোটি নয়খোলাশক্তি নেই, ধীরে থামে
BrakeS2, S4 (বা S1, S3)দুই প্রান্ত জোড়াback-EMF নিজের coil-এ current চালায়, দ্রুত থামে
Shoot-throughS1, S2 বা S3, S4—VM থেকে GND-তে সরাসরি short: কখনো নয়

শেষ সারিটি H-bridge-এর সবচেয়ে বড় বিপদ, যাকে shoot-through বলে। Firmware-এ ভুল করে দুটি switch একসাথে চালু না করলেও এটি ঘটতে পারে: MOSFET চালু হতে আর বন্ধ হতে কিছু সময় লাগে, সাধারণত ns থেকে µs-এর ঘরে। S1 বন্ধ আর S2 চালুর আদেশ একই মুহূর্তে দিলে S1 পুরো বন্ধ হওয়ার আগেই S2 চালু হতে পারে, আর সেই ছোট সময়ে বিশাল current. তাই একটি বন্ধ আর অন্যটি চালুর মাঝে একটু বিরতি রাখা হয়, যাকে dead time বলে। নিজের MOSFET দিয়ে bridge বানালে dead time আপনার দায়িত্ব; STM32-এর advanced timer (TIM1)-এ complementary output আর hardware dead-time generator এই কাজের জন্যই (পর্ব ৪৫)।

Brake আর coast-এর পার্থক্য PWM-এর সময়ও গুরুত্বপূর্ণ। PWM-এর off অংশে coil-এর current হঠাৎ থামতে পারে না; সে কোথাও দিয়ে চলতে থাকে, যাকে recirculation বলে। দুটি পথ আছে, যাকে driver-এর ভাষায় decay mode বলে। Fast decay-এ সব switch বন্ধ, current diode দিয়ে supply-এর দিকে ফেরে আর দ্রুত কমে। Slow decay-এ দুটি low-side switch চালু, coil নিজের ওপর short, current ধীরে কমে। অংশ ২-এর মডেল slow decay ধরে চলেছে; এতে একই duty-তে current মসৃণ থাকে, আর গতি duty-র সঙ্গে মোটামুটি সরলরেখায় বদলায়।

তৈরি driver IC — truth table পড়া

বাস্তবে বেশিরভাগ ছোট প্রকল্পে চারটি আলাদা MOSFET নয়, একটি driver IC ব্যবহার হয়। দুটি পরিচিত উদাহরণ, তাদের datasheet থেকে:

  • TI DRV8833 (datasheet SLVSAR1E): দুটি H-bridge, N-channel MOSFET দিয়ে; সরবরাহ 2.7 থেকে 10.8 V; PWP আর RTY package-এ প্রতিটি bridge-এ 1.5 A RMS, 2 A peak (VM = 5 V, 25 °C-এ); undervoltage, overcurrent আর অতিরিক্ত তাপের সুরক্ষা, nFAULT pin আর nSLEEP দিয়ে ঘুম। দুটি DC motor বা একটি bipolar stepper চালাতে পারে।
  • ST L298: পুরোনো bipolar transistor-এর দুটি full bridge; datasheet অনুযায়ী সরবরাহ 46 V পর্যন্ত, মোট DC current 4 A পর্যন্ত। Datasheet স্পষ্ট বলে, inductive load চালাতে আর input chop করলে বাইরে diode-এর একটি bridge লাগবে (দ্রুত recovery-র, Schottky হলে ভালো)।
xIN1xIN2xOUT1xOUT2কাজ (datasheet-এর Table 1)
00ZZCoast / fast decay
01LHReverse
10HLForward
11LLBrake / slow decay

লক্ষ করুন, চারটি input-এর কোনোটিই shoot-through-এর অবস্থা নয়: IC-এর ভেতরের logic ঠিক করে কোন MOSFET কখন চালু হবে। PWM দিয়ে গতি বদলাতে datasheet-এর Table 2 দুটি উপায় দেয়: একটি input-এ PWM আর অন্যটি 0 (fast decay), বা একটি input 1 রেখে অন্যটিতে PWM (slow decay); slow decay-তে PWM উল্টো অর্থে কাজ করে, কারণ input 0-এর সময়টাই চালানোর সময়। L298-এর ভাষা একটু আলাদা: Enable pin low হলে “free running motor stop” (coast), আর দুই input সমান হলে “fast motor stop” (brake).

একটি বড় শিক্ষা আছে firmware-এর জন্য। চলন্ত motor-কে সরাসরি সামনে থেকে পেছনে ঘোরালে কী হয়? সেই মুহূর্তে back-EMF আর নতুন সরবরাহ একই দিকে যোগ হয়: অংশ ২-এর motor 4746 rpm-এ থাকলে E = 9.94 V, তাই current প্রায় (12 + 9.94) ÷ 4 = 5.485 ≈ 5.5 A, stall current-এরও প্রায় দ্বিগুণ। একে plugging বলে। তাই দিক বদলের আগে PWM কমানো, তারপর coast বা brake দিয়ে গতি নামানো, আর তারপর নতুন দিক, এটিই নিরাপদ নিয়ম। এটি transistor-স্তরের dead time (ns বা µs) থেকে আলাদা, এখানে বিরতি ms-এর ঘরে, motor-এর গতি কমার জন্য।

৪ · বাজারঘর board-এ H-bridge আর stepper — আসল run

এখন firmware লিখে board-এ চালানো যাক। Board-এর README শুধু তিনটি pin-এর নাম দেয় (PA0 বোতাম, PA5 LED, PA6 alarm), কিন্তু Spec decision 23 অনুযায়ী DIR-এ 1 লেখা যেকোনো pin output হয় আর প্রতিটি বদল log-এ আসে। তাই কাল্পনিক wiring: PA7 আর PA8 একটি DRV8833-ধাঁচের driver-এর IN1 আর IN2-এ, আর PA1 থেকে PA4 একটি stepper-এর চারটি coil-এর driver-এ (A, B, A′, B′)। SysTick প্রতি 1 ms-এ একটি interrupt দেয় (LOAD = 8 000 000 ÷ 1000 − 1 = 7999, Spec decision 22). আমার lab-এর motor.c-এর মূল অংশ, reference lab-এর bazarghar.h আর bglib.c ব্যবহার করে:

static const uint8_t half_step[8] = {0x1, 0x3, 0x2, 0x6, 0x4, 0xC, 0x8, 0x9};
static volatile uint32_t ms_ticks;        /* ISR লেখে, main পড়ে */
static volatile int32_t step_pos;         /* ISR লেখে, main পড়ে */
static volatile int32_t step_target;      /* main লেখে, ISR পড়ে */

static void put_pins(uint32_t mask, uint32_t bits)   /* একটি store */
{
    GPIOA->BSRR = (bits & mask) | ((~bits & mask) << 16);
}

static void hbridge_set(enum hb s)
{
    if ((hb_now == HB_FWD && s == HB_REV) || (hb_now == HB_REV && s == HB_FWD)) {
        put_pins(HB_MASK, 0);             /* সরাসরি উল্টো নয়: আগে coast */
        uart_puts("H-bridge: COAST (pause before reversing)\n");
        delay_ms(2);
    }
    uint32_t bits = ((s & 1u) ? 1u << IN1 : 0u) | ((s & 2u) ? 1u << IN2 : 0u);
    put_pins(HB_MASK, bits);
    hb_now = s;                           /* তারপর অবস্থার নাম UART-এ */
}

void SysTick_Handler(void)
{
    ms_ticks++;
    if (ms_ticks % 5u == 0u && step_pos != step_target) {   /* 5 ms-এ এক half step */
        int32_t p = step_pos + (step_target > step_pos ? 1 : -1);
        put_pins(COIL_MASK, (uint32_t)half_step[p & 7] << 1);
        step_pos = p;
    }
}
/* main: FWD 20 ms, REV 20 ms, BRAKE 10 ms, COAST; তারপর stepper 0 → 8 → 4, coil বন্ধ */

তিনটি নকশার সিদ্ধান্ত লক্ষ করুন। প্রথমত put_pins: একটি BSRR store-এ mask-এর যে বিট 1 চাই সেগুলো নিচের অর্ধেকে (set), আর যেগুলো 0 চাই সেগুলো ওপরের অর্ধেকে (reset). কোনো read-modify-write নেই, তাই main আর ISR একই port-এ লিখলেও একে অন্যের বিট নষ্ট করে না, আর একই বিটে set ও reset কখনো একসাথে নয় (পর্ব ৩৫)। দ্বিতীয়ত hbridge_set নিজেই নিয়ম রক্ষা করে: সামনে থেকে পেছনে বা উল্টো যাওয়ার অনুরোধ এলে আগে 2 ms coast. ডাকার কোড ভুলে গেলেও motor বাঁচে। তৃতীয়ত main আর ISR-এর ভাগ করা তিনটি চলক volatile (পর্ব ৩৪)। Build আর run:

সত্যিকারের run · Clang 22.1.8 (ziglang 0.17.1), Unicorn 2.1.4, বাজারঘর board BG-M3
~/lab/bg$ python -B board.py build ../fw/motor.c -o ../build/motor.elf
built ../build/motor.elf
~/lab/bg$ python -B board.py run ../build/motor.elf
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0084 ms] GPIO PA7 = 1
[     0.0256 ms] UART: H-bridge: FORWARD
[    20.0109 ms] GPIO PA7 = 0
[    20.0425 ms] UART: H-bridge: COAST (pause before reversing)
[    22.0084 ms] GPIO PA8 = 1
[    22.0256 ms] UART: H-bridge: REVERSE
[    42.0104 ms] GPIO PA7 = 1
[    42.0261 ms] UART: H-bridge: BRAKE
[    52.0104 ms] GPIO PA7 = 0
[    52.0104 ms] GPIO PA8 = 0
[    52.0261 ms] UART: H-bridge: COAST
[    52.0269 ms] GPIO PA1 = 1
[    55.0106 ms] GPIO PA2 = 1
[    60.0106 ms] GPIO PA1 = 0
[    65.0106 ms] GPIO PA3 = 1
[    70.0106 ms] GPIO PA2 = 0
[    75.0106 ms] GPIO PA4 = 1
[    80.0106 ms] GPIO PA3 = 0
[    85.0106 ms] GPIO PA1 = 1
[    90.0106 ms] GPIO PA4 = 0
[    90.0375 ms] UART: stepper: pos=8 half-steps
[    95.0105 ms] GPIO PA4 = 1
[   100.0105 ms] GPIO PA1 = 0
[   105.0105 ms] GPIO PA3 = 1
[   110.0105 ms] GPIO PA4 = 0
[   110.0374 ms] UART: stepper: pos=4 half-steps
[   110.0380 ms] GPIO PA3 = 0
[   110.0531 ms] UART: stepper: coils off
[   110.0539 ms] exit(0) after 880431 cycles

board.py reference lab-এর হুবহু কপি, আমার lab-এর ভেতরে রাখা, যাতে compiler-এর temp ফাইল সেখানেই থাকে। Log-এর প্রতিটি সময় = cycle ÷ 8000 (Spec decision 31). H-bridge অংশ পড়ুন: 0.0084 ms-এ PA7 = 1 (FORWARD); 20.0109-এ PA7 = 0, firmware নিজে coast দিল; ঠিক 2 ms পরে, 22.0084-এ, PA8 = 1 (REVERSE); 42.0104-এ PA7 = 1, দুটিই 1, অর্থাৎ BRAKE; 52.0104-এ দুটি pin একই মুহূর্তে 0, একটি store-এ COAST. Board একটি store-এ বদলানো একাধিক pin পরপর দুটি লাইনে ছাপে, একই সময়ে। নিচের stepper এই চারটি অবস্থা driver-এর output আর switch-এর ভাষায় অনুবাদ করে।

PA7 = IN1, PA8 = IN2 (DRV8833-এর truth table)
সময় (log)
IN1 IN2
OUT1 OUT2
চালু switch
অবস্থা
  1. সামনে। hbridge_set(HB_FWD): BSRR-এ একটি store, PA7 = 1, PA8 আগেই 0. Driver-এ OUT1 = H, OUT2 = L, অর্থাৎ S1 আর S4 চালু, current বাঁ থেকে ডানে। 20 ms চলে।
  2. নিজে থেকে coast. Main সরাসরি REVERSE চাইল। Function দেখল আগের অবস্থা FORWARD, তাই আগে দুটি input 0: সব switch বন্ধ, motor-এ শক্তি নেই। আসল motor-এ এখানে গতি কমার সময়; 2 ms শুধু প্রদর্শনের জন্য, বড় motor-এ এটি অনেক বেশি লাগে।
  3. পেছনে। 22.0084 ms-এ PA8 = 1: OUT1 = L, OUT2 = H, S3 আর S2 চালু, current ডান থেকে বাঁয়ে। কোনো মুহূর্তে একই পায়ের দুটি switch চালু হয়নি।
  4. Brake. 42.0104-এ PA7-ও 1: DRV8833-এর 11 = দুই output L, অর্থাৎ দুটি low-side switch (S2, S4) চালু। Motor-এর দুই প্রান্ত জোড়া, তার নিজের back-EMF current চালিয়ে তাকে দ্রুত থামায়।
  5. Coast. 52.0104-এ PA7 আর PA8 একই store-এ 0: driver-এর output খোলা (Z), motor নিজের ঘর্ষণে থামবে। এরপর firmware stepper-এ যায়।

Compiler ISR-এর stepper অংশ কীভাবে বানিয়েছে, তা দেখতে একই flag দিয়ে clang -S --target=thumbv7m-none-eabi -mcpu=cortex-m3 -O2 চালানো হয়েছে (Clang 22.1.8). ISR-এর দুটি টুকরো (directive-এর লাইন বাদ, মন্তব্য আমার):

সত্যিকারের run · Clang 22.1.8, SysTick_Handler-এর অংশ
	movw	r1, #52429
	movt	r1, #52428            @ r1 = 0xCCCCCCCD
	muls	r0, r1, r0            @ ms_ticks × 0xCCCCCCCD
	cmp.w	r0, #858993459        @ 0x33333333
	bls	.LBB0_2               @ এর নিচে বা সমান: 5 দিয়ে বিভাজ্য
	...
	ldrb	r2, [r3, r2]          @ half_step[p & 7]
	lsls	r3, r2, #17
	orr.w	r2, r3, r2, lsl #1
	and	r2, r2, #1966110      @ 0x001E001E
	eor	r2, r2, #1966080      @ 0x001E0000: reset অর্ধেক উল্টানো
	movw	r3, #2064
	movt	r3, #16385            @ 0x40010810 = BSRR
	str	r2, [r3]              @ চারটি coil, একটি store

দুটি জিনিস শেখার মতো। এক, % 5-এর জন্য Clang কোনো ভাগ করেনি: 32 বিটে 5-এর গুণের উল্টো (0xCCCCCCCD) দিয়ে গুণ করে ফল 0x33333333-এর নিচে বা সমান কি না দেখেছে, যা কেবল 5-এর গুণিতকে সত্য হয়। দুই, চারটি coil-এর নতুন অবস্থা একটি str-এ যায়, তাই কোনো মুহূর্তে আধা-বদলানো pattern pin-এ আসে না। একটি উন্নতির জায়গাও output-এ ধরা পড়ে: step_pos volatile বলে C-র লাইনটি তাকে দুবার পড়ে, আর compiler দুটি আলাদা ldr রাখে। এখানে ক্ষতি নেই, কারণ শুধু ISR-ই step_pos লেখে; তবু ভালো অভ্যাস হলো volatile চলক একবার একটি local-এ পড়ে নেওয়া।

Log-এর stepper অংশে প্রতি 5 ms-এ ঠিক একটি pin বদলায়। কেন একটিই, তা half-step টেবিলে লুকিয়ে আছে: পাশাপাশি দুটি ঘরের পার্থক্য সবসময় এক বিট। নিচের stepper-এ ধাপে ধাপে দেখুন; শেষ সারিতে লেখা কোণটি ধরে নেওয়া একটি 1.8° hybrid motor-এর, কারণ board-এ কোনো motor নেই।

PA1 = A, PA2 = B, PA3 = A′, PA4 = B′; 5 ms-এ এক ধাপ
সময় (log)
step_pos
বদলানো pin
চালু coil
কোণ (1.8° motor ধরে)
  1. শুরুর অবস্থান। Main প্রথমে coil A চালু করে rotor-কে অবস্থান 0-তে ধরে রাখে: 52.0269 ms-এ PA1 = 1.
  2. ধাপ ১. 55 ms-এর tick-এ (5 দিয়ে বিভাজ্য) ISR টেবিলের ঘর 1 = 0x3 লেখে: A আর B দুটোই চালু। শুধু PA2 বদলাল। দুই coil-এর মাঝামাঝি টানে rotor আধা ধাপ সরে।
  3. ধাপ ২. ঘর 2 = 0x2: শুধু B. PA1 = 0. এখন rotor পুরো এক full step, 1.8°.
  4. ধাপ ৩. ঘর 3 = 0x6: B আর A′. PA3 = 1. A′ হলো A-এর উল্টো দিকের টান, unipolar motor-এ একই coil-এর অন্য অর্ধেক।
  5. ধাপ ৪. ঘর 4 = 0x4: শুধু A′. PA2 = 0. চার half step-এ 3.6°.
  6. ধাপ ৫. ঘর 5 = 0xC: A′ আর B′. PA4 = 1. প্রতিটি ধাপে ঠিক একটি বিট বদলায়, একটি BSRR store-এ।
  7. ধাপ ৭. (ধাপ ৬, অর্থাৎ 80.0106 ms-এ PA3 = 0 আর শুধু B′ চালু, এখানে বাদ রাখা হয়েছে।) ঘর 7 = 0x9: B′ আর A. 85.0106-এ PA1 = 1.
  8. ধাপ ৮ = এক পূর্ণ চক্র। 8 & 7 = 0, তাই আবার ঘর 0: শুধু A. PA4 = 0. আটটি half step-এ চক্র পুরো; 1.8° motor-এ 7.2°, যা ৫০ দাঁতের rotor-এর এক দাঁতের দূরত্ব। Main 90.0375-এ pos=8 ছাপে।
  9. চার ধাপ পেছনে। Target 4: ISR প্রতি 5 ms-এ এক ঘর পেছনে যায় (95 ms-এ PA4 = 1, 100-এ PA1 = 0, 105-এ PA3 = 1, 110.0105-এ PA4 = 0). একই টেবিল, উল্টো ক্রম। এখন শুধু A′, অবস্থান 4.
  10. Coil বন্ধ। 110.0380-এ PA3 = 0: সব coil বন্ধ। এতে তাপ আর বিদ্যুৎ বাঁচে, কিন্তু rotor-কে ধরে রাখার torque আর থাকে না; ভার থাকলে বা কেউ ঠেললে অবস্থান হারাতে পারে।

৫ · Stepper motor — ধাপ, step angle আর sequence

Stepper-এর rotor ঘোরে কারণ চালু coil-গুলো তাকে নির্দিষ্ট একটি অবস্থানে টানে; firmware চালু coil-এর pattern বদলালে rotor পরের অবস্থানে লাফ দেয়। প্রতিটি লাফ একটি ধাপ, আর এক ধাপে কত ডিগ্রি তা step angle. তিন ধরনের stepper প্রচলিত: variable reluctance (নরম লোহার দাঁতওয়ালা rotor), permanent magnet (চুম্বকের rotor), আর দুটির মিশ্রণ hybrid, যা আজকের printer আর CNC-তে সবচেয়ে বেশি। হিসাবের দুটি সূত্র:

Step angle

Variable reluctance: θ = (Ns − Nr) ÷ (Ns × Nr) × 360°  (Ns = stator-এর মেরু, Nr = rotor-এর দাঁত)

দুই phase-এর hybrid: চারটি full step = rotor-এর এক দাঁতের দূরত্ব, তাই θ = 360° ÷ (4 × Nr); half step-এ এর অর্ধেক

Coil চালুর ক্রমের তিনটি রূপ আছে। Wave drive-এ একবারে একটি coil (A, B, A′, B′): কম current, কিন্তু torque-ও কম। Full step, দুই phase চালু-এ সবসময় দুটি coil (A+B, B+A′ …): একই ধাপের আকারে বেশি torque, বেশি current. Half step-এ দুটি মিশিয়ে আটটি অবস্থা: ধাপ অর্ধেক, চলন মসৃণ, তবে এক coil-এর অবস্থাগুলোয় torque একটু কম। নিচের block তিনটি sequence টেবিল থেকে বানায় আর step angle ও conveyor-এর হিসাব করে।

# Stepper motor: step angle, তিন ধরনের sequence আর একটি conveyor-এর হিসাব
import math

ns, nr = 8, 6                                   # variable reluctance
print(f"VR: Ns={ns}, Nr={nr} -> step {(ns - nr) / (ns * nr) * 360:.1f} deg")
nr = 50                                         # hybrid, 2 phase
full = 360 / (4 * nr)                           # ৪টি full step = এক tooth pitch
print(f"hybrid: Nr={nr} -> tooth pitch {360/nr:.1f} deg, full {full:.1f} deg, "
      f"half {full/2:.2f} deg, {round(360/full)} full steps/rev")

COILS = ("A", "B", "A'", "B'")                  # bit0..bit3 = PA1..PA4
seqs = {"wave (1 phase)": [0x1, 0x2, 0x4, 0x8],
        "full (2 phase)": [0x3, 0x6, 0xC, 0x9],
        "half step":      [0x1, 0x3, 0x2, 0x6, 0x4, 0xC, 0x8, 0x9]}
for name, s in seqs.items():
    cells = ["+".join(c for b, c in enumerate(COILS) if v >> b & 1) for v in s]
    print(f"{name:15s}: {' '.join(cells)}")

# বাজারঘরের কাল্পনিক conveyor: pulley-র ব্যাস 20 mm, 1.8° motor, half step
d_mm, step = 20.0, full / 2
mm_per_step = math.pi * d_mm * step / 360
steps = round(300 / mm_per_step)                # 300 mm সরাতে
rate = 800                                      # half-step প্রতি সেকেন্ডে
print(f"{mm_per_step:.4f} mm/step, 300 mm -> {steps} half-steps, "
      f"{rate} steps/s = {rate * step / 360 * 60:.0f} rpm, {steps / rate:.3f} s")

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

VR: Ns=8, Nr=6 -> step 15.0 deg
hybrid: Nr=50 -> tooth pitch 7.2 deg, full 1.8 deg, half 0.90 deg, 200 full steps/rev
wave (1 phase) : A B A' B'
full (2 phase) : A+B B+A' A'+B' A+B'
half step      : A A+B B B+A' A' A'+B' B' A+B'
0.1571 mm/step, 300 mm -> 1910 half-steps, 800 steps/s = 120 rpm, 2.388 s

৮টি stator মেরু আর ৬টি rotor দাঁতের variable reluctance motor-এ (8 − 6) ÷ 48 × 360 = 15°, পাঠ্যবইয়ের চেনা উদাহরণ। ৫০ দাঁতের hybrid-এ এক দাঁতের দূরত্ব 7.2°, চারটি full step-এ সেটুকু, তাই 1.8° আর প্রতি পাকে 200 ধাপ; half step-এ 0.9°. তিনটি sequence-এর মধ্যে half-step-এর আটটি ঘরই board-এর firmware-এর টেবিল {0x1, 0x3, 0x2, 0x6, 0x4, 0xC, 0x8, 0x9}. Conveyor: 20 mm ব্যাসের pulley-র পরিধি π × 20 ≈ 62.83 mm, half step-এ 0.9° মানে প্রতি ধাপে 0.1571 mm; 300 mm সরাতে 1910টি ধাপ (পূর্ণসংখ্যায় গোল করা)। প্রতি সেকেন্ডে 800 half step মানে 800 × 0.9 ÷ 360 = 2 পাক/সেকেন্ড = 120 rpm, আর পুরো পথে 2.388 s. গোল করার ফলে শেষ অবস্থান কয়েক শতাংশ mm সরে যায়, যা পরের চালানে জমতে পারে; তাই দীর্ঘ পথে পূর্ণ সংখ্যায় হিসাব রাখা জরুরি।

Stepper সাধারণত open loop: firmware ধরে নেয় প্রতিটি আদেশে rotor এক ধাপ সরেছে, কেউ যাচাই করে না। এর বিপদ missed step: load বেশি, ধাপের হার হঠাৎ খুব বেশি, বা কোনো resonance-এর গতিতে rotor পিছিয়ে পড়ে, আর firmware-এর হিসাব আর আসল অবস্থান আলাদা হয়ে যায়। সমাধান তিনটি: ধীরে শুরু করে হার বাড়ানো আর থামার আগে কমানো (acceleration ramp), শুরুতে একটি limit switch-এ “home” করা, আর দরকারে encoder দিয়ে যাচাই (অংশ ৭)।

Driver. Unipolar stepper-এর (প্রতিটি coil-এর মাঝখানে একটি সাধারণ তার) প্রতিটি অর্ধেক এক দিকেই current পায়, তাই চারটি সাধারণ low-side switch যথেষ্ট; TI-র ULN2003A-এর মতো Darlington array-এ সাতটি channel আর ভেতরে clamp diode থাকে, যার COM pin motor-এর সরবরাহে জুড়তে হয় (datasheet দেখুন)। Bipolar stepper-এর দুটি coil-এ দুই দিকেই current লাগে, তাই দুটি H-bridge, যেমন একটি DRV8833. বড় stepper-এ microstepping driver ব্যবহার হয়, যা দুই coil-এর current sine আর cosine-এর আকারে ভাগ করে এক full step-কে অনেক ছোট ধাপে ভাঙে; এতে চলন মসৃণ আর শব্দ কম, যদিও প্রতিটি ক্ষুদ্র ধাপের নির্ভুলতা load-এর ওপর নির্ভর করে।

৬ · Servo — feedback ভেতরেই

Hobby servo-র ভেতরে একটি DC motor, gear, একটি potentiometer আর একটি ছোট নিয়ন্ত্রক circuit. বাইরের তিনটি তার: সরবরাহ, GND আর সংকেত। সংকেতে নিয়মিত pulse, প্রচলিত ধরনে প্রায় 20 ms অন্তর (50 Hz), প্রস্থ মোটামুটি 1 থেকে 2 ms, যা কোণ বলে দেয়। ভেতরের circuit potentiometer দিয়ে আসল কোণ মাপে, লক্ষ্যের সঙ্গে তুলনা করে, আর পার্থক্য অনুযায়ী motor চালায়: একটি ছোট closed loop. Pulse-এর timer-এর হিসাব আর একটি block পর্ব ৪৫-এ আছে; এখানে শুধু তিনটি ব্যবহারিক সতর্কতা। প্রথমত pulse-এর পরিসর servo-ভেদে আলাদা (অনেকে 0.5 থেকে 2.5 ms নেয়), সীমার বাইরে গেলে gear যান্ত্রিক থামায় ঠেকে আর stall current টানে; নির্দিষ্ট servo-র datasheet দেখুন। দ্বিতীয়ত servo চলতে শুরুর মুহূর্তে বড় current টানে, যা MCU-র সরবরাহ নামিয়ে brown-out reset ঘটাতে পারে (পর্ব ৩৩); servo-কে আলাদা সরবরাহ দিন, শুধু GND এক রাখুন। তৃতীয়ত servo নিজে শুধু অবস্থান ধরে; গতি বা torque-এর সূক্ষ্ম নিয়ন্ত্রণ চাইলে নিজের feedback loop লাগে, যার নকশা পর্ব ৬৯-এ (PID control).

৭ · Encoder — কোন দিকে, কত দূর, কত জোরে

DC motor-এর গতি load-এর সঙ্গে বদলায়, আর stepper ধাপ হারাতে পারে; তাই আসল অবস্থান জানতে চাই। সবচেয়ে প্রচলিত উপায় quadrature encoder: শ্যাফটের সঙ্গে ঘোরা একটি চাকতি, যার দাগ বা চুম্বক দুটি sensor-এর সামনে দিয়ে যায়। দুটি sensor এমনভাবে বসানো যে তাদের সংকেত A আর B একই আকারের square wave, কিন্তু এক-চতুর্থাংশ চক্র (90°) সরানো। সামনে ঘুরলে A আগে ওঠে, পেছনে ঘুরলে B আগে। দুই বিট মিলিয়ে চারটি অবস্থা ক্রমে আসে, সামনে 00 → 10 → 11 → 01 → 00; প্রতিটি বদলে ঠিক একটি বিট বদলায়, যা একটি দুই-বিটের Gray code. প্রতিটি বদল গুনলে প্রতি দাগে চারটি count পাওয়া যায়; একে ৪x decoding বলে।

Firmware-এ সবচেয়ে পরিষ্কার উপায় একটি ১৬ ঘরের lookup table: আগের অবস্থা × 4 + নতুন অবস্থা = ঘরের সংখ্যা, আর ঘরে লেখা +1, −1, 0 বা “ভুল”। “ভুল” মানে দুটি বিট একসাথে বদলেছে, যা আসল encoder-এ হয় না; এর অর্থ নমুনা নেওয়া খুব ধীর (মাঝের একটি অবস্থা হারিয়েছে) বা সংকেতে শব্দ।

# Quadrature encoder decoder: ৪x decoding, 16 ঘরের lookup table
# state = A*2 + B; সামনে (A আগে): 00 -> 10 -> 11 -> 01 -> 00
FWD = {(0, 2), (2, 3), (3, 1), (1, 0)}
TABLE = [0] * 16
for prev in range(4):
    for cur in range(4):
        if (prev, cur) in FWD:   TABLE[prev * 4 + cur] = +1
        elif (cur, prev) in FWD: TABLE[prev * 4 + cur] = -1
        elif prev != cur:        TABLE[prev * 4 + cur] = 99   # দুই বিট একসাথে: ভুল
print("table:", " ".join("E" if t == 99 else f"{t:+d}" if t else "0" for t in TABLE))

def decode(samples):
    count, errors, prev = 0, 0, samples[0]
    for cur in samples[1:]:
        d = TABLE[prev * 4 + cur]
        if d == 99: errors += 1
        else:       count += d
        prev = cur
    return count, errors

fwd = [0, 2, 3, 1] * 3 + [0]                     # সামনে তিন চক্র
rev = [1, 3, 2, 0]                               # তারপর এক চক্র পেছনে
print("forward 3 cycles:", decode(fwd))
print("then back 1 cycle:", decode(fwd + rev))
print("same + bounce on A:", decode(fwd + [2, 0, 2, 0] + rev))
print("sample too slow (skip):", decode([0, 2, 1, 0]))

# গতি: 100 লাইনের encoder, ৪x -> 400 count/rev, 10 ms-এ 200 count
cpr, counts, window_s = 400, 200, 0.010
print(f"{counts} counts in {window_s*1000:.0f} ms -> "
      f"{counts / cpr / window_s * 60:.0f} rpm")

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

table: 0 -1 +1 E +1 0 E -1 -1 E 0 +1 E +1 -1 0
forward 3 cycles: (12, 0)
then back 1 cycle: (8, 0)
same + bounce on A: (8, 0)
sample too slow (skip): (2, 1)
200 counts in 10 ms -> 3000 rpm

টেবিলের ১৬টি ঘরে চারটি +1, চারটি −1, চারটি 0 (অবস্থা বদলায়নি) আর চারটি E (দুই বিট একসাথে)। সামনে তিন চক্রে 12 count, ভুল শূন্য; এক চক্র পেছনে গেলে 8. তৃতীয় সারিটি সবচেয়ে শিক্ষণীয়: A-এর লাইনে একটি bounce বা শব্দ (10, 00, 10, 00) count-কে +1, −1, +1, −1 করে, যোগফল শূন্য; quadrature নিজেই কাঁপুনি বাতিল করে, যা একটি সাধারণ এক-লাইনের pulse counter পারে না। চতুর্থ সারিতে নমুনা খুব ধীর: 00 → 10 ঠিক, কিন্তু 10 থেকে সরাসরি 01-এ, মাঝের 11 হারিয়েছে; decoder একটি ভুল গোনে আর count আসলের চেয়ে কম। শেষ লাইনে গতি: 100 দাগের encoder ৪x-এ প্রতি পাকে 400 count; 10 ms-এ 200 count মানে 0.5 পাক ÷ 0.01 s = 50 পাক/সেকেন্ড = 3000 rpm.

state = A × 2 + B; ঘর = আগের × 4 + নতুন
A B (আগে → এখন)
ঘর
টেবিলের মান
count
errors
  1. A উঠল। 00 থেকে 10: A আগে বদলাল, তাই সামনে। ঘর 2-এ +1, count 1.
  2. B উঠল। 10 থেকে 11: ঘর 11-এ +1, count 2.
  3. A নামল। 11 থেকে 01: ঘর 13-এ +1, count 3.
  4. B নামল। 01 থেকে 00: ঘর 4-এ +1, count 4. একটি দাগের পুরো চক্র, চারটি count: ৪x decoding.
  5. দিক বদল। 00 থেকে 01: এবার B আগে, অর্থাৎ পেছনে। ঘর 1-এ −1, count 3. কোনো আলাদা “দিক” সংকেত লাগেনি; ক্রমই দিক বলে।
  6. কিছু বদলায়নি। 01 থেকে 01: ঘর 5-এ 0. Shaft থেমে থাকলে বা নমুনা দ্রুত হলে এমনই হয়।
  7. অসম্ভব লাফ। 01 থেকে 10: দুটি বিটই বদলেছে। ঘর 6-এ E: count অপরিবর্তিত, errors 1. Firmware এখানে সতর্ক হবে: নমুনার হার বাড়াতে হবে, বা hardware decoder ব্যবহার করতে হবে।

বাস্তবে software-এ নমুনা নিলে CPU-কে encoder-এর সবচেয়ে দ্রুত বদলের চেয়ে বেশি হারে জাগতে হয়: ওপরের 3000 rpm-এ প্রতি সেকেন্ডে 20 000 বদল। তাই microcontroller-এর timer-এ প্রায়ই hardware encoder interface থাকে। STM32F103-এর general-purpose timer-এর SMCR register-এর SMS field-এ encoder mode বেছে নিলে counter নিজেই A আর B-এর ধারে ওপরে বা নিচে গোনে, আর firmware শুধু CNT পড়ে (RM0008-এর “Encoder interface mode” অংশ; mode 3 দুই channel-এর সব ধারে গোনে)। গতির হিসাব দুইভাবে হয়: একটি নির্দিষ্ট সময়ে count গোনা (দ্রুত গতিতে ভালো, ওপরের মতো), অথবা দুটি ধারের মাঝের সময় মাপা, যা input capture দিয়ে হয় (ধীর গতিতে ভালো; পর্ব ৪৪)।

৮ · Motor-এর circuit-এর নিরাপত্তা আর বৈদ্যুতিক শব্দ

Motor-এর firmware যত ভালোই হোক, circuit-এর ভুল সবকিছু নষ্ট করতে পারে। পাঁচটি নিয়ম মনে রাখুন।

  1. প্রতিটি coil-এর জন্য current-এর ফেরার পথ। Inductance-এ V = L × dI/dt: switch হঠাৎ বন্ধ হলে dI/dt বিশাল, আর ভোল্টেজের ঝটকা transistor ভাঙতে পারে। Relay বা এক-দিকের motor-এ coil-এর উল্টো দিকে একটি flyback diode; H-bridge-এ প্রতিটি switch-এর পাশে diode (MOSFET-এর body diode বা L298-এর মতো বাইরের দ্রুত diode).
  2. Current-এর হিসাব stall ধরে। Driver, তার, connector আর fuse বাছুন stall current আর চালুর peak ধরে, চলার গড় current ধরে নয়। অংশ ২-এর মডেলে চলার current 0.5 A, কিন্তু peak 2.83 A, আর plugging-এ প্রায় 5.5 A.
  3. সরবরাহ আলাদা, GND এক। Motor-এর সরবরাহ আর MCU-র 3.3 V আলাদা রাখুন, driver-এর কাছে বড় capacitor (bulk) আর ছোট ceramic capacitor (decoupling) দিন। Motor-এর বড় current যেন MCU-র GND-এর তার দিয়ে না ফেরে; দুই GND এক বিন্দুতে মেলান।
  4. Brake-এর শক্তি কোথায় যায়। Brake বা দ্রুত গতি কমানোর সময় motor generator হয়ে শক্তি ফেরত দেয়। Driver-এর diode দিয়ে সেটি supply-এর দিকে গেলে, আর supply সেটি শুষতে না পারলে, সরবরাহের ভোল্টেজ বেড়ে যেতে পারে। বড় motor-এ এর জন্য আলাদা ব্যবস্থা লাগে; ছোট প্রকল্পেও driver-এর সর্বোচ্চ ভোল্টেজের মার্জিন রাখুন।
  5. শুরুর অবস্থা নিরাপদ। Reset-এর পরে, firmware চালু হওয়ার আগে, MCU-র pin কিছু সময় input (ভাসমান) থাকে। Driver-এর input-এ pull-down রাখুন, যাতে তখন motor হঠাৎ না ঘোরে; DRV8833-এর nSLEEP-ও এভাবে low রাখা যায়। Watchdog reset-এর পরেও একই নিয়ম (পর্ব ৬১)।

Motor বৈদ্যুতিক শব্দের বড় উৎস: brush-এর স্ফুলিঙ্গ আর PWM-এর খাড়া ধার কাছের analog circuit-এ ঢোকে। বাজারঘরের smart scale-এর পাশে conveyor থাকলে load cell-এর সংকেতে কয়েক count-এর কাঁপুনি আসতে পারে, আর README-র calibration অনুযায়ী এক count প্রায় 1.43 g (2000 g ÷ 1400 count). তাই ওজন মাপার মুহূর্তে conveyor থামিয়ে রাখা একটি সহজ firmware-সমাধান; বাকিটা ভালো layout, shielding আর filter, যার digital অংশ পর্ব ৬৮-এ (Digital filtering আর sensor fusion).

আরও গভীরে: আধুনিক ফ্যান, drone আর বৈদ্যুতিক যানের motor বেশিরভাগ brushless (BLDC বা PMSM): brush আর commutator নেই, তার বদলে তিন phase-এর inverter, অর্থাৎ তিনটি half-bridge, আর firmware নিজে commutation করে। সরল পদ্ধতিতে তিনটি Hall sensor দেখে ছয় ধাপে phase বদলানো হয়; উন্নত পদ্ধতি field-oriented control (FOC), যেখানে তিন phase-এর current-কে Clarke আর Park রূপান্তরে rotor-এর সঙ্গে ঘোরা দুটি অক্ষে নিয়ে গিয়ে দুটি PI loop দিয়ে নিয়ন্ত্রণ করা হয়। এর জন্য দ্রুত ADC, centre-aligned PWM আর dead time-ওয়ালা timer লাগে, যা STM32-এর মতো MCU-তে motor-control-এর timer হিসেবে থাকে; বিস্তারিত নির্মাতাদের application note-এ।

পরীক্ষা ও ইন্টারভিউতে: (১) “H-bridge-এ shoot-through কী, কীভাবে ঠেকান?” → একই পায়ের ওপর-নিচের switch একসাথে চালু হয়ে supply short; dead time আর driver-এর interlock. (২) “Back-EMF কেন চালুর current বাড়ায়?” → থেমে থাকলে E = 0, তাই I = V ÷ R. (৩) “৮ stator মেরু, ৬ rotor দাঁত, step angle?” → (8 − 6) ÷ 48 × 360 = 15°. (৪) “1.8° stepper-এ half step-এ এক পাকে কত ধাপ?” → 400. (৫) “Quadrature-এ দিক কীভাবে বোঝা যায়?” → A আর B-এর কোনটি আগে বদলায়, তার ক্রম থেকে; ৪x decoding-এ প্রতি দাগে চার count.

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

“Arduino দিয়ে motor ঘোরানোর কোড দিন” লিখলে AI assistant কয়েক সেকেন্ডে কোড আর একটি wiring-এর বর্ণনা দেয়। কোড প্রায়ই চলে, কিন্তু motor-এর ভুলের দাম আলাদা: পোড়া driver, গলা তার, বা হঠাৎ ঘুরে ওঠা যন্ত্র। চেনা ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
Motor বা relay সরাসরি GPIO pin-এ জোড়ে, flyback diode ভোলেPin-এর current-এর সীমা datasheet থেকে দেখুন; প্রতিটি coil-এর ফেরার পথ আঁকুন
Driver IC-এর truth table গুলিয়ে ফেলে (যেমন 11-কে coast বলে), বা L298-এর বাইরের diode-এর কথা বাদ দেয়নির্দিষ্ট IC-এর datasheet-এর logic table মিলিয়ে নিন; একটি board বা simulator-এ pin-এর ক্রম log করুন
সামনে থেকে সরাসরি পেছনে দেয়, বা দুই input আলাদা দুটি RMW লেখায় বদলায়অবস্থা বদলের function-এ coast বা brake-এর ধাপ আছে কি না দেখুন; একটি store-এ (BSRR) দুই pin বদলান
Step angle বা ধাপের সংখ্যা ভুল সূত্রে দেয়, gear অনুপাত ভোলে, half step-এ দ্বিগুণ করতে ভোলেMotor-এর datasheet-এর step angle আর gear অনুপাত নিয়ে নিজে হিসাব করুন; Python-এ মেলান
ISR-এ delay() বা print রাখে, shared চলক volatile দেয় না, ODR-এ ^= দিয়ে coil বদলায়ISR ছোট কি না, volatile আছে কি না দেখুন; -S দিয়ে compiler-এর output পড়ুন
Encoder-এর গতি ভুল একে দেয় (৪x ভুলে যায়) বা servo-র pulse-এর পরিসর নিশ্চিত বলেEncoder-এর দাগের সংখ্যা আর decoding-এর ধরন মিলিয়ে নিন; servo-র নিজের datasheet দেখুন

AI-কে কাজে লাগাতে hardware, সীমা আর নিরাপত্তার শর্ত শুরুতেই বলে দিন:

আমি একটি Cortex-M3 microcontroller (3.3 V logic) দিয়ে একটি 12 V brushed DC motor চালাব, driver TI DRV8833 (datasheet SLVSAR1E). Motor-এর stall current প্রায় 3 A ধরে নাও। ১. DRV8833 এই motor-এর জন্য যথেষ্ট কি না, datasheet-এর সরবরাহ আর current-এর সীমা থেকে যুক্তি দাও। না হলে স্পষ্ট বলো। ২. IN1/IN2-এর truth table থেকে সামনে, পেছনে, coast আর brake-এর মান লেখো, আর PWM-এ fast decay আর slow decay-এর পার্থক্য বলো। ৩. C-তে একটি motor_set(dir, duty) function লেখো, যা দিক বদলের আগে duty শূন্য করে আর coast দেয়; দুই pin একটি register লেখায় বদলাবে, ISR-এ কোনো delay থাকবে না। ৪. Flyback, fuse, decoupling আর reset-এর সময় pin-এর pull-down নিয়ে একটি নিরাপত্তার তালিকা দাও। কোনো সংখ্যা নিয়ে নিশ্চিত না হলে "datasheet দেখুন" লিখবে।

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

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

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

প্র ০১Motor আর generator কি আসলে একই যন্ত্র? Back-EMF-এর ধারণা কোথা থেকে এসেছে, আর আজকের বৈদ্যুতিক যানের “regenerative braking” এর সঙ্গে কীভাবে যুক্ত?

দুটি একই নিয়মের দুই দিক। ১৮২০-এর দশকের শুরুতে Michael Faraday দেখিয়েছিলেন, current-বাহী তার চুম্বকের পাশে ঘুরতে পারে, যাকে প্রায়ই বৈদ্যুতিক motor-এর প্রথম প্রদর্শন বলা হয় (১৮২১ সাল বলে বর্ণিত)। এক দশক পরে, ১৮৩১ সালে, তিনি উল্টোটি দেখান: চুম্বকক্ষেত্রে তার নড়লে বা ক্ষেত্র বদলালে তারে ভোল্টেজ জন্মায়, যা electromagnetic induction নামে পরিচিত। একটি DC motor-এর coil চুম্বকের মধ্যে ঘোরে, তাই দুটি ঘটনা একসাথে চলে: current torque দেয়, আর ঘূর্ণন ভোল্টেজ জন্মায়। Lenz-এর নিয়ম অনুযায়ী এই জন্মানো ভোল্টেজ যে কারণে জন্মেছে তার বিরোধিতা করে, তাই সরবরাহের উল্টো দিকে: এটিই back-EMF.

এই পর্বের সূত্রে বিষয়টি পরিষ্কার: V = I R + k ω. Motor-কে বাইরে থেকে ঘোরালে আর কোনো সরবরাহ না দিলে টার্মিনালে k ω ভোল্টেজ পাওয়া যায়; motor তখন generator. আবার সরবরাহ দিলে k ω যত বাড়ে, current তত কমে, আর motor নিজের গতি নিজেই সীমিত করে। এজন্যই no-load গতি প্রায় V ÷ k, আর এজন্যই থেমে থাকা motor-এ current সবচেয়ে বেশি। অংশ ২-এর মডেলে চালুর peak 2.83 A, চলার current 0.52 A.

Regenerative braking এই দ্বৈততার ব্যবহারিক রূপ। গতি কমাতে driver motor-কে এমনভাবে নিয়ন্ত্রণ করে যাতে back-EMF থেকে current উল্টো দিকে, অর্থাৎ ব্যাটারির দিকে, যায়; motor তখন generator হয়ে চলন্ত গাড়ির গতিশক্তি বিদ্যুতে ফেরায়। বৈদ্যুতিক গাড়ি, ট্রেন আর লিফটে এটি প্রচলিত। সাধারণ H-bridge-এর brake অবস্থা (দুই low-side চালু) শক্তি ফেরায় না, coil-এর resistance-এ তাপ বানায়; শক্তি ফেরাতে driver-কে PWM দিয়ে কৌশলে current-কে supply-এর দিকে ঠেলতে হয়, আর supply বা ব্যাটারিকে তা গ্রহণ করতে পারতে হয়। না পারলে অংশ ৮-এর মতো সরবরাহের ভোল্টেজ বেড়ে যায়। ব্যাটারিতে শক্তি ফেরানোর হারেরও সীমা আছে, বিশেষ করে Li-ion-এ, তাই এই নকশা battery management-এর সঙ্গে মিলিয়ে করতে হয়।

মূল উপলব্ধি: Motor আর generator একই যন্ত্র; back-EMF গতি সীমিত করে আর চালুর current বাড়ায়, আর সেই একই নিয়ম দিয়ে গতিশক্তি বিদ্যুতে ফেরানো যায়, যদি driver আর সরবরাহ তা সামলাতে পারে।

প্র ০২Brushed DC motor সহজে চলে, তবু ফ্যান, drone আর বৈদ্যুতিক যানে brushless motor কেন জায়গা নিচ্ছে? Firmware-এর দিক থেকে এই বদলের দাম কী?

Brushed motor-এর সৌন্দর্য তার সরলতা: দুটি তারে DC দিলেই ঘোরে, কারণ commutator আর brush যান্ত্রিকভাবে ঠিক সময়ে coil-এর current উল্টে দেয়। একটি transistor বা H-bridge আর PWM-ই যথেষ্ট, firmware প্রায় কিছুই জানে না। কিন্তু এই যান্ত্রিক সুইচই দুর্বলতা। Brush ঘষে ঘষে ক্ষয় হয়, তাই আয়ু সীমিত; প্রতিটি commutation-এ স্ফুলিঙ্গ হয়, যা বৈদ্যুতিক শব্দ ছড়ায় আর দাহ্য পরিবেশে বিপজ্জনক; আর ঘর্ষণ ও brush-এর ভোল্টেজের ক্ষতি দক্ষতা কমায়। তাপ তৈরি হয় ঘূর্ণমান armature-এ, যা বাইরে বের করা কঠিন।

Brushless motor (BLDC) চুম্বককে rotor-এ আর coil-কে স্থির stator-এ রাখে। Commutation তখন যান্ত্রিক নয়, electronic: একটি তিন phase-এর inverter, যা আসলে তিনটি half-bridge, ঠিক সময়ে ঠিক coil-এ current দেয়। এতে brush-এর ক্ষয় নেই, আয়ু মূলত bearing-এ সীমিত, শব্দ কম, আর তাপ stator থেকে সহজে বের হয়। আধুনিক power MOSFET আর সস্তা microcontroller এই electronic commutation-কে সাধারণ পণ্যেও সম্ভব করেছে। বাংলাদেশেও এখন বিদ্যুৎ-সাশ্রয়ী BLDC সিলিং ফ্যান বাজারে দেখা যায় বলে বর্ণিত; সঠিক সাশ্রয় নির্মাতা আর মডেলভেদে আলাদা, তাই বিজ্ঞাপনের সংখ্যা যাচাই করে নিতে হয়।

দাম পড়ে firmware আর electronics-এ। Controller-কে জানতে হয় rotor কোথায়: Hall sensor দিয়ে, বা sensor ছাড়া, যখন firmware বন্ধ থাকা phase-এর back-EMF মেপে অবস্থান অনুমান করে। Sensorless পদ্ধতি থেমে থাকা অবস্থায় কাজ করে না, কারণ তখন back-EMF শূন্য; তাই শুরুতে একটি আলাদা “open-loop” ধাপ লাগে। তিনটি পায়ের প্রতিটিতে shoot-through-এর বিপদ, তাই dead time আর hardware সুরক্ষা অপরিহার্য। মসৃণ আর দক্ষ চলার জন্য field-oriented control লাগে, যার জন্য দ্রুত current মাপা, গণিত আর নির্দিষ্ট সময়ে loop চালানো দরকার, অর্থাৎ hard real-time firmware (পর্ব ৫৪)। একটি ভুল, যেমন ISR দেরিতে চলা, motor-কে ঝাঁকাতে বা driver পোড়াতে পারে।

মূল উপলব্ধি: Brushless motor যান্ত্রিক commutator-কে electronic switch আর firmware দিয়ে বদলেছে; ফলে আয়ু, দক্ষতা আর শব্দে লাভ, কিন্তু দায়িত্ব চলে গেছে firmware আর power electronics-এর ঘাড়ে।

প্র ০৩Stepper motor feedback ছাড়াই অবস্থান জানে বলে দাবি করে। এই “open loop” কতটা বিশ্বাসযোগ্য, আর printer বা CNC-র মতো যন্ত্র কীভাবে এর দুর্বলতা সামলায়?

Stepper-এর মূল আকর্ষণ হলো ধাপ গোনা মানেই অবস্থান জানা। একটি 1.8° motor-কে 200টি ধাপ দিলে এক পাক, যদি rotor প্রতিটি আদেশ মানে। এজন্য দীর্ঘদিন ধরে কম্পিউটারের যন্ত্রাংশ, যেমন floppy disk drive-এর head সরানো, dot-matrix আর inkjet printer-এর কাগজ ও head, আর পরে hobby 3D printer ও ছোট CNC, stepper ব্যবহার করে আসছে। Encoder, feedback loop বা tuning ছাড়াই একটি পূর্বানুমানযোগ্য অবস্থান: খরচ আর জটিলতা দুটোই কম।

কিন্তু “যদি rotor আদেশ মানে” শর্তটিই দুর্বলতা। Stepper-এর torque গতি বাড়লে কমে, কারণ coil-এর inductance উচ্চ ধাপ-হারে current-কে পুরো মানে উঠতে দেয় না। Load torque-কে ছাড়িয়ে গেলে rotor পিছিয়ে পড়ে, আর firmware তা জানে না: missed step. আরও সূক্ষ্ম সমস্যা resonance: কিছু নির্দিষ্ট ধাপ-হারে rotor প্রতিটি ধাপের পরে দুলতে থাকে, আর দোলন বাড়লে ধাপ হারায়। হঠাৎ পূর্ণ গতিতে শুরু করলে rotor-এর জড়তা তাকে প্রথম কয়েকটি ধাপ ধরতে দেয় না।

যন্ত্রগুলো তিনটি স্তরে এটি সামলায়। প্রথমত নকশার মার্জিন: motor বাছা হয় দরকারের চেয়ে বেশি torque-এর, আর চলার গতি torque–speed রেখার নিরাপদ অংশে রাখা হয়। দ্বিতীয়ত firmware: acceleration ramp দিয়ে ধাপের হার ধীরে বাড়ানো-কমানো, microstepping দিয়ে resonance কমানো, আর শুরুতে একটি limit switch-এ “homing” করে শূন্য অবস্থান ঠিক করা। 3D printer-এর firmware চালুর পরে প্রতিটি অক্ষ একটি switch পর্যন্ত চালায় ঠিক এই কারণে। তৃতীয়ত যাচাই: কিছু driver IC coil-এর current বা back-EMF দেখে stall আঁচ করতে পারে, আর দামি যন্ত্রে encoder যোগ করে “closed-loop stepper” বানানো হয়।

বাজারঘরের conveyor-এর জন্য তাই নকশা দাঁড়ায়: half step, ramp দিয়ে 800 ধাপ/সেকেন্ড পর্যন্ত, প্রতিটি চালানের শুরুতে একটি সেন্সরে home, আর জ্যাম হলে ধরার জন্য একটি সাধারণ encoder বা অন্তত থলে পৌঁছানোর একটি সেন্সর।

মূল উপলব্ধি: Stepper-এর open loop সঠিক থাকে যতক্ষণ torque-এর মার্জিন থাকে; ramp, homing আর প্রয়োজনে encoder সেই বিশ্বাসকে যাচাই আর রক্ষা করে।

প্র ০৪নিজের চারটি MOSFET দিয়ে H-bridge বানানো আর একটি তৈরি driver IC ব্যবহারের মধ্যে কী পার্থক্য? Shoot-through ঠেকানোর দায় কোথায় কোথায় থাকে?

চারটি আলাদা MOSFET দিয়ে bridge বানালে প্রথম বাধা gate চালানো। Low-side N-channel MOSFET-এর source মাটিতে, তাই gate-এ কয়েক ভোল্ট দিলেই চালু। কিন্তু high-side N-channel MOSFET-এর source motor-এর টার্মিনালে, যা চালু অবস্থায় প্রায় VM-এ ওঠে; তাকে পুরো চালু রাখতে gate-কে VM-এর চেয়েও কয়েক ভোল্ট ওপরে নিতে হয়। এজন্য gate driver-এ bootstrap capacitor বা charge pump লাগে। High-side-এ P-channel MOSFET দিলে এই ঝামেলা কমে, কিন্তু একই আকারে তার resistance সাধারণত বেশি। তার ওপর 3.3 V-এর MCU pin সরাসরি বড় MOSFET-এর gate-এর capacitance দ্রুত চার্জ করতে পারে না, ফলে ধার ধীর আর switching loss বেশি।

Shoot-through-এর দায় তখন তিন জায়গায় ভাগ হয়। Firmware-কে কখনো একই পায়ের দুটি switch-এর আদেশ একসাথে দিতে নেই; timer-কে বন্ধ আর চালুর মাঝে dead time দিতে হয়, যার মান MOSFET-এর বন্ধ হতে লাগা সময় আর gate driver-এর delay থেকে আসে; আর hardware-এ একটি interlock বা current-সীমা থাকা উচিত, যাতে firmware-এর ভুল বা noise-এ একটি glitch হলেও short স্থায়ী না হয়। STM32-এর advanced timer-এর complementary output আর dead-time generator, আর তার “break” input, যা একটি fault সংকেতে সব output নিরাপদ অবস্থায় নেয়, ঠিক এই প্রয়োজন থেকে।

তৈরি driver IC এই দায়ের বড় অংশ নিজে নেয়। DRV8833-এর truth table-এ shoot-through-এর কোনো input নেই; gate চালানো, charge pump, overcurrent, undervoltage আর অতিরিক্ত তাপের সুরক্ষা ভেতরেই, আর সমস্যা হলে nFAULT pin. Firmware-এর কাজ তখন শুধু ঠিক অবস্থা বাছা, PWM দেওয়া আর fault pin দেখা। দাম হলো সীমা: সরবরাহ 10.8 V পর্যন্ত, current কয়েক A-এর ঘরে। বড় motor-এ তাই আলাদা gate driver IC আর বাইরের MOSFET, যেখানে আবার নকশাকারীর দায় বাড়ে। L298-এর মতো পুরোনো bipolar chip সহজলভ্য, কিন্তু তার ভেতরের transistor-এ ভোল্টেজ বেশি হারায়, তাই তাপ বেশি, আর datasheet নিজেই বাইরের diode চায়।

মূল উপলব্ধি: নিজের bridge-এ gate চালানো, dead time আর সুরক্ষা সবই আপনার; driver IC সেগুলো ভেতরে নেয় কিন্তু সীমার মধ্যে বাঁধে। দুই ক্ষেত্রেই firmware-এর নিয়ম একই: বিপজ্জনক অবস্থা কখনো চাওয়া নয়।

প্র ০৫Quadrature encoder-এর A আর B সংকেত আসলে একটি দুই-বিটের Gray code. Gray code কোথা থেকে এসেছে, আর absolute encoder-এ এটি কেন প্রায় অপরিহার্য?

Gray code এমন একটি সংখ্যার ক্রম যেখানে পাশাপাশি দুটি সংখ্যা ঠিক এক বিটে আলাদা। নামটি Bell Labs-এর গবেষক Frank Gray-এর নামে; তাঁর “Pulse Code Communication” নামের patent ১৯৪৭ সালে জমা পড়ে আর ১৯৫৩ সালে মঞ্জুর হয় বলে বর্ণিত, যেখানে এই ধরনের কোড একটি vacuum tube-ভিত্তিক রূপান্তরে ব্যবহারের কথা ছিল। ধারণাটি আরও পুরোনো বলে উল্লেখ পাওয়া যায়, যেমন উনিশ শতকের ফরাসি টেলিগ্রাফের নকশায়; ইতিহাসের খুঁটিনাটি সূত্রভেদে আলাদা।

যান্ত্রিক যন্ত্রে এর গুরুত্ব বোঝা যায় একটি সাধারণ binary চাকতি দিয়ে। ধরুন একটি তিন-বিটের চাকতি 3 (011) থেকে 4 (100)-এ যাচ্ছে। তিনটি বিটই একসাথে বদলায়, কিন্তু বাস্তবে তিনটি sensor কখনো ঠিক একই মুহূর্তে বদলায় না; মাঝের এক মুহূর্তে পড়লে 111 বা 000-এর মতো সম্পূর্ণ ভুল মান আসতে পারে, অর্থাৎ শ্যাফট হঠাৎ উল্টো প্রান্তে বলে মনে হয়। Gray code-এ প্রতিটি সীমায় শুধু একটি বিট বদলায়, তাই সীমার মুহূর্তে পড়লেও ফল হয় পুরোনো মান, নয় নতুন মান, কখনো দূরের কিছু নয়। এজন্য absolute encoder, যা চালু হওয়ামাত্র শ্যাফটের পুরো অবস্থান বলে, বহু ক্ষেত্রে Gray code-এর দাগ ব্যবহার করে আর firmware সেটি binary-তে রূপান্তর করে।

Incremental quadrature encoder সেই ধারণার সবচেয়ে ছোট রূপ: দুই বিট, চারটি অবস্থা, প্রতিটি ধাপে এক বিট বদল। এই কারণেই এই পর্বের decoder-এর টেবিলে “দুই বিট একসাথে” মানে ভুল: Gray code-এর নিয়মে সেটি স্বাভাবিকভাবে ঘটতে পারে না। একই নিয়ম স্থির-থাকা কাঁপুনিকেও বাতিল করে, কারণ একটি সংকেতের এদিক-ওদিক দোলা +1 আর −1-এর জোড়া দেয়। অসুবিধা হলো incremental encoder চালুর মুহূর্তে অবস্থান জানে না; তাই একটি তৃতীয় “index” সংকেত (প্রতি পাকে একবার) বা homing লাগে, আর বিদ্যুৎ চলে গেলে count হারায়, যদি না তা non-volatile memory-তে রাখা হয়।

Embedded-এর অন্য জায়গাতেও একই নীতি দেখা যায়: দুই clock domain-এর মধ্যে একটি counter পার করতে Gray code ব্যবহার হয়, কারণ মাঝপথে পড়লেও ভুল এক ধাপের বেশি হয় না।

মূল উপলব্ধি: Gray code-এ প্রতি ধাপে এক বিট বদলায় বলে সীমার মুহূর্তে পড়া মান কখনো দূরে লাফায় না; quadrature encoder এর দুই-বিটের রূপ, আর এই নিয়মই দিক, ভুল ধরা আর কাঁপুনি বাতিলের ভিত্তি।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — conveyor-এর এক ধাপ: একটি unipolar stepper-এর চারটি coil PA1 (A), PA2 (B), PA3 (A′), PA4 (B′)-এ। একটি void stepper_step(int dir) লিখুন, যা half-step টেবিল ধরে dir = +1 হলে এক ধাপ সামনে আর −1 হলে পেছনে যায়, চারটি pin একটি register লেখায় বদলায় আর ISR থেকে ডাকা নিরাপদ। তারপর বলুন: 1.8° motor, 20 mm pulley, 300 mm সরাতে কতবার ডাকতে হবে, আর SysTick 1 ms হলে 800 ধাপ/সেকেন্ড পাওয়া যায় কি না।
    static const uint8_t half_step[8] = {0x1, 0x3, 0x2, 0x6, 0x4, 0xC, 0x8, 0x9};
    static volatile uint32_t phase;           /* 0..7, শুধু এখানে বদলায় */
    
    void stepper_step(int dir)
    {
        uint32_t p = (phase + (dir > 0 ? 1u : 7u)) & 7u;   /* -1 = +7 (mod 8) */
        uint32_t bits = (uint32_t)half_step[p] << 1;       /* PA1..PA4 */
        GPIOA->BSRR = bits | ((~bits & (0xFu << 1)) << 16); /* একটি store */
        phase = p;
    }

    এটি এই পর্বের board-এর firmware-এর একই কৌশল: একটি BSRR store, তাই কোনো read-modify-write নেই আর অন্য pin-এ হাত পড়ে না। ISR আর main দুই জায়গা থেকে ডাকলে phase-এর read আর write-এর মাঝে interrupt আসতে পারে, তাই একটি জায়গা থেকেই ডাকুন (যেমন শুধু timer-এর ISR). হিসাব: অংশ ৫-এর block অনুযায়ী 0.1571 mm/ধাপ, তাই 1910 বার। 1 ms-এর SysTick-এ প্রতি tick-এ এক ধাপ মানে সর্বোচ্চ 1000 ধাপ/সেকেন্ড, কিন্তু 800 পেতে ধাপের ব্যবধান 1.25 ms লাগে, যা 1 ms-এর গুণিতক নয়; হয় SysTick 250 µs করুন (প্রতি ৫ tick-এ এক ধাপ), নয় একটি আলাদা hardware timer. শুরুতে ramp দিতে ভুলবেন না।

  2. ভুল খুঁজুন — fan-এর দিক বদল: একজন cold room-এর fan উল্টো দিকে ঘোরাতে লিখলেন (PA7 = IN1, PA8 = IN2, DRV8833-এর মতো driver; motor অংশ ২-এর মডেলের মতো, পূর্ণ গতিতে চলছে):
    int reverse_req;                       /* বোতামের ISR 1 করে */
    void SysTick_Handler(void)
    {
        if (reverse_req) {
            GPIOA->ODR ^= (1u << 7) | (1u << 8);   /* দিক উল্টানো */
            reverse_req = 0;
        }
    }
    কমপক্ষে তিনটি সমস্যা খুঁজুন, আর দিক বদলের মুহূর্তে current আনুমানিক কত হতে পারে হিসাব করুন।

    ১. সরাসরি উল্টো দিক (plugging): চলন্ত motor-এ back-EMF সরবরাহের সঙ্গে যোগ হয়। অংশ ২-এর মডেলে 4746 rpm-এ E = 9.94 V, তাই I ≈ (12 + 9.94) ÷ 4 = 5.485 ≈ 5.5 A, stall current 3.00 A-এর প্রায় দ্বিগুণ; DRV8833-এর 2 A peak-এর অনেক ওপরে, তাই overcurrent সুরক্ষা bridge বন্ধ করবে, বা দুর্বল driver পুড়তে পারে। আগে duty শূন্য, তারপর coast বা brake, গতি নামলে নতুন দিক। ২. ODR-এ ^=: এটি read-modify-write; main বা অন্য ISR একই port-এ লিখলে তাদের বিট হারাতে পারে। তার ওপর XOR আগের অবস্থার ওপর নির্ভর করে: input 11 (brake) বা 00 (coast) থাকলে XOR দিক উল্টায় না, শুধু 00 আর 11-এর মধ্যে বদলায়। ঠিক অবস্থা BSRR-এ একটি store-এ লিখুন। ৩. reverse_req volatile নয়: দুটি ISR-এর ভাগ করা চলক; volatile ছাড়া compiler পড়া বা লেখা বাদ দিতে বা সরাতে পারে (পর্ব ৩৪)। ৪. বাড়তি: বোতামের debounce নেই (পর্ব ৪২), তাই একটি চাপে কয়েকবার দিক বদল হতে পারে। হিসাব Python-এ চালিয়ে মেলানো: 5.485 A.

  3. আগে বলুন, তারপর মেলান — stepper-এর log: অংশ ৪-এর firmware (half-step টেবিল {0x1, 0x3, 0x2, 0x6, 0x4, 0xC, 0x8, 0x9}, bit0 = PA1 … bit3 = PA4, প্রতি 5 ms-এ এক ধাপ, প্রতিটি ধাপ একটি BSRR store). অবস্থান 0-তে শুধু PA1 = 1. Main আগে step_to(3) আর তারপর step_to(1) ডাকলে board-এর log-এ কোন পাঁচটি GPIO লাইন কোন ক্রমে আসবে? শেষে কোন coil চালু থাকবে?

    সামনে: অবস্থান 1 (0x3) → GPIO PA2 = 1; অবস্থান 2 (0x2) → GPIO PA1 = 0; অবস্থান 3 (0x6) → GPIO PA3 = 1. পেছনে: অবস্থান 2 (0x2) → GPIO PA3 = 0; অবস্থান 1 (0x3) → GPIO PA1 = 1. শেষে A আর B দুটোই চালু (0x3). প্রতিটি ধাপে ঠিক একটি লাইন, কারণ টেবিলের পাশাপাশি দুটি ঘর এক বিটে আলাদা; আর board শুধু বদলানো pin ছাপে। ক্রমটি একটি ছোট Python মডেলে টেবিল ধরে চালিয়ে, আর অংশ ৪-এর আসল run-এর প্রথম তিনটি ধাপের সঙ্গে মিলিয়ে যাচাই করা (55.0106, 60.0106, 65.0106 ms-এর লাইন)।

  4. হিসাব — 24 V-এর motor: একটি DC motor: R = 2 Ω, k = 0.05 V·s/rad, সরবরাহ 24 V. (ক) Stall current আর stall torque কত? (খ) No-load গতি কত rpm? (গ) 0.1 N·m load-এ current আর গতি কত? (ঘ) একই load-এ 60% duty-র PWM দিলে (গড় ভোল্টেজ ধরে) গতি কত? (ঙ) এই motor-এ 100 দাগের encoder ৪x-এ 10 ms-এ কত count দেবে (গ)-এর গতিতে?

    (ক) 24 ÷ 2 = 12 A; torque 0.05 × 12 = 0.6 N·m. (খ) 24 ÷ 0.05 = 480 rad/s = 480 × 60 ÷ 2π ≈ 4584 rpm. (গ) I = 0.1 ÷ 0.05 = 2 A; ω = (24 − 2 × 2) ÷ 0.05 = 400 rad/s ≈ 3820 rpm. (ঘ) গড় 0.6 × 24 = 14.4 V; I একই 2 A; ω = (14.4 − 4) ÷ 0.05 = 208 rad/s ≈ 1986 rpm. (ঙ) 3820 rpm ≈ 63.66 পাক/সেকেন্ড; 10 ms-এ 0.6366 পাক × 400 ≈ 255 count. সব মান Python-এ চালিয়ে মেলানো: 12.0 A, 4584 rpm, 3820 rpm, 1986 rpm, 255 counts. মনে রাখুন, এটি আদর্শ মডেল: আসল motor-এ ঘর্ষণ, brush-এর ভোল্টেজ আর গরম হলে R বেড়ে যাওয়া ফল কিছুটা বদলায়।

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

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

ক্রমH-bridge দিয়ে চলন্ত একটি DC motor-এর দিক নিরাপদে বদলানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. PWM-এর duty ধীরে শূন্যে নামানো
  2. H-bridge-কে coast বা brake অবস্থায় নেওয়া
  3. Encoder বা সময় দেখে গতি প্রায় শূন্য হওয়া পর্যন্ত অপেক্ষা
  4. একটি register লেখায় দুই input-এ নতুন দিকের মান বসানো
  5. Duty ধীরে বাড়িয়ে লক্ষ্যের গতিতে তোলা

TI DRV8833-এর একটি H-bridge-এ xIN1 = 1 আর xIN2 = 1 দিলে datasheet-এর truth table অনুযায়ী কী হয়?

  • Forward
  • Coast / fast decay
  • Shoot-through, তাই নিষিদ্ধ
  • Brake / slow decay

একটি দুই phase-এর hybrid stepper-এর rotor-এ 50টি দাঁত। Full step-এ step angle আর half step-এ প্রতি পাকে ধাপের সংখ্যা কত?

  • 7.2°, 50
  • 1.8°, 400
  • 1.8°, 200
  • 0.9°, 800

একটি H-bridge-এর বাঁ পায়ে ওপরে S1, নিচে S2; ডান পায়ে ওপরে S3, নিচে S4. কোন জোড়া একসাথে চালু হলে shoot-through হয়?

  • S1 আর S2
  • S1 আর S4
  • S2 আর S4
  • S3 আর S2

একটি DC motor: সরবরাহ 12 V, R = 4 Ω, k = 0.02 V·s/rad. এটি 400 rad/s-এ ঘুরছে। আদর্শ মডেলে এখন current কত?

  • 3 A
  • 5 A
  • 1 A
  • 0 A

100 দাগের একটি quadrature encoder ৪x decoding-এ পড়া হচ্ছে। 50 ms-এ 1000 count এল। শ্যাফটের গতি কত rpm?

  • 12000 rpm
  • 3000 rpm
  • 0.83 rpm
  • 6000 rpm

একটি stepper-এর চারটি coil-এর pin একটি timer ISR-এ বদলানো হয়, আর main loop একই GPIO port-এ একটি LED চালু-বন্ধ করে। কোন লেখার পদ্ধতি সবচেয়ে নিরাপদ?

  • ISR-এ ODR ^= mask
  • চারটি pin চারটি আলাদা ODR |= আর ODR &= ~ লেখায়
  • প্রতিবার interrupt বন্ধ করে ODR = (ODR & ~mask) | bits
  • BSRR-এ set আর reset বিট মিলিয়ে একটি store

শব্দকোষ

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

মনে রাখুন

  1. DC motor: E = k ω, T = k I, I = (V − k ω) ÷ R; থেমে থাকলে stall current V ÷ R, তাই চালুর peak সবচেয়ে বড়। Driver আর fuse বাছুন peak ধরে।
  2. H-bridge: সামনে S1 + S4, পেছনে S3 + S2, coast সব বন্ধ, brake দুই low-side; একই পায়ের দুটি একসাথে কখনো নয় (shoot-through), মাঝে dead time; চলন্ত motor উল্টানোর আগে coast বা brake.
  3. Board-এর আসল run: DRV8833-ধাঁচের IN1/IN2-এ FORWARD, নিজে থেকে 2 ms COAST, REVERSE, BRAKE, COAST; stepper-এর প্রতিটি half step একটি BSRR store-এ ঠিক একটি pin বদলায়।
  4. Stepper: VR-এ θ = (Ns − Nr) ÷ (Ns Nr) × 360°, ৫০ দাঁতের hybrid-এ 1.8°; wave, full আর half step; open loop-এর জন্য ramp আর homing.
  5. Encoder আর নিরাপত্তা: quadrature-এর ক্রম থেকে দিক, ৪x-এ প্রতি দাগে চার count, ১৬ ঘরের টেবিল; প্রতিটি coil-এর flyback পথ, আলাদা সরবরাহ, এক GND আর driver input-এ pull-down.

পরের পর্বে: পর্ব ৬৮ (Digital filtering আর sensor fusion). Moving average আর exponential moving average, spike-এর জন্য median filter, smart scale-এর ৪টি নমুনার গড় আর board-এ noise চালু করে আসল run, আর accelerometer ও gyro মিলিয়ে complementary filter.

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

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