বাংলায় PID Algorithm

pid_algorithm.md

🧠 PID Controller কী?

PID মানে:

• P = Proportional
• I = Integral
• D = Derivative

PID Controller এমন একটা অ্যালগরিদম যেটা কোনও সিস্টেমকে (যেমন গাড়ি, ফ্যান, তাপমাত্রা কন্ট্রোল, ইত্যাদি) ঠিক মত নিয়ন্ত্রণ করতে সাহায্য করে।

🎯 উদাহরণ দিয়ে শুরু করি:

ধরো তুমি একটা হিটার কন্ট্রোল করছো, যেটার কাজ হচ্ছে রুমের তাপমাত্রা ২৫°C তে ঠিক রাখা।
কিন্তু রুমের বর্তমান তাপমাত্রা ২০°C।

তাহলে এখন তোমার লক্ষ্য (Setpoint) = ২৫
বর্তমান মান (Current value) = ২০
তাপমাত্রার ভুল (Error) = ২৫ - ২০ = ৫

এই ভুলটাকে ঠিক করার জন্য PID কাজ করে।

🔍 PID-এর প্রতিটি অংশ ব্যাখ্যা করি:

✅ 1. P = Proportional (অনুপাতিক)

• এটা দেখে বর্তমানে কতটা ভুল হয়েছে।
• যদি ভুল বড় হয়, তাহলে বড় সিগনাল দেবে।
• ফর্মুলা:
  P_output = Kp * error

📌 যত বেশি ভুল হবে, তত বেশি অ্যাকশন।

---

✅ 2. I = Integral (সমষ্টিগত)

• এটা দেখে আগের ভুলগুলো কতো সময় ধরে হয়েছে, সেইসব যোগ করে অ্যাকশন নেয়।
• যদি ছোট ছোট ভুল বারবার হয়, এটা সেটাকেও সংশোধন করে।
• ফর্মুলা:
  I_output = Ki * ∑(error)

📌 দীর্ঘ সময় ধরে যদি লক্ষ্য পূরণ না হয়, তাহলে এই অংশ সেটা কভার করে।

---

✅ 3. D = Derivative (গতি পরিবর্তন)

• এটা দেখে ভুল কত দ্রুত পরিবর্তন হচ্ছে।
• ফর্মুলা:
  D_output = Kd * (error_now - error_previous)

📌 ভবিষ্যতের ভুল আন্দাজ করতে সাহায্য করে এবং বেশি হঠাৎ পরিবর্তন ঠেকায়।

⚙️ PID-এর মোট Output ফর্মুলা:

Output = (Kp × error) + (Ki × ∑error) + (Kd × Δerror)

📘 Python কোড উদাহরণ (ধারণার জন্য):

previous_error = 0
integral = 0

def pid(setpoint, current_value):
    global previous_error, integral
    error = setpoint - current_value
    integral += error
    derivative = error - previous_error

    output = (Kp * error) + (Ki * integral) + (Kd * derivative)
    
    previous_error = error
    return output

🔧 Tuning (Kp, Ki, Kd মান ঠিক করা)

তুমি এই তিনটা মান ঠিক করতে হবে চেষ্টা করে করে:

গেইন	বেশি হলে কী হয়	কম হলে কী হয়
Kp	বেশি overshoot	ধীরে কাজ করে
Ki	ইনস্টেবল হয়	steady error ঠিক হয় না
Kd	বেশি sensitive	slow response

📊 PID সিমুলেশন

import matplotlib.pyplot as plt
import numpy as np

# Simulation setup
setpoint = 1.0  # Desired value
Kp = 0.8        # Proportional gain
Ki = 0.1        # Integral gain
Kd = 0.05       # Derivative gain

# Initialize variables
dt = 0.1  # time step
time = np.arange(0, 20, dt)
n = len(time)
output = np.zeros(n)
error = np.zeros(n)
integral = 0
prev_error = 0

# PID simulation loop
for i in range(1, n):
    error[i] = setpoint - output[i-1]
    integral += error[i] * dt
    derivative = (error[i] - prev_error) / dt
    control = Kp * error[i] + Ki * integral + Kd * derivative
    output[i] = output[i-1] + control * dt
    prev_error = error[i]

