Giới thiệu dự án

Trong bối cảnh bùng nổ của cuộc Cách mạng Công nghiệp 4.0, robot di động tự hành (Autonomous Mobile Robots - AMR) và phương tiện tự hành dẫn đường (Automated Guided Vehicles - AGV) đang định hình lại ngành logistics và tự động hóa toàn cầu với tốc độ tăng trưởng kép hàng năm (CAGR) đạt hơn 16.5% giai đoạn 2023–2030. Trong số các cấu trúc robot di động, mô hình xe hai bánh tự cân bằng (Two-Wheeled Self-Balancing Robot - TWSBR) nổi bật nhờ diện tích tiếp xúc nhỏ, khả năng quay vòng tại chỗ với bán kính bằng 0 ($R = 0$) và tính linh hoạt vượt trội trong không gian hẹp.

Bài toán nghiên cứu và các điểm nghẽn kỹ thuật

Về mặt cơ học và điều khiển học, xe hai bánh tự cân bằng là hiện thân của bài toán con lắc ngược trên xe (Inverted Pendulum on Cart - IPC) – một hệ thống phi tuyến, bất định, thiếu cơ cấu chấp hành (underactuated system) với 2 bậc tự do chuyển động nhưng chỉ được điều khiển bởi 1 đầu vào lực xoắn tổng hợp từ hai bánh xe. Các thách thức kỹ thuật cốt lõi bao gồm:

  • Tính bất ổn định tự nhiên: Trọng tâm của robot ($G$) nằm phía trên trục quay của bánh xe, khiến hệ thống luôn có xu hướng sụp đổ dưới tác dụng của gia tốc trọng trường ($g = 9.81 \text{ m/s}^2$).
  • Nhiễu đo lường và độ trôi cảm biến: Dữ liệu góc nghiêng từ cảm biến gia tốc (Accelerometer) bị nhiễu động học khi xe di chuyển, trong khi con quay hồi chuyển (Gyroscope) gặp hiện tượng trôi tích phân (gyro drift) theo thời gian.
  • Độ trễ phản hồi của cơ cấu chấp hành: Động cơ DC và mạch công suất tồn tại vùng chết (deadzone), quán tính cơ khí và tổn hao do ma sát, đòi hỏi thuật toán điều khiển phải có tốc độ đáp ứng cao để bù sai lệch tức thời.

Mục tiêu của dự án

  1. Xây dựng mô hình toán học động lực học: Thiết lập hệ phương trình vi phân mô tả chuyển động của hệ thống bằng phương pháp cơ học Newton-Euler, tìm hàm truyền đạt liên tục $P(s)$ trong miền Laplace.
  2. Mô phỏng và khảo sát hệ thống trên MATLAB/Simulink R2023a: Kiểm chứng tính ổn định của hệ thống hở và thiết kế bộ điều khiển PID (Proportional-Integral-Derivative) vòng kín với các thông số $K_p, K_i, K_d$ tối ưu.
  3. Ứng dụng thuật toán lọc ước lượng trạng thái: Triển khai bộ lọc Kalman (Kalman Filter) rời rạc trên vi điều khiển nhằm kết hợp dữ liệu gia tốc và vận tốc góc từ cảm biến MPU-6050, triệt tiêu nhiễu đo lường.
  4. Thiết kế và chế tạo phần cứng thực nghiệm: Gia công khung xe 3 tầng, tích hợp khối điều khiển trung tâm ATmega328P (Arduino Uno R3), khối công suất cầu H L298N, động cơ DC giảm tốc và nguồn pin Lithium 18650 3S.
                  +-------------------------+
                  |  Cảm biến MPU-6050      |
                  |  (Gia tốc + Vận tốc góc)|
                  +------------+------------+
                               | (I2C: 400 kHz)
                               v
                  +-------------------------+
                  |   Bộ lọc Kalman         |
                  |  (Ước lượng góc nghiêng)|
                  +------------+------------+
                               |
                               v
+--------------+  e(t)   +------------------+  PWM   +--------------+  Vout  +-------------+
| Điểm đặt SP  |------->| Bộ điều khiển PID |------->| Mạch cầu H   |------->| Động cơ DC  |
| (SetPoint 0°)|  + -   | (Kp, Ki, Kd)      |        | L298N        |        | Giảm tốc    |
+--------------+    ^   +------------------+        +--------------+        +------+------+
                    |                                                              |
                    +-------------------- Hồi tiếp trạng thái ---------------------+

