Giới thiệu dự án

Công nghệ xe tự hành (Autonomous Vehicles - AV) đang định hình lại tương lai của ngành giao thông vận tải và logistics thông minh. Theo các báo cáo công nghiệp ô tô toàn cầu, hơn 85% các vụ tai nạn giao thông bắt nguồn từ lỗi chủ quan của con người, thúc đẩy sự phát triển cấp thiết của các hệ thống hỗ trợ lái nâng cao (ADAS) và tự hành cấp độ SAE Level 3+. Tuy nhiên, các giải pháp xe tự hành thương mại hiện nay phụ thuộc nặng nề vào cảm biến LiDAR 3D đắt đỏ (chi phí dao động từ 5.000 đến hơn 70.000 USD/cảm biến), tạo ra rào cản tài chính lớn đối với việc mở rộng quy mô trên các phương tiện cỡ nhỏ hoặc robot dịch vụ nội khu.

Đồ án tốt nghiệp chuyên ngành Kỹ thuật Điều khiển và Tự động hóa (Khoa Đào tạo Chất lượng cao, Trường Đại học Sư phạm Kỹ thuật TP.HCM - HCMUTE) của nhóm tác giả Nguyễn Hoàng Hải Nam và Phạm Duy Hưng, dưới sự hướng dẫn của PGS. TS. Lê Mỹ Hà, tập trung giải quyết bài toán cốt lõi: "Thiết kế và hiện thực hóa hệ thống giữ làn đường (Lane Keeping) và điều hướng (Navigation) cho mô hình xe tự hành dựa trên sự kết hợp giữa Camera, GPS và IMU".

                           +------------------------+
                           |   Cảm biến Đầu vào     |
                           | Camera / GPS / IMU 9DoF|
                           +-----------+------------+
                                       |
                                       v
         +-----------------------------------------------------------+
         |              NVIDIA Jetson TX2 (Edge Compute)             |
         |  +-----------------------+     +-----------------------+  |
         |  |   Thị giác máy tính   |     |    Định vị & Lọc EKF  |  |
         |  | BiSeNet (ResNet-18)   |     | Smartphone GPS + IMU  |  |
         |  | Trích xuất tâm làn    |     | Nội suy Waypoint OSM  |  |
         |  +-----------+-----------+     +-----------+-----------+  |
         |              |                             |              |
         |              +-------------->+<------------+              |
         |                              |                            |
         |                              v                            |
         |                +---------------------------+              |
         |                | Flag-based Fusion Control |              |
         |                | Stanley / PID Controller  |              |
         |                +-------------+-------------+              |
         +------------------------------|----------------------------+
                                        |
                                        v
                 +---------------------------------------------+
                 |       Cơ cấu chấp hành & Vi điều khiển      |
                 | Arduino Uno R3 -> PCA9685 -> MG996R / RC540 |
                 +---------------------------------------------+

Vấn đề thực tiễn (Problem Statement)

  1. Hạn chế của phương pháp End-to-End Deep Learning thuần túy: Việc ánh xạ trực tiếp từ ảnh camera sang góc lái khiến hệ thống vận hành như một "hộp đen" (black-box), thiếu tính giải thích, dễ mất ổn định khi môi trường ánh sáng thay đổi và không thể can thiệp bằng các thuật toán điều khiển cổ điển.
  2. Độ trễ tính toán của mạng Semantic Segmentation truyền thống: Các kiến trúc mạng phân đoạn như FCN hay UNet đòi hỏi năng lực phần cứng rất lớn, không thể đạt tốc độ xử lý thời gian thực (Real-time FPS) trên các máy tính nhúng biên giới hạn công suất.
  3. Hiện tượng trôi tín hiệu (Drift & Noise) của cảm biến giá rẻ: Tín hiệu GPS đô thị thường xuyên bị phản xạ đa đường (Multipath) và sai số lớn (bán kính sai lệch 3–5m), trong khi cảm biến IMU bị tích lũy trôi dạt (drift) theo thời gian.

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

  1. Xây dựng nền tảng phần cứng mô hình xe tự hành tỷ lệ 1/10 hoàn chỉnh sử dụng khung gầm RC, máy tính nhúng NVIDIA Jetson TX2 và vi điều khiển Arduino.
  2. Thiết kế và huấn luyện mô hình mạng phân đoạn ảnh ngữ nghĩa thời gian thực BiSeNet (Bilateral Segmentation Network) nhận dạng làn đường, người đi bộ và phương tiện.
  3. Ứng dụng bộ lọc Kalman mở rộng (Extended Kalman Filter - EKF) để hợp nhất dữ liệu vị trí GPS và vận tốc góc/gia tốc từ IMU, triệt tiêu nhiễu ngoài trời.
  4. Xây dựng thuật toán dung hợp (Flag-based Fusion Strategy) giữa bộ điều khiển bám làn quang học và bộ điều khiển điều hướng theo tọa độ điểm (Waypoint Tracking) OpenStreetMap.

