এই পর্বে যা শিখবেন
- Open loop আর closed loop নিয়ন্ত্রণের পার্থক্য, আর setpoint, error, actuator, plant ও disturbance-এর ভূমিকা ব্যাখ্যা করা
- P, I আর D পদ আলাদাভাবে কী করে তা বোঝা, শুধু P-এর steady-state error হিসাব করা, আর তিন রকম gain-এর সাড়া তুলনা করা
- Sample time আর fixed-point (Q16) মিলিয়ে firmware-এ একটি discrete PID লেখা, আর একটি update হাতে হিসাব করে মেলানো
- Integral windup কেন হয়, clamping দিয়ে কীভাবে ঠেকাতে হয়, আর derivative kick ও sensor-এর ধাপের সমস্যা কীভাবে কমাতে হয় তা দেখানো
- হাতে tuning আর Ziegler–Nichols পদ্ধতি প্রয়োগ করা, আর কোথায় on-off with hysteresis-ই যথেষ্ট তা বিচার করা
১ · মেপে শোধরানো — open loop বনাম closed loop
বাজারঘরের cold-storage monitor এতদিন শুধু দেখত: প্রতি সেকেন্ডে তাপমাত্রা পড়ত, সীমা পেরোলে alarm বাজাত। এবার দোকানের মালিক চান, যন্ত্রটি নিজেই ঘরের compressor নিয়ন্ত্রণ করুক, যাতে মাছ আর সবজির ঘর সারাদিন 4.00 °C-এর কাছে থাকে। এই পর্বের প্রশ্ন একটাই: কতটা ঠান্ডা করতে হবে, তা firmware প্রতি মুহূর্তে কীভাবে ঠিক করবে? এই পর্বে hex লেখা হবে C-এর ধাঁচে, 0x দিয়ে (যেমন sensor-এর ঠিকানা 0x48).
উপমা — রিকশাচালক আর ঢাল: একজন রিকশাচালক সমান রাস্তায় একটি নির্দিষ্ট জোরে প্যাডেল করেন। সামনে ঢাল এলে গতি কমতে শুরু করে; তিনি তা টের পান আর জোর বাড়ান। ঢাল শেষে গতি বেড়ে গেলে জোর কমান। তিনি কোনো সূত্র জানেন না, কিন্তু প্রতি মুহূর্তে চাওয়া গতি আর আসল গতির পার্থক্য দেখে জোর বদলান। এটিই feedback. চোখ বন্ধ করে একই জোরে চালালে ঢালে রিকশা থেমে যেত: সেটি open loop.
Open-loop control-এ controller একটি আগে থেকে ঠিক করা আদেশ দেয়, ফল মাপে না। ধরা যাক মডেলের ঘরে (অংশ ২-এ বিস্তারিত) compressor সবসময় 65 %-এ চলে। বাইরে 30 °C থাকলে ঘর ঠিক 4 °C-এ স্থির হয়, কারণ মডেলে 65 % cooling ঘরকে বাইরের চেয়ে 0.65 × 40 = 26 °C ঠান্ডা রাখে। কিন্তু চৈত্রের দুপুরে বাইরে 34 °C হলে ঘর 34 − 26 = 8 °C-এ উঠবে, আর দরজা বারবার খুললে আরও ওপরে। Controller জানতেও পারবে না।
Closed-loop control-এ controller ফল মাপে আর তা দিয়ে আদেশ শোধরায়। কয়েকটি শব্দ পুরো পর্বে লাগবে। Setpoint (SP) হলো চাওয়া মান, এখানে 4.00 °C. মাপা মান (process variable) আসে sensor থেকে। দুটির পার্থক্য error, e = মাপা − setpoint (ঠান্ডা করার যন্ত্রে এই চিহ্নই সুবিধাজনক: ঘর গরম হলে e ধনাত্মক, cooling বাড়াতে হবে)। Controller-এর আদেশ u যায় actuator-এ, এখানে compressor. যা নিয়ন্ত্রণ করা হচ্ছে, সেই ঘরটিকে নিয়ন্ত্রণ-তত্ত্বের ভাষায় plant বলে, আর বাইরের যে প্রভাব (গরম বাতাস, দরজা খোলা, নতুন মাছের চালান) plant-কে নড়ায়, তা disturbance.
ছবি ৬৯.১ — বাজারঘরের ঠান্ডা ঘরের closed loop
ডান কলামে আদেশের পথ, বাঁ কলামে মাপের পথ; Σ-এ মাপা মান আর setpoint-এর তুলনা হয়ে error তৈরি হয়
Feedback-এর একটি দামও আছে। মাপ দেরিতে এলে বা controller খুব জোরে সাড়া দিলে loop নিজেই দুলতে শুরু করে, যেমন নতুন চালক স্টিয়ারিং বেশি ঘুরিয়ে এদিক-ওদিক করেন। এই পর্বের বাকি অংশ এই আপসের গল্প: যথেষ্ট জোরে শোধরানো, কিন্তু দোলানো নয়।
২ · বাজারঘরের ঠান্ডা ঘর — plant-এর একটি মডেল
কোর্সের virtual বাজারঘর board-এ (BG-M3, আসল Cortex-M chip-এর আদলে বানানো একটি virtual board, Spec decision 17) temperature sensor আছে, কিন্তু কোনো compressor, ঘর বা তাপের পদার্থবিদ্যা নেই; sensor-এর মান আসে script থেকে (README-র “Scripts”). তাই PID পরীক্ষার জন্য ঘরটিকে একটি ছোট গাণিতিক plant model হিসেবে firmware-এর ভেতরেই রাখা হয়েছে, যেমনটি hardware-in-the-loop পরীক্ষায় করা হয় (পর্ব ৬৪). মডেলটি কাল্পনিক, কোনো আসল ঘরের মাপ নয়; সংখ্যাগুলো বেছে নেওয়া হয়েছে যাতে আচরণ চেনা ঠান্ডা ঘরের মতো হয়।
| অংশ | মডেলে | মানে |
|---|---|---|
| বাইরের তাপমাত্রা | 30 °C | Disturbance-এর মূল উৎস |
| ঘরের time constant | τ = 600 s | Compressor বন্ধ থাকলে ঘর ধীরে বাইরের দিকে গরম হয় |
| Cooling-এর জোর | 40 °C × u | u = 100 % হলে ঘর শেষে বাইরের চেয়ে 40 °C ঠান্ডা, অর্থাৎ −10 °C |
| Dead time | 30 s | আদেশ বদলের 30 s পরে ঘরে প্রভাব পড়ে |
| Sensor | 1/16 °C ধাপ, নিচের দিকে কাটা | README-র TMP102-ধাঁচের sensor (0.0625 °C প্রতি LSB) |
| Setpoint, sample time | 4.00 °C, Ts = 1 s | README-র cold room প্রতি 1 s-এ মাপে; 4.00 °C এই পর্বের পছন্দ |
প্রতি সেকেন্ডে মডেল একটি সরল নিয়মে চলে: Tনতুন = T + ((30 − T) − 40 × u30 s আগে) ÷ 600. প্রথম অংশ গরম ঢোকা: ঘর যত ঠান্ডা, বাইরের সঙ্গে পার্থক্য তত বড়, গরম তত দ্রুত ঢোকে। দ্বিতীয় অংশ compressor-এর টেনে নেওয়া তাপ। ঘর 4 °C-এ স্থির থাকতে হলে দুটি সমান হতে হবে: 30 − 4 = 40 × u, তাই u = 26 ÷ 40 = 65 %. এই সংখ্যাটি পুরো পর্বে বারবার আসবে।
Dead time (transport delay) হলো সেই 30 s, যে সময়ে আদেশ বদলালেও ঘরে কিছু ঘটে না: compressor-এর গতি বাড়তে, refrigerant ঘুরে আসতে, ঠান্ডা বাতাস sensor-এর কাছে পৌঁছাতে সময় লাগে। মডেলে এটি একটি ৩০ ঘরের ring buffer: প্রতি সেকেন্ডে নতুন আদেশ এক প্রান্তে ঢোকে, ৩০ সেকেন্ড আগের আদেশ অন্য প্রান্ত থেকে বেরিয়ে ঘরে প্রভাব ফেলে। নিয়ন্ত্রণকে কঠিন করে প্রধানত এই দেরি, কারণ controller ভুল বুঝতে পারে অনেক পরে।
/* ---- plant model (not a real room) ---- */
static int32_t room_u = TA_U; /* ঘরের তাপমাত্রা, micro-°C, শুরু 30 °C */
static int32_t ubuf[DEAD_S]; /* 30 s-এর আদেশ জমা রাখার ring buffer */
static uint32_t ui;
static void plant_step(int32_t u) /* u: ‰, 1000 = 100 % cooling */
{
int32_t ua = ubuf[ui]; /* 30 s আগের আদেশ */
ubuf[ui] = u;
ui = (ui + 1u) % DEAD_S;
room_u += ((TA_U - room_u) - ua * 40000) / 600;
}
static int32_t sense_t16(void) /* TMP102-এর মতো 1/16 °C-এ, নিচে কাটা */
{
return (room_u + 100000000) / 62500 - 1600;
}Cortex-M3-এ FPU নেই, আর কোর্সের build -nostdlib, তাই software float-এর library-ও link হয় না। সেজন্য ঘরের তাপমাত্রা রাখা হয়েছে micro-°C-এ (int32_t-এ ±2147 °C আঁটে)। Sensor-এর ভাগে 100 000 000 যোগ করে আবার 1600 বাদ দেওয়ার কৌশলটি ঋণাত্মক তাপমাত্রায়ও নিচের দিকে কাটা নিশ্চিত করে, কারণ C-এর ভাগ শূন্যের দিকে কাটে। Sensor-এর বিস্তারিত পর্ব ৬৫-এ আর I2C-র পর্ব ৫১-এ।
৩ · সবচেয়ে সরল নিয়ন্ত্রণ — on-off আর hysteresis
বাড়ির ফ্রিজ বা দোকানের সাধারণ ঠান্ডা ঘরে নিয়ন্ত্রণ সাধারণত on-off control: compressor হয় পুরো চালু, নয়তো বন্ধ। একটি মাত্র সীমা রাখলে (4.00 °C-এর ওপরে চালু, নিচে বন্ধ) sensor-এর ছোট কাঁপুনিতেই compressor সেকেন্ডে সেকেন্ডে চালু-বন্ধ হতো, যা motor আর contactor-এর জন্য ক্ষতিকর। সমাধান hysteresis: চালু আর বন্ধের জন্য আলাদা সীমা।
বাজারঘরের firmware-এ এই কৌশল আগে থেকেই আছে, alarm-এর যুক্তিতে। README-র নিয়ম: পরপর ৩টি পড়া 8.00 °C-এর ওপরে হলে HIGH alarm, 0.00 °C-এর নিচে হলে LOW alarm; আর alarm বন্ধ হয় শুধু তখন, যখন পরপর ৩টি পড়া 0.50 … 7.50 °C-এর ভেতরে, অর্থাৎ 0.50 °C hysteresis. Reference-এর run-এ 9 s-এর 7.75 °C পড়া তাই alarm চালুও রাখে না, বন্ধও করে না। এই পর্বের PID firmware এই alarm-এর যুক্তি হুবহু রেখেছে, নিয়ন্ত্রণ থেকে আলাদা পাহারাদার হিসেবে; পরে দেখবেন, সেই পাহারাদারই windup ধরে ফেলে।
একই ধাঁচে একটি thermostat: compressor চালু যখন T > 4.5 °C, বন্ধ যখন T < 3.5 °C, মাঝে আগের অবস্থা বজায়। কাগজে মনে হয় ঘর 3.5 থেকে 4.5 °C-এর মধ্যে থাকবে। কিন্তু dead time আছে: compressor বন্ধ হওয়ার পরেও ৩০ s ধরে আগের ঠান্ডা আসতে থাকে, আর চালুর পরে ৩০ s ধরে কিছুই আসে না। অংশ ৪-এর block-এ মডেলের আসল ফল দেখবেন: ঘর দোলে 2.81 থেকে 5.81 °C-এর মধ্যে, band-এর তিন গুণ, আর ২০ মিনিটে compressor ৬ বার চালু হয়। On-off সস্তা আর মজবুত, কিন্তু মাঝামাঝি জোর দিতে পারে না। ঠিক 65 % চালানোর জন্য দরকার এমন actuator, যার জোর বদলানো যায় (inverter compressor, PWM-চালিত fan বা ভাল্ভ; PWM পর্ব ৪৫-এ, motor পর্ব ৬৭-এ), আর এমন controller, যে কতটা জোর তা হিসাব করে। সেটিই PID.
৪ · P, I আর D — বর্তমান, অতীত আর ভবিষ্যৎ
PID controller-এর আদেশ তিনটি পদের যোগফল:
u[k] = Kp·e[k] + Ki·Σ e·Ts + Kd·(e[k] − e[k−1]) ÷ Ts
এখানে e = মাপা − setpoint (ঠান্ডা করার যন্ত্রে)। এই পর্বে u ভগ্নাংশে (1 = 100 % cooling), তাই Kp-এর একক “প্রতি °C”, Ki-এর “প্রতি °C·s”, Kd-এর “s প্রতি °C”.
P, বর্তমান: proportional পদ এখনকার error-এর সমানুপাতে কাজ করে। Kp = 0.30 মানে প্রতি 1 °C বেশি গরমে 30 % বেশি cooling. সমস্যা হলো, শুধু P দিয়ে ঘর কখনো ঠিক 4 °C-এ পৌঁছায় না। কারণ 4 °C-এ e = 0, তাই u = 0, অথচ ঘর ধরে রাখতে 65 % লাগে। ঘর তাই এমন জায়গায় থামে, যেখানে error-ই ঠিক যতটা দরকার ততটা cooling চায়: 0.30 × e × 40 = 26 − e, অর্থাৎ e = 26 ÷ (1 + 40 × 0.30) = 26 ÷ 13 = 2.00 °C. এই থেকে যাওয়া পার্থক্যই steady-state error; Kp বাড়ালে কমে, কিন্তু শূন্য হয় না, আর বেশি বাড়ালে loop দুলতে শুরু করে (অংশ ৮).
I, অতীত: integral পদ error জমাতে থাকে। যতক্ষণ সামান্য error-ও থাকে, জমা বাড়তেই থাকে আর cooling বাড়ায়। স্থির অবস্থায় জমা আর বাড়ে না, যা সম্ভব শুধু e = 0 হলে। তাই I থাকলে steady-state error শূন্য: I পদ নিজেই সেই 65 % ধরে রাখে, যা P পারেনি। দাম হলো ধীরতা আর overshoot-এর ঝুঁকি, কারণ অতীতের জমা হঠাৎ মোছে না।
D, ভবিষ্যৎ: derivative পদ error কত দ্রুত বদলাচ্ছে তা দেখে। ঘর দ্রুত ঠান্ডা হতে থাকলে D আগেভাগে cooling কমায়, যেন গাড়ি থামানোর আগে ব্রেকে আলতো চাপ। Dead time-ওয়ালা ঘরে এটি কাজে লাগে, কিন্তু D noise আর sensor-এর ধাপ বড় করে দেখায় (অংশ ৭).
তিনটি নকশা একই ঘরে চালিয়ে দেখা যাক। গল্পটি পরিচিত: লোডশেডিং-এ বিদ্যুৎ গিয়েছিল, ঘর গরম হয়ে 8 °C হয়েছে, বিদ্যুৎ ফেরার পরে controller নতুন করে চালু হলো (I = 0). নিচের সহায়ক file coldroom_pid.py হলো board-এর firmware-এর (অংশ ৫) হুবহু integer হিসাব, Python-এ; প্রতিটি block এটি import করে।
# লোডশেডিং শেষে বিদ্যুৎ ফিরল: ঘর 8 °C-এ, controller নতুন করে চালু (I = 0)
# setpoint 4.00 °C; ঘর আর sensor coldroom_pid.py-র মডেল (pid_core.h-এর হুবহু হিসাব)
from coldroom_pid import run, c
def settle(log): # এর পরে T সবসময় 4.00 ± 0.25 °C-এর ভেতরে
out = [k for k, m, u, i in log if abs(m - 64) > 4]
return f"{out[-1]} s" if out and out[-1] < len(log) else "কখনো না"
print("নকশা t=60 t=120 t=240 t=480 t=900 t=1800 u শেষে স্থির")
for name, kp, ki, kd in [("P", 0.30, 0, 0), ("PI", 0.30, 0.002, 0),
("PID", 0.30, 0.002, 3.0)]:
log = run(kp, ki, kd, t0=8.0)
T = [c(log[t - 1][1]) for t in (60, 120, 240, 480, 900, 1800)]
print(f"{name:8s}", *T, f"{log[-1][2] / 10:5.1f} %", settle(log))
# একই ঘরে on-off: compressor 100 % যখন T > 4.5 °C, বন্ধ যখন T < 3.5 °C
for name, log in [("on-off", run(0, 0, 0, t0=8.0, onoff=(3.5, 4.5))),
("PID", run(0.30, 0.002, 3.0, t0=8.0))]:
w = log[600:] # 600 s-এর পরের 20 মিনিট
starts = sum(1 for a, b in zip(w, w[1:]) if a[2] == 0 and b[2] > 0)
lo, hi = c(min(x[1] for x in w)), c(max(x[1] for x in w))
print(f"{name}: T {lo} … {hi} °C, compressor বন্ধ থেকে চালু {starts} বার")আসল আউটপুট (ব্রাউজারের Python):
নকশা t=60 t=120 t=240 t=480 t=900 t=1800 u শেষে স্থির
P +8.12 +6.43 +6.00 +6.00 +6.00 +6.00 60.0 % কখনো না
PI +8.12 +6.43 +4.68 +4.06 +4.00 +4.00 64.9 % 341 s
PID +8.12 +6.43 +4.68 +4.00 +4.00 +4.00 65.0 % 307 s
on-off: T +2.81 … +5.81 °C, compressor বন্ধ থেকে চালু 6 বার
PID: T +4.00 … +4.06 °C, compressor বন্ধ থেকে চালু 0 বার
প্রথম সারিতে তত্ত্ব মিলে গেল: শুধু P-তে ঘর 6.00 °C-এ থামে, u = 60.0 %, অর্থাৎ 0.30 × 2.00. PI আর PID দুটিই 4.00 °C-এ পৌঁছায়, আর শেষে u প্রায় 65 %. t = 60 s-এ তিনটিই 8.12 °C, শুরুর 8 °C-এর ওপরে: প্রথম ৩০ সেকেন্ড আদেশ ঘরে পৌঁছায়ইনি, dead time. শেষ দুই লাইনে on-off বনাম PID: on-off 3 °C চওড়া দোলে আর compressor বারবার চালু-বন্ধ করে; PID ঘরকে 4.00 থেকে 4.06 °C-এ, অর্থাৎ sensor-এর একটি ধাপের ভেতরে রাখে, compressor একবারও বন্ধ হয় না, শুধু গতি বদলায়।
| সময় | |
| P (0.30) | |
| PI (+0.002) | |
| PID (+3.0) |
- শুরু। ঘর 8.00 °C, error 4 °C. P একাই চায় 0.30 × 4 = 120 %, তাই তিনটিরই আদেশ সীমায়, 100 %. Anti-windup (অংশ ৬) থাকায় সীমায় থাকা অবস্থায় I জমে না, 0-ই থাকে।
- Dead time-এর শিক্ষা। ৩১ সেকেন্ডে ঘর উল্টো গরম হয়ে 9.06 °C! বিদ্যুৎ ফেরার আগে compressor বন্ধ ছিল, আর নতুন আদেশ ৩০ s পরে পৌঁছায়। এই সময়ে কোনো controller-ই কিছু করতে পারে না।
- Cooling পৌঁছেছে। তিনটিই 6.43 °C-এ। P চায় 73.1 %. PI-তে I জমেছে 18.2 %, তাই আদেশ 91.3 %. PID-তে ঘর দ্রুত নামছে বলে D ব্রেক কষেছে: 75.5 %.
- পার্থক্য দেখা দেয়। P-এর ঘর 5.81 °C-এ, আদেশ 54.4 %, যা এই তাপমাত্রা ধরে রাখার দরকারের চেয়ে কম; তাই ঘর আবার একটু উঠবে। PI 5.18 °C, PID 5.31 °C: D-এর ব্রেকে PID একটু ধীরে নামছে, কিন্তু মসৃণভাবে।
- P থেমে গেল। P-এর ঘর 6.00 °C-এ স্থির, u = 60.0 %: steady-state error 2.00 °C, তত্ত্বের 26 ÷ 13-এর সঙ্গে হুবহু। PI আর PID 4.68 °C-এ, I জমেই চলেছে।
- শেষ ধাপ। PI 4.25 °C, PID 4.12 °C; দুটিরই I এখন 60–63 %-এ, প্রায় সেই দরকারি 65 %. এখানে বেশিরভাগ কাজ করছে I, কারণ error ছোট।
- স্থির। PI আর PID 4.00 °C-এ, u আর I প্রায় 65 %: পুরো আদেশ এখন I-এর। 4.00 ± 0.25 °C-এ স্থায়ীভাবে ঢোকে PID 307 s-এ, PI 341 s-এ; P কখনো নয়।
৫ · Firmware-এ discrete PID — sample time আর fixed-point
Microcontroller-এ PID একটি ছোট function, যা নির্দিষ্ট সময় পরপর একবার চলে। এই নির্দিষ্ট সময়ই sampling period Ts, এখানে 1 s. প্রতিবার চারটি কাজ: sensor পড়া, error হিসাব, তিন পদ যোগ করে আদেশ বানানো, আর আদেশ actuator-এ লেখা। Ts স্থির থাকা জরুরি, কারণ Ki আর Kd-এর মানে Ts-এর সঙ্গে বাঁধা: loop দ্বিগুণ ঘন চললে আর কোড Ts না জানলে I দ্বিগুণ দ্রুত জমে আর D অর্ধেক হয়ে যায়। তাই PID সাধারণত timer-এর interrupt বা RTOS-এর নির্দিষ্ট period-এর task থেকে ডাকা হয় (পর্ব ৪৪, পর্ব ৫৬), আর সময়ের jitter ছোট রাখা হয় (পর্ব ৫৪). প্রচলিত নিয়ম হিসেবে Ts loop-এর সাড়ার সময়ের অনেক ছোট রাখা হয়; এখানে 1 s, ঘরের 600 s আর dead time-এর 30 s-এর তুলনায় ছোট।
এবার সংখ্যার প্রশ্ন। Kp = 0.30 প্রতি °C, কিন্তু firmware দেখে sensor-এর ধাপ (1/16 °C) আর আদেশ রাখে ‰-এ (0…1000). তাই একক বদলাতে হয়: 0.30 প্রতি °C = 300 ‰ প্রতি °C = 300 ÷ 16 = 18.75 ‰ প্রতি LSB. ভগ্নাংশ রাখতে fixed-point Q16 (Q format, ১৬টি ভগ্নাংশ বিট): 18.75 × 65 536 = 1 228 800. একইভাবে Ki = 0.002 → 0.125 ‰ → 8192, আর Kd = 3.0 → 187.5 ‰ → 12 288 000. সব পদ Q16-এ যোগ করে শেষে 32 768 (অর্ধেক) যোগ করে 16 বিট ডানে সরালে গোল করা ‰ পাওয়া যায়। Fixed-point-এর পুরো কৌশল পর্ব ৪০-এ। বাজারঘরের firmware-এর মূল function:
#define SP16 64 /* setpoint 4.00 C (1/16 C units) */
#define KP_Q 1228800 /* Kp = 0.30 per C = 18.75 permille/LSB, Q16 */
#define KI_Q 8192 /* Ki = 0.002 per C*s = 0.125 permille/LSB, Q16 */
#define KD_Q 12288000 /* Kd = 3.0 s per C = 187.5 permille/LSB, Q16 */
#define U_MAX 1000 /* output in permille: 1000 = 100 % cooling */
typedef struct { int64_t integ; int32_t prev; } pidc_t;
static int32_t pid_update(pidc_t *c, int32_t t16)
{
int32_t e = t16 - SP16; /* + = too warm -> more cooling */
int64_t p = (int64_t)KP_Q * e;
int64_t d = (int64_t)KD_Q * (t16 - c->prev); /* derivative on measurement */
c->prev = t16;
int64_t i_new = c->integ + (int64_t)KI_Q * e; /* Ts = 1 s */
int32_t u = (int32_t)((p + i_new + d + 32768) >> 16);
#if ANTI_WINDUP
if (!((u > U_MAX && e > 0) || (u < 0 && e < 0))) { /* clamping */
if (i_new < 0) i_new = 0;
if (i_new > ((int64_t)U_MAX << 16)) i_new = (int64_t)U_MAX << 16;
c->integ = i_new;
}
#else
c->integ = i_new;
#endif
if (u > U_MAX) u = U_MAX;
if (u < 0) u = 0;
return u;
}লক্ষ করুন int64_t: 1 228 800 × 416 (30 °C-এ error-এর LSB) = 511 180 800, ৩২ বিটে আঁটে, কিন্তু তিন পদের যোগফল বড় error-এ সীমা ছুঁতে পারে; ৬৪ বিটে কোনো ঝুঁকি নেই। Cortex-M3-এ ৬৪ বিটের গুণ-যোগ একটি নির্দেশ, তবে ৬৪ বিটের ভাগ library ডাকে, তাই কোডে ভাগ নেই, শুধু shift. Board-এর build (Clang 22.1.8, -O2) থেকে আমার lab-এ বানানো Thumb assembly-র অংশ, যেখানে pid_update inline হয়ে main-এর loop-এ ঢুকেছে:
$ python -m ziglang clang --target=thumbv7m-none-eabi -mcpu=cortex-m3 -mthumb
-mfloat-abi=soft -ffreestanding -nostdlib -O2 -std=c11 -S pid_aw.c
sub.w r6, lr, #1664 @ e = t16 − 64 (1600 + 64 একসাথে)
...
adds.w r5, r0, r6, lsl #13 @ I + e × 8192 (Ki_q = 2^13, তাই shift)
...
adcs r0, r4 @ ওপরের ৩২ বিট, carry-সহ
...
mov.w r1, #1228800 @ KP_Q
smlal r3, r4, r6, r1 @ ৬৪ বিটের যোগফল += Kp × e
sub.w r1, lr, #1600 @ এখনকার t16
subs r2, r1, r2 @ t16 − prev
movw r1, #32768
movt r1, #187 @ 187 × 65536 + 32768 = 12288000 = KD_Q
smlal r3, r4, r2, r1 @ += Kd × (t16 − prev)
adds.w r2, r3, #32768 @ গোল করতে অর্ধেক যোগ
...
adc r3, r4, #0
lsrs r2, r2, #16 @ ৬৪ বিট >> 16 …
...
orr.w r2, r2, r3, lsl #16 @ … দুই অর্ধেক জোড়া লাগিয়ে u
কয়েকটি মজার জিনিস চোখে পড়ে (comment আমার যোগ করা, “...” মানে মাঝের কিছু লাইন বাদ)। প্রথম লাইনেই compiler 1600 আর setpoint-এর 64 এক নির্দেশে বিয়োগ করেছে। Compiler Ki-এর গুণকে shift বানিয়েছে, কারণ 8192 = 213. smlal একটি নির্দেশে ৩২×৩২ বিটের গুণফল ৬৪ বিটের যোগফলে যোগ করে। আর পুরো ফাইলে কোথাও __aeabi_ldivmod-এর মতো library ডাক নেই; মডেলের 600 আর 62 500 দিয়ে ভাগও compiler গুণ আর shift-এ বদলে দিয়েছে (smull দিয়ে)। এখন একটি update হাতে মেলানো যাক, AW firmware-এর 601 নম্বর সেকেন্ড:
| ধাপ | |
| হিসাব | |
| ফল | |
| Q16-এ |
- Sensor. মডেলের ঘর 5.748432 °C. × 16 = 91.97, নিচে কেটে t16 = 91, অর্থাৎ sensor বলছে 5.6875 °C; UART-এ ছাপা হতো 5.68. আগের সেকেন্ডে পড়া ছিল 92.
- Error. Setpoint 4.00 °C = 64 LSB. e = 91 − 64 = 27 LSB = 1.6875 °C, ধনাত্মক, অর্থাৎ ঘর গরম, cooling চাই।
- P. 18.75 ‰ প্রতি LSB × 27 = 506.25 ‰. Q16-এ 1 228 800 × 27 = 33 177 600.
- I. আগের জমা 359.625 ‰, যোগ হয় 0.125 × 27 = 3.375 ‰, নতুন 363.0 ‰. সীমায় নেই বলে (নিচে দেখুন) এই মান রাখা হবে।
- D. মাপ এক ধাপ নেমেছে (92 → 91), ঘর ঠান্ডা হচ্ছে, তাই D cooling কমায়: 187.5 × (−1) = −187.5 ‰. মাত্র 0.0625 °C-এর বদলে এত বড় পদ, এই কথায় অংশ ৭-এ ফিরব।
- যোগ ও গোল। 506.25 + 363.0 − 187.5 = 681.75 ‰; অর্ধেক যোগ করে 16 বিট সরালে u = 682 ‰ = 68.2 %. 0 আর 1000-এর মাঝে, তাই সীমা ছোঁয়নি আর anti-windup-এর শর্তে I-এর 363.0 রাখা হলো।
- ঘরে প্রভাব। 682 যায় ring buffer-এ; ঘরে ঢোকে t = 571 s-এর আদেশ 938 ‰. নতুন ঘর = 5.748432 + ((30 − 5.748432) − 40 × 0.938) ÷ 600 = 5.726318 °C.
৬ · Integral windup আর anti-windup — সত্যিকারের board run
Actuator-এর একটি সীমা আছে: compressor 100 %-এর বেশি ঠান্ডা করতে পারে না। নতুন ঘর প্রথমবার চালু হলে 30 °C থেকে 4 °C-এ নামতে মিনিটের পর মিনিট লাগে, আর পুরো সময় error বড়। আদেশ 100 %-এ আটকে থাকলেও I পদ জানে না যে তার চাওয়া পূরণ হচ্ছে না; সে জমাতেই থাকে। ঘর লক্ষ্যে পৌঁছালে সেই বিশাল জমা মুছতে অনেক সময় লাগে, আর ততক্ষণ compressor পুরো জোরে চলে। এর নাম integral windup. সমাধান anti-windup; এখানে সবচেয়ে সরল রূপ, clamping বা conditional integration: আদেশ সীমা ছুঁয়েছে আর error সেই দিকেই আরও ঠেলছে, তখন I জমানো বন্ধ; আর I নিজেও 0 … 100 %-এর ভেতরে আটকানো। pid_update-এর #if ANTI_WINDUP অংশটি এটিই।
দুটি firmware আমার lab-এ board-এর build দিয়ে তৈরি: pid_aw.c (#define ANTI_WINDUP 1) আর pid_noaw.c (0), দুটিই একই pid_core.h নেয়। SysTick 1 s-এর tick দেয় (LOAD = 8 000 000 − 1 = 7 999 999, ২৪ বিটে আঁটে), main প্রতি tick-এ একবার কাজ করে বাকি সময় WFI-তে ঘুমায়, আর প্রতি 60 s-এ একটি লাইন ছাপে। ticks চলকটি ISR আর main দুজনেই ছোঁয় বলে volatile (পর্ব ৩৪). ৩০ মিনিট board-সময় চালাতে --cycles বাড়াতে হয়েছে; board WFI-র সময় লাফিয়ে যায় (Spec decision 21), তাই run এক সেকেন্ডের কম সময়ে শেষ। সত্যিকারের run (অংশ বাদ দেওয়া জায়গায় “…”):
$ python -B board.py build ~/lab/pid/pid_aw.c -o ~/lab/pid/build/pid_aw.elf
$ python -B board.py run ~/lab/pid/build/pid_aw.elf --cycles 15000000000
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0416 ms] UART: PID cold room, anti-windup ON
[ 3000.0319 ms] GPIO PA6 ALARM ON
[ 3000.0545 ms] UART: ALARM ON: HIGH temperature
[ 60000.0956 ms] UART: t=60 s T=+28.06 C u=100.0 % I=0.0 %
…
[480000.0956 ms] UART: t=480 s T=+8.87 C u=100.0 % I=0.0 %
[527000.0349 ms] GPIO PA6 ALARM OFF
[527000.0441 ms] UART: ALARM OFF
[540000.0965 ms] UART: t=540 s T=+7.06 C u=82.8 % I=9.7 %
[600000.0985 ms] UART: t=600 s T=+5.75 C u=88.5 % I=36.0 %
[660000.0985 ms] UART: t=660 s T=+4.87 C u=77.5 % I=51.2 %
…
[900000.0985 ms] UART: t=900 s T=+4.00 C u=45.9 % I=64.6 %
…
[1800000.1010 ms] UART: t=1800 s T=+4.00 C u=65.0 % I=65.0 %
[1800000.1231 ms] UART: min T=+4.00 C
[1800000.1240 ms] exit(0) after 14400000992 cycles
$ python -B board.py run ~/lab/pid/build/pid_noaw.elf --cycles 15000000000
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0424 ms] UART: PID cold room, anti-windup OFF
[ 3000.0318 ms] GPIO PA6 ALARM ON
[ 3000.0544 ms] UART: ALARM ON: HIGH temperature
[ 60000.0996 ms] UART: t=60 s T=+28.06 C u=100.0 % I=306.1 %
…
[480000.1022 ms] UART: t=480 s T=+8.87 C u=100.0 % I=1427.1 %
[527000.0328 ms] GPIO PA6 ALARM OFF
[527000.0420 ms] UART: ALARM OFF
…
[600000.1033 ms] UART: t=600 s T=+5.43 C u=100.0 % I=1501.5 %
[660000.1031 ms] UART: t=660 s T=+4.00 C u=100.0 % I=1509.8 %
[720000.1033 ms] UART: t=720 s T=+2.62 C u=100.0 % I=1501.2 %
[780000.1031 ms] UART: t=780 s T=+1.43 C u=100.0 % I=1477.5 %
[840000.1029 ms] UART: t=840 s T=+0.37 C u=100.0 % I=1439.9 %
[865000.0319 ms] GPIO PA6 ALARM ON
[865000.0536 ms] UART: ALARM ON: LOW temperature
[900000.1019 ms] UART: t=900 s T=-0.62 C u=100.0 % I=1389.9 %
…
[1500000.1019 ms] UART: t=1500 s T=-6.56 C u=100.0 % I=417.4 %
[1560000.0975 ms] UART: t=1560 s T=-6.18 C u=3.0 % I=289.9 %
[1620000.0975 ms] UART: t=1620 s T=-3.00 C u=0.0 % I=186.4 %
[1680000.1005 ms] UART: t=1680 s T=+0.12 C u=24.5 % I=122.0 %
[1690000.0325 ms] GPIO PA6 ALARM OFF
[1690000.0418 ms] UART: ALARM OFF
[1740000.0987 ms] UART: t=1740 s T=+2.18 C u=35.2 % I=89.6 %
[1800000.0987 ms] UART: t=1800 s T=+3.25 C u=71.4 % I=75.2 %
[1800000.1202 ms] UART: min T=-6.75 C
[1800000.1211 ms] exit(0) after 14400000969 cycles
শুরুর HIGH alarm দুটিতেই একই: ঘর 30 °C, পরপর তিনটি পড়া 8.00-এর ওপরে, 3 s-এ alarm (README-র নিয়ম)। 527 s-এ দুটিতেই alarm বন্ধ, কারণ ঘর 7.50 °C-এর নিচে তিনটি পড়া দিয়েছে। তারপর পথ আলাদা। নিচের stepper দুটি run পাশাপাশি রাখে:
| সময় | |
| AW চালু | |
| AW বন্ধ |
- প্রথম মিনিট। দুটিতেই ঘর 28.06 °C আর u = 100 %: আদেশ একই। পার্থক্য ভেতরে: AW-তে I = 0.0 %, কারণ সীমায় থাকা অবস্থায় জমানো বন্ধ; AW ছাড়া I এর মধ্যেই 306.1 %, যা কোনো কাজে লাগছে না।
- ৮ মিনিট। ঘর দুটিতেই 8.87 °C, ঘর একই পথে নামছে, কারণ compressor দুটিতেই পুরো জোরে। কিন্তু AW ছাড়া I এখন 1427.1 %, compressor-এর সর্বোচ্চ ক্ষমতার চৌদ্দ গুণের বেশি।
- লক্ষ্যের কাছে। AW-তে আদেশ সীমা থেকে নেমেছে (77.5 %), I শান্তভাবে 51.2 %-এ উঠছে। AW ছাড়া ঘর ঠিক 4.00 °C-এ, error শূন্য, তবু u = 100 %: 1509.8 %-এর জমা আদেশকে সীমার অনেক ওপরে রেখেছে।
- Windup-এর দাম। AW-তে ঘর 4.00 °C-এ স্থির; u = 45.9 % এক মুহূর্তের, sensor এক ধাপ নামায় D-এর ঝাঁকুনি। AW ছাড়া ঘর −0.62 °C, মাছ জমে যাওয়ার পথে; 865 s-এ পাহারাদার alarm LOW বাজিয়েছে, PA6 চালু।
- উল্টো জমায় মোছা। AW ছাড়া I কমছে শুধু ঋণাত্মক error-এ: 417.4 %, ঘর −6.56 °C, তখনো পুরো জোরে cooling. AW-তে I = u = 65.0 %, ঠিক তত্ত্বের দরকারি মান।
- শেষ। ৩০ মিনিটে AW-এর ঘর একবারও 4.00 °C-এর নিচে যায়নি। AW ছাড়া সর্বনিম্ন −6.75 °C, প্রায় ১৪ মিনিট (863–1676 s) 0 °C-এর নিচে, আর ৩০ মিনিটেও 3.25 °C-এ উঠছে, এখনো স্থির নয়।
Board-এর এই সংখ্যাগুলো কি Python মডেলের সঙ্গে মেলে? নিচের block একই coldroom_pid.py দিয়ে দুটি run আবার করে। Firmware-এ যুক্তি host-এ আগে পরীক্ষা করা এমবেডেড কাজের একটি মূল অভ্যাস (পর্ব ৬৪):
# নতুন ঘর প্রথমবার ঠান্ডা হচ্ছে: শুরু 30 °C, setpoint 4.00 °C, Kp 0.30, Ki 0.002, Kd 3.0
# aw=True হলো pid_aw.c, aw=False হলো pid_noaw.c — একই integer হিসাব, host-এ
from coldroom_pid import run, c # c(): firmware-এর মতো করে °C ছাপা
for aw in (True, False):
log = run(0.30, 0.002, 3.0, aw=aw)
print("anti-windup", "ON" if aw else "OFF")
for t in (480, 660, 900, 1500, 1800):
k, m, u, i = log[t - 1]
print(f" t={k} s T={c(m)} C u={u / 10:.1f} % I={i / 10:.1f} %")
cold = [k for k, m, u, i in log if m < 0]
print(f" সর্বনিম্ন T={c(min(x[1] for x in log))} C;", end=" ")
print(f"0 °C-এর নিচে {cold[0]}–{cold[-1]} s" if cold else "0 °C-এর নিচে কখনো নয়")
# integrator কতটা ফুলেছিল, আর নামাতে কত "উল্টো" error লাগে
peak = max(i for *_, i in run(0.30, 0.002, 3.0, aw=False))
print(f"I-এর চূড়া {peak / 10:.1f} %; 65 %-এ নামাতে দরকার "
f"{(peak - 650) / 1000 / 0.002:.0f} °C·s ঋণাত্মক error")আসল আউটপুট (ব্রাউজারের Python):
anti-windup ON
t=480 s T=+8.87 C u=100.0 % I=0.0 %
t=660 s T=+4.87 C u=77.5 % I=51.2 %
t=900 s T=+4.00 C u=45.9 % I=64.6 %
t=1500 s T=+4.00 C u=65.0 % I=65.0 %
t=1800 s T=+4.00 C u=65.0 % I=65.0 %
সর্বনিম্ন T=+4.00 C; 0 °C-এর নিচে কখনো নয়
anti-windup OFF
t=480 s T=+8.87 C u=100.0 % I=1427.1 %
t=660 s T=+4.00 C u=100.0 % I=1509.8 %
t=900 s T=-0.62 C u=100.0 % I=1389.9 %
t=1500 s T=-6.56 C u=100.0 % I=417.4 %
t=1800 s T=+3.25 C u=71.4 % I=75.2 %
সর্বনিম্ন T=-6.75 C; 0 °C-এর নিচে 863–1676 s
I-এর চূড়া 1509.8 %; 65 %-এ নামাতে দরকার 7224 °C·s ঋণাত্মক error
প্রতিটি লাইন board run-এর লাইনের সঙ্গে অক্ষরে অক্ষরে এক; আমার lab-এ একটি script দুই run-এর ৩১টি করে UART লাইন মিলিয়ে দেখেছে, সব সমান। Python-এর // নিচের দিকে কাটে, C-এর / শূন্যের দিকে; তাই helper-এ cdiv() লাগে, নইলে ঋণাত্মক তাপমাত্রায় এক micro-°C-এর পার্থক্য জমে ফল বদলাত। শেষ লাইনটি windup-এর মাপ: Ki = 0.002 প্রতি °C·s মানে প্রতি °C·s-এ 0.2 %, তাই (1509.8 − 65.0) ÷ 0.2 = 7224 °C·s উল্টো error জমলে তবে I স্বাভাবিকে ফেরে; যেমন গড়ে প্রায় −6 °C, প্রায় ২০ মিনিট।
Clamping ছাড়াও anti-windup-এর অন্য পরিচিত রূপ আছে। Back-calculation: সীমায় আটকানো আদেশ আর হিসাবের আদেশের পার্থক্য একটি gain দিয়ে I থেকে বাদ দেওয়া, যাতে I নিজেই সীমার সঙ্গে মিলে যায়। Velocity (incremental) form: প্রতিবার পুরো আদেশ নয়, শুধু পরিবর্তন Δu হিসাব করে আগের (আটকানো) আদেশে যোগ করা; আদেশটি নিজেই সীমায় আটকে থাকে বলে আলাদা জমা ফুলতে পারে না (অনুশীলন ১). যেটিই বাছুন, শর্ত একটাই: controller-কে জানতে হবে actuator আসলে কী করছে।
নিরাপত্তা: Refrigeration-এর compressor আর তার মূল সরবরাহ mains voltage-এ চলে, আর refrigerant চাপে থাকে। এই পর্বের সব পরীক্ষা মডেলে আর virtual board-এ; আসল ঠান্ডা ঘরের wiring বা compressor-এ হাত দেওয়া প্রশিক্ষিত টেকনিশিয়ানের কাজ। Firmware-এর দিকেও নিয়ম: নিয়ন্ত্রণ যত ভালোই হোক, তার বাইরে একটি আলাদা alarm (এখানে README-র পাহারাদার) আর hardware-এর সুরক্ষা রাখুন। Compressor-এর মতো যন্ত্রে নির্মাতার সর্বনিম্ন চালু ও বন্ধের সময় মানতে হয়; PID-এর আদেশও সেই সীমার মধ্যে বাঁধুন।
৭ · D-এর দুই সমস্যা — derivative kick আর sensor-এর ধাপ
অংশ ৪-এর সূত্রে D দেখে error-এর পরিবর্তন। কিন্তু error = মাপ − setpoint, তাই setpoint হঠাৎ বদলালে error-ও এক ধাপে বদলায়, আর D সেই এক মুহূর্তে বিশাল আদেশ দেয়। ঘরের কিছুই বদলায়নি, শুধু লক্ষ্য বদলেছে; এই অপ্রয়োজনীয় লাফের নাম derivative kick. সমাধান সরল: D নিন শুধু মাপের পরিবর্তন থেকে (derivative on measurement). Setpoint স্থির থাকলে দুটি হুবহু এক, পার্থক্য শুধু setpoint বদলের মুহূর্তে। বাজারঘরের firmware শুরু থেকেই এই রূপ নেয় (t16 - c->prev).
দ্বিতীয় সমস্যা ধাপ। Sensor-এর resolution 0.0625 °C, তাই মাপ ধাপে ধাপে বদলায়, আর প্রতিটি ধাপে D = 3.0 × 0.0625 ÷ 1 s = 0.1875, অর্থাৎ 18.75 % আদেশের লাফ। Noise থাকলে আরও খারাপ। প্রচলিত উপায় D-কে একটি low-pass filter দিয়ে মসৃণ করা; firmware-এ সবচেয়ে সহজ রূপ exponential moving average, df ← df + α(d − df). Filter-এর বিস্তারিত পর্ব ৬৮-এ; এখানে শুধু PID-এর ওপর তার প্রভাব। নিচের block দুটি পরীক্ষাই চালায়: মাছের নতুন চালান আসায় 1200 s-এ setpoint 4.00 থেকে 3.50 °C, আর স্থির অবস্থায় তিনটি α.
# D-এর দুই সমস্যা: setpoint বদলের "kick" আর sensor-এর ধাপে লাফানো output
from coldroom_pid import run
G = (0.30, 0.002, 3.0)
# ১) 1200 s-এ ঘর স্থির 4.00 °C-এ; তারপর setpoint 3.50 °C (মাছের নতুন চালান)
for d_on in ("err", "meas"):
log = run(*G, n=1205, sp_at=(1200, 3.5), d_on=d_on)
u = [f"{x[2] / 10:.1f}" for x in log[1198:1205]]
print(f"D {d_on:4s} থেকে, t=1199…1205 s-এ u (%):", " ".join(u))
# ২) স্থির অবস্থায় (1000–1800 s) sensor 1/16 °C-এর ধাপে নড়ে; D তা বড় করে
print("filter alpha | u-এর পরিসর (%) | ≥10 %-এর লাফ | T-এর পরিসর (°C)")
for a in (1.0, 0.25, 0.1):
w = run(*G, alpha=a)[1000:]
us, ts = [x[2] for x in w], [x[1] / 16 for x in w]
jumps = sum(1 for p, q in zip(us, us[1:]) if abs(q - p) >= 100)
print(f" {a:<9} | {min(us) / 10:5.1f} … {max(us) / 10:5.1f} | {jumps:^12} |"
f" {min(ts):.4f} … {max(ts):.4f}")
# ৩) D-এর একটি ধাপ কত বড়: Kd × (এক LSB ÷ Ts)
print(f"এক LSB-এর D = 3.0 × 0.0625 °C ÷ 1 s = {3.0 * 0.0625 * 100:.2f} % output")আসল আউটপুট (ব্রাউজারের Python):
D err থেকে, t=1199…1205 s-এ u (%): 65.0 65.0 100.0 80.1 80.2 80.3 80.4
D meas থেকে, t=1199…1205 s-এ u (%): 65.0 65.0 80.1 80.2 80.3 80.4 80.5
filter alpha | u-এর পরিসর (%) | ≥10 %-এর লাফ | T-এর পরিসর (°C)
1.0 | 46.3 … 85.3 | 4 | 4.0000 … 4.0625
0.25 | 58.5 … 71.3 | 0 | 3.9375 … 4.0625
0.1 | 61.4 … 68.6 | 0 | 3.9375 … 4.0625
এক LSB-এর D = 3.0 × 0.0625 °C ÷ 1 s = 18.75 % output
Error থেকে D নিলে setpoint বদলের সেকেন্ডে (t = 1201 s) আদেশ 65.0 থেকে লাফিয়ে 100.0 %, পরের সেকেন্ডেই 80.1 %: kick. হিসাব: e এক ধাপে 8 LSB (0.5 °C) বাড়ে, D = 187.5 × 8 = 1500 ‰, সীমায় কাটা। মাপ থেকে D নিলে শুধু P-এর ন্যায্য লাফ: 0.30 × 0.5 = 15 %, 65.0 থেকে 80.1 %. Compressor বা ভাল্ভের জন্য প্রতিটি অকারণ ঝাঁকুনি ক্ষয়। দ্বিতীয় অংশে filter ছাড়া (α = 1) স্থির ঘরেই আদেশ 46.3 থেকে 85.3 %-এর মধ্যে লাফায়, চারবার 10 % বা তার বেশি এক ধাক্কায়; α = 0.25-এ পরিসর 58.5 … 71.3 %, একটিও বড় লাফ নেই, আর ঘর তখনো sensor-এর এক-দুই ধাপের ভেতরে। দাম: filter D-কে একটু দেরি করায়; α খুব ছোট হলে D-এর আগাম ব্রেকের সুবিধাই হারায়।
এই অংশের একটি সাধারণ শিক্ষা: Kd বাড়ানোর আগে দেখুন sensor-এর resolution আর noise কত। ঠান্ডা ঘরের মতো ধীর plant-এ অনেক প্রকৌশলী D বাদই দেন, PI দিয়েই কাজ সারেন; motor-এর গতি বা অবস্থানের মতো দ্রুত plant-এ D বেশি কাজে লাগে, সঙ্গে filter প্রায় সবসময়।
৮ · Tuning — হাতে, আর Ziegler–Nichols
Tuning মানে Kp, Ki, Kd বাছাই। কোন gain ভালো, তা নির্ভর করে কী চাই তার ওপর: দ্রুত পৌঁছানো, কম overshoot (লক্ষ্য পেরিয়ে যাওয়া), নাকি actuator-এর কম ঝাঁকুনি। এগুলো একে অপরের বিরুদ্ধে টানে। ধাপের মতো একটি বদলের পরে loop কীভাবে সাড়া দেয়, তাকে step response বলে; tuning-এর সব আলোচনা এই ছবি ঘিরে।
হাতে tuning-এর একটি প্রচলিত ক্রম: (১) I আর D শূন্য রেখে Kp ধীরে বাড়ান, যতক্ষণ সাড়া দ্রুত কিন্তু দোল সামান্য। (২) Ki যোগ করুন, ছোট থেকে, যতক্ষণ steady-state error যুক্তিসংগত সময়ে মুছে যায় আর overshoot সহনীয়। (৩) দরকার হলে সামান্য Kd, filter-সহ, overshoot কমাতে। প্রতিবার একটি gain বদলান আর একই পরীক্ষা (যেমন 8 °C থেকে চালু) চালান। এই পর্বের “নরম” সেট (0.30, 0.002, 3.0) এভাবেই মডেলে বাছা।
Ziegler–Nichols পদ্ধতি: J. G. Ziegler আর N. B. Nichols ১৯৪২ সালে (Transactions of the ASME-এ “Optimum Settings for Automatic Controllers”) একটি পরীক্ষাভিত্তিক নিয়ম দেন। Closed-loop রূপে: শুধু P দিয়ে Kp বাড়াতে থাকুন, যতক্ষণ না loop একটি স্থির, না-বাড়া না-কমা দোলে পৌঁছায়। সেই gain ultimate gain Ku, আর দোলের period Pu. তারপর PID-এর জন্য Kp = 0.6 Ku, Ti = Pu ÷ 2, Td = Pu ÷ 8 (তাহলে Ki = Kp ÷ Ti, Kd = Kp × Td); শুধু P-এর জন্য 0.5 Ku, PI-এর জন্য 0.45 Ku আর Ti = Pu ÷ 1.2. নিয়মগুলোর লক্ষ্য ছিল মোটামুটি এক-চতুর্থাংশ হারে কমে আসা দোল, যা আজকের মানে বেশ আক্রমণাত্মক। আসল ঠান্ডা ঘরে loop-কে ইচ্ছে করে দোলানো ঝুঁকিপূর্ণ (মাছ জমে যেতে পারে), তাই এই পরীক্ষা মডেলে:
# Ziegler–Nichols-এর "ultimate gain" পরীক্ষা, মডেলের ঘরে (float, saturation ছাড়া)
from coldroom_pid import run, c
def p_only(kp, n=4000): # 4.00 °C-এ স্থির ঘরে setpoint 0.5 °C নামানো
T, u0 = 4.0, 26 / 40 # 65 % cooling-এ 4 °C স্থির থাকে
buf, Ts = [u0] * 30, []
for k in range(n):
u = u0 + kp * (T - 3.5)
buf.append(u)
T += ((30 - T) - 40 * buf.pop(0)) / 600
Ts.append(T)
return Ts
def grows(kp): # শেষের দোল কি মাঝের দোলের চেয়ে বড়?
Ts = p_only(kp)
return max(Ts[3500:]) - min(Ts[3500:]) > max(Ts[2000:2500]) - min(Ts[2000:2500])
lo, hi = 0.1, 2.0
for _ in range(30): # bisection: স্থির আর অস্থিরের সীমা
lo, hi = (lo, (lo + hi) / 2) if grows((lo + hi) / 2) else ((lo + hi) / 2, hi)
Ku = hi
tail = p_only(Ku)[3000:]
mid = sum(tail) / len(tail)
up = [k for k in range(1, len(tail)) if tail[k - 1] < mid <= tail[k]]
Pu = (up[-1] - up[0]) / (len(up) - 1)
Kp, Ti, Td = 0.6 * Ku, Pu / 2, Pu / 8
print(f"Ku = {Ku:.3f} প্রতি °C, Pu = {Pu:.1f} s")
print(f"Z-N PID: Kp = {Kp:.3f}, Ki = Kp/Ti = {Kp / Ti:.4f}, Kd = Kp·Td = {Kp * Td:.2f}")
for name, g in [("Z-N", (Kp, Kp / Ti, Kp * Td)), ("নরম PID", (0.30, 0.002, 3.0))]:
log = run(*g, t0=8.0)
out = [k for k, m, u, i in log if abs(m - 64) > 4]
print(f"{name}: সর্বনিম্ন {c(min(x[1] for x in log))} °C, স্থির {out[-1]} s")আসল আউটপুট (ব্রাউজারের Python):
Ku = 0.788 প্রতি °C, Pu = 119.6 s
Z-N PID: Kp = 0.473, Ki = Kp/Ti = 0.0079, Kd = Kp·Td = 7.06
Z-N: সর্বনিম্ন +3.81 °C, স্থির 225 s
নরম PID: সর্বনিম্ন +4.00 °C, স্থির 307 s
Bisection স্থির আর অস্থিরের সীমা খুঁজে পায় Ku = 0.788 প্রতি °C-এ, period 119.6 s; আমার lab-এ continuous-time মডেলের হিসাব (dead time আর time constant থেকে) দিয়েছে Ku ≈ 0.80, Pu ≈ 117.7 s, প্রায় একই; Pu এখানে dead time-এর প্রায় চার গুণ। Z-N-এর PID ঘরকে দ্রুত স্থির করে (225 s, নরম সেটের 307 s-এর চেয়ে কম), কিন্তু 3.81 °C পর্যন্ত নামে, লক্ষ্যের 0.19 °C নিচে, আর তার Kd = 7.06 sensor-এর প্রতিটি ধাপে 7.06 × 0.0625 = 0.44, অর্থাৎ 44 % আদেশের লাফ দেয়। Z-N তাই শুরু করার একটি জায়গা, শেষ কথা নয়। পরে আরও পদ্ধতি এসেছে, যেমন relay feedback দিয়ে স্বয়ংক্রিয় tuning আর model-ভিত্তিক নিয়ম; শিল্পের অনেক controller-এ “autotune” বোতাম এমন কোনো পদ্ধতিই চালায়।
Kp = 1.0-এর মতো Ku-এর ওপরের gain-এ কী হয়? Loop অস্থির; কিন্তু actuator 0 আর 100 %-এ আটকানো বলে দোল অসীমে যায় না, একটি স্থায়ী দোলে (limit cycle) আটকে যায় (অনুশীলন ৪). বাস্তবে এটিও বিপদ: compressor সারাক্ষণ পুরো চালু আর প্রায় বন্ধের মধ্যে ঝাঁপায়।
আরও গভীরে: Feedback নিয়ন্ত্রণের গাণিতিক বিশ্লেষণের একটি পরিচিত সূচনা James Clerk Maxwell-এর ১৮৬৮ সালের “On Governors”, যেখানে তিনি steam engine-এর centrifugal governor-এর দোল ব্যাখ্যা করেন। PID-এর তিন পদের স্পষ্ট বিশ্লেষণের কৃতিত্ব সাধারণত Nicolas Minorsky-কে দেওয়া হয়, যিনি ১৯২২ সালে জাহাজের স্বয়ংক্রিয় হাল নিয়ন্ত্রণ নিয়ে লেখেন, দক্ষ মাঝিদের আচরণ দেখে। Firmware-এ PID-এর বাস্তব খুঁটিনাটি (sample time, windup, kick, filter, manual থেকে auto-তে ঝাঁকুনিহীন বদল বা bumpless transfer) controller-এর মূল সূত্রের চেয়ে কম গুরুত্বপূর্ণ নয়; শিল্পের PID-এ D-এর filter-এর অনুপাত N প্রায়ই ২ থেকে ২০-এর মধ্যে বলা হয় (Åström আর তাঁর সহলেখকদের বইয়ে এমন সীমা পাওয়া যায়; নির্দিষ্ট মান নির্মাতাভেদে আলাদা)।
৯ · পরীক্ষার ধাঁচে — একটি পূর্ণ হিসাব
প্রশ্ন: একটি ঠান্ডা ঘরের PID: Kp = 0.5 প্রতি °C, Ki = 0.01 প্রতি °C·s, Kd = 2 s প্রতি °C, Ts = 1 s, setpoint 4.00 °C, D মাপ থেকে, e = মাপ − setpoint. আগের মাপ 5.25 °C, এখনকার মাপ 5.00 °C, আগের I = 0.30. (ক) এবারের আদেশ u কত? (খ) Sensor 1/16 °C-এর আর আদেশ ‰-এ হলে gain তিনটির Q16 মান কত? (গ) এই ঘরের মডেল (বাইরে 30 °C, cooling 40 °C × u) হলে শুধু P (Kp = 0.5) দিয়ে ঘর কোথায় থামবে? (ঘ) কোড Ts = 1 s ধরে লেখা, কিন্তু ভুল করে loop প্রতি 0.5 s-এ ডাকা হলে আসল Ki আর Kd কত হয়?
- (ক) e = 5.00 − 4.00 = 1.00 °C. P = 0.5 × 1.00 = 0.50. I = 0.30 + 0.01 × 1.00 × 1 = 0.31. D = 2 × (5.00 − 5.25) ÷ 1 = −0.50. u = 0.50 + 0.31 − 0.50 = 0.31, অর্থাৎ 31 %. ঘর দ্রুত ঠান্ডা হচ্ছে বলে D পুরো P-কে কাটাকাটি করেছে।
- (খ) Kp: 0.5 × 1000 ÷ 16 = 31.25 ‰ প্রতি LSB, × 65 536 = 2 048 000. Ki: 0.01 × 1000 ÷ 16 = 0.625, × 65 536 = 40 960. Kd: 2 × 1000 ÷ 16 = 125, × 65 536 = 8 192 000.
- (গ) স্থির অবস্থায় 0.5 × e × 40 = 26 − e, তাই e = 26 ÷ (1 + 20) = 1.238 °C, ঘর প্রায় 5.24 °C. আমার lab-এ মডেল ৬০ মিনিট চালিয়ে শেষ ২০ মিনিটে sensor 5.1875 … 5.25 °C দেখিয়েছে: হিসাবের সঙ্গে মেলে, পার্থক্য শুধু sensor-এর ধাপ।
- (ঘ) প্রতি 0.5 s-এ I-তে Ki × e × 1 যোগ হয়, অর্থাৎ প্রতি সেকেন্ডে দ্বিগুণ: আসল Ki = 0.02 প্রতি °C·s. D = Kd × Δm ÷ 1, অথচ Δm এখন 0.5 s-এর বদল, তাই আসল Kd = 2 × 0.5 = 1 s প্রতি °C. ভুলটি loop-কে বেশি আক্রমণাত্মক আর কম ব্রেকওয়ালা করে।
পরীক্ষা ও ইন্টারভিউতে:
- P, I আর D আলাদাভাবে কী করে? P এখনকার error-এ, I জমা error-এ (steady-state error মোছে), D error-এর পরিবর্তনের হারে (আগাম ব্রেক) সাড়া দেয়।
- শুধু P-তে steady-state error কেন থাকে? Error শূন্য হলে আদেশও শূন্য, অথচ plant ধরে রাখতে শূন্য-নয় আদেশ লাগে; তাই কিছু error থেকেই যায়, e = দরকার ÷ (1 + K·Kp)-এর ধাঁচে।
- Integral windup কী, কীভাবে ঠেকাবেন? Actuator সীমায় আটকে থাকার সময় I-এর অকারণ জমা; clamping (সীমায় থাকলে জমানো বন্ধ), back-calculation বা velocity form.
- Derivative kick কী? Setpoint বদলের মুহূর্তে error-এর ধাপ থেকে D-এর বিশাল লাফ; সমাধান derivative on measurement.
- Firmware-এ PID লিখতে কী কী খেয়াল রাখবেন? স্থির sample time, gain-এ Ts, overflow-মুক্ত fixed-point, আদেশ আর I-এর সীমা, D-এর filter, sensor fail হলে নিরাপদ আচরণ।
১০ · AI-এর যুগে PID কোড যাচাই
“C-তে একটি PID controller লিখে দিন” বললে AI assistant কয়েক সেকেন্ডে পরিষ্কার কোড দেয়। সমস্যা হলো, PID-এর ভুল compile-এ ধরা পড়ে না, পড়ে মাঠে: ঘর একদিন জমে যায়, motor ঝাঁকুনিতে ক্ষয় হয়। এই বিষয়ে AI-এর পরিচিত ভুল আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
| Anti-windup ছাড়া I জমায়, বা শুধু আদেশ আটকায় কিন্তু I নয় | Plant model-এ actuator-কে সীমায় রেখে (যেমন 30 °C থেকে চালু) I-এর মান ছাপা |
| D নেয় error থেকে, filter ছাড়া | Setpoint বদলের মুহূর্তে আদেশ দেখা; sensor-এর resolution-এ D-এর এক ধাপের লাফ হিসাব |
| dt-কে ধ্রুবক ধরে, অথচ loop অনিয়মিত সময়ে ডাকা হয়, বা ISR-এর ভেতরে blocking delay রাখে | Timer বা RTOS-এর নির্দিষ্ট period থেকে ডাকা নিশ্চিত করা; loop-এর সময় মেপে ছাপা |
Cortex-M3-এ float বা double ব্যবহার করে, বা ৩২ বিটে overflow-প্রবণ গুণ লেখে | Chip-এ FPU আছে কি না reference manual-এ দেখা; সবচেয়ে বড় error-এ গুণফলের বিট গোনা; compiler-এর assembly-তে library ডাক খোঁজা |
| Error-এর চিহ্ন উল্টো ধরে (heating-এর সূত্র cooling-এ) | “ঘর গরম হলে আদেশ বাড়ে কি?” — একটি ধাপের পরীক্ষা মডেলে |
ISR আর main-এর ভাগাভাগির চলকে volatile বা atomic পড়া ভুলে যায় | পর্ব ৪৩-এর নিয়ম মেলানো; ৬৪ বিটের state ISR-এর বাইরে পড়লে interrupt বন্ধ রেখে পড়া |
| Gain-এর সংখ্যা বানিয়ে দেয়, যেন সব plant-এ চলবে | Gain plant-নির্ভর; মডেলে বা নিরাপদ পরীক্ষায় step response মেপে বাছা |
AI-কে কাজে লাগাতে plant, সীমা, chip আর যাচাইয়ের শর্ত শুরুতেই দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১Steam engine-এর governor থেকে জাহাজের হাল পর্যন্ত, feedback নিয়ন্ত্রণের ইতিহাস আজকের firmware লেখককে কী শেখায়?
অষ্টাদশ শতকের শেষে James Watt-এর steam engine-এ centrifugal governor ব্যবহারের কথা ব্যাপকভাবে উল্লেখ পাওয়া যায়: ঘূর্ণায়মান দুটি ভারী বল গতি বাড়লে ছড়িয়ে পড়ে আর বাষ্পের ভাল্ভ কমায়। এটি খাঁটি proportional feedback, কোনো computer ছাড়াই। কিন্তু এমন engine কখনো কখনো নিজেই দুলত, গতি ওঠানামা করত। ১৮৬৮ সালে James Clerk Maxwell “On Governors” প্রবন্ধে এই দোলকে গণিত দিয়ে ব্যাখ্যা করেন, আর দেখান যে স্থিতিশীলতা নির্ভর করে সিস্টেমের সমীকরণের মূলের ওপর। আজকের ভাষায় তিনি বলেছিলেন: feedback-এর জোর আর দেরি মিলে loop স্থির থাকবে না দুলবে, তা ঠিক হয়।
বিংশ শতকের শুরুতে জাহাজের স্বয়ংক্রিয় হাল নিয়ন্ত্রণের সমস্যা নিয়ে Nicolas Minorsky ১৯২২ সালে লেখেন। তিনি দক্ষ মাঝিদের দেখেন: তাঁরা শুধু এখনকার দিকের ভুল দেখে হাল ঘোরান না, ভুল কত দ্রুত বাড়ছে তাও দেখেন, আর দীর্ঘ সময় ধরে থাকা ছোট বিচ্যুতি (যেমন স্রোতের টান) ধীরে ধীরে শোধরান। এই তিন আচরণই P, D আর I. অর্থাৎ PID কোনো বিমূর্ত আবিষ্কার নয়, মানুষের দক্ষতার একটি গাণিতিক রূপ।
তারপর ১৯৪০-এর দশকে শিল্পে pneumatic controller ছড়িয়ে পড়ে, আর Ziegler ও Nichols ১৯৪২ সালে tuning-এর পরীক্ষাভিত্তিক নিয়ম দেন। Microcontroller আসার পরে একই সূত্র কয়েক লাইনের C হয়ে গেল, আর সঙ্গে এল নতুন সমস্যা: sample time, fixed-point, actuator-এর সীমা, sensor-এর resolution. এই পর্বের বেশিরভাগ ভুল (windup, kick, ধাপের লাফ) সূত্রে নেই, আছে বাস্তবায়নে।
Firmware লেখকের জন্য শিক্ষা তিনটি। এক, feedback শক্তিশালী কিন্তু দেরি আর বেশি জোর মিলে দোল আনে, Maxwell-এর যুগ থেকে আজ পর্যন্ত একই। দুই, মডেল দিয়ে আগে বোঝা, তারপর যন্ত্রে; Maxwell সমীকরণ দিয়ে engine বুঝেছিলেন, আমরা plant model দিয়ে ঘর। তিন, সূত্র জানা যথেষ্ট নয়; যন্ত্রের সীমা আর মাপের ত্রুটি জানাই আসল দক্ষতা।
মূল উপলব্ধি: PID মানুষের দক্ষ নিয়ন্ত্রণের গাণিতিক রূপ; তার ঝুঁকি (দোল) দেড়শো বছরের পুরোনো, আর তার বাস্তব খুঁটিনাটি firmware-এর দায়িত্ব।
প্র ০২Ziegler–Nichols নিয়ম আশি বছরের বেশি পুরোনো আর প্রায়ই আক্রমণাত্মক। তবু আজও পাঠ্যবইয়ে আর পরীক্ষায় কেন টিকে আছে, আর কখন এড়ানো উচিত?
Ziegler আর Nichols ১৯৪২ সালে দুটি সরল পদ্ধতি দেন: একটি loop-কে শুধু P দিয়ে স্থায়ী দোলে নিয়ে Ku আর Pu মাপা (closed-loop), অন্যটি খোলা loop-এর step response-এর ঢাল আর দেরি থেকে (open-loop বা reaction curve). তখন কম্পিউটার নেই, process-এর সমীকরণও প্রায়ই অজানা; কারখানার মিস্ত্রি একটি পরীক্ষা করে টেবিল থেকে gain বের করতে পারতেন। এই সরলতাই তার টিকে থাকার মূল কারণ। পরীক্ষায় এটি জনপ্রিয় কারণ সূত্র ছোট আর হিসাব পরিষ্কার: Ku = 0.8, Pu = 120 s হলে Kp = 0.48, Ti = 60 s, Td = 15 s.
নিয়মের লক্ষ্য ছিল প্রায় এক-চতুর্থাংশ হারে কমে আসা দোল: প্রতিটি দোল আগেরটির প্রায় চার ভাগের এক ভাগ। কারখানার অনেক কাজে দ্রুত সাড়ার জন্য তা মেনে নেওয়া যেত, কিন্তু বহু আধুনিক কাজে এই overshoot অগ্রহণযোগ্য। এই পর্বের মডেলেই Z-N-এর PID ঘরকে 3.81 °C-এ নামিয়েছে, আর তার বড় Kd sensor-এর প্রতিটি ধাপে 44 % আদেশের লাফ দিয়েছে। Dead time আর time constant-এর অনুপাত ভেদে ফল আরও খারাপ হতে পারে।
দ্বিতীয় সমস্যা পরীক্ষাটি নিজে। Closed-loop রূপে loop-কে ইচ্ছে করে স্থায়ী দোলের কিনারায় নিতে হয়। ঠান্ডা ঘরে মাছ, রাসায়নিক reactor-এ চাপ, বা মানুষবাহী যন্ত্রে এটি গ্রহণযোগ্য নয়। এই কারণে ১৯৮৪ সালের দিকে Åström আর Hägglund relay feedback দিয়ে একটি নিয়ন্ত্রিত, ছোট দোল থেকে Ku আর Pu মাপার পদ্ধতি প্রস্তাব করেন বলে উল্লেখ পাওয়া যায়, যা পরে অনেক শিল্প controller-এর autotune-এর ভিত্তি হয়েছে। আরও পরে মডেল-ভিত্তিক নিয়ম (যেমন ২০০০-এর দশকের শুরুতে Skogestad-এর SIMC) robustness-কে সামনে রাখে।
তাই ব্যবহারের নিয়ম: Z-N দিয়ে শুরুর একটি আন্দাজ নিন, বিশেষত মডেলে বা নিরাপদ পরীক্ষায়; তারপর Kp কমিয়ে, Ti বাড়িয়ে, D-এ filter দিয়ে নিজের চাহিদামতো নরম করুন। যেখানে overshoot নিষিদ্ধ বা দোলানো বিপজ্জনক, সেখানে loop দোলানোর পরীক্ষাই করবেন না; মডেল বা খোলা loop-এর ছোট step থেকে শুরু করুন।
মূল উপলব্ধি: Ziegler–Nichols টিকে আছে সরলতার জন্য; এটি একটি ভালো শুরুর বিন্দু, কিন্তু আক্রমণাত্মক, আর তার পরীক্ষাটি নিজেই সব plant-এ নিরাপদ নয়।
প্র ০৩বাড়ির ফ্রিজ আর অনেক দোকানের ঠান্ডা ঘর আজও on-off thermostat-এ চলে। PID এত ভালো হলে কেন? কোথায় on-off-ই ঠিক উত্তর?
প্রথম কারণ actuator. PID-এর আদেশ মাঝামাঝি মান, যেমন 65 %. একটি সাধারণ fixed-speed compressor শুধু চালু বা বন্ধ হতে পারে; তার জন্য PID-এর ভগ্নাংশ আদেশের মানে নেই, যদি না আদেশকে সময়ের ভাগে (যেমন প্রতি দশ মিনিটে সাড়ে ছয় মিনিট চালু) বদলানো হয়, যা আসলে খুব ধীর PWM. Inverter compressor বা পরিবর্তনশীল গতির fan থাকলেই PID-এর পুরো সুবিধা আসে। অর্থাৎ নিয়ন্ত্রণের পদ্ধতি বেছে নেওয়ার আগে actuator কী পারে, তা দেখতে হয়।
দ্বিতীয় কারণ প্রয়োজন। এই পর্বের মডেলে on-off ঘরকে 2.81 থেকে 5.81 °C-এ দোলায়। অনেক খাবারের জন্য এই পরিসর গ্রহণযোগ্য হতে পারে, আর README-র alarm সীমা (0.00 আর 8.00 °C) এর বাইরে। যদি পরিসর যথেষ্ট হয়, on-off-এর সুবিধা অনেক: tuning নেই, অস্থিরতার ঝুঁকি নেই, sensor একটু ভুল হলেও আচরণ বোঝা সহজ, আর যন্ত্র সস্তা। Hysteresis-এর চওড়া band compressor-এর চালু-বন্ধের সংখ্যা কমায়; compressor-এর নির্মাতারা প্রায়ই সর্বনিম্ন চালু আর বন্ধের সময় বেঁধে দেন, যাতে ঘনঘন চালুতে motor আর contact নষ্ট না হয়।
তৃতীয় কারণ নির্ভরযোগ্যতা আর প্রমাণ। Safety-র প্রসঙ্গে (পর্ব ৬৩) সরল যুক্তি যাচাই করা সহজ: on-off-এর সব অবস্থা গুনে বলা যায়। PID-এ windup, overflow, sample time-এর ভুল, sensor-এর noise, সবকিছুর পরীক্ষা লাগে। তাই অনেক নকশায় দুটি স্তর থাকে: সাধারণ কাজে PID, আর তার ওপরে একটি সরল on-off বা সীমা-ভিত্তিক সুরক্ষা, যেমন এই পর্বের firmware-এ README-র alarm.
PID জেতে যেখানে মান ধরে রাখা জরুরি (ওষুধ বা টিকার ঠান্ডা ঘর, যেখানে সংকীর্ণ পরিসর লাগে), যেখানে actuator মাঝামাঝি জোর দিতে পারে, আর যেখানে শক্তির খরচ বা ঝাঁকুনি কমানো মূল্যবান। ধীর গতিতে টানা চলা inverter compressor সাধারণত বারবার পুরো জোরে চালু-বন্ধের চেয়ে কম ঝাঁকুনি দেয়, যদিও শক্তির সাশ্রয় কত তা নির্দিষ্ট যন্ত্রের ওপর নির্ভর করে।
মূল উপলব্ধি: নিয়ন্ত্রণ বাছাই শুরু হয় actuator আর প্রয়োজনের পরিসর দিয়ে; on-off with hysteresis সরল, মজবুত আর প্রায়ই যথেষ্ট, PID দরকার যখন মাঝামাঝি জোর আর সংকীর্ণ পরিসর চাই।
প্র ০৪এই পর্বের PID পুরোটাই integer-এ। Cortex-M4F-এর মতো FPU-ওয়ালা chip-এ float-এ লিখলে কী লাভ, কী ঝুঁকি থেকে যায়?
Cortex-M3-এ floating-point unit নেই; float-এর প্রতিটি যোগ-গুণ software-এর library-তে চলে, যা ধীর আর কোড বড় করে। কোর্সের build-এ -nostdlib থাকায় সেই library-ও নেই, তাই fixed-point ছিল বাধ্যতামূলক। Cortex-M4F বা M7-এর মতো chip-এ single-precision FPU থাকে, যেখানে float-এর যোগ-গুণ hardware-এ হয়। সেখানে PID float-এ লেখা স্বাভাবিক আর পড়তে সহজ: Kp = 0.30f লিখলেই হয়, একক বদল বা Q16-এর হিসাব লাগে না। সূক্ষ্ম gain (যেমন 0.0079) সহজে রাখা যায়, আর overflow-এর ভয় প্রায় নেই।
কিন্তু float সব সমস্যা মোছে না। প্রথমত, float-এর ২৪ বিটের mantissa বড় জমার সঙ্গে ছোট সংখ্যা যোগ করলে ছোটটি হারিয়ে যেতে পারে: I-এর জমা যদি বড় হয় আর প্রতি ধাপের Ki·e·Ts খুব ছোট হয়, যোগ কিছুই বদলায় না। Fixed-point-এ এই সমস্যা পরিষ্কার দেখা যায় (বিট গোনা যায়); float-এ লুকিয়ে থাকে। দ্বিতীয়ত, interrupt-এর ভেতরে FPU ব্যবহার করলে Cortex-M-এ FPU-র register-ও stack-এ রাখতে হয়, যা latency আর stack বাড়ায় (lazy stacking এটি কমায়)। তৃতীয়ত, একই কোড FPU-ছাড়া chip-এ নিলে হঠাৎ ধীর হয়ে যায়, আর double লিখলে single-precision FPU-ও সাহায্য করে না।
Integer-এর সুবিধা হলো নির্ধারিততা: এই পর্বে board আর Python একই integer হিসাব করে লাইনে লাইনে একই ফল দিয়েছে। Float-এ compiler-এর অপ্টিমাইজেশন বা ভিন্ন library-তে শেষ বিট আলাদা হতে পারে, যা test-এ তুলনা কঠিন করে। দাম হলো একক বদল, গোল করা আর overflow-এর হিসাব, যা ভুলের উৎস (পর্ব ৪০-এর saturation আর Q format এখানে সরাসরি কাজে লাগে)।
বাস্তব নিয়ম: FPU থাকলে float-এ লিখুন, কিন্তু I-এর জমা কত বড় হতে পারে আর ছোট ধাপ হারায় কি না দেখুন, ISR-এ float এড়ান বা তার খরচ মাপুন। FPU না থাকলে fixed-point, সবচেয়ে বড় error আর জমায় বিট গুনে, ৬৪ বিটের যোগফল আর shift দিয়ে। দুই ক্ষেত্রেই host-এ একটি plant model-এর বিরুদ্ধে একই পরীক্ষা চালান।
মূল উপলব্ধি: FPU থাকলে float সরল আর নিরাপদ, কিন্তু precision-এর ফাঁদ থাকে; FPU না থাকলে fixed-point বাধ্যতামূলক আর নির্ধারিত, তবে একক আর overflow নিজে সামলাতে হয়।
প্র ০৫Sensor হঠাৎ নষ্ট হলে (I2C-তে NACK, বা মান আটকে গেলে) একটি PID loop কী করবে? নিরাপদ নকশা কীভাবে করবেন?
PID-এর পুরো যুক্তি দাঁড়িয়ে আছে একটি ধারণার ওপর: মাপ সত্য। মাপ ভুল হলে controller আত্মবিশ্বাসের সঙ্গে ভুল কাজ করে। ধরুন sensor-এর তার খুলে গেল আর I2C-তে NACK এল। কোর্সের board-এ অজানা ঠিকানায় DATA = 0xFFFF আসে (Spec decision 26); যদি firmware NACK না দেখে সেই মান ব্যবহার করত, 0xFFFF-কে ১২ বিটে নিলে হয় −1 LSB, অর্থাৎ −0.0625 °C. Controller ভাববে ঘর খুব ঠান্ডা, compressor বন্ধ করবে, আর আসল ঘর ধীরে 30 °C-এর দিকে উঠবে, অথচ কেউ জানবে না। আটকে যাওয়া sensor আরও সূক্ষ্ম: সবসময় 4.00 °C দেখালে PID শান্ত থাকে, আর ঘর যা খুশি করে।
নিরাপদ নকশার প্রথম স্তর মাপের বৈধতা: প্রতিটি পড়ায় NACK আর পরিসর দেখা (এই ঘরে −30 °C-এর নিচে বা 60 °C-এর ওপরে অসম্ভব), পরপর পড়ার পরিবর্তনের হার দেখা (৬০০ s time constant-এর ঘর এক সেকেন্ডে 5 °C লাফাতে পারে না), আর অনেকক্ষণ হুবহু একই মান থাকলে সন্দেহ। দ্বিতীয় স্তর নিরাপদ অবস্থা: মাপ অবৈধ হলে PID থামিয়ে I-কে জমে রাখা (যাতে windup না হয়), আর actuator-কে একটি জানা নিরাপদ আদেশে নেওয়া, যেমন ঠান্ডা ঘরে শেষ ভালো I-এর মান বা একটি স্থির 65 %, সঙ্গে alarm.
তৃতীয় স্তর স্বাধীন পাহারাদার। এই পর্বের firmware-এ README-র alarm আলাদা যুক্তি, যা PID-এর ওপর নির্ভর করে না; windup-এর run-এ সে-ই LOW alarm বাজিয়েছে। আরও ভালো নকশায় একটি দ্বিতীয়, ভিন্ন ধরনের sensor বা একটি যান্ত্রিক thermostat থাকে, যা firmware আটকে গেলেও কাজ করে। Firmware আটকে গেলে watchdog reset দেয় (পর্ব ৬১); reset-এর পরে PID কীভাবে শুরু হবে (I = 0, নাকি সংরক্ষিত মান) তাও আগে ভাবতে হয়, কারণ লোডশেডিং-এর পরের শুরুর মতো এটিও একটি transient.
শেষে telemetry: মাপ অবৈধ হওয়া, নিরাপদ অবস্থায় যাওয়া আর alarm, সবই dashboard-এ জানানো উচিত, যা IoT মডিউলের বিষয় (পর্ব ৭৩, MQTT). এসব মিলিয়ে নকশাটি defence in depth: একটি স্তর ব্যর্থ হলে পরেরটি ধরে।
মূল উপলব্ধি: PID মাপকে অন্ধভাবে বিশ্বাস করে; তাই মাপের বৈধতা, নিরাপদ অবস্থা আর নিয়ন্ত্রণ থেকে স্বাধীন alarm ছাড়া কোনো control loop সম্পূর্ণ নয়।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর মডেলে বা কোর্সের virtual board-এ চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — velocity form:
pid_update-কে incremental রূপে লিখুন: প্রতিবার Δu হিসাব করে আগের আদেশে যোগ, তারপর আদেশকে 0 … 1000 ‰-এ আটকানো। D মাপ থেকে রাখতে Δu-এর D অংশে কী লাগবে? এই রূপে আলাদা anti-windup কেন লাগে না? 30 °C থেকে চালু করলে কী আশা করেন?Positional রূপ u = Kp·e + I + Kd·(m − m₁)-এর পরপর দুই মানের পার্থক্য নিলে: Δu = Kp·(e − e₁) + Ki·e + Kd·(m − 2m₁ + m₂), যেখানে m₁, m₂ আগের দুটি মাপ। Q16-এ:
int64_t du = (int64_t)KP_Q * (e - e1) + (int64_t)KI_Q * e + (int64_t)KD_Q * (t16 - 2 * m1 + m2); u_q += du; /* u_q: Q16-এ আদেশ */ if (u_q < 0) u_q = 0; if (u_q > ((int64_t)U_MAX << 16)) u_q = (int64_t)U_MAX << 16; e1 = e; m2 = m1; m1 = t16; return (int32_t)((u_q + 32768) >> 16);এখানে জমা বলতে শুধু আদেশ নিজে, আর সেটি সীমায় আটকানো; তাই সীমার ওপরে কিছু জমতে পারে না। আমার lab-এ একই integer মডেলে চালিয়ে: সর্বনিম্ন 4.00 °C (কোনো windup নেই), 4.00 ± 0.25 °C-এ স্থির 844 s-এ (positional + clamping-এ 751 s), শেষে u = 65.0 %. একটু ধীর, কারণ সীমায় থাকা অবস্থায় P-এর প্রতিটি কমতি সঙ্গে সঙ্গে আদেশ কমায়: t = 480 s-এ ঘর 11.00 °C, যেখানে positional রূপে 8.87 °C. দাম আরেকটি: I = 0 বা Ki = 0 হলে velocity রূপে setpoint ধরে রাখার কিছু নেই, তাই সাধারণত I রাখা হয়।
-
ভুল খুঁজুন — firmware-এর তিনটি ভুল: একজন লিখেছেন:
ঘর 3.50 °C-এ (লক্ষ্যের নিচে) গেলে error-এর হিসাবে কী গোলমাল হবে? আর কোন দুটি ভুল windup আর setpoint বদলে সমস্যা করবে?static int64_t integ; static int32_t prev_e; int32_t pid(int32_t t16) { /* প্রতি 1 s, SP16 = 64 */ uint32_t e = t16 - SP16; integ += (int64_t)KI_Q * e; int64_t v = (int64_t)KP_Q * e + integ + (int64_t)KD_Q * (e - prev_e); prev_e = e; int32_t u = (int32_t)((v + 32768) >> 16); return u > 1000 ? 1000 : (u < 0 ? 0 : u); }ভুল ১, চিহ্নহীন error:
uint32_t e. 3.50 °C = 56 LSB, তাই t16 − 64 = −8, কিন্তু unsigned-এ তা 4 294 967 288.(int64_t)-এ নিলে এটি একটি বিশাল ধনাত্মক সংখ্যা, তাই ঘর ঠান্ডা হলেও controller-এর হিসাবে ঘর প্রচণ্ড গরম। গুণফল এত বড় যে শেষে(int32_t)-এ নামানোর সময় শুধু নিচের ৩২ বিট থাকে (C-তে এই রূপান্তর implementation-defined), তাই আদেশ কার্যত অর্থহীন একটি সংখ্যা, error-এর সঙ্গে যার কোনো যুক্তিসংগত সম্পর্ক নেই। সমাধানint32_t e;-Wsign-conversionদিলে compiler এমন অন্তর্নিহিত রূপান্তর ধরিয়ে দিতে পারে।ভুল ২, windup:
integপ্রতিবার জমে, আদেশ সীমায় থাকুক বা না থাকুক, আর কোনো সীমা নেই। অংশ ৬-এর board run-এ ঠিক এই আচরণ ঘরকে −6.75 °C-এ নিয়েছিল। সমাধান: সীমায় থাকলে আর error একই দিকে ঠেললে জমানো বন্ধ, আর I-কে 0 … 1000 ‰-এ আটকানো।ভুল ৩, derivative kick: D নেওয়া হয়েছে error থেকে (
e - prev_e). Setpoint 4.00 থেকে 3.50 °C করলে এক সেকেন্ডে e আট LSB লাফায়, আর D দেয় 187.5 × 8 = 1500 ‰; মডেলে আদেশ 65.0 থেকে 100.0 %-এ লাফিয়েছিল (অংশ ৭). সমাধান মাপ থেকে D:KD_Q * (t16 - prev_t16). -
হিসাব — একটি update হাতে: অংশ ৫-এর firmware-এ (Kp 18.75, Ki 0.125, Kd 187.5 ‰ প্রতি LSB) t = 602 s-এ sensor আবার t16 = 91 পড়ে (আগের সেকেন্ডেও 91), আর আগের I = 363.0 ‰. এবারের P, I, D আর u কত? আগের সেকেন্ডের 682 ‰-এর সঙ্গে তুলনা করে কী দেখেন?
e = 91 − 64 = 27. P = 18.75 × 27 = 506.25 ‰. I = 363.0 + 0.125 × 27 = 366.375 ‰. D = 187.5 × (91 − 91) = 0. যোগফল 872.625 ‰, গোল করে u = 873 ‰ = 87.3 %. আমার lab-এর instrument করা trace-এ হুবহু এই মান (Q16-এ যোগফল 57 188 352). আগের সেকেন্ডে 682, এবার 873: শুধু D-এর −187.5 ‰ চলে যাওয়ায় আদেশ 19.1 % লাফাল, যদিও ঘরে প্রায় কিছুই বদলায়নি। এটিই অংশ ৭-এর sensor-এর ধাপের সমস্যা, যার সমাধান D-এর filter.
-
আগে বলুন, তারপর মিলিয়ে দেখুন — শুধু P, দুই gain: মডেলের ঘরে (বাইরে 30 °C, cooling 40 °C × u, dead time 30 s, Ku ≈ 0.79) শুধু P দিয়ে 8 °C থেকে চালু করা হলো। (ক) Kp = 0.6-এ ঘর কোথায় থামবে? (খ) Kp = 1.0-এ কী ঘটবে?
(ক) e = 26 ÷ (1 + 40 × 0.6) = 26 ÷ 25 = 1.04 °C, তাই প্রায় 5.04 °C. মডেল ৬০ মিনিট চালিয়ে শেষ ২০ মিনিটে sensor দেখিয়েছে 5.00 … 5.0625 °C আর আদেশ 60.0 … 63.8 %: হিসাব মেলে, sensor-এর দুই ধাপের মধ্যে দোলে। Kp দ্বিগুণ করায় error 2.00 থেকে 1.04 °C, অর্ধেকের কাছাকাছি, কিন্তু শূন্য নয়।
(খ) 1.0 > Ku, তাই loop অস্থির। কিন্তু আদেশ 0 … 100 %-এ আটকানো বলে দোল অসীমে যায় না; শেষ ২০ মিনিটে ঘর 4.0625 থেকে 5.375 °C-এ দোলে আর আদেশ 6.3 থেকে 100 %-এর মধ্যে ঝাঁপায়: একটি limit cycle. ভেতরের গড় তখনো লক্ষ্যের ওপরে, কারণ এটি শুধু P.
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমTimer-এর tick-এ চলা একটি fixed-point PID update-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Sensor পড়া আর মাপের বৈধতা দেখা
- Error হিসাব: e = মাপ − setpoint
- P, নতুন I আর মাপ থেকে D হিসাব
- যোগ করে গোল করা আর আদেশকে সীমায় আটকানো
- সীমায় না থাকলে নতুন I রাখা (anti-windup)
- আদেশ actuator-এ লেখা আর এই মাপকে “আগের মাপ” হিসেবে রাখা
একটি ঠান্ডা ঘরকে 4 °C-এ রাখতে 65 % cooling লাগে। শুধু P controller (I আর D নেই) দিয়ে ঘর লক্ষ্যে পৌঁছায় না, একটু ওপরে থামে। মূল কারণ কী?
- Kp যথেষ্ট বড় নয়; বড় করলেই error শূন্য হবে
- Error শূন্য হলে P-এর আদেশও শূন্য, অথচ ঘর ধরে রাখতে আদেশ লাগে
- Sensor-এর resolution কম বলে
- Dead time-এর কারণে
Integral windup সবচেয়ে বেশি হয় কোন অবস্থায়?
- Error খুব ছোট আর দ্রুত চিহ্ন বদলায়
- D-এর filter-এর α খুব ছোট হলে
- Actuator দীর্ঘক্ষণ সীমায় আটকে আছে আর error বড়
- Sample time খুব ছোট হলে
Setpoint হঠাৎ বদলালে PID-এর আদেশে এক মুহূর্তের বিশাল লাফ (derivative kick) এড়ানোর প্রচলিত উপায় কোনটি?
- D-কে error থেকে না নিয়ে শুধু মাপের পরিবর্তন থেকে নেওয়া
- Ki বাড়ানো
- Anti-windup চালু করা
- Sample time দ্বিগুণ করা
একটি loop-এ শুধু P দিয়ে পরীক্ষায় স্থায়ী দোল আসে Ku = 0.8-এ, দোলের period Pu = 120 s. Ziegler–Nichols-এর closed-loop নিয়মে PID-এর Kp, Ti, Td কত?
- Kp = 0.40, Ti = 120 s, Td = 30 s
- Kp = 0.36, Ti = 100 s, Td = 0
- Kp = 0.80, Ti = 60 s, Td = 15 s
- Kp = 0.48, Ti = 60 s, Td = 15 s
FPU-ছাড়া একটি microcontroller-এ PID-এর আদেশ ‰-এ (0…1000), sensor-এর ধাপ 1/16 °C, আর gain Q16 fixed-point-এ রাখা হয়। Kp = 0.30 প্রতি °C (অর্থাৎ 1 °C-এ 30 % আদেশ) হলে Q16-এ পূর্ণসংখ্যাটি কত?
- 19 661
- 1 228 800
- 19 660 800
- 4 800
একটি PID কোড sample time 1 s ধরে লেখা (Ki·e যোগ হয় প্রতি ডাকে, D = Kd·Δmeasurement), কিন্তু ভুল করে প্রতি 0.1 s-এ ডাকা হচ্ছে। আসল আচরণে কী হয়?
- কিছুই বদলায় না, শুধু হিসাব বেশি হয়
- I দশ গুণ দুর্বল আর D দশ গুণ শক্তিশালী
- I দশ গুণ শক্তিশালী আর D দশ গুণ দুর্বল
- শুধু P দশ গুণ শক্তিশালী হয়
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Closed loop: মাপ − setpoint = error, error থেকে আদেশ। Open loop disturbance টের পায় না; on-off with hysteresis সরল, কিন্তু dead time-এ band-এর চেয়ে বেশি দোলে (মডেলে 2.81 … 5.81 °C).
- তিন পদ: P এখনকার error-এ (একা থাকলে steady-state error, এখানে 26 ÷ 13 = 2.00 °C), I জমায় (error মোছে, ধীর), D পরিবর্তনের হারে (আগাম ব্রেক, noise বাড়ায়)।
- Firmware: স্থির Ts, gain-এ Ts আর একক বদল (0.30 প্রতি °C → 1 228 800 Q16), ৬৪ বিটের যোগফল, গোল করা, আদেশ আর I-এর সীমা। Board আর host-এর একই integer হিসাব লাইনে লাইনে মেলে।
- Windup: সীমায় আটকানো actuator-এর সময় I-এর অকারণ জমা; board run-এ anti-windup ছাড়া I 1509.8 %, ঘর −6.75 °C, LOW alarm; clamping-এ সর্বনিম্ন 4.00 °C.
- D আর tuning: D মাপ থেকে (kick নেই) আর filter-সহ; Ziegler–Nichols (0.6 Ku, Pu ÷ 2, Pu ÷ 8) দ্রুত কিন্তু আক্রমণাত্মক, শুরুর বিন্দু মাত্র।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ৪০ · Fixed-point গণিতআগের ভিত্তিQ format, গোল করা আর saturation, যা PID-এর integer হিসাবের ভিত্তি।
- পর্ব ৫৪ · Real-time systemআগের ভিত্তিPeriod, deadline আর jitter, যা control loop-এর sample time-কে বাঁধে।
- পর্ব ৬৪ · এমবেডেড software testingআগের ভিত্তিHost-এ test, plant model আর HIL, যেভাবে এই পর্বের firmware যাচাই হলো।
- পর্ব ৬৭ · Motor নিয়ন্ত্রণএই মডিউলPWM, H-bridge আর encoder, যেখানে PID দিয়ে গতি বা অবস্থান ধরে রাখা হয়।
- C প্রোগ্রামিং পর্ব ৫৪ · এমবেডেড Cপাশের ট্র্যাকRegister, volatile আর bit-এর কাজ, firmware-এর C-এর ভিত্তি।
- Operating Systems পর্ব ২০ · Multiprocessor আর real-time schedulingপাশের ট্র্যাকRM আর EDF, যা নির্দিষ্ট period-এর control task চালানোর তত্ত্ব।