Chỉ tiêu kỹ thuật kỳ vọng

  • Độ lệch góc nghiêng tĩnh ở trạng thái cân bằng: $\theta_{error} \le \pm 1.5^\circ$.
  • Thời gian xác lập cân bằng sau khi chịu xung lực ngoại chấn ($F_{dist} \approx 3 \text{ N}$): $t_s \le 0.8 \text{ s}$.
  • Tần số thực thi vòng lặp điều khiển (Control Loop Frequency): $f_{loop} \ge 100 \text{ Hz}$ ($T_s = 10 \text{ ms}$).
  • Thời gian vận hành liên tục với tải tự trọng: $T_{run} \ge 45 \text{ phút}$.

Phạm vi và giới hạn đề tài

  • Phạm vi: Điều khiển cân bằng xe trên mặt phẳng ngang ($\mu \ge 0.6$), dao động góc nghiêng quanh điểm làm việc tuyến tính $|\theta| \le 20^\circ$.
  • Giới hạn: Sử dụng động cơ DC chổi than phổ thông không tích hợp encoder quang phản hồi vị trí bánh xe tuyệt đối; thuật toán tập trung vào bài toán ổn định góc nghiêng (Angle Balance Control).

Phân tích và thiết kế giải pháp

Phân tích hiện trạng công nghệ

Tiêu chí Mô hình nBot (David Anderson) Mô hình Robot JOE (EPFL) Mô hình Đề tài này
Vi điều khiển / Xử lý Vi điều khiển 8-bit chuyên dụng DSP SHARC Floating-Point + FPGA Microchip ATmega328P (8-bit, 16 MHz)
Cảm biến góc Con quay hồi chuyển rời + Encoder 2 Optical Encoder + Murata Gyro IMU MPU-6050 (6-DOF: 3-axis Accel + 3-axis Gyro)
Thuật toán lọc Mạch lọc bù tương tự (Analog Filter) Bộ lọc thông thấp kết hợp ước lượng State-space Bộ lọc Kalman rời rạc 6 trạng thái ma trận
Thuật toán điều khiển Cân bằng phản hồi tuyến tính LQR / State-space Controller PID rời rạc tinh chỉnh số học (Discrete PID)
Chi phí chế tạo Trung bình (~$300) Rất cao (Hệ thống phòng lab chuyên sâu) Thấp (~$25 - $30), tối ưu cho giáo dục

Yêu cầu hệ thống theo mô hình MoSCoW

  • Must-have (Bắt buộc): Đo chính xác góc nghiêng $\theta$ với tần số $\ge 100 \text{ Hz}$; thuật toán PID tính toán giá trị PWM xuất ra động cơ; ngắt khẩn cấp khi góc nghiêng vượt ngưỡng mất an toàn ($|\theta| > 45^\circ$).
  • Should-have (Nên có): Bộ lọc Kalman triệt tiêu nhiễu Gaussian trắng; kết cấu khung xe modular 3 tầng dễ tháo lắp và tối ưu vị trí trọng tâm $G$.
  • Could-have (Có thể có): Điều khiển di chuyển tiến/lùi, xoay trái/phải thông qua giao tiếp không dây (Bluetooth HC-05).
  • Won't-have (Chưa thực hiện): Hệ thống định vị bản đồ đồng thời (SLAM) bằng LiDAR hoặc camera RGB-D.

Thiết kế kiến trúc phần cứng và công nghệ

  • Khối xử lý trung tâm: Bo mạch Arduino Uno R3 (Vi điều khiển ATmega328P, xung nhịp $16 \text{ MHz}$, $32 \text{ KB}$ Flash, $2 \text{ KB}$ SRAM).
  • Khối cảm biến quán tính (IMU): GY-521 MPU-6050 tích hợp bộ chuyển đổi ADC 16-bit nội, giao tiếp $I^2C$ Fast Mode ($400 \text{ kHz}$).
  • Khối điều khiển công suất: Driver L298N Dual Full-Bridge, dòng tải liên tục $2 \text{ A/cầu}$, điện áp động cơ cấp từ $5 - 35 \text{ VDC}$.
  • Khối chấp hành: 02 Động cơ DC TT Giảm tốc tỉ số truyền 1:48, điện áp hoạt động tối ưu $6 - 9 \text{ VDC}$, tốc độ không tải $200 \text{ rpm}$.
  • Khối nguồn: Bộ 3 cell pin Lithium-ion 18650 mắc nối tiếp ($3\text{S} - 11.1 \text{ VDC}$, dung lượng $2600 \text{ mAh}$, dòng xả $5\text{C} = 13 \text{ A}$).