Phạm vi và Giới hạn

  • Phạm vi thử nghiệm: Tuyến đường thực nghiệm nội khu khuôn viên Trường ĐH Sư phạm Kỹ thuật TP.HCM (cung đường từ Tòa nhà C sang Tòa nhà F).
  • Giới hạn kỹ thuật: Mô hình hoạt động tối ưu dưới điều kiện thời tiết khô ráo, ban ngày hoặc chiều tối có đèn đường; chưa xử lý tự động trong điều kiện mưa bão lớn hoặc bóng tối hoàn toàn do hạn chế góc nhìn camera đơn (130° FOV).

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

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

Tiêu chí Hệ thống LiDAR SLAM công nghiệp Phương pháp End-to-End CNN Giải pháp Đồ án (BiSeNet + EKF + Sensor Fusion)
Chi phí phần cứng Rất cao (> $10.000 USD) Trung bình ($500 - $1.000 USD) Thấp (< $400 USD, tối ưu cho R&D)
Năng lực giải thích (Explainability) Cao (Dựa trên bản đồ 3D Point Cloud) Rất thấp (Black-box hoàn toàn) Cao (Tách biệt Perception và Control)
Tốc độ xử lý (Real-time FPS) 10 - 20 Hz (Nặng về I/O bus) 30 - 60 FPS 11 - 13 FPS trên Jetson TX2 (360x640)
Độ tin cậy định vị Cực cao trong nhà/Đô thị quét sẵn Phụ thuộc vào đặc trưng hình ảnh Ổn định nhờ EKF dung hợp GPS + IMU
Khả năng can thiệp điều khiển Dễ dàng tích hợp Controller Rất khó can thiệp thủ công Linh hoạt qua cơ chế Flag-based Switching

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

  • Must Have (Bắt buộc):
    • Phân đoạn chính xác mặt đường (Road), người đi bộ (Pedestrian), xe cộ (Car) ở độ phân giải $640 \times 360$.
    • Thuật toán ước lượng góc lái từ tâm hình học của làn đường đã phân đoạn.
    • Lọc nhiễu tọa độ GPS và tính toán Yaw Rate thời gian thực bằng bộ lọc EKF.
    • Khả năng chuyển đổi mượt mà giữa chế độ lái Tự động (Auto Mode) và Thủ công (Manual RC qua DEVO7).
  • Should Have (Nên có):
    • Tự động phát hiện ngã rẽ và giao lộ thông qua bản đồ định tuyến OpenStreetMap (OSM).
    • Tối ưu hóa mô hình AI qua TensorRT/ONNX để đạt tốc độ suy luận $\ge 10$ FPS trên NVIDIA Jetson TX2.
  • Could Have (Có thể mở rộng):
    • Tránh vật cản động bằng mạng phát hiện đối tượng YOLOv4-Tiny.
  • Won't Have (Chưa thực hiện trong phạm vi này):
    • Bản đồ hóa 3D đám mây điểm tầm xa và tự động lập lộ trình tránh tắc đường thời gian thực.

