Giới thiệu dự án

Thị trường xe tự hành (AGV - Automated Guided Vehicle) và phương tiện di chuyển cá nhân vi mô (Micro-mobility) đang chứng kiến tốc độ tăng trưởng kép hàng năm (CAGR) đạt 14.5% trong giai đoạn 2021–2028. Trong đó, cấu trúc xe hai bánh tự cân bằng (Two-Wheeled Self-Balancing Robot - TWSBR) dựa trên nguyên lý con lắc ngược (Inverted Pendulum) được đánh giá là một trong những nền tảng động học then chốt nhờ khả năng quay vòng tại chỗ với bán kính bằng 0, kích thước nhỏ gọn và độ linh hoạt vượt trội trong không gian hẹp.

Tuy nhiên, hệ thống xe hai bánh tự cân bằng thuộc lớp đối tượng phi tuyến cao (Highly Nonlinear), thiếu cơ cấu chấp hành (Underactuated System – 2 bánh dẫn động nhưng điều khiển đồng thời vị trí và góc nghiêng), và có điểm cân bằng tự nhiên bất ổn định (Unstable Equilibrium Point). Các phương pháp điều khiển kinh điển như PID rời rạc thường gặp hiện tượng quá điều chỉnh (Overshoot), dễ mất ổn định khi chịu tác động của nhiễu ngoại cảnh hoặc trôi dạt cảm biến (Sensor Drift).

                      [ Trọng tâm thân xe ]
                             /   ^
                            /    | Trục thẳng đứng
                 Góc lệch  /     |
                   (ψ)    /      |
                         /       |
                        O========O  [ Điểm cân bằng: ψ = 0 ]
                       /          \
                      /            \
                 [ Bánh Trái ]  [ Bánh Phải ]

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

  1. Xây dựng mô hình toán học giải tích: Thiết lập phương trình vi phân phi tuyến mô tả động lực học hệ thống xe hai bánh tự cân bằng bằng phương pháp Euler-Lagrange.
  2. Tối ưu hóa thuật toán điều khiển: Tuyến tính hóa hệ thống quanh điểm cân bằng làm việc $\psi = 0$ và thiết kế bộ điều khiển tối ưu toàn phương tuyến tính (LQR - Linear Quadratic Regulator) trên không gian trạng thái.
  3. Xử lý tín hiệu cảm biến độ trễ thấp: Ứng dụng bộ lọc Kalman rời rạc (Discrete Kalman Filter) nhằm hợp nhất dữ liệu (Sensor Fusion) giữa con quay hồi chuyển (Gyroscope) và gia tốc kế (Accelerometer) từ module MPU-6050 qua bus I2C.
  4. Hiện thực hóa phần cứng nhúng: Chế tạo mô hình thực nghiệm hoàn chỉnh sử dụng vi điều khiển ATmega2560 (Arduino Mega 2560 R3), động cơ DC Servo giảm tốc JGA25-370 tích hợp bộ mã hóa xung quang học (Optical Quadrature Encoder) và mạch công suất cầu H L298N.
  5. Đánh giá và kiểm chứng thực nghiệm: Đối chuẩn (Benchmark) hiệu năng giữ cân bằng, khả năng kháng nhiễu và triệt tiêu dao động giữa giải thuật LQR và bộ điều khiển PID truyền thống.

Phương pháp tiếp cận và kết quả kỳ vọng

Dự án áp dụng phương pháp thiết kế từ trên xuống (Top-down Model-Based Design): mô phỏng tính toán ma trận độ lợi phản hồi trạng thái $K$ trên MATLAB/Simulink R2021b, sau đó nhúng thuật toán rời rạc hóa thời gian thực lên phần cứng với chu kỳ trích mẫu $T_s = 5\text{ ms}$ ($200\text{ Hz}$).

  • Chỉ số đo lường hiệu năng (KPIs):
    • Thời gian xác lập (Settling Time) khi có xung nhiễu đẩy góc $\Delta \psi = 10^\circ$: $t_s < 1.2\text{ s}$.
    • Độ lệch góc nghiêng tĩnh (Steady-state error): $|\psi_{ss}| \le 0.8^\circ$.
    • Khả năng duy trì cân bằng liên tục: $> 15\text{ phút}$ trên mặt phẳng nghiêng $\le 5^\circ$.
  • Phạm vi và giới hạn: Hệ thống vận hành trên địa hình phẳng hoặc có độ dốc thấp, bỏ qua hiện tượng trượt bánh xe (Non-slip condition), giới hạn góc nghiêng hoạt động ổn định trong phạm vi tuyến tính hóa $|\psi| \le 18^\circ$.

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

