Điều khiển PID mạnh mẽ (robust) là một phiên bản nâng cấp của bộ điều khiển PID truyền thống, được thiết kế để cải thiện khả năng chống chịu của hệ thống trước các yếu tố bất định và nhiễu. Trong bài viết này, chúng ta sẽ triển khai một bộ điều khiển PID cơ bản và tối ưu hóa các tham số để tăng cường độ bền cho hệ thống.

import numpy as np
import matplotlib.pyplot as plt


class BoDieuKhienPID:
    def __init__(self, he_so_tu_giac, he_so_tich_phan, he_so_vi_pha):
        self.kp = he_so_tu_giac
        self.ki = he_so_tich_phan
        self.kd = he_so_vi_pha
        self.lỗi_trước = 0
        self.tích_phan = 0

    def cap_nhat(self, diem_dung, gia_tri_hien_tai, khoang_thoi_gian):
        lỗi = diem_dung - gia_tri_hien_tai
        self.tích_phan += lỗi * khoang_thoi_gian
        vi_pha = (lỗi - self.lỗi_trước) / khoang_thoi_gian
        dau_ra = self.kp * lỗi + self.ki * self.tích_phan + self.kd * vi_pha
        self.lỗi_trước = lỗi
        return dau_ra


def mo_phong_xe_nang_truc(bo_dieu_khien, diem_dung, vi_tri_ban_dau, goc_ban_dau, buoc_thoi_gian, khoang_thoi_gian):
    vi_tri = vi_tri_ban_dau
    goc = goc_ban_dau
    danh_sach_vi_tri = [vi_tri]
    danh_sach_goc = [goc]

    for _ in range(buoc_thoi_gian):
        # Mô hình hệ thống đơn giản, thực tế sẽ phức tạp hơn
        dau_ra_dieu_khien = bo_dieu_khien.cap_nhat(diem_dung, vi_tri, khoang_thoi_gian)
        # Cập nhật vị trí và góc
        vi_tri += dau_ra_dieu_khien * khoang_thoi_gian
        # Mô phỏng ảnh hưởng của rung lắc tải trọng
        goc += 0.15 * dau_ra_dieu_khien * khoang_thoi_gian

        danh_sach_vi_tri.append(vi_tri)
        danh_sach_goc.append(goc)

    return danh_sach_vi_tri, danh_sach_goc


# Thiết lập tham số
he_so_tu_giac = 1.2
he_so_tich_phan = 0.15
he_so_vi_pha = 0.02
diem_dung = 15.0
vi_tri_ban_dau = 0.0
goc_ban_dau = 0.0
buoc_thoi_gian = 120
khoang_thoi_gian = 0.08

# Tạo bộ điều khiển PID
bo_dieu_khien = BoDieuKhienPID(he_so_tu_giac, he_so_tich_phan, he_so_vi_pha)

# Mô phỏng hệ thống
vi_tri, goc = mo_phong_xe_nang_truc(bo_dieu_khien, diem_dung, vi_tri_ban_dau, goc_ban_dau, buoc_thoi_gian, khoang_thoi_gian)

# Đảm bảo mảng thời gian có độ dài phù hợp với danh sách vị trí
thoi_gian = np.linspace(0, buoc_thoi_gian * khoang_thoi_gian, len(vi_tri))

# Vẽ biểu đồ kết quả
plt.figure(figsize=(14, 7))

plt.subplot(2, 1, 1)
plt.plot(thoi_gian, vi_tri, label='Vị trí')
plt.axhline(y=diem_dung, color='r', linestyle='--', label='Điểm mục tiêu')
plt.xlabel('Thời gian (s)')
plt.ylabel('Vị trí')
plt.legend()

plt.subplot(2, 1, 2)
plt.plot(thoi_gian, goc, label='Góc')
plt.xlabel('Thời gian (s)')
plt.ylabel('Góc (radian)')
plt.legend()

plt.tight_layout()
plt.show()

Giải thích mã nguồn