# Plotting
plt.figure(figsize=(10, 5))
plt.plot(time, output, label='System Output')
plt.plot(time, [setpoint]*n, 'r--', label='Setpoint (Target)')
plt.xlabel('Time (s)')
plt.ylabel('Output')
plt.title('PID Controller Simulation')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

এই গ্রাফটি হচ্ছে PID Controller এর একটি সাধারণ সিমুলেশন।

📊 কী দেখানো হয়েছে:

• লাল ড্যাশলাইন = তোমার টার্গেট মান (Setpoint), যেমন ১.০
• নীল লাইন = সিস্টেমের বর্তমান আউটপুট (Output), যা ধীরে ধীরে টার্গেটের দিকে যাচ্ছে

🔍 বোঝার জন্য:

• শুরুতে সিস্টেমের আউটপুট ০ ছিলো
• PID ধীরে ধীরে সেটা বাড়িয়ে নিয়েছে, কিন্তু খুব বেশি না বাড়িয়ে সুন্দরভাবে টার্গেটে পৌঁছেছে
• সেটাই PID এর কাজ: দ্রুত এবং মসৃণভাবে নির্ধারিত লক্ষ্য পূরণ করা।

🚗 উদাহরণ ১: গাড়ির স্পিড কন্ট্রোল (Cruise Control)

🎯 লক্ষ্য:

তুমি গাড়ির স্পিড 60 কিমি/ঘণ্টা রাখতে চাও।

🧠 PID কীভাবে কাজ করবে:

• P (Proportional):
  এখন যদি গাড়ির স্পিড হয় 50, তাহলে ভুল (error) = 60 - 50 = 10
  গাড়ির গতি বাড়ানো হবে এই ভুলের অনুপাতে।

• I (Integral):
  যদি অনেকক্ষণ ধরে গাড়ি 58-59 তে থাকে, তাহলে এই ছোট ছোট ভুল জমা হবে এবং গতি আরেকটু বাড়াবে।

• D (Derivative):
  যদি গাড়ি হঠাৎ 50 থেকে 58 চলে আসে, তাহলে ডি-অংশ বুঝবে যে গাড়ির গতি খুব দ্রুত বাড়ছে, তাই সেটাকে একটু শান্ত করবে।

🌡️ উদাহরণ ২: ঘরের তাপমাত্রা কন্ট্রোল (Thermostat)

🎯 লক্ষ্য:

ঘরের তাপমাত্রা ২৫°C রাখতে হবে।

🧠 PID কীভাবে কাজ করবে:

• P:
  যদি এখন ২০°C হয়, তাহলে হিটার বেশি গরম করবে।
• I:
  অনেক সময় ধরে যদি তাপমাত্রা ২৪°C তে থাকে, তখন হিটার আরেকটু গরম করবে যেন ২৫°C হয়।
• D:
  যদি হিটার খুব দ্রুত গরম করছে, তাহলে সেটা বুঝে হিটারকে ধীর করে দেবে যেন বেশি না গরম হয়।

🌀 উদাহরণ ৩: ফ্যান স্পিড কন্ট্রোল

🎯 লক্ষ্য:

তুমি চাও ফ্যান ৫০০ RPM (Revolutions Per Minute) ঘুরুক।

🧠 PID কীভাবে কাজ করবে:

• P:
  যদি ফ্যান ঘুরছে ৪০০ RPM, তাহলে স্পিড বাড়াবে ৫০০ এর কাছাকাছি যেতে।
• I:
  যদি স্পিড ধীরে ধীরে বাড়লেও ৫০০ তে না যায়, তাহলে সেই ধাক্কা দিবে।
• D:
  যদি হঠাৎ ৫৫০ RPM এ পৌঁছায়, তাহলে সেটা আগেভাগেই ধরে ফ্যান কমিয়ে দিবে।

🤖 ছোট উদাহরণ: রোবট হাত (Robot Arm Positioning)

🎯 লক্ষ্য:

রোবটের হাত ৩০ ডিগ্রিতে ঘুরাতে হবে।

• P: ভুল যত বেশি, অ্যাকশন তত বেশি।
• I: আগের ভুলগুলো থেকে শিখে।
• D: যদি হাত খুব দ্রুত ঘুরে, সেটাকে ব্রেক করে।