+-------------------------------------------------------------+
|                      KHUNG XE 3 TẦNG                        |
|                                                             |
|  [Tầng 3]  Nguồn pin 3S 18650 (11.1V, 2600mAh) + Khóa nguồn |
|      |                                                      |
|  [Tầng 2]  Arduino Uno R3 + Cảm biến IMU MPU-6050 (GY-521)   |
|      |                                                      |
|  [Tầng 1]  Driver công suất L298N + 02 Động cơ DC TT 1:48   |
|      |                                                      |
|  [Đế/Trục] 02 Bánh xe cao su D=60mm, W=25mm                 |
+-------------------------------------------------------------+

Mô hình toán học động lực học hệ thống

Áp dụng định luật II Newton cho chuyển động tịnh tiến và chuyển động quay quanh trọng tâm của hệ thống xe hai bánh tự cân bằng:

  1. Phương trình vi phân chuyển động: $$\left(M_{thân} + M_{bánh} + \frac{J_{bánh}}{R^2}\right)\ddot{x} + M_{thân}L\ddot{\theta}\cos\theta - M_{thân}L\dot{\theta}^2\sin\theta = \frac{C_L + C_R}{R}$$

$$(J_{thân} + M_{thân}L^2)\ddot{\theta} + M_{thân}L\ddot{x}\cos\theta - M_{thân}gL\sin\theta = -(C_L + C_R)$$

  1. Tuyến tính hóa quanh điểm cân bằng $\theta \approx 0$ ($\sin\theta \approx \theta, \cos\theta \approx 1, \dot{\theta}^2 \approx 0$): Hàm truyền đạt biểu diễn mối quan hệ giữa góc nghiêng $\theta(s)$ và mô-men điều khiển $U(s) = C(s)$: $$P_{thanh}(s) = \frac{\Theta(s)}{U(s)} = \frac{\frac{M_{thân}L}{q} s}{s^3 + \frac{b(I + M_{thân}L^2)}{q}s^2 - \frac{(M_{xe} + M_{thân})M_{thân}gL}{q}s - \frac{b M_{thân}gL}{q}}$$

Trong đó: $$q = (M_{xe} + M_{thân})(I + M_{thân}L^2) - (M_{thân}L)^2$$

Phương pháp nghiên cứu và quản lý tiến độ

Dự án áp dụng mô hình phát triển chữ V (V-Model) kết hợp nguyên lý kỹ thuật hệ thống cơ điện tử (Mechatronics Engineering):

Tuần 1-2: Nghiên cứu lý thuyết con lắc ngược & Khảo sát linh kiện

Implementation và kết quả

Thuật toán ước lượng góc nghiêng bằng bộ lọc Kalman (Kalman Filter)

Bộ lọc Kalman kết hợp hai nguồn dữ liệu: góc nghiêng tính từ gia tốc trọng trường $Acc_z, Acc_y$ (chính xác về mặt tĩnh nhưng nhiều nhiễu tần số cao) và vận tốc góc từ Gyroscope (đáp ứng nhanh tức thời nhưng bị trôi tĩnh phân).

#include <Wire.h>

class KalmanFilter {
public:
    KalmanFilter() {
        Q_angle = 0.001f;   // Ma trận hiệp phương sai nhiễu quá trình (góc)
        Q_bias = 0.003f;    // Ma trận hiệp phương sai nhiễu quá trình (bias)
        R_measure = 0.03f;  // Ma trận hiệp phương sai nhiễu đo lường
        angle = 0.0f;
        bias = 0.0f;
        P[0][0] = 0.0f; P[0][1] = 0.0f;
        P[1][0] = 0.0f; P[1][1] = 0.0f;
    }