Thiết kế kiến trúc hệ thống

flowchart TD
    subgraph SENSORS ["Khối Cảm Biến"]
        CAM["Camera 130° Wide FOV"]
        GPS["Module GPS (Smartphone Stream)"]
        IMU["IMU 9-DOF (Accelerometer/Gyroscope)"]
    end

    subgraph JETSON ["NVIDIA Jetson TX2 (Main Compute Unit)"]
        subgraph PERCEPTION ["Module Thị Giác"]
            CALIB["Camera Calibration (K, R, t Matrix)"]
            BISENET["BiSeNet Semantic Segmentation\n(Spatial Path + Context Path)"]
            CONTOUR["Edge Detection & Centerline Extraction"]
            CAM_STEER["Lane-Keeping Steering Estimator"]
        end

        subgraph LOCALIZATION ["Module Định Vị & Lộ Trình"]
            OSM["OpenStreetMap Waypoint Interpolator\n(400 -> 4000 Waypoints)"]
            EKF["Extended Kalman Filter (EKF State Estimation)"]
            WAY_STEER["Waypoint-based Lateral Controller (Stanley)"]
        end

        FUSION{"Flag-based Fusion Controller"}
        PID["PID Steering Filter"]
    end

    subgraph ACTUATION ["Khối Chấp Hành & Giao Tiếp"]
        ARDUINO["Arduino Uno R3 (I2C / PWM Master)"]
        PCA["PCA9685 16-Channel PWM Driver"]
        SERVO["MG996R Steering Servo (Ackermann Angle)"]
        ESC["Brushed Motor RC-540 + ESC"]
    end

    CAM --> CALIB --> BISENET --> CONTOUR --> CAM_STEER
    GPS --> EKF
    IMU --> EKF
    OSM --> WAY_STEER
    EKF --> WAY_STEER

    CAM_STEER --> FUSION
    WAY_STEER --> FUSION
    FUSION --> PID --> ARDUINO --> PCA
    PCA --> SERVO
    PCA --> ESC

Danh mục công nghệ và thông số kỹ thuật

  • Nền tảng tính toán biên: NVIDIA Jetson TX2 (Dual-core Denver 2 + Quad-core ARM Cortex-A57, 256-core NVIDIA Pascal GPU, 8GB 128-bit LPDDR4, 59.7 GB/s).
  • Vi điều khiển thứ cấp: Arduino Uno R3 (ATmega328P, 16 MHz, UART/I2C communication).
  • Mạch điều khiển xung: PCA9685 I2C PWM 16-Channel 12-bit Controller.
  • Động cơ & Chấp hành: Động cơ Brushed DC RC-540; Servo kỹ thuật số bánh răng kim loại TowerPro MG996R (lực kéo $11\text{ kg}\cdot\text{cm}$).
  • Framework phần mềm: Python 3.6/3.8, PyTorch 1.8.0, OpenCV 4.5, NumPy, CUDA 10.2, TensorRT.

Implementation và kết quả

Chi tiết các thuật toán then chốt

1. Hiệu chuẩn Camera và Ma trận chiếu phối cảnh (Camera Calibration)

Để triệt tiêu hiện tượng méo góc rộng từ ống kính $130^\circ$, hệ thống sử dụng ma trận thông số nội tại $K$ và ma trận chuyển đổi không gian ngoại tại $[R|t]$:

$$P = K \cdot [R \mid t] = \begin{bmatrix} f_x & \gamma & c_x \ 0 & f_y & c_y \ 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} r_{11} & r_{12} & r_{13} & t_x \ r_{21} & r_{22} & r_{23} & t_y \ r_{31} & r_{32} & r_{33} & t_z \end{bmatrix}$$

Trong đó $f_x, f_y$ là tiêu cự theo trục $x, y$; $c_x, c_y$ là tọa độ tâm quang học; $\gamma$ là hệ số xiên trục.

2. Mạng phân đoạn ảnh BiSeNet (Bilateral Segmentation Network)

