Tinh chỉnh PID cho robot dò line - từ lý thuyết đến xe chạy mượt

Bài này dành cho ai?

Bạn đã biết PID là gì (nếu chưa, đọc bài Giới thiệu PID ở mục Kiến thức trước) và robot dò line của bạn đã chạy được kiểu bậc thang if-else nhưng: lắc như rắn bò trên đường thẳng, văng khỏi vạch ở khúc cua khi tăng tốc. Bài này là quy trình thực chiến đưa robot từ "chạy được" lên "chạy mượt và nhanh" — kèm code đầy đủ và trình tự chỉnh từng hệ số.

Bước 1 - Tính vị trí vạch bằng trung bình trọng số

PID cần đầu vào là con số liên tục đo độ lệch khỏi vạch, không phải 3 trạng thái trái/giữa/phải. Với mảng 5 mắt analog (đọc chân A0 từng mắt):

const int SENSOR[5] = {36, 39, 34, 35, 32};   // toàn ADC1 - an toàn khi bật WiFi
const int WEIGHT[5] = {-2000, -1000, 0, 1000, 2000};

int sensorMin[5], sensorMax[5];   // học được khi hiệu chuẩn

// vị trí vạch: -2000 (lệch hẳn trái) đến +2000 (lệch hẳn phải)
int readLinePosition() {
  long weightedSum = 0, total = 0;
  for (int i = 0; i < 5; i++) {
    int raw = analogRead(SENSOR[i]);
    // chuẩn hóa 0-1000 theo hiệu chuẩn (đen = giá trị cao)
    int v = map(raw, sensorMin[i], sensorMax[i], 0, 1000);
    v = constrain(v, 0, 1000);
    weightedSum += (long)v * WEIGHT[i];
    total += v;
  }
  if (total < 300) return lastPosition;   // mất vạch: giữ giá trị cuối
  return weightedSum / total;
}

Hai chi tiết quyết định chất lượng:

• Hiệu chuẩn lúc khởi động: quét robot ngang vạch 2-3 giây, ghi min/max từng mắt — mỗi mắt một độ nhạy, không hiệu chuẩn thì mắt lệch kéo sai cả vị trí
• Nhớ vị trí cuối khi mất vạch: robot văng khỏi vạch ở cua gắt sẽ biết vạch nằm phía nào để đánh lái về

Bước 2 - Vòng điều khiển PID

float Kp = 0.08, Ki = 0.0, Kd = 0.6;    // điểm khởi đầu cho BASE=150
int BASE = 150;                          // tốc độ nền 0-255
int lastPosition = 0;
int lastError = 0;
long integral = 0;

void loop() {
  int position = readLinePosition();     // -2000..2000, đích = 0
  int error = position;

  integral += error;
  integral = constrain(integral, -50000, 50000);   // chống windup
  int derivative = error - lastError;
  lastError = error;

  float output = Kp * error + Ki * integral + Kd * derivative;

  int left  = constrain(BASE + output, 0, 255);
  int right = constrain(BASE - output, 0, 255);
  ledcWrite(ENA, left);
  ledcWrite(ENB, right);
  // KHÔNG delay ở đây - vòng càng nhanh PID càng mịn (mục tiêu 200+ Hz)
}

Lưu ý cấu trúc: không có delay trong loop — tần số vòng điều khiển là sức mạnh thầm lặng của PID; đọc analog 5 mắt + tính toán trên ESP32 chạy được trên 500 Hz thoải mái.

Bước 3 - Trình tự chỉnh hệ số (quan trọng nhất bài)

Chỉnh sai thứ tự là nguồn đau khổ chính. Làm đúng trình tự sau, mỗi lần chỉ đổi MỘT thứ:

3.1. Đặt Ki = 0, Kd = 0, chỉnh Kp trước

1. Bắt đầu Kp rất nhỏ (0.02): robot ôm cua yếu, trượt ra ở khúc cua — tăng dần
2. Tăng Kp gấp rưỡi mỗi lần đến khi robot bám được mọi khúc cua nhưng lắc (dao động) trên đường thẳng
3. Ghi lại giá trị này — gọi là Kp_dao_động. Lùi về ~60-70% của nó

3.2. Thêm Kd để dập dao động

1. Bắt đầu Kd = 5 x Kp, quan sát: đường thẳng phải hết lắc, vào cua phải "ghim" vạch dứt khoát
2. Tăng Kd đến khi hết lắc hoàn toàn; quá tay sẽ thấy robot rung tần số cao (giật giật) do khuếch đại nhiễu — lùi lại 20%
3. Giờ có thể tăng lại Kp thêm chút nữa nếu cua gắt vẫn trượt — hai hệ số này chỉnh xen kẽ 2-3 vòng

3.3. Ki - thường không cần

Robot dò line hiếm khi cần Ki: sai số tĩnh (chạy lệch hẳn một bên vạch liên tục) mới cần Ki, và thường do cơ khí lệch (mắt gắn lệch tâm, một động cơ yếu) — sửa phần cứng tốt hơn vá bằng Ki. Nếu buộc phải dùng: Ki cực nhỏ (0.0001-0.001) kèm chống windup như code trên.

3.4. Tăng tốc độ nền

BASE tăng thì bộ hệ số cũ dần đuối: quán tính lớn hơn, thời gian phản ứng ngắn hơn. Tăng BASE từng nấc 20-30, mỗi nấc chỉnh lại Kd (thường tăng) rồi Kp. Các đội thi đấu lưu nhiều bộ hệ số theo tốc độ và chuyển bằng nút bấm khi thi sân lạ.

Bảng chẩn đoán hành vi

Ba nâng cấp của các đội mạnh

1. Giảm tốc chủ động trước cua: |derivative| tăng vọt nghĩa là đang vào cua — hạ BASE tạm thời; robot chạy thẳng 255, vào cua tự về 150
2. Phanh bằng chiều ngược: khi output lớn, thay vì hạ một bánh về 0, đảo chiều bánh trong cua (giá trị âm) — robot xoay gắt hơn hẳn tại hairpin; cần driver nhận chiều độc lập từng bánh
3. Log ra Serial để chỉnh bằng dữ liệu: in position và output mỗi 50 ms, vẽ bằng Serial Plotter — dao động và trễ hiện rõ trên đồ thị, hết chỉnh mò. Kỹ thuật debug chi tiết trong bài Debug bằng Serial Monitor ở mục Kiến thức

Câu hỏi thường gặp

Có bộ hệ số PID "chuẩn" dùng chung không?

Không — hệ số phụ thuộc khối lượng xe, tốc độ, bánh xe, độ cao cảm biến, thậm chí độ mòn pin. Bộ số trong bài (Kp=0.08, Kd=0.6 với thang vị trí ±2000, BASE=150) chỉ là điểm xuất phát hợp lý; quy trình chỉnh mới là thứ dùng chung được.

Dò line digital (D0) có chạy PID được không?

Được một phần: 5 mắt digital cho ~9 mức vị trí rời rạc thay vì liên tục — PID vẫn chạy nhưng thô. Đáng công chuyển sang đọc analog: cùng phần cứng module, chỉ đổi dây từ D0 sang A0 và thêm hiệu chuẩn.

Vòng điều khiển bao nhiêu Hz là đủ?

Kinh nghiệm: tối thiểu 100 Hz cho BASE ≤ 150; 300-500 Hz khi chạy 200-255. Kẻ giết tần số số một là Serial.print mỗi vòng — in thưa 10-20 lần/giây thôi.

Sao robot chạy tốt ở nhà, đến sân thi lại loạn?

Khác biệt ánh sáng (đèn sân chứa hồng ngoại), độ bóng mặt sân và độ phẳng. Đối sách: hiệu chuẩn lại NGAY TẠI SÂN trước khi thi (quy trình quét ngang vạch 3 giây), che chắn cảm biến khỏi ánh sáng tạt ngang, và mang theo 2-3 bộ hệ số đã thử ở tốc độ khác nhau.