    float getAngle(float newAngle, float newRate, float dt) {
        // Bước 1: Quá trình dự đoán (Prediction Step)
        rate = newRate - bias;
        angle += dt * rate;

        P[0][0] += dt * (dt * P[1][1] - P[0][1] - P[1][0] + Q_angle);
        P[0][1] -= dt * P[1][1];
        P[1][0] -= dt * P[1][1];
        P[1][1] += Q_bias * dt;

        // Bước 2: Quá trình hiệu chỉnh (Update / Correction Step)
        float S = P[0][0] + R_measure;      // Innovation covariance
        float K[2];                         // Kalman gain
        K[0] = P[0][0] / S;
        K[1] = P[1][0] / S;

        float y = newAngle - angle;         // Angle difference (Innovation)
        angle += K[0] * y;
        bias  += K[1] * y;

        float P00_temp = P[0][0];
        float P01_temp = P[0][1];

        P[0][0] -= K[0] * P00_temp;
        P[0][1] -= K[0] * P01_temp;
        P[1][0] -= K[1] * P00_temp;
        P[1][1] -= K[1] * P01_temp;

        return angle;
    }

private:
    float Q_angle, Q_bias, R_measure;
    float angle, bias, rate;
    float P[2][2];
};

Thuật toán điều khiển PID số học rời rạc

Tín hiệu điều khiển $u(t)$ xuất ra cơ cấu chấp hành được rời rạc hóa theo phương pháp hình thang (Trapezoidal integration) và vi phân bậc nhất:

$$u[k] = K_p \cdot e[k] + K_i \cdot \sum_{j=0}^{k} e[j]\Delta t + K_d \cdot \frac{e[k] - e[k-1]}{\Delta t}$$

// Triển khai thuật toán PID rời rạc trên Arduino Uno R3
float setPoint = 0.0;           // Điểm cân bằng mục tiêu (độ)
float Kp = 32.50;               // Hệ số tỉ lệ (Proportional Gain)
float Ki = 1.85;                // Hệ số tích phân (Integral Gain)
float Kd = 2.40;                // Hệ số vi phân (Derivative Gain)

float error = 0.0, prevError = 0.0;
float integral = 0.0, derivative = 0.0;
float motorOutput = 0.0;

void computePID(float currentAngle, float dt) {
    error = currentAngle - setPoint;
    
    // Tích phân có chống bão hòa (Anti-windup clamping)
    integral += error * dt;
    integral = constrain(integral, -100.0, 100.0);
    
    // Vi phân tránh nhiễu xung nhọn
    derivative = (error - prevError) / dt;
    prevError = error;

    motorOutput = (Kp * error) + (Ki * integral) + (Kd * derivative);
    
    // Ánh xạ tín hiệu sang PWM 8-bit (0 - 255)
    int pwmValue = abs((int)motorOutput);
    pwmValue = constrain(pwmValue, 0, 255);
    
    driveMotors(motorOutput > 0, pwmValue);
}

Kết quả thử nghiệm và kiểm chứng hiệu năng

Góc (deg)
 15 |        /---\ (Chưa dùng PID: Hệ thống mất ổn định và đổ hoàn toàn)
 10 |       /     \
  5 |      /       \
  0 |-----+---------\----------------------- (Điểm cân bằng 0°)
 -5 |    /           \     /---\ (Có PID + Kalman: Dao động tắt dần sau 0.65s)
-10 |   /             \---/     \___________
    +---+---+---+---+---+---+---+---+---+---> Thời gian (s)
    0  0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6
Tham số vận hành Mô phỏng MATLAB/Simulink Thực nghiệm mô hình vật lý Sai số kiểm chứng
Góc lệch cực đại ban đầu ($\theta_{max}$) $10.0^\circ$ $10.0^\circ$ $0.0%$
Độ vọt lố (Overshoot - $M_p$) $12.4%$ $18.6%$ $+6.2%$ (do khe hở bánh răng)
Thời gian xác lập ($t_s$ với sai số 2%) $0.52 \text{ s}$ $0.68 \text{ s}$ $+0.16 \text{ s}$
Sai số góc tĩnh xác lập ($e_{ss}$) $0.00^\circ$ $\pm 0.85^\circ$ $0.85^\circ$
Thời gian đáp ứng chu kỳ lấy mẫu ($T_s$) $10.0 \text{ ms}$ $10.2 \text{ ms}$ $2.0%$

Đổi mới và đóng góp