BiSeNet giải quyết đồng thời hai bài toán đối nghịch: bảo toàn độ phân giải không gian và mở rộng trường tiếp nhận (Receptive Field):

  • Spatial Path (SP): Gồm 3 tầng tích chập với stride = 2, Batch Normalization và ReLU, trích xuất đặc trưng hình học chi tiết ở kích thước bằng $1/8$ ảnh gốc.
  • Context Path (CP): Sử dụng Backbone ResNet-18 kết hợp Global Average Pooling (GAP) và các khối Attention Refinement Module (ARM) để tinh chỉnh đặc trưng ngữ cảnh toàn cục.
  • Feature Fusion Module (FFM): Hợp nhất đặc trưng không gian từ SP và đặc trưng ngữ cảnh từ CP qua phép cộng kết hợp với trọng số học tập qua tầng $1\times 1$ Convolution.
import numpy as np

def compute_lane_steering_angle(binary_mask, image_height, image_width):
    """
    Trích xuất tâm đường từ mặt nạ phân đoạn và tính toán góc bẻ lái lateral.
    """
    # Lấy vùng quan tâm (ROI) ở nửa dưới ảnh
    roi = binary_mask[int(image_height * 0.6):, :]
    road_pixels = np.where(roi == 1)
    
    if len(road_pixels[1]) == 0:
        return 0.0  # Mất dấu làn đường, duy trì góc lái thẳng
        
    # Tính tọa độ trung bình của làn đường
    mean_x = np.mean(road_pixels[1])
    center_offset = mean_x - (image_width / 2.0)
    
    # Tính góc bẻ lái tỷ lệ với khoảng cách lệch tâm (Normalized Offset)
    norm_offset = center_offset / (image_width / 2.0)
    steering_angle_rad = np.arctan(norm_offset * np.tan(np.radians(25))) # Giới hạn góc max 25 độ
    return float(np.degrees(steering_angle_rad))

3. Bộ lọc Kalman mở rộng (Extended Kalman Filter - EKF)

Hệ thống sử dụng mô hình động học xe đạp (Bicycle Kinematic Model) để dự đoán và cập nhật trạng thái $x_t = [p_x, p_y, \psi, v]^T$ (vị trí x, y, góc hướng mũi xe Yaw, và vận tốc):

$$\bar{x}t = f(x{t-1}, u_{t-1}) + w_t$$

$$K_t = \bar{P}_t H_t^T (H_t \bar{P}_t H_t^T + R)^{-1}$$

$$x_t = \bar{x}_t + K_t (z_t - h(\bar{x}_t))$$

$$P_t = (I - K_t H_t)\bar{P}_t$$

class ExtendedKalmanFilter:
    def __init__(self, dt, std_gps, std_imu):
        self.dt = dt
        self.x = np.zeros((4, 1)) # [px, py, yaw, v]
        self.P = np.eye(4) * 5.0  # Ma trận hiệp phương sai sai số
        self.R = np.diag([std_gps**2, std_gps**2, std_imu**2]) # Nhiễu đo lường
        self.Q = np.eye(4) * 0.1  # Nhiễu quá trình

    def predict(self, accel, yaw_rate):
        yaw = self.x[2, 0]
        v = self.x[3, 0]
        
        # Cập nhật phi tuyến trạng thái theo Kinematic Bicycle Model
        self.x[0, 0] += v * np.cos(yaw) * self.dt
        self.x[1, 0] += v * np.sin(yaw) * self.dt
        self.x[2, 0] += yaw_rate * self.dt
        self.x[3, 0] += accel * self.dt
        
        # Ma trận Jacobian F
        F = np.eye(4)
        F[0, 2] = -v * np.sin(yaw) * self.dt
        F[0, 3] = np.cos(yaw) * self.dt
        F[1, 2] = v * np.cos(yaw) * self.dt
        F[1, 3] = np.sin(yaw) * self.dt
        
        self.P = F @ self.P @ F.T + self.Q

    def update(self, z_measured):
        # z_measured: [gps_x, gps_y, imu_yaw]
        H = np.zeros((3, 4))
        H[0, 0] = 1.0
        H[1, 1] = 1.0
        H[2, 2] = 1.0
        
        y = z_measured - H @ self.x # Innovation
        S = H @ self.P @ H.T + self.R
        K = self.P @ H.T @ np.linalg.inv(S) # Kalman Gain
        
        self.x = self.x + K @ y
        self.P = (np.eye(4) - K @ H) @ self.P