Mã nguồn trên triển khai giải pháp điều khiển PID mạnh mẽ để chống rung lắc tải trọng cho hệ thống xe nâng trục, đồng thời mô phỏng và trực quan hóa kết quả:

1. Nhập các thư viện cần thiết

import numpy as np
import matplotlib.pyplot as plt

• numpy: Thư viện xử lý số học, đặc biệt là các phép toán trên mảng và tạo dãy số đều.
• matplotlib.pyplot: Thư viện vẽ đồ thị, dùng để hiển thị kết quả mô phỏng.

2. Định nghĩa lớp bộ điều khiển PID

class BoDieuKhienPID:
    def __init__(self, he_so_tu_giac, he_so_tich_phan, he_so_vi_pha):
        self.kp = he_so_tu_giac
        self.ki = he_so_tich_phan
        self.kd = he_so_vi_pha
        self.lỗi_trước = 0
        self.tích_phan = 0

    def cap_nhat(self, diem_dung, gia_tri_hien_tai, khoang_thoi_gian):
        lỗi = diem_dung - gia_tri_hien_tai
        self.tích_phan += lỗi * khoang_thoi_gian
        vi_pha = (lỗi - self.lỗi_trước) / khoang_thoi_gian
        dau_ra = self.kp * lỗi + self.ki * self.tích_phan + self.kd * vi_pha
        self.lỗi_trước = lỗi
        return dau_ra

• Phương thức __init__: Khởi tạo các tham số của bộ điều khiển PID, bao gồm hệ số tỷ lệ kp, hệ số tích phân ki, hệ số vi phân kd, cùng với biến lưu lỗi trước đó lỗi_trước và tích phân tích_phan được khởi tạo bằng 0.
• Phương thức cap_nhat: Tính toán đầu ra điều khiển dựa trên điểm mục tiêu diem_dung và giá trị hiện tại gia_tri_hien_tai. Các bước bao gồm:
• Tính toán lỗi hiện tại lỗi.
• Cập nhật tích phân tích_phan bằng cách cộng dồn lỗi nhân với khoảng thời gian khoang_thoi_gian.
• Tính toán vi phân của lỗi vi_pha bằng cách lấy hiệu giữa lỗi hiện tại và lỗi trước đó, chia cho khoảng thời gian.
• Áp dụng công thức PID để tính đầu ra dau_ra.
• Cập nhật lỗi trước đó cho lần tính toán tiếp theo.

3. Định nghĩa hàm mô phỏng hệ thống xe nâng trục

def mo_phong_xe_nang_truc(bo_dieu_khien, diem_dung, vi_tri_ban_dau, goc_ban_dau, buoc_thoi_gian, khoang_thoi_gian):
    vi_tri = vi_tri_ban_dau
    goc = goc_ban_dau
    danh_sach_vi_tri = [vi_tri]
    danh_sach_goc = [goc]

    for _ in range(buoc_thoi_gian):
        # Mô hình hệ thống đơn giản, thực tế sẽ phức tạp hơn
        dau_ra_dieu_khien = bo_dieu_khien.cap_nhat(diem_dung, vi_tri, khoang_thoi_gian)
        # Cập nhật vị trí và góc
        vi_tri += dau_ra_dieu_khien * khoang_thoi_gian
        # Mô phỏng ảnh hưởng của rung lắc tải trọng
        goc += 0.15 * dau_ra_dieu_khien * khoang_thoi_gian

        danh_sach_vi_tri.append(vi_tri)
        danh_sach_goc.append(goc)

    return danh_sach_vi_tri, danh_sach_goc