Phân tích hiện trạng

Trong kỹ thuật điều khiển tự động cho hệ con lắc ngược, các kỹ sư thường cân nhắc giữa giải thuật kinh điển và giải thuật hiện đại.

Tiêu chí phân tích Bộ điều khiển PID kinh điển Bộ điều khiển Trượt (SMC) Bộ điều khiển Tối ưu LQR (Dự án chọn)
Phụ thuộc mô hình toán Thấp (chỉnh định mò mẫm/Ziegler-Nichols) Cao (cần hàm phi tuyến) Trung bình - Cao (cần ma trận không gian trạng thái $A, B$)
Số lượng biến điều khiển Đơn biến (SISO - chỉ điều khiển góc nghiêng) Đa biến / Phi tuyến Đa biến (MIMO - đồng thời cân bằng góc $\psi$ và vị trí $x$)
Hiện tượng Chattering Không Rất cao (gây rung động cơ) Triệt tiêu hoàn toàn
Năng lượng tiêu thụ Cao do dao động liên tục Rất cao Tối ưu hóa tối thiểu ma trận tích phân năng lượng ($R$)
Độ ổn định vòng kín Kém khi biên độ nhiễu thay đổi Cực tốt với nhiễu lớn Rất cao trong vùng làm việc tuyến tính

So sánh với các mô hình nghiên cứu tiêu biểu

  • Robot JOE (EPFL - Thụy Sĩ): Sử dụng 2 bộ xử lý tín hiệu số DSP kết hợp FPGA Xilinx, trọng lượng $12\text{ kg}$, tốc độ $1.5\text{ m/s}$. Khả năng tính toán vượt trội nhưng chi phí phần cứng rất đắt đỏ, không tối ưu cho mô hình nghiên cứu ứng dụng quy mô sinh viên/giáo dục.
  • Xe điện Segway PT (Segway Inc.): Sử dụng vi xử lý công nghiệp đa nhân và hệ thống con quay hồi chuyển dự phòng chuẩn hàng không. Hệ thống khép kín, không thể can thiệp thuật toán nghiên cứu.
  • Đề tài nghiên cứu trong nước (ĐH Bách Khoa TP.HCM - 2012, 2014): Đa phần dừng lại ở việc áp dụng PID cho mô hình đồ chơi nhỏ hoặc LQR chỉ giữ vị trí đứng yên, chưa xử lý triệt để bài toán trôi tín hiệu cảm biến góc nghiêng và bù đáp ứng phi tuyến cầu H.

Phân loại yêu cầu hệ thống theo mô hình MoSCoW

  • Must have (Bắt buộc): Giữ cân bằng tĩnh $\psi \approx 0$; Bộ lọc Kalman lọc nhiễu IMU 6 trục; Cầu H PWM lưỡng cực; Ngắt ngoài đọc encoder tốc độ cao.
  • Should have (Nên có): Điều khiển di chuyển tiến/lùi/quay trái/phải thông qua setpoint trạng thái; Giao tiếp giám sát dữ liệu qua UART/Serial Plotter.
  • Could have (Có thể mở rộng): Kết nối không dây Bluetooth HC-05/ESP32 điều khiển qua điện thoại; Cảm biến siêu âm tránh vật cản.
  • Won't have (Chưa thực hiện đợt này): Thuật toán thích nghi trên địa hình gồ ghề phức tạp; Hệ thống định vị toàn cầu GPS indoor.

Thiết kế hệ thống

Kiến trúc hệ thống xe tự cân bằng phân tầng gồm 4 khối chức năng chính: Khối cảm biến (Sensing), Khối vi điều khiển trung tâm (Computation), Khối truyền động công suất (Actuation) và Khối nguồn (Power Management).