🎓 সহজ করে মনে রাখার উপায়

অংশ	কী দেখে	কাজ
P	এখন কত ভুল	দ্রুত অ্যাকশন
I	আগের সব ভুল	ধীর কিন্তু সঠিক অ্যাকশন
D	ভুল কত দ্রুত বদলাচ্ছে	শান্ত রাখে সিস্টেম

🎥 লাইভ অ্যানিমেশন

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

# Common simulation setup
dt = 0.1
time = np.arange(0, 20, dt)
n = len(time)

def run_pid_simulation(setpoint, Kp, Ki, Kd):
    output = np.zeros(n)
    error = np.zeros(n)
    integral = 0
    prev_error = 0

    for i in range(1, n):
        error[i] = setpoint - output[i-1]
        integral += error[i] * dt
        derivative = (error[i] - prev_error) / dt
        control = Kp * error[i] + Ki * integral + Kd * derivative
        output[i] = output[i-1] + control * dt
        prev_error = error[i]

    return output

# Two examples: Car speed and Fan speed
car_setpoint = 60  # km/h
fan_setpoint = 500  # RPM

car_output = run_pid_simulation(car_setpoint, Kp=0.6, Ki=0.05, Kd=0.1)
fan_output = run_pid_simulation(fan_setpoint, Kp=0.5, Ki=0.04, Kd=0.08)

# Set up the figure and axes
fig, axs = plt.subplots(2, 1, figsize=(10, 8))

# Car plot
axs[0].set_title("Car Speed Control using PID")
axs[0].set_xlim(0, 20)
axs[0].set_ylim(0, car_setpoint * 1.2)
axs[0].set_xlabel("Time (s)")
axs[0].set_ylabel("Speed (km/h)")
axs[0].grid(True)
car_line, = axs[0].plot([], [], label="Car Speed", lw=2)
car_target, = axs[0].plot([], [], 'r--', label="Target Speed", lw=1.5)
axs[0].legend(loc='lower right')

# Fan plot
axs[1].set_title("Fan Speed Control using PID")
axs[1].set_xlim(0, 20)
axs[1].set_ylim(0, fan_setpoint * 1.2)
axs[1].set_xlabel("Time (s)")
axs[1].set_ylabel("Speed (RPM)")
axs[1].grid(True)
fan_line, = axs[1].plot([], [], label="Fan Speed", lw=2)
fan_target, = axs[1].plot([], [], 'r--', label="Target RPM", lw=1.5)
axs[1].legend(loc='lower right')

def animate(i):
    if i >= n:
        return

    t = time[i]
    car_line.set_data(time[:i], car_output[:i])
    car_target.set_data(time[:i], [car_setpoint]*i)

    fan_line.set_data(time[:i], fan_output[:i])
    fan_target.set_data(time[:i], [fan_setpoint]*i)

    return car_line, car_target, fan_line, fan_target

ani = animation.FuncAnimation(fig, animate, frames=n, interval=50, blit=True, repeat=False)

# Show animation
plt.tight_layout()
plt.show()

simulation.mov

এখানে একটি ডুয়াল লাইভ অ্যানিমেশন তৈরি করা হয়েছে, যেখানে দুটি বাস্তব উদাহরণ দেখানো হয়েছে:

🚗 ১. গাড়ির স্পিড কন্ট্রোল

• টার্গেট: 60 km/h
• PID ধীরে ধীরে গাড়ির স্পিড বাড়িয়ে ওই লক্ষ্য পর্যন্ত পৌঁছে দিচ্ছে = অতিরিক্ত স্পিড যাতে না হয়, সেটাও কন্ট্রোল করছে

🌀 ২. ফ্যান স্পিড কন্ট্রোল

• টার্গেট: 500 RPM
• PID অ্যালগরিদম অনুযায়ী ধীরে ধীরে স্পিড বাড়ছে এবং নির্দিষ্ট টার্গেটে পৌঁছে যাচ্ছে

🧠 এই দুটি সিমুলেশন থেকে যা বোঝা যায়:

PID কিভাবে ভুল (error) বুঝে, তা শুধরায় এবং লক্ষ্য অনুযায়ী সিস্টেমের আউটপুটকে ধাপে ধাপে নিখুঁত করে।