4. Chiến lược dung hợp điều khiển (Flag-based Fusion Strategy)

Hệ thống sử dụng cơ chế chuyển đổi logic: Khi xe di chuyển trên đoạn đường thẳng có làn rõ ràng, bộ điều khiển ưu tiên tín hiệu thị giác từ BiSeNet. Khi xe tiếp cận giao lộ, ngã rẽ phức tạp (được xác định dựa trên khoảng cách tới Waypoint ngã rẽ trên bản đồ OSM) hoặc khi độ tin cậy thị giác giảm sút, cờ điều khiển (flag_navigation) được kích hoạt để chuyển quyền lái sang bộ điều khiển hình học Stanley theo định vị EKF.

def arbitration_controller(cam_angle, ekf_waypoint_angle, is_junction, mIoU_confidence):
    """
    Trọng tài điều khiển dung hợp đa cảm biến
    """
    if is_junction or mIoU_confidence < 0.65:
        # Chế độ điều hướng tọa độ ngã rẽ qua GPS/IMU EKF
        final_steering = ekf_waypoint_angle
        mode = "WAYPOINT_NAVIGATION"
    else:
        # Chế độ bám làn chính xác bằng Camera
        final_steering = cam_angle
        mode = "LANE_KEEPING"
        
    return final_steering, mode

Kết quả thử nghiệm và đánh giá thực nghiệm

  • Tập dữ liệu tùy biến (Custom Dataset): 1.299 ảnh độ phân giải $640 \times 360$ được thu thập thực tế tại khuôn viên HCMUTE trong 3 khung giờ (Sáng, Chiều, Tối) và gán nhãn qua Hasty.ai (3 lớp: Đường, Xe cộ, Người đi bộ).
  • Độ chính xác mô hình BiSeNet (ResNet-18 Backbone):
    • Điểm mIoU (Mean Intersection over Union) đạt 78.4% trên tập kiểm thử sau 200 epochs huấn luyện.
    • Tốc độ suy luận đạt 11 - 13 FPS ổn định trực tiếp trên NVIDIA Jetson TX2 mà không bị hiện tượng sụt khung hình.
  • Nội suy Waypoint OSM: Thuật toán Linear Interpolation đã mở rộng thành công từ 400 điểm mốc thô ban đầu lên 4.000 điểm mốc mịn, đảm bảo bán kính quay vòng mượt mà theo cấu trúc lái Ackermann.
  • Hiệu quả lọc EKF: Sai số góc hướng mũi xe (Yaw Rate Error) so với Ground Truth giảm hơn 62% qua 2.260 bước thời gian (timesteps), triệt tiêu hoàn toàn các bước nhảy đột ngột của GPS ngoại vi.

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

  1. Kiến trúc phân cấp thời gian thực trên phần cứng nhúng công suất thấp: Khác với các nghiên cứu dùng máy tính để bàn (Desktop GPU) cồng kềnh, đồ án đã triển khai trọn vẹn mô hình Deep Learning phức tạp cùng thuật toán lọc trạng thái trên NVIDIA Jetson TX2 với mức tiêu thụ điện năng dưới 15W.
  2. Dung hợp linh hoạt giữa Deep Learning và Điều khiển Cổ điển: Khắc phục nhược điểm mất kiểm soát của mạng End-to-End bằng cách sử dụng BiSeNet làm bộ trích xuất đặc trưng hình học, kết hợp với bộ lọc thông thấp PID và mô hình điều khiển bám vết Stanley.
  3. Giải pháp định vị chi phí thấp (Low-cost Localization Pipeline): Kết hợp bộ lọc EKF với cảm biến trên thiết bị di động truyền thông qua Wi-Fi Socket, giúp giảm hơn 95% chi phí cảm biến so với các hệ thống dẫn đường vi sai RTK-GPS chuyên dụng.

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