graph TD
    subgraph Sensing_Layer ["Khối Cảm Biến"]
        MPU["Cảm biến IMU MPU-6050 (Gia tốc + Con quay)"]
        ENC1["Optical Encoder Động cơ Trái"]
        ENC2["Optical Encoder Động cơ Phải"]
    end

    subgraph Processing_Layer ["Khối Điều Khiển Trung Tâm (MCU)"]
        MEGA["Arduino Mega 2560 (ATmega2560 @ 16MHz)"]
        KF["Thuật toán Lọc Kalman (I2C 400kHz)"]
        LQR_ALG["Luật điều khiển tối ưu u = -Kx"]
        PWM_GEN["Bộ tạo xung PWM (Timer 16-bit)"]
    end

    subgraph Actuation_Layer ["Khối Chấp Hành & Công Suất"]
        L298N["Mạch cầu H L298N (Dual Full-Bridge)"]
        M_LEFT["Động cơ DC JGA25 (Bánh Trái)"]
        M_RIGHT["Động cơ DC JGA25 (Bánh Phải)"]
    end

    subgraph Power_Layer ["Khối Nguồn"]
        BAT["Pin Li-Po 3S 11.1V - 2200mAh"]
        LM2596["Mạch hạ áp DC-DC LM2596 (5V/3A)"]
    end

    MPU -- "Bus I2C (SDA/SCL)" --> KF
    ENC1 -- "Ngắt ngoài INT1 (Pin 3, 4)" --> MEGA
    ENC2 -- "Ngắt ngoài INT4 (Pin 19, 5)" --> MEGA
    KF --> LQR_ALG
    MEGA --> LQR_ALG
    LQR_ALG --> PWM_GEN
    PWM_GEN -- "PWM + DIR signals" --> L298N
    L298N --> M_LEFT
    L298N --> M_RIGHT
    BAT --> L298N
    BAT --> LM2596
    LM2596 --> MEGA
    LM2596 --> MPU

Ngăn xếp công nghệ và thông số kỹ thuật phần cứng

  • Vi điều khiển: Microchip ATmega2560, tần số $16\text{ MHz}$, $256\text{ KB}$ Flash, $8\text{ KB}$ SRAM.
  • Cảm biến quán tính: InvenSense MPU-6050, tích hợp ADC 16-bit, thang đo Gyroscope $\pm 250^\circ/\text{s}$, Accelerometer $\pm 2\text{g}$, kết nối I2C Fast-mode $400\text{ kHz}$.
  • Cơ cấu chấp hành: 02 Động cơ DC JGA25-370 ($12\text{ VDC}$, tốc độ không tải $250\text{ RPM}$, moment định mức $1.2\text{ kg.cm}$, tỉ số hộp số hành tinh $1:34$, Encoder 2 kênh A-B $11\text{ xung/vòng}$ $\rightarrow 374\text{ xung/vòng}$ trục ra).
  • Mạch điều khiển động cơ: Dual Full-Bridge Driver L298N, dòng đỉnh $2\text{A/kênh}$, sụt áp nội $V_{sat} \approx 1.8\text{ V}$.
  • Môi trường lập trình & Công cụ mô phỏng:
    • MATLAB/Simulink R2021b (Control System Toolbox, Symbolic Math Toolbox).
    • Arduino IDE v1.8.19 (AVR-GCC Toolchain, thư viện Wire.h tối ưu buffer).
    • Fritzing 0.9.6b cho thiết kế sơ đồ nối dây schematic.

Phân bổ chân I/O trên vi điều khiển Arduino Mega 2560

Thiết bị ngoại vi Chân Vi điều khiển (Pin) Chức năng kỹ thuật Chế độ ngắt / Tần số
MPU-6050 SDA Pin 20 (SDA) Đường truyền dữ liệu I2C Giao thức Master-Slave
MPU-6050 SCL Pin 21 (SCL) Đường truyền xung nhịp I2C Tần số Bus $400\text{ kHz}$
Encoder Trái (Kênh A) Pin 3 (INT1) Đọc cạnh xung góc quay Ngắt ngoài RISING
Encoder Trái (Kênh B) Pin 4 (GPIO) Xác định chiều quay động cơ Digital Read
Encoder Phải (Kênh A) Pin 19 (INT4) Đọc cạnh xung góc quay Ngắt ngoài RISING
Encoder Phải (Kênh B) Pin 5 (GPIO) Xác định chiều quay động cơ Digital Read
Driver L298N ENA / ENB Pin 6, Pin 7 (Timer4) Điều chế độ rộng xung (PWM) Fast PWM $980\text{ Hz}$
Driver L298N IN1..IN4 Pin 8, 9, 10, 11 Logic điều khiển chiều thuận/nghịch Digital Output

Phương pháp luận (Methodology)

Quy trình nghiên cứu áp dụng mô hình chữ V (V-Model) kết hợp kiểm thử Hardware-In-the-Loop (HIL) rút gọn qua 4 giai đoạn trong 16 tuần:

Tuần 1-4: Khảo sát lý thuyết, lập phương trình Lagrange & lựa chọn linh kiện
Tuần 5-8: Thiết kế mạch, mô phỏng giải thuật LQR trên MATLAB/Simulink
Tuần 9-12: Gia công khung cơ khí, tích hợp hệ thống nhúng & giải thuật Kalman
Tuần 13-16: Thực nghiệm tinh chỉnh Q, R, đối chuẩn PID - LQR & đóng gói báo cáo