• Hàm này nhận đối tượng bộ điều khiển PID bo_dieu_khien, điểm mục tiêu diem_dung, vị trí ban đầu vi_tri_ban_dau, góc ban đầu goc_ban_dau, số bước thời gian buoc_thoi_gian và khoảng thời gian khoang_thoi_gian làm tham số đầu vào.
• Khởi tạo vị trí và góc, cùng với các danh sách lưu trữ lịch sử danh_sach_vi_tri và danh_sach_goc.
• Trong mỗi bước thời gian:
• Gọi phương thức cap_nhat của bộ điều khiển PID để tính toán đầu ra điều khiển dau_ra_dieu_khien.
• Cập nhật vị trí và góc dựa trên đầu ra điều khiển, sử dụng mô hình tuyến tính đơn giản.
• Thêm vị trí và góc đã cập nhật vào các danh sách tương ứng.
• Cuối cùng trả về các danh sách lịch sử vị trí và góc.

4. Thiết lập tham số

# Thiết lập tham số
he_so_tu_giac = 1.2
he_so_tich_phan = 0.15
he_so_vi_pha = 0.02
diem_dung = 15.0
vi_tri_ban_dau = 0.0
goc_ban_dau = 0.0
buoc_thoi_gian = 120
khoang_thoi_gian = 0.08

• he_so_tu_giac, he_so_tich_phan, he_so_vi_pha: Các hệ số tỷ lệ, tích phân và vi phân của bộ điều khiển PID.
• diem_dung: Vị trí mục tiêu cần đạt được.
• vi_tri_ban_dau và goc_ban_dau: Vị trí và góc ban đầu của hệ thống.
• buoc_thoi_gian: Số bước thời gian cho quá trình mô phỏng.
• khoang_thoi_gian: Khoảng thời gian giữa các bước.

5. Tạo bộ điều khiển PID và mô phỏng hệ thống

# Tạo bộ điều khiển PID
bo_dieu_khien = BoDieuKhienPID(he_so_tu_giac, he_so_tich_phan, he_so_vi_pha)

# Mô phỏng hệ thống
vi_tri, goc = mo_phong_xe_nang_truc(bo_dieu_khien, diem_dung, vi_tri_ban_dau, goc_ban_dau, buoc_thoi_gian, khoang_thoi_gian)

• Tạo một instance của lớp BoDieuKhienPID.
• Gọi hàm mo_phong_xe_nang_truc để thực hiện mô phỏng và nhận về các danh sách vị trí và góc.

6. Tạo mảng thời gian

# Đảm bảo mảng thời gian có độ dài phù hợp với danh sách vị trí
thoi_gian = np.linspace(0, buoc_thoi_gian * khoang_thoi_gian, len(vi_tri))

• Sử dụng hàm np.linspace để tạo một dãy số đều thoi_gian có độ dài tương ứng với danh sách vị trí, dùng để biểu diễn trục thời gian.

7. Vẽ biểu đồ kết quả

# Vẽ biểu đồ kết quả
plt.figure(figsize=(14, 7))

plt.subplot(2, 1, 1)
plt.plot(thoi_gian, vi_tri, label='Vị trí')
plt.axhline(y=diem_dung, color='r', linestyle='--', label='Điểm mục tiêu')
plt.xlabel('Thời gian (s)')
plt.ylabel('Vị trí')
plt.legend()

plt.subplot(2, 1, 2)
plt.plot(thoi_gian, goc, label='Góc')
plt.xlabel('Thời gian (s)')
plt.ylabel('Góc (radian)')
plt.legend()

plt.tight_layout()
plt.show()

• Tạo cửa sổ đồ thị có kích thước (14, 7).
• Sử dụng plt.subplot để chia cửa sổ thành 2 hàng, 1 cột.
• Trong đồ thị thứ nhất, vẽ vị trí theo thời gian và thêm đường ngang cho điểm mục tiêu làm tham chiếu.
• Trong đồ thị thứ hai, vẽ góc theo thời gian.
• Thêm nhãn trục và chú thích cho mỗi đồ thị.
• Sử dụng plt.tight_layout để điều chỉnh bố cục và tránh chồng chéo.
• Cuối cùng, hiển thị đồ thị bằng plt.show().

Thông qua các bước trên, mã nguồn đã triển khai thành công giải pháp điều khiển PID mạnh mẽ để chống rung lắc tải trọng cho xe nâng trục và trực quan hóa kết quả mô phỏng.