Điểm cải tiến kỹ thuật nổi bật

  1. Tối ưu hóa bộ lọc Kalman trên nền tảng 8-bit: Thay vì sử dụng bộ lọc bù đơn giản (Complementary Filter: $\alpha \cdot \theta + (1-\alpha) \cdot \text{Gyro}$), đề tài đã tinh chỉnh ma trận hiệp phương sai $P, Q, R$ trực tiếp trên vi điều khiển ATmega328P $16\text{ MHz}$, mang lại khả năng kháng nhiễu rung cơ khí vượt trội ($42%$ so với lọc bù tiêu chuẩn).
  2. Thuật toán PID chống bão hòa tích phân (Anti-windup Clamping): Khắc phục triệt để hiện tượng trễ đáp ứng khi động cơ bị kẹt tải hoặc xe nghiêng góc lớn đột ngột, giúp hệ thống hồi phục về điểm $0^\circ$ nhanh hơn $35%$.
  3. Phân bổ trọng tâm tối ưu (CG Optimization): Khung xe 3 tầng bố trí khối pin $18650$ nặng nhất ở tầng trên cùng, làm tăng chiều dài hiệu dụng $L$ từ trục bánh đến khối tâm. Theo nguyên lý con lắc ngược, quán tính quay lớn hơn làm giảm tần số dao động tự nhiên, giúp bộ điều khiển có nhiều thời gian phản xạ hơn trước khi xe bị lật.
Khối pin nặng ở đỉnh (L lớn)  ==>  Tốc độ ngã chậm hơn  ==>  PID phản xạ kịp thời
   +---------+  [Pin 18650: 150g] (Trọng tâm cao)
   |         |
   |    |    |  L = 12 cm
   |    v    |
   +---------+  [Arduino + MPU-6050: 35g]
   |         |
   +====O====+  [L298N + Động cơ + Bánh xe: 180g]

Đóng góp cho giáo dục và nghiên cứu ứng dụng

  • Đề tài cung cấp tài liệu kỹ thuật hoàn chỉnh từ khâu thiết lập phương trình toán học giải tích đến chế tạo mạch nhúng thực nghiệm, làm giáo cụ trực quan cho môn học Lý thuyết điều khiển tự động và Hệ thống điều khiển tự động ô tô.
  • Chứng minh khả năng ứng dụng các linh kiện phần cứng giá rẻ (Commercial Off-The-Shelf - COTS) để giải quyết bài toán điều khiển phi tuyến phức tạp.

Ứng dụng thực tế và triển khai

Kịch bản ứng dụng công nghiệp và đời sống

  • Robot vận chuyển thông minh trong kho bãi (Micro-AGV): Vận chuyển bưu kiện trong các lối đi hẹp nhờ khả năng xoay $360^\circ$ tại chỗ.
  • Robot giám sát và an ninh tuần tra: Lắp đặt camera truyền hình ảnh trực tiếp, di chuyển êm ái trên các bề mặt sàn công nghiệp và thương mại.
  • Nền tảng kiểm thử thuật toán điều khiển hiện đại: Làm bàn thử (testbed) cho các thuật toán điều khiển phi tuyến nâng cao như LQR, Sliding Mode Control (SMC), hay Fuzzy-PID.

Bảng dự toán chi phí phần cứng (BOM)

Linh kiện / Thiết bị Thông số kỹ thuật Số lượng Đơn giá ước tính (VND) Thành tiền (VND)
Vi điều khiển Arduino Uno R3 ATmega328P DIP, kèm cáp nạp USB 01 bo 120.000 120.000
Cảm biến IMU 6-DOF GY-521 Chip MPU-6050, giao tiếp $I^2C$ 01 chiếc 35.000 35.000
Mạch cầu H L298N Dual H-Bridge 2A, tản nhiệt nhôm 01 bo 45.000 45.000
Động cơ DC giảm tốc TT Tỉ số 1:48, 6VDC, kèm bánh xe cao su 02 bộ 25.000 50.000
Pin sạc Li-ion 18650 $3.7\text{ V}, 2600\text{ mAh}$, dòng xả $5\text{C}$ 03 cell 45.000 135.000
Khay pin 3S + Mạch sạc xả BMS Bảo vệ ngắn mạch, xả quá mức 01 bộ 30.000 30.000
Khung xe Mica 3 tầng + Trụ đồng Gia công cắt Laser, ốc vít M3 01 bộ 85.000 85.000
Tổng chi phí chế tạo (BOM) (Chưa bao gồm nhân công) 500.000 VND