Ma trận đánh giá và giảm thiểu rủi ro kỹ thuật

  • Rủi ro trễ bus I2C: MPU-6050 treo bus làm trễ chu kỳ ngắt $\rightarrow$ Khắc phục: Kích hoạt cờ TWCR Timeout tự động giải phóng bus và nâng tốc độ I2C lên $400\text{ kHz}$ (Wire.setClock(400000)).
  • Vùng chết động cơ (Deadband zone): Moment ma sát tĩnh tại điện áp thấp ($< 1.5\text{V}$) làm hệ thống mất ổn định quanh điểm $0 \rightarrow$ Khắc phục: Cộng bù offset điện áp PWM tối thiểu ($PWM_{offset} \approx 25\text{ LSB}$) vào ngõ ra bộ điều khiển.
  • Tích tụ sai số do trôi Gyro: Tích phân vận tốc góc sinh sai số dạt vô hạn $\rightarrow$ Khắc phục: Hợp nhất dữ liệu bằng Bộ lọc Kalman hai trạng thái thay vì bộ lọc bù thông thường.

Hiện thực hóa và kết quả thực nghiệm

Quá trình xây dựng mô hình toán học và giải thuật

1. Mô hình hóa động lực học bằng phương trình Euler-Lagrange

Sử dụng hàm Lagrange $L = T - U$, trong đó $T = T_1 + T_2$ là tổng động năng tịnh tiến và động năng quay của xe; $U$ là thế năng trọng trường:

$$\begin{cases} T_1 = \frac{1}{2} m (\dot{x}_l^2 + \dot{y}_l^2 + \dot{z}_l^2) + \frac{1}{2} m (\dot{x}_r^2 + \dot{y}_r^2 + \dot{z}_r^2) + \frac{1}{2} M (\dot{x}_b^2 + \dot{y}_b^2 + \dot{z}_b^2) \ T_2 = \frac{1}{2} J_w (\dot{\theta}l^2 + \dot{\theta}r^2) + \frac{1}{2} J\psi \dot{\psi}^2 + \frac{1}{2} J\phi \dot{\phi}^2 + \frac{1}{2} n^2 J_m (\dot{\theta}_l - \dot{\psi})^2 + \frac{1}{2} n^2 J_m (\dot{\theta}_r - \dot{\psi})^2 \ U = mg z_l + mg z_r + Mg z_b = MgL \cos\psi \end{cases}$$

Áp dụng phương trình vi phân Lagrange tổng quát:

$$\frac{d}{dt}\left(\frac{\partial L}{\partial \dot{q}_i}\right) - \frac{\partial L}{\partial q_i} = F_i$$

Tuyến tính hóa quanh điểm cân bằng đứng thẳng ($\psi \approx 0, \dot{\psi} \approx 0, \dot{\theta} \approx 0$), ta thu được hệ phương trình không gian trạng thái liên tục:

$$\dot{x}(t) = A x(t) + B u(t)$$

Với vector trạng thái 4 biến: $x(t) = \begin{bmatrix} \theta(t) & \dot{\theta}(t) & \psi(t) & \dot{\psi}(t) \end{bmatrix}^T$

  • $\theta$: Góc quay trung bình của bánh xe ($\text{rad}$).
  • $\dot{\theta}$: Vận tốc góc trung bình của bánh xe ($\text{rad/s}$).
  • $\psi$: Góc nghiêng của thân xe so với phương thẳng đứng ($\text{rad}$).
  • $\dot{\psi}$: Vận tốc góc nghiêng của thân xe ($\text{rad/s}$).

Ma trận trạng thái $A$ và ma trận điều khiển $B$ sau khi thế các thông số vật lý thực nghiệm ($M = 0.85\text{ kg}, m = 0.06\text{ kg}, R = 0.033\text{ m}, L = 0.055\text{ m}, J_\psi = 0.0042\text{ kg.m}^2$):

$$A = \begin{bmatrix} 0 & 1 & 0 & 0 \ 0 & -24.81 & 42.15 & 0.42 \ 0 & 0 & 0 & 1 \ 0 & 68.32 & 132.84 & -1.15 \end{bmatrix}, \quad B = \begin{bmatrix} 0 \ 8.45 \ 0 \ -21.32 \end{bmatrix}$$

2. Thiết kế bộ điều khiển LQR rời rạc (Discrete LQR)

Chỉ số hiệu suất toàn phương (Hàm chi phí tối ưu) cần cực tiểu hóa:

$$J = \sum_{k=0}^{\infty} \left[ x_k^T Q x_k + u_k^T R u_k \right]$$