+-------------------------------------------------------------------------+
|                  KHẢ NĂNG ỨNG DỤNG THỰC TIỄN CỦA ĐỒ ÁN                  |
+------------------------------------+------------------------------------+
|  Robot Giao Hàng Nội Khu (Last-Mile)|  Xe Điện Tự Hành Khu Du Lịch / Sân Bay|
|  Vận hành trong các khu đô thị     |  Di chuyển theo lộ trình định sẵn  |
|  khép kín, trường đại học, nhà máy.|  trong khuôn viên resort, sân golf.|
+------------------------------------+------------------------------------+
|  Xe Vệ Sinh & Tuần Tra Tự Động     |  Nền Tảng Giáo Dục & Nghiên Cứu R&D|
|  Quét dọn vỉa hè, tuần tra an ninh |  Bộ kit thực hành giá rẻ cho các   |
|  trong các khu công nghiệp tập trung|  trường đại học đào tạo AI / Robotics|
+------------------------------------+------------------------------------+

Lộ trình triển khai thực tế (Roadmap)

  1. Giai đoạn 1 (Đã hoàn thành): Xây dựng hoàn chỉnh mô hình xe tỷ lệ 1/10, kiểm chứng thuật toán BiSeNet và EKF trên cung đường thử nghiệm HCMUTE.
  2. Giai đoạn 2 (3 - 6 tháng): Tích hợp mạng phát hiện vật cản YOLOv4-Tiny, bổ sung cảm biến siêu âm/Sonar chống va chạm khẩn cấp.
  3. Giai đoạn 3 (6 - 12 tháng): Nâng cấp phần cứng lên NVIDIA Jetson Orin Nano, chuyển giao thuật toán lên khung gầm xe điện cỡ nhỏ (Golf Cart) phục vụ vận chuyển sinh viên nội bộ.

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

Hạn chế kỹ thuật

  • Điều kiện ánh sáng khắc nghiệt: Khi gặp ánh sáng ngược cực mạnh (chói lóa) hoặc bóng tối hoàn toàn, độ tương phản của ảnh giảm làm suy giảm độ chính xác nhận diện làn đường của mạng BiSeNet.
  • Độ trễ truyền nhận không dây: Việc truyền dữ liệu cảm biến GPS/IMU từ smartphone qua giao thức Wi-Fi có thể xuất hiện hiện tượng trễ gói tin (Jitter) cục bộ.
  • Chưa tích hợp tránh vật cản động: Hệ thống hiện tại tập trung tối đa vào bám làn và điều hướng theo lộ trình, chưa có cơ chế tự động chuyển làn để vượt chướng ngại vật tĩnh.

Hướng phát triển tương lai

  • Ứng dụng công nghệ TensorRT FP16/INT8 để đẩy tốc độ suy luận mạng BiSeNet lên trên 25 FPS.
  • Thay thế module truyền tín hiệu qua Wi-Fi bằng giao tiếp trực tiếp qua bus CAN hoặc kết nối cứng Serial UART công nghiệp.
  • Bổ sung camera RGB-D (Intel RealSense D435) để thu nhận bản đồ độ sâu phục vụ tính năng phanh tự động khẩn cấp (AEB).

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

  • Sinh viên & Học viên chuyên ngành Tự động hóa / Cơ điện tử / Robotics: Tiếp cận mã nguồn mẫu, phương pháp thiết kế bộ lọc EKF và kinh nghiệm triển khai mô hình học sâu trên máy tính nhúng NVIDIA Jetson.
  • Kỹ sư R&D & Lập trình viên hệ thống nhúng: Tài liệu tham khảo thực tế về cách khắc phục hiện tượng trôi tín hiệu GPS giá rẻ và cấu trúc điều khiển chuyển hướng theo hình học Ackermann.
  • Các doanh nghiệp Logistics / Nhà máy thông minh: Mô hình tham chiếu để chế tạo các dòng AGV (Automated Guided Vehicles) tự hành ngoài trời với chi phí linh kiện tối ưu.

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