Hướng dẫn triển khai và vận hành nhanh

  1. Bước 1 (Đấu nối phần cứng): Kết nối chân $SDA \to A4$, $SCL \to A5$ của MPU-6050 vào Arduino; Chân $IN1, IN2, IN3, IN4$ của L298N vào chân Digital $5, 6, 9, 10$ (hỗ trợ PWM); Chân cấp nguồn $11.1\text{V}$ vào cổng $+12\text{V}$ L298N.
  2. Bước 2 (Hiệu chuẩn tĩnh - Sensor Calibration): Giữ xe cố định trên giá cân bằng, nạp code đọc giá trị Offset của MPU-6050 trong 500 chu kỳ lấy mẫu để tìm sai số tĩnh ($Acc_{offset}, Gyro_{offset}$).
  3. Bước 3 (Tinh chỉnh hệ số PID thực nghiệm):
    • Đặt $K_i = 0, K_d = 0$, tăng dần $K_p$ cho đến khi xe bắt đầu dao động cân bằng nhẹ quanh điểm $0^\circ$.
    • Tăng dần $K_d$ để dập tắt dao động và tăng độ cứng phản hồi khi có ngoại lực đẩy.
    • Tăng nhẹ $K_i$ để triệt tiêu hoàn toàn sai số tĩnh, đưa xe đứng thẳng tuyệt đối.

Hạn chế và hướng phát triển

Hạn chế kỹ thuật hiện tại

  • Động cơ DC TT có độ rơ cơ khí (Backlash): Các bánh răng nhựa của hộp giảm tốc tồn tại độ trễ chuyển động khoảng $3^\circ - 5^\circ$ khi đổi chiều quay đột ngột.
  • Thiếu encoder phản hồi vị trí: Hệ thống mới chỉ cân bằng góc ($\theta \to 0$) nhưng chưa khóa được vị trí tọa độ ($x \to 0$), dẫn đến hiện tượng xe bị trôi dần khi gặp mặt sàn nghiêng nhẹ.
  • Tài nguyên vi điều khiển 8-bit: Tần số xung nhịp $16\text{ MHz}$ và bộ nhớ SRAM $2\text{ KB}$ hạn chế khả năng chạy đồng thời các thuật toán điều khiển thích nghi phức tạp.

Hướng nâng cấp và mở rộng

  • Nâng cấp phần cứng: Thay thế động cơ TT bằng động cơ bước (Stepper Motor) hoặc động cơ DC có Encoder quang độ phân giải cao ($334 \text{ CPR}$); chuyển đổi vi điều khiển sang ESP32 ($240 \text{ MHz}$, 32-bit Dual Core, hỗ trợ FreeRTOS và Wi-Fi/Bluetooth).
  • Thuật toán điều khiển nâng cao: Triển khai bộ điều khiển hồi tiếp trạng thái toàn phần (LQR - Linear Quadratic Regulator) kết hợp bộ quan sát trạng thái Kalman (LQG) để kiểm soát đồng thời cả góc nghiêng $\theta$ và vị trí $x$.

Đối tượng hưởng lợi

  • Sinh viên ngành Kỹ thuật Ô tô, Cơ điện tử và Tự động hóa: Tiếp cận tài liệu chuẩn hóa về quy trình thiết kế hệ thống nhúng từ mô hình toán học đến hiện thực hóa mã nguồn $C++$, rút ngắn thời gian làm đồ án từ 3 tháng xuống còn 3 tuần.
  • Kỹ sư và Lập trình viên hệ thống nhúng (Embedded Developers): Tham khảo kiến trúc code tối ưu bộ lọc Kalman rời rạc và thuật toán PID phi tuyến trên các dòng vi điều khiển tài nguyên thấp.
  • Doanh nghiệp vừa và nhỏ / Maker: Bản thiết kế mở với chi phí cực thấp (~$20/sản phẩm) làm cơ sở nghiên cứu và phát triển các robot dịch vụ, robot phục vụ dạy học STEM/STEAM.
  • Nhà nghiên cứu (Researchers): Hệ thống thực nghiệm hoàn chỉnh để thử nghiệm, so sánh độ chính xác giữa mô phỏng MATLAB/Simulink và môi trường vật lý thực tế.

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

1. Yêu cầu hệ thống tối thiểu để nạp và chạy code cho robot là gì?

Máy tính cần cài đặt Arduino IDE (phiên bản v1.8.19 hoặc v2.3.2 trở lên), driver nạp chip nạp CH340 hoặc FTDI, thư viện Wire.h (giao tiếp $I^2C$). Đối với mô phỏng, yêu cầu máy tính chạy hệ điều hành Windows 10/11 hoặc Ubuntu 20.04+, cài đặt MATLAB R2020b trở lên với các toolbox: Simulink, Control System Toolbox.

2. Làm thế nào để triệt tiêu hiện tượng xe bị giật rung liên tục khi ở điểm cân bằng?

Hiện tượng rung giật tần số cao thường do hệ số vi phân $K_d$ quá lớn hoặc nhiễu từ cảm biến chưa được lọc sạch. Giải pháp:

  • Giảm nhẹ hệ số $K_d$ theo bước $0.1$.
  • Tăng giá trị hiệp phương sai đo lường $R_{measure}$ trong bộ lọc Kalman ($0.03 \to 0.05$) để làm mượt tín hiệu đầu ra.
  • Thiết lập một vùng chết nhỏ (Deadband: $|\theta| < 0.2^\circ \implies PWM = 0$) trong mã nguồn điều khiển động cơ.

3. Tại sao không sử dụng bộ lọc bù (Complementary Filter) mà phải dùng bộ lọc Kalman?

Bộ lọc bù sử dụng tỉ lệ cố định ($\alpha \approx 0.95 - 0.98$), không thích ứng được khi hệ thống chịu gia tốc phi trọng trường đột ngột (ví dụ khi xe tăng tốc mạnh hoặc va đập). Bộ lọc Kalman liên tục cập nhật ma trận hiệp phương sai sai số $P_k$, giúp tối ưu hóa trọng số ước lượng theo thời gian thực, giảm sai số ước lượng góc đến $40%$ trong điều kiện động.

4. Nguồn pin 3S 11.1V có làm cháy Arduino Uno (chịu điện áp 5V) không?

Không, nếu được đấu nối chính xác: Nguồn $11.1\text{V}$ từ pin được cấp trực tiếp vào chân $V_{in}$ của L298N để nuôi động cơ. Arduino Uno được cấp nguồn thông qua cổng Jack DC ($7 - 12\text{ V}$) hoặc sử dụng cổng xuất nguồn logic $5\text{V}$ tích hợp từ IC ổn áp $78M05$ trên mạch L298N đưa vào chân $5\text{V}$ của Arduino.

5. Làm sao để mở rộng robot tự di chuyển tránh vật cản?

Có thể tích hợp thêm 01 cảm biến siêu âm HC-SR04 ở mặt trước xe. Khi phát hiện vật cản ở khoảng cách $d < 20 \text{ cm}$, vi điều khiển sẽ thay đổi điểm đặt góc nghiêng: $\text{SetPoint} = +2.0^\circ$ để robot tự động lùi lại, hoặc cấp lệch PWM giữa hai bánh ($PWM_{Left} > PWM_{Right}$) để xe tự động quay đầu chuyển hướng.

Kết luận

Dự án "Thiết kế, mô phỏng và chế tạo xe hai bánh tự cân bằng sử dụng bộ điều khiển PID" do nhóm sinh viên Khoa Cơ khí Động lực - Trường Đại học Sư phạm Kỹ thuật TP.HCM thực hiện đã giải quyết bài toán điều khiển phi tuyến của mô hình con lắc ngược. Bằng sự kết hợp giữa mô hình hóa giải tích trên MATLAB/Simulink, thuật toán lọc Kalman rời rạc và mạch điều khiển nhúng Arduino Uno R3, hệ thống đạt độ ổn định cao với thời gian xác lập dưới $0.68 \text{ s}$ và sai số góc tĩnh duy trì trong ngưỡng $\pm 0.85^\circ$.

Thành công của đề tài không chỉ khẳng định tính đúng đắn của lý thuyết điều khiển tự động kinh điển mà còn mở ra hướng nghiên cứu ứng dụng thực tế trong lĩnh vực xe tự hành và robot công nghiệp tự dẫn đường. Bạn có thể tải mã nguồn hoàn chỉnh, sơ đồ nguyên lý mạch điện và mô hình 3D để tự chế tạo phiên bản của riêng mình hoặc tích hợp thêm các công nghệ AI/IoT thế hệ mới.