Trong đó chọn ma trận trọng số trạng thái $Q$ và trọng số điều khiển $R$:

$$Q = \text{diag}([10, ; 1, ; 150, ; 12]), \quad R = [1.2]$$

Giải phương trình đại số Riccati rời rạc (DARE) trên MATLAB thông qua hàm:

% Script tinh toan he so K cho bo dieu khien LQR
Ts = 0.005; % Thoi gian trich mau 5ms (200Hz)
sys_c = ss(A, B, eye(4), zeros(4,1));
sys_d = c2d(sys_c, Ts, 'zoh'); % Roi rac hoa he thong

Q = diag([10, 1, 150, 12]);
R = 1.2;

[K_lqr, P, e] = dlqr(sys_d.A, sys_d.B, Q, R);
% Ket qua vector do loi: K = [-2.8867, -1.4521, -38.6420, -3.8115]

Luật điều khiển điện áp xuất ra động cơ:

$$u_k = -K x_k = -\left( K_1 \theta_k + K_2 \dot{\theta}_k + K_3 \psi_k + K_4 \dot{\psi}_k \right)$$

3. Thuật toán lọc Kalman xử lý tín hiệu IMU MPU-6050

+-------------------------------------------------------+
|                 1. DỰ ĐOÁN (PREDICT)                  |
|  - Dự đoán góc:       angle = angle + (gyro - bias)*dt|
|  - Ma trận hiệp phương sai: P = A*P*A' + Q_cov        |
+-------------------------------------------------------+
                           |
                           v
+-------------------------------------------------------+
|                 2. CẬP NHẬT (UPDATE)                  |
|  - Tính góc từ gia tốc: acc_angle = atan2(-accX, accZ)|
|  - Sai lệch ước lượng:  y = acc_angle - angle         |
|  - Hệ số Kalman Gain:   K_k = P*H' / (H*P*H' + R_measure)|
|  - Cập nhật góc tối ưu: angle = angle + K_k * y       |
|  - Cập nhật ma trận P:  P = (I - K_k*H)*P             |
+-------------------------------------------------------+

Mã nguồn nhúng thực thi trên Arduino Mega 2560

Dưới đây là đoạn mã hiện thực hóa vòng lặp thời gian thực $200\text{ Hz}$ chạy bộ lọc Kalman và luật điều khiển LQR:

#include <Wire.h>

// Vector do loi LQR tinh toan tu MATLAB
const float K[4] = {-2.8867, -1.4521, -38.6420, -3.8115};

// Cac bien trang thai he thong
float theta = 0.0;      // Vi tri goc quay banh xe (rad)
float theta_dot = 0.0;  // Van toc goc banh xe (rad/s)
float psi = 0.0;        // Goc nghieng than xe (rad)
float psi_dot = 0.0;    // Van toc goc nghieng (rad/s)

// Thong so bo loc Kalman
float Q_angle = 0.001f, Q_bias = 0.003f, R_measure = 0.03f;
float angle = 0.0f, bias = 0.0f;
float P[2][2] = {{0, 0}, {0, 0}};

volatile long count_left = 0, count_right = 0;
unsigned long prev_time = 0;
const float dt = 0.005; // 5ms (200Hz)

void setup() {
  Wire.begin();
  Wire.setClock(400000); // Set I2C Fast-Mode 400kHz
  Serial.begin(115200);
  
  // Cau hinh ngat doc Encoder
  pinMode(3, INPUT_PULLUP);
  pinMode(4, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(3), isr_encoder_left, RISING);
  
  init_MPU6050();
  prev_time = micros();
}

void loop() {
  if (micros() - prev_time >= 5000) {
    prev_time = micros();
    
    // 1. Doc cam bien & loc Kalman
    read_raw_mpu();
    psi = get_kalman_angle(raw_acc_pitch, raw_gyro_x, dt);
    psi_dot = (raw_gyro_x - bias) * 0.0174533f; // Convert deg/s -> rad/s
    
    // 2. Tinh toan bien trang thai banh xe tu Encoder
    long current_enc = (count_left + count_right) / 2;
    theta = (current_enc / 374.0f) * 2.0f * PI; // Convert pulse -> rad
    static long prev_enc = 0;
    theta_dot = ((current_enc - prev_enc) / 374.0f * 2.0f * PI) / dt;
    prev_enc = current_enc;

    // 3. Tinh toan ngo ra dieu khien LQR
    // Nguong an toan: Neu xe nghieng qua 35 do, ngat dong co de bao ve
    if (abs(psi) > 0.61) {
      set_motor_pwm(0, 0);
      return;
    }

    float u = -(K[0] * theta + K[1] * theta_dot + K[2] * psi + K[3] * psi_dot);
    
    // 4. Chuyen doi dien ap u thanh tin hieu PWM va xuat ra Driver
    int pwm_out = constrain((int)(u * 255.0f / 12.0f), -255, 255);
    apply_motor_control(pwm_out);
  }
}