1. Yêu cầu cấu hình tối thiểu để triển khai hệ thống này là gì?

Hệ thống yêu cầu máy tính biên hỗ trợ tăng tốc GPU với tối thiểu 4GB VRAM (khuyến nghị dòng NVIDIA Jetson Nano, Jetson TX2, hoặc Jetson Orin), camera độ phân giải HD góc rộng, vi điều khiển giao tiếp I2C/UART và bộ cảm biến GPS/IMU 9-DOF có tần số cập nhật $\ge 10\text{ Hz}$.

2. Tại sao đồ án lựa chọn mạng BiSeNet thay vì UNet hay FCN?

Mạng UNet và FCN có cấu trúc Encoder-Decoder tuần tự với số lượng tham số lớn, dẫn đến tốc độ khung hình chỉ đạt dưới 3–5 FPS trên Jetson TX2. BiSeNet tách biệt thành hai nhánh xử lý song song (Spatial Path thu nhận chi tiết và Context Path mở rộng trường nhìn), giúp đạt độ chính xác mIoU cao (78.4%) ở tốc độ thời gian thực (11–13 FPS).

3. Bộ lọc EKF đóng vai trò gì trong việc triệt tiêu sai số GPS?

Tín hiệu GPS ngoài trời thường bị sai lệch vài mét và nhảy vị trí đột ngột. Bộ lọc Kalman mở rộng (EKF) kết hợp dữ liệu gia tốc/vận tốc góc từ IMU với mô hình động học xe đạp để liên tục ước lượng và điều chỉnh tọa độ, đảm bảo đường đi của xe luôn bám sát vệt Waypoint mượt mà.

4. Hệ thống xử lý thế nào khi mất dấu vạch kẻ đường hoặc vào giao lộ?

Khi hệ thống phát hiện độ tin cậy phân đoạn làn đường giảm xuống dưới ngưỡng an toàn ($mIoU < 0.65$) hoặc tọa độ xe đi vào vùng giao lộ đã đánh dấu trên bản đồ OSM, cờ điều khiển sẽ tự động chuyển quyền sang bộ điều hướng EKF Waypoint Navigation để bẻ lái theo tọa độ định sẵn.

5. Chi phí ước tính để chế tạo một mô hình tương tự là bao nhiêu?

Tổng chi phí chế tạo mô hình xe tự hành tỷ lệ 1/10 trong đồ án dao động trong khoảng 8.000.000 – 12.000.000 VNĐ (tùy thuộc vào phiên bản kit Jetson TX2 cũ/mới và khung gầm RC), tiết kiệm hơn 90% so với việc trang bị cảm biến LiDAR quét laser chuyên dụng.

Kết luận

Đồ án "Design and Implementation of a Lane Keeping and Navigation System for Self-Driving Vehicle Based on the Fusion of Camera, GPS and IMU" đã chứng minh tính khả thi vượt trội của việc kết hợp giữa công nghệ Thị giác máy tính Deep Learning (BiSeNet) và Kỹ thuật điều khiển tự động cổ điển (EKF, Stanley Controller, PID). Bằng cách tận dụng tối đa năng lực xử lý của máy tính nhúng NVIDIA Jetson TX2 cùng các cảm biến giá thành thấp, nhóm tác giả đã xây dựng thành công một mô hình xe tự hành hoạt động ổn định trong môi trường thực tế tại khuôn viên HCMUTE. Đây là bước đệm kỹ thuật và nền tảng phương pháp luận vững chắc, mở ra tiềm năng ứng dụng to lớn cho việc phát triển các phương tiện tự hành kích thước thật (Full-scale Autonomous Cars) phục vụ xã hội trong tương lai.