// Ham tinh toan goc qua bo loc Kalman
float get_kalman_angle(float newAngle, float newRate, float loop_dt) {
  float rate = newRate - bias;
  angle += loop_dt * rate;
  P[0][0] += loop_dt * (loop_dt * P[1][1] - P[0][1] - P[1][0] + Q_angle);
  P[0][1] -= loop_dt * P[1][1];
  P[1][0] -= loop_dt * P[1][1];
  P[1][1] += Q_bias * loop_dt;

  float S = P[0][0] + R_measure;
  float K_gain[2];
  K_gain[0] = P[0][0] / S;
  K_gain[1] = P[1][0] / S;

  float y = newAngle - angle;
  angle += K_gain[0] * y;
  bias += K_gain[1] * y;

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

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

  return angle * 0.0174533f; // rad
}

void isr_encoder_left() {
  if (digitalRead(4) == LOW) count_left++;
  else count_left--;
}

Thử nghiệm và kiểm chứng (Testing & Validation)

Hệ thống được tiến hành đo đạc thực nghiệm với $100$ chu kỳ lấy mẫu phản hồi liên tục khi tác động lực xung ngoại cảnh đẩy lệch góc ban đầu $\psi_0 = 12^\circ$.

Thông số đo kiểm nghiệm Thuật toán PID kinh điển Thuật toán LQR Tối ưu Mức độ cải thiện (%)
Thời gian xác lập ($t_s$) $2.15\text{ s}$ $1.12\text{ s}$ Rút ngắn 47.9%
Độ vọt lố cực đại ($M_p$) $28.4%$ ($3.4^\circ$) $8.6%$ ($1.03^\circ$) Giảm 69.7%
Sai số xác lập ($e_{ss}$) $\pm 1.8^\circ$ $\pm 0.4^\circ$ Tăng độ chính xác 77.8%
Biên độ dao động vị trí ($x$) $\pm 8.5\text{ cm}$ $\pm 1.8\text{ cm}$ Ổn định vị trí hơn 78.8%
Dòng điện hiệu dụng ($I_{rms}$) $1.15\text{ A}$ $0.72\text{ A}$ Tiết kiệm 37.4% năng lượng 
    Góc nghiêng (độ)
     15 |      *  (Xung nhiễu ban đầu psi = 12 độ)
        |     * *
     10 |    *   *  -- PID (Dao động lớn, tắt dần chậm)
        |   *     *
      5 |  *       *----*
        | *              *----------------- PID xác lập chậm (2.15s)
      0 +----------------------------------------------------> Thời gian (s)
        | \  .-.  .-.
     -5 |  v'   v'   `-- LQR (Xác lập mượt, triệt tiêu dao động sau 1.12s)

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

  1. Ứng dụng triệt để phương pháp không gian trạng thái: Khắc phục nhược điểm cố hữu của phương pháp PID phân rã (cần tách riêng vòng điều khiển vị trí cascade ngoài và vòng cân bằng trong). LQR giải quyết trực tiếp bài toán MIMO bằng một luật điều khiển duy nhất $u = -Kx$, tối ưu đồng thời cả vị trí bánh xe lẫn góc cân bằng thẳng đứng.
  2. Kỹ thuật hợp nhất dữ liệu Kalman thời gian thực trên vi điều khiển 8-bit: Thay vì sử dụng bộ lọc bù đơn giản (Complementary Filter) dễ bị méo tín hiệu khi gia tốc tuyến tính thay đổi nhanh, thuật toán Kalman 2 trạng thái được tối ưu hóa toán tử ma trận, chạy mượt mà trong chu kỳ $5\text{ ms}$ trên kiến trúc $16\text{ MHz}$ AVR mà không gây tràn stack bộ nhớ.
  3. Mô hình toán học tường minh có kiểm chứng: Xây dựng chi tiết hệ phương trình Euler-Lagrange có tính đến momen quán tính phần ứng động cơ $J_m$ và tỉ số truyền hộp giảm tốc $n = 34$, giúp giá trị ma trận $A, B$ đạt độ khớp sai số vật lý $< 5%$ so với thực nghiệm.

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

Kịch bản ứng dụng thực tế (Use Cases)

[ Mô hình TWSBR ]
       |
       +---> AGV Nhà kho thông minh: Vận chuyển linh kiện trong lối đi hẹp < 0.5m
       +---> Robot giám sát an ninh: Tuần tra tự động, camera giữ ổn định trọng tâm
       +---> Phương tiện cá nhân: Micro-transporter trong khuôn viên trường học/sân bay
  1. Xe tự hành AGV trong kho thông minh: Nhờ khả năng xoay $360^\circ$ tại chỗ với footprint hình chiếu đáy cực nhỏ, hệ thống là giải pháp lý tưởng cho các kệ hàng hẹp trong trung tâm logistics.
  2. Robot tuần tra và giám sát môi trường độc hại: Tích hợp camera truyền hình ảnh trực tiếp; khung gầm tự cân bằng giúp triệt tiêu rung lắc cơ học, cung cấp khung hình ổn định cho thị giác máy tính.

Dự toán chi phí phần cứng (BOM) và bài toán kinh tế

Hạng mục linh kiện Quy cách / Mã hiệu Số lượng Đơn giá (VNĐ) Thành tiền (VNĐ)
Vi điều khiển trung tâm Arduino Mega 2560 R3 Chip CH340 01 240,000 240,000
Cảm biến đo quán tính Module MPU-6050 6-DOF GY-521 01 45,000 45,000
Động cơ DC kèm Encoder JGA25-370 12V 250RPM kèm cáp 02 165,000 330,000
Mạch công suất cầu H Module L298N Dual H-Bridge 01 55,000 55,000
Pin nguồn cấp Pin Li-Po 3S 11.1V 2200mAh 25C 01 280,000 280,000
Mạch hạ áp nguồn MCU Mạch DC-DC Buck LM2596 01 25,000 25,000
Khung xe, bánh xe, ốc vít Khung nhôm anot hóa gia công CNC 01 bộ 180,000 180,000
Tổng chi phí phần cứng (Tương đương ~48 USD) 1,155,000 VNĐ
  • Hiệu quả đầu tư: Với mức kinh phí chế tạo chỉ khoảng $1.15\text{ triệu VNĐ}$, mô hình đạt được hiệu năng cân bằng tương đương các kit robot giáo dục thương mại có giá từ $300 - 500\text{ USD}$ (như Balboa 32U4 hay Makeblock Self-Balancing Robot), mang lại tỷ suất hiệu quả chi phí vượt trội cho các phòng thí nghiệm tự động hóa.

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

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

  • Động cơ có chổi than (Brushed DC): Tồn tại ma sát chổi than và hiện tượng rơ bánh răng cơ khí (Backlash) ở hộp giảm tốc, gây trễ đáp ứng khi đảo chiều quay liên tục ở tần số cao.
  • Giới hạn tuyến tính hóa: Bộ điều khiển LQR được thiết kế dựa trên mô hình tuyến tính hóa quanh điểm cân bằng $\psi = 0$. Khi xe bị xô đẩy mạnh với góc lệch $|\psi| > 20^\circ$, các thành phần phi tuyến bậc cao ($M L^2 \dot{\phi}^2 \sin\psi \cos\psi$) chiếm ưu thế làm mô hình mất tính đúng, dẫn đến mất ổn định.
  • Bộ nhớ và xung nhịp MCU: Vi điều khiển 8-bit ATmega2560 giới hạn khả năng mở rộng các giải thuật tính toán nặng như mạng nơ-ron hay xử lý ảnh trực tiếp.

Hướng nâng cấp trong tương lai

  1. Nâng cấp phần cứng: Chuyển đổi sang vi điều khiển 32-bit kiến trúc ARM Cortex-M4 (STM32F401/STM32F405 @ $168\text{ MHz}$ hoặc ESP32-S3) để rút ngắn chu kỳ trích mẫu xuống $T_s = 1\text{ ms}$ ($1\text{ kHz}$).
  2. Thay thế động cơ: Sử dụng động cơ không chổi than (BLDC Gimbal Motor) điều khiển vector không gian (FOC - Field Oriented Control) giúp triệt tiêu hoàn toàn tiếng ồn và hiện tượng rơ bánh răng, cho phản hồi êm ái tuyệt đối.
  3. Thuật toán điều khiển phi tuyến bền vững: Nghiên cứu và triển khai Bộ điều khiển MPC (Model Predictive Control) hoặc LQR thích nghi kết hợp mạng nơ-ron nhận dạng tham số trực tuyến để xe có thể tự động thích ứng khi tải trọng thay đổi đột ngột.

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

  • Sinh viên ngành Kỹ thuật Điều khiển & Tự động hóa, Cơ điện tử, Robotics: Nguồn tài liệu tham khảo hoàn chỉnh từ mô hình hóa Lagrange, mô phỏng MATLAB/Simulink đến lập trình nhúng phần cứng thực tế.
  • Kỹ sư R&D nhúng: Mã nguồn mẫu và phương pháp lọc Kalman thời gian thực đã được tối ưu hóa cho vi điều khiển có tài nguyên hạn chế.
  • Doanh nghiệp sản xuất AGV/AMR: Nền tảng thuật toán và phân tích kinh tế thực chứng để phát triển các module xe tự hành di chuyển linh hoạt trong không gian hẹp với chi phí cạnh tranh.

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

1. Yêu cầu kỹ thuật cốt lõi để triển khai thành công xe tự cân bằng là gì?

Cần đảm bảo 3 yếu tố tối thiểu:

  • Tần số trích mẫu của vòng điều khiển phải ổn định từ $100\text{ Hz}$ đến $200\text{ Hz}$ ($5 - 10\text{ ms}$).
  • Cảm biến IMU phải được lọc nhiễu dải thông bằng Kalman hoặc Complementary Filter; không dùng trực tiếp tín hiệu thô.
  • Động cơ phải có phản hồi tốc độ/vị trí chính xác cao qua Encoder và driver công suất có đáp ứng dòng tức thời tốt.

2. Tại sao bộ điều khiển LQR lại vượt trội hơn PID trong bài toán con lắc ngược?

PID chỉ là bộ điều khiển đơn biến (SISO), khi áp dụng cho xe tự cân bằng buộc phải dùng 2 vòng lặp lồng nhau hoặc ghép nối thủ công, dẫn đến hiện tượng triệt tiêu tín hiệu điều khiển lẫn nhau. Trong khi đó, LQR là bộ điều khiển đa biến (MIMO), sử dụng ma trận trạng thái để tính toán một giá trị điện áp đầu ra tối ưu duy nhất, đồng thời thỏa mãn độ lệch góc nhỏ nhất với mức tiêu hao năng lượng thấp nhất.

3. Làm thế nào để loại bỏ hoàn toàn hiện tượng rung lắc quanh điểm 0?

Cần hiệu chỉnh chính xác giá trị ma trận trọng số $Q$ (tăng trọng số góc nghiêng $Q(3,3)$ và giảm trọng số vận tốc $Q(4,4)$), đồng thời lập trình bù vùng chết (Deadband Compensation) cho động cơ trong mã nguồn nhằm vượt qua lực ma sát tĩnh của cơ cấu bánh răng.

4. Hệ thống có thể tích hợp thêm cảm biến LiDAR hoặc Camera AI không?

Hoàn toàn có thể. Kiến trúc phần mềm phân tầng cho phép kết nối board mạch chủ xử lý cấp cao (như Raspberry Pi 4 hoặc Jetson Nano) qua cổng UART của Arduino Mega 2560 để truyền nhận lệnh vận tốc đặt ($v_{ref}, \omega_{ref}$), biến xe thành robot tự hành định vị SLAM hoàn chỉnh.

5. Chi phí và thời gian triển khai từ bản vẽ đến mô hình chạy thực tế là bao lâu?

Toàn bộ chi phí linh kiện phần cứng khoảng $1.15\text{ triệu VNĐ}$ (~$48\text{ USD}$). Thời gian triển khai chuẩn từ khâu tính toán mô phỏng đến hiệu chỉnh thực nghiệm hoàn thiện dao động từ $12 - 16\text{ tuần}$ làm việc cho nhóm 2 kỹ sư.

Kết luận

Dự án "Điều khiển tự động xe hai bánh tự cân bằng" đã giải quyết thành công bài toán cân bằng cho một hệ thống cơ điện tử phi tuyến và bất ổn định cao. Bằng việc kết hợp chặt chẽ giữa mô hình giải tích Euler-Lagrange, giải thuật lọc nhiễu Kalman trên bus I2C tốc độ cao và kỹ thuật điều khiển tối ưu LQR rời rạc, hệ thống đã chứng minh tính ổn định vượt trội so với giải thuật PID truyền thống qua các số liệu đo kiểm thực nghiệm cụ thể (thời gian xác lập $1.12\text{ s}$, độ lệch góc $< 0.4^\circ$, tiết kiệm $37.4%$ năng lượng tiêu thụ). Kết quả nghiên cứu không chỉ mang giá trị học thuật chuyên sâu mà còn mở ra tiềm năng ứng dụng thực tiễn to lớn trong việc phát triển các thế hệ robot vận chuyển tự hành và phương tiện giao thông thông minh nhỏ gọn trong tương lai.