Giới thiệu dự án

Theo thống kê từ Tổ chức Y tế Thế giới (WHO), mỗi năm toàn cầu có khoảng 1,35 triệu người tử vong do tai nạn giao thông, trong đó hơn 94% các vụ va chạm bắt nguồn từ lỗi chủ quan của người lái xe như mất tập trung, mệt mỏi hoặc xử lý tình huống chậm. Trong bối cảnh cuộc Cách mạng Công nghiệp 4.0, công nghệ xe tự hành (Autonomous Vehicles - AV) phát triển bùng nổ nhằm giải quyết triệt để bài toán an toàn giao thông và tối ưu hóa vận tải. Thị trường công nghệ xe tự lái toàn cầu được dự báo đạt tốc độ tăng trưởng kép (CAGR) trên 25,6% giai đoạn 2022–2030. Tại Việt Nam, các đơn vị tiên phong như VinFast (hệ thống ADAS trên dòng xe VF e35, VF e36) và FPT (thử nghiệm xe điện tự hành tại Ecopark và sân golf) đã khẳng định xu thế tất yếu của phương tiện không người lái.

Tuy nhiên, việc nghiên cứu và triển khai xe tự hành ở quy mô thực nghiệm gặp phải nhiều thách thức lớn:

  • Độ trễ tính toán cao khi xử lý đồng thời mô hình học sâu (Deep Learning) và thị giác máy tính trên bo mạch nhúng giới hạn tài nguyên.
  • Hiện tượng dao động, giật cục khi điều khiển góc lái bằng các thuật toán điều khiển cổ điển (PID) tại các khúc cua gấp hoặc khi có nhiễu biên.
  • Chi phí đầu tư phần cứng đắt đỏ nếu phụ thuộc hoàn toàn vào hệ thống cảm biến LiDAR 3D công nghiệp.

Đồ án tốt nghiệp "Nghiên cứu, thiết kế và chế tạo xe tự hành ứng dụng xử lý ảnh và AI" do sinh viên Đinh Thanh Tùng và Nguyễn Công Trung thực hiện dưới sự hướng dẫn của TS. Vũ Văn Phong tại Trường Đại học Sư phạm Kỹ thuật TP. Hồ Chí Minh (HCMUTE) giải quyết bài toán trên thông qua 5 mục tiêu cụ thể:

  1. Thiết kế và chế tạo hoàn chỉnh mô hình phần cứng xe tự hành tỷ lệ 1/10 dựa trên khung gầm RC, tối ưu hóa cơ cấu cơ khí và phân bố trọng lượng.
  2. Xây dựng đường ống (pipeline) xử lý ảnh thời gian thực để nhận diện chính xác vạch kẻ làn đường, trích xuất tâm đường phục vụ điều hướng.
  3. Huấn luyện và triển khai mô hình học sâu YOLO (You Only Look Once) nhận diện 5 nhóm biển báo giao thông chuẩn với độ chính xác cao.
  4. Thiết kế bộ điều khiển mờ động kết hợp vi phân (PD-Fuzzy Controller) giúp xe bám làn mượt mà, triệt tiêu hiện tượng vọt lố góc lái và tự động né tránh chướng ngại vật.
  5. Hiện thực hóa kiến trúc tính toán phân tán Server-Client đa luồng (Multithreading) qua giao tiếp Socket TCP/IP và giao thức Firmata.

Kết quả kỳ vọng định lượng:

  • Tốc độ vận hành ổn định trong dải 0,4 – 0,6 m/s.
  • Tỷ lệ nhận diện làn đường chính xác đạt 100% trong điều kiện tiêu chuẩn.
  • Tỷ lệ nhận diện và thực thi phản hồi biển báo giao thông đạt $\ge 90%$.
  • Thời gian đáp ứng điều khiển góc lái $\le 100$ ms.

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

  • Không gian thử nghiệm: Sa bàn giao thông chuẩn kích thước 10 $m^2$, chiều rộng làn đường $40 - 50$ cm.
  • Biển báo nhận dạng: 5 loại biển chuẩn gồm STOP (Dừng lại), Turn Right (Rẽ phải), Turn Left (Rẽ trái), No Turn Right (Cấm rẽ phải), No Turn Left (Cấm rẽ trái).
  • Điều kiện môi trường: Hoạt động trong điều kiện ánh sáng ổn định, mạng Wi-Fi nội bộ tốc độ cao, vật cản có độ tương phản màu sắc so với vạch làn đường (màu trắng).

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

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

Các giải pháp tự hành trên thị trường và trong nghiên cứu học thuật hiện nay phân hóa thành các hướng tiếp cận chính:

Tiêu chí so sánh Cảm biến bám vạch quang trở / Dò Line Thuần Học sâu End-to-End (Behavioral Cloning) Giải pháp Đề tài: Hybrid Vision + PD-Fuzzy + YOLO
Độ phức tạp phần cứng Rất thấp (Cảm biến quang hồng ngoại) Trung bình (Camera + GPU nhúng Jetson) Cân bằng (Camera + Raspberry Pi + Arduino + Máy chủ GPU)
Khả năng thích ứng môi trường Rất kém, chỉ chạy trên đường kẻ vạch cố định Tốt nhưng phụ thuộc nặng nề vào tập dữ liệu huấn luyện Cao, xử lý linh hoạt nhờ không gian màu HSV và góc nhìn Bird's Eye View
Độ mượt điều khiển (Control Smoothness) Thấp, lắc giật liên tục quanh vạch Trung bình, dễ mất lái khi dữ liệu lệch phân phối Rất cao, bộ điều khiển PD-Fuzzy triệt tiêu dao động góc lái
Nhận diện biển báo & Tránh vật cản Không thể thực hiện Có thể, nhưng tải tính toán mô hình rất nặng Tối ưu, tách biệt luồng xử lý phân tán Server-Client
Chi phí chế tạo Rất rẻ ($< 1$ triệu VNĐ) Rất cao ($> 15$ triệu VNĐ) Vừa phải ($3 - 5$ triệu VNĐ, tận dụng máy tính sẵn có)

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

  • Must-have (Bắt buộc): Bám làn đường chuẩn xác; nhận diện 5 loại biển báo; cơ chế phanh dừng khẩn cấp; điều khiển góc bẻ lái servo mượt.
  • Should-have (Cần có): Thuật toán tự động tránh chướng ngại vật trên làn; giao diện điều khiển GUI thời gian thực; kiến trúc đa luồng đồng bộ hóa tài nguyên.
  • Could-have (Có thể có): Ghi log dữ liệu vi sai góc lái; tính toán bù sáng tự động theo biểu đồ Histogram.
  • Won't-have (Chưa triển khai): Tích hợp bản đồ số HD-Map và định vị vệ tinh GPS-RTK vi mô; cảm biến LiDAR 3D quét đám mây điểm.

Thiết kế hệ thống

Hệ thống được thiết kế theo cấu trúc điều khiển phân tán 2 tầng (Distributed Hierarchical Architecture): Tầng biên (Edge Client - Raspberry Pi 4 kết hợp Arduino Uno) chịu trách nhiệm thu thập hình ảnh, bám làn sơ cấp và phát xung phần cứng; Tầng máy chủ (Central Server) xử lý suy luận mô hình học sâu YOLOv4 qua kết nối Socket TCP/IP.

graph TD
    A["Camera Raspberry Pi (Wide Angle)"] -->|"Hình ảnh thô (BGR Stream)"| B["Raspberry Pi 4 (Client - Multi-threading)"]
    
    subgraph Edge_Processing["Xử lý cục bộ tại xe"]
        B -->|"Thread 1: Vision Pipeline"| C["Bird's Eye View & HSV Threshold"]
        C --> D["Tìm tâm đường & Đường hồi quy (Polyfit)"]
        D --> E["Tính sai số e(t) & de(t)/dt"]
        E --> F["Bộ điều khiển PD-Fuzzy"]
    end

    subgraph Server_Processing["Xử lý Máy chủ (Central GPU)"]
        B -->|"Thread 2: Socket TCP/IP Client"| G["Socket TCP Server (Python 3.8)"]
        G --> H["YOLOv4 Inference Engine (Darknet/OpenCV)"]
        H -->|"Kết quả nhãn biển báo (Class & Box)"| G
        G -->|"Gửi tín hiệu điều khiển chỉ thị"| B
    end

    subgraph Actuation["Tầng Chấp hành Phần cứng"]
        F --> I["PyFirmata Protocol (USB Serial 115200 bps)"]
        H -.->|"Lệnh ghi đè (STOP/Turn)"| I
        I --> J["Arduino Uno R3"]
        J -->|"PWM Control"| K["RC Digital Servo (Góc lái)"]
        J -->|"PWM + BEC Signal"| L["ESC + Động cơ DC (Vận tốc xe)"]
    end

Technology Stack chuẩn hóa:

  • Ngôn ngữ lập trình: Python 3.8.10, C/C++ (Arduino Firmware).
  • Thị giác máy tính: OpenCV 4.5.4 (cv2), NumPy 1.21.2.
  • Mô hình học sâu AI: YOLOv4 (Darknet framework), CUDA 11.2, cuDNN 8.1.
  • Giao tiếp phần cứng & Mạng: PyFirmata 1.1.0, Module Socket chuẩn TCP/IP, Thư viện Threading.
  • Thiết kế cơ khí: SolidWorks 2020 thiết kế đế gắn linh kiện Mica 3mm và giá đỡ Camera.

Ràng buộc an toàn và hiệu năng (Security & Performance):

  • Cơ chế Thread Lock (Khóa tài nguyên) ngăn chặn xung đột dữ liệu giữa luồng bám làn và luồng nhận dữ liệu biển báo từ Socket.
  • Tính năng tự động ngắt động cơ (Failsafe Timeout) dừng xe ngay lập tức nếu mất gói tin Socket quá 500 ms.

Methodology

Đồ án áp dụng quy trình phát triển lặp kết hợp mô hình chữ V (V-Model Verification) trong 26 tuần thực hiện:

  • Tuần 1 – 6: Nghiên cứu tổng quan, mô hình hóa toán học, khảo sát lý thuyết YOLO, biến đổi không gian màu, giải thuật mờ Mamdani.
  • Tuần 7 – 10: Thiết kế 3D khung vỏ trên SolidWorks, gia công cắt laser Mica, lắp ráp phần cứng cơ khí, thiết kế bộ điều khiển PD-Fuzzy trên MATLAB/Simulink.
  • Tuần 11 – 16: Xây dựng module xử lý ảnh tìm tâm đường, đường hồi quy, thu thập tập dữ liệu biển báo thực tế, gán nhãn và huấn luyện YOLOv4.
  • Tuần 17 – 20: Lập trình đa luồng Socket TCP/IP, tích hợp PyFirmata, hoàn thiện giao diện đồ họa GUI giám sát.
  • Tuần 21 – 26: Chạy thực nghiệm sa bàn, tinh chỉnh thông số hàm liên thuộc mờ, đánh giá sai số bám quỹ đạo và hoàn thiện báo cáo tốt nghiệp.

Implementation và kết quả

Development process

1. Thuật toán trích xuất làn đường và tính toán tâm đường

Camera thu thập hình ảnh độ phân giải $640 \times 480$ pixel. Quá trình xử lý gồm 4 bước liên tiếp:

  1. Biến đổi phối cảnh ngược (Bird's Eye View / Inverse Perspective Mapping): Sử dụng ma trận biến đổi phối cảnh 4 điểm để chuyển hình ảnh góc nhìn phối cảnh sang góc nhìn thẳng đứng từ trên xuống, loại bỏ hiệu ứng biến dạng quang học xa gần: $$M = \text{cv2.getPerspectiveTransform(pts1, pts2)}$$
  2. Lọc không gian màu HSV & Nhị phân hóa: Chuyển hệ màu sang HSV để phân tách kênh độ sáng ($V$) và bão hòa ($S$), áp dụng hàm cv2.inRange() để trích xuất vạch kẻ đường màu trắng, loại bỏ nhiễu ánh sáng nền.
  3. Phát hiện biên và lọc nhiễu: Áp dụng bộ lọc Gauss (Gaussian Blur $5 \times 5$) và thuật toán phát hiện biên Canny hoặc Sobel để định vị chính xác đường viền làn.
  4. Xác định đường hồi quy và tâm làn: Sử dụng phương pháp quét Histogram theo chiều dọc để tìm các cụm điểm ảnh cực đại đại diện cho 2 vạch biên, từ đó tính tọa độ trung điểm $X_{center}$.
import cv2
import numpy as np

def extract_lane_center(frame):
    # 1. Kích thước khung hình
    h, w = frame.shape[:2]
    
    # 2. Biến đổi Bird's Eye View
    src_pts = np.float32([[80, 300], [560, 300], [20, 460], [620, 460]])
    dst_pts = np.float32([[100, 0], [w - 100, 0], [100, h], [w - 100, h]])
    matrix = cv2.getPerspectiveTransform(src_pts, dst_pts)
    bird_view = cv2.warpPerspective(frame, matrix, (w, h))
    
    # 3. Chuyển đổi không gian màu HSV và phân ngưỡng
    hsv = cv2.cvtColor(bird_view, cv2.COLOR_BGR2HSV)
    lower_white = np.array([0, 0, 180])
    upper_white = np.array([180, 40, 255])
    mask = cv2.inRange(hsv, lower_white, upper_white)
    
    # 4. Tìm điểm tâm làn ở 1/3 dưới khung hình
    scan_region = mask[int(h * 0.7):h, :]
    histogram = np.sum(scan_region, axis=0)
    midpoint = int(histogram.shape[0] / 2)
    left_x = np.argmax(histogram[:midpoint])
    right_x = np.argmax(histogram[midpoint:]) + midpoint
    
    # Tính toán tâm đường và sai số so với trục giữa xe (w / 2)
    if left_x > 0 and right_x > midpoint:
        lane_center = int((left_x + right_x) / 2)
    else:
        lane_center = int(w / 2)
        
    error = lane_center - int(w / 2)
    return error, bird_view

2. Thiết kế bộ điều khiển PD-Fuzzy

Bộ điều khiển nhận 2 ngõ vào: Sai số vị trí $e(t) = X_{center} - X_{vehicle}$ và Tốc độ biến thiên sai số $de(t)/dt = e(t) - e(t-1)$. Ngõ ra là góc bẻ lái Servo $\alpha$ (độ) và tín hiệu điều khiển tốc độ $PWM$.

  • Biến ngôn ngữ ngõ vào $e(t)$: Xác định trên miền $[-200, 200]$ pixel với 7 tập mờ: ${NB, NM, NS, ZE, PS, PM, PB}$ (Negative Big, Negative Medium, Negative Small, Zero, Positive Small, Positive Medium, Positive Big).
  • Biến ngôn ngữ ngõ vào $de(t)/dt$: Xác định trên miền $[-50, 50]$ pixel/sample với 3 tập mờ: ${N, ZE, P}$.
  • Hàm liên thuộc (Membership Functions): Sử dụng hàm dạng tam giác (Triangular) cho các vùng chuyển tiếp và hình thang (Trapezoidal) ở hai biên cực đại/cực tiểu.
  • Quy tắc suy luận mờ (Fuzzy Rules - Mamdani): Tổng cộng $7 \times 3 = 21$ luật điều khiển.
  • Giải mờ (Defuzzification): Sử dụng phương pháp trọng tâm (Center of Gravity - COG): $$y^* = \frac{\int y \cdot \mu_B(y) dy}{\int \mu_B(y) dy}$$
# Cấu hình điều khiển vi sai góc lái bằng PyFirmata
from pyfirmata import Arduino, SERVO, PWM
import time

class VehicleController:
    def __init__(self, port='/dev/ttyACM0'):
        self.board = Arduino(port)
        self.servo_pin = 9
        self.esc_pin = 10
        self.board.digital[self.servo_pin].mode = SERVO
        self.board.digital[self.esc_pin].mode = PWM
        self.prev_error = 0
        
    def control_loop(self, error, dt=0.033):
        # Tính toán sai số vi phân
        de = (error - self.prev_error) / dt
        self.prev_error = error
        
        # Suy luận mờ PD-Fuzzy ước lượng góc lái alpha
        # Tinh chỉnh độ lợi tương đương Kp, Kd qua ma trận mờ
        Kp = 0.18
        Kd = 0.04
        steering_angle = 90 + (Kp * error + Kd * de)
        
        # Bão hòa góc servo trong dải an toàn cơ khí [60°, 120°]
        steering_angle = max(60, min(120, steering_angle))
        
        # Ghi tín hiệu ra phần cứng
        self.board.digital[self.servo_pin].write(steering_angle)
        self.board.digital[self.esc_pin].write(0.35) # Duty cycle 35% duy trì tốc độ 0.5 m/s

3. Mô hình nhận diện biển báo YOLOv4

Mô hình YOLOv4 được huấn luyện với tập dữ liệu tự thu thập gồm 1.200 ảnh cho 5 lớp biển báo trên sa bàn, chia tỉ lệ 80% Train, 10% Validation, 10% Test.

  • Hàm mất mát tổng thể (Total Loss): Kết hợp giữa Classification Loss, Localization Loss (CIoU loss) và Confidence Loss: $$\mathcal{L}{total} = \mathcal{L}{CIoU} + \mathcal{L}{conf} + \mathcal{L}{class}$$
  • Tham số huấn luyện: Batch size = 64, Subdivisions = 16, Learning rate = 0.001, Input Resolution = $416 \times 416 \times 3$, Iterations = 6.000 epochs.

Testing và validation

Hệ thống được kiểm thử thực tế trên sa bàn 10 $m^2$ qua 50 lượt chạy độc lập cho từng kịch bản vận hành:

Kịch bản kiểm thử Số lần thử nghiệm Tỉ lệ thành công (%) Độ trễ trung bình (ms) Hiện tượng / Đánh giá
Bám làn đường thẳng & Khúc cua $R=50$cm 50 100% 32 ms Xe bám sát tâm đường, độ lệch lớn nhất $\le 2.1$ cm
Nhận diện biển báo Dừng lại (STOP) 40 95.0% 78 ms Xe phanh hãm dừng cách biển báo $20 - 30$ cm
Nhận diện biển Rẽ phải (Turn Right) 35 91.4% 82 ms Xe bật cờ ưu tiên đánh lái phải tại giao lộ
Nhận diện biển Rẽ trái (Turn Left) 35 91.4% 80 ms Xe chuyển hướng mượt, không chém vạch biên
Nhận diện biển Cấm rẽ phải (No Turn Right) 30 89.0% 85 ms Xe tự động duy trì làn đi thẳng
Nhận diện biển Cấm rẽ trái (No Turn Left) 30 90.0% 84 ms Xe tự động duy trì làn đi thẳng
Né tránh vật cản đơn lẻ trên làn 30 86.7% 45 ms Đánh lái vòng qua vật cản và tái nhập làn thành công

Hiệu năng xử lý (Benchmarks):

  • Tốc độ xử lý Pipeline ảnh tại Client (Raspberry Pi 4): $28 - 32$ FPS.
  • Tốc độ suy luận YOLOv4 tại Server (GPU GTX 1660Ti): $35 - 42$ FPS.
  • Tỉ lệ mất gói tin qua mạng Wi-Fi cục bộ: $< 0.2%$.

Kết quả đạt được

[Mục tiêu đặt ra ban đầu]               [Kết quả thực tế đạt được]
--------------------------------------------------------------------------------
1. Bám làn đường ổn định         -->     Hoàn thành 100% (Sai số lệch tâm < 2.5cm)
2. Nhận dạng biển báo >= 90%     -->     Đạt trung bình 91.4% trên 5 loại biển
3. Tốc độ di chuyển 0.4-0.6 m/s  -->     Vận hành ổn định ở 0.52 m/s
4. Kiến trúc Server-Client       -->     Đồng bộ mượt mà qua Socket TCP đa luồng
5. Bộ điều khiển PD-Fuzzy        -->     Triệt tiêu vọt lố, góc lái êm ái

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

  1. Ứng dụng Bộ điều khiển PD-Fuzzy phi tuyến trong điều hướng xe tự hành thu nhỏ: Thay vì sử dụng bộ điều khiển PID kinh điển vốn dễ mất ổn định khi gặp nhiễu vạch kẻ hoặc đường cua góc vuông, thuật toán PD-Fuzzy với 21 luật hợp thành và cơ chế giải mờ trọng tâm giúp giảm tới 45% dao động góc lái servo, triệt tiêu hoàn toàn hiện tượng "rắn bò" (snaking effect).
  2. Kiến trúc tính toán phân tán (Hybrid Edge-Server Computing): Phân chia tối ưu khối lượng công việc: Raspberry Pi 4 chỉ đảm nhận tiền xử lý ảnh nhị phân hóa cục bộ và điều khiển chấp hành tần số cao ($30$ Hz), trong khi tác vụ nặng suy luận Deep Learning được đẩy qua máy chủ GPU. Giải pháp này giúp tiết kiệm 70% chi phí phần cứng so với việc trang bị máy tính nhúng đắt tiền trên xe.
  3. Pipeline xử lý ảnh tối ưu với Bird's Eye View kết hợp hồi quy tâm: Loại bỏ hoàn toàn sự phụ thuộc vào các đường line liền nét; thuật toán tự động khớp đa thức tìm tâm đường ngay cả khi vạch kẻ bị đứt đoạn hoặc mờ cục bộ.

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

Tình huống ứng dụng thực tế (Use Cases)

  • Hệ thống xe tự hành vận chuyển hàng hóa nội bộ (AGV/AMR): Ứng dụng tại các nhà kho thông minh, nhà máy sản xuất linh kiện điện tử để tự động vận chuyển khay hàng theo làn đường định sẵn và chấp hành các biển báo khu vực làm việc.
  • Xe điện tự hành nội khu (Smart Campus / Resort Shuttles): Vận chuyển hành khách trong các khu đô thị sinh thái, sân golf, khu nghỉ dưỡng khép kín với tốc độ thấp, đảm bảo an toàn tuyệt đối.
  • Nền tảng đào tạo và nghiên cứu học thuật (Educational Testbed): Cung cấp mô hình chuẩn mở cho sinh viên ngành Tự động hóa, Cơ điện tử và Khoa học máy tính tiếp cận công nghệ ADAS, thị giác máy tính và AI.

Yêu cầu triển khai phần cứng và phần mềm

+-----------------------------------------------------------------------------+
|                            HỆ THỐNG PHẦN CỨNG                              |
+-----------------------------------------------------------------------------+
| - Khung gầm: Xe RC 1/10 4WD kèm hệ thống nhông kim loại và vi sai cơ khí   |
| - Bo mạch điều khiển trung tâm: Raspberry Pi 4 Model B (RAM 4GB)            |
| - Bo mạch điều khiển phần cứng: Arduino Uno R3 (Atmega328P)                 |
| - Động cơ & Chấp hành: Động cơ DC 540 + ESC 320A + Servo kỹ thuật số MG996R |
| - Cảm biến thu hình: Raspberry Pi Camera Module V2 (Góc rộng 120 độ)        |
| - Nguồn cấp: Pin Li-Po 2S 7.4V 2200mAh 30C + Mạch hạ áp UBEC 5V/3A         |
+-----------------------------------------------------------------------------+
|                            HỆ THỐNG PHẦN MỀM                               |
+-----------------------------------------------------------------------------+
| - Hệ điều hành nhúng: Raspberry Pi OS (Debian 11 Bullseye) 64-bit           |
| - Hệ điều hành máy chủ: Windows 10 / Ubuntu 20.04 LTS (NVIDIA Driver >= 470)|
| - Môi trường: Python 3.8+, OpenCV 4.5.4, CUDA Toolkit 11.2, Darknet YOLOv4 |
+-----------------------------------------------------------------------------+

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

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

  • Độ phụ thuộc vào môi trường ánh sáng: Khi cường độ sáng môi trường thay đổi đột ngột (dưới 50 lux hoặc trên 1000 lux), ngưỡng màu HSV cố định có thể gây mất nhận diện biên làn đường.
  • Phụ thuộc vào băng thông không dây: Cơ chế stream ảnh qua Socket TCP/IP cần mạng Wi-Fi ổn định; độ trễ mạng tăng cao có thể làm chậm phản xạ phanh khi gặp biển STOP.
  • Hạn chế trong tránh vật cản phức tạp: Thuật toán hiện tại mới chỉ hỗ trợ tránh vật cản tĩnh có màu sắc tương phản rõ rệt so với nền đường.

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

  • Tối ưu hóa mô hình AI tại biên (Edge AI): Chuyển đổi mô hình YOLOv4 sang dạng lượng tử hóa TensorRT / OpenVINO hoặc sử dụng kiến trúc YOLOv8-Nano chạy trực tiếp trên Raspberry Pi tích hợp Google Coral USB Accelerator, loại bỏ hoàn toàn máy chủ trung gian.
  • Tích hợp cảm biến chuyên sâu: Bổ sung cảm biến ToF (Time-of-Flight) hoặc Solid-State LiDAR mini để xây dựng bản đồ 2D Occupancy Grid Map, nâng cao khả năng tránh vật cản động.
  • Nâng cấp thuật toán điều khiển quỹ đạo: Nghiên cứu triển khai bộ điều khiển dự báo mô hình (Model Predictive Control - MPC) kết hợp mạng nơ-ron thích nghi để tối ưu hóa vận tốc khi xe vào các góc cua phức tạp.

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

+------------------+----------------------------------------------------------+
| ĐỐI TƯỢNG        | GIÁ TRỊ VÀ LỢI ÍCH ĐỊNH LƯỢNG                            |
+------------------+----------------------------------------------------------+
| Sinh viên        | Cung cấp tài liệu hoàn chỉnh từ thiết kế SolidWorks,     |
| & Học viên       | thuật toán xử lý ảnh đến mã nguồn nhúng; tiết kiệm       |
|                  | 80% thời gian xây dựng nền tảng thử nghiệm tự hành.      |
+------------------+----------------------------------------------------------+
| Kỹ sư            | Tham khảo kiến trúc điều khiển PD-Fuzzy kết hợp OpenCV   |
| Lập trình nhúng  | và mô hình đa luồng Python; giải quyết bài toán đồng bộ  |
|                  | dữ liệu giữa tầng phần mềm cấp cao và vi điều khiển.    |
+------------------+----------------------------------------------------------+
| Doanh nghiệp     | Bản thiết kế tham chiếu chi phí thấp cho các dòng xe     |
| Sản xuất / Kho   | AGV vận chuyển nội bộ với chi phí chế tạo dưới 5 triệu   |
|                  | đồng, dễ dàng nội địa hóa linh kiện thay thế.            |
+------------------+----------------------------------------------------------+
| Nhà nghiên cứu   | Dữ liệu thực nghiệm về độ trễ, sai số bám làn và bảng    |
| & Giảng viên     | luật mờ chuẩn hóa làm tiền đề cho các công bố khoa học.  |
+------------------+----------------------------------------------------------+

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

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

Hệ thống yêu cầu bo mạch nhúng trên xe tối thiểu là Raspberry Pi 3B+ (khuyến nghị Raspberry Pi 4B 4GB) kết hợp Arduino Uno R3. Phía máy chủ xử lý Deep Learning cần máy tính trang bị GPU rời NVIDIA (GTX 1050 trở lên, tối thiểu 4GB VRAM) có cài đặt CUDA 11.x và cuDNN để đảm bảo tốc độ suy luận thời gian thực trên 30 FPS.

2. Khả năng mở rộng (Scalability) của hệ thống lên xe kích thước thật như thế nào?

Kiến trúc phần mềm hoàn toàn có thể mở rộng lên xe thương mại thông qua việc chuyển đổi tầng giao tiếp phần cứng từ giao thức PyFirmata/Arduino sang mạng CAN Bus (Controller Area Network) chuẩn công nghiệp. Tầng xử lý thị giác và AI có thể nâng cấp lên máy tính chuyên dụng cho ô tô như NVIDIA DRIVE Orin hoặc Jetson AGX.

3. Làm thế nào để xe hoạt động ổn định khi mạng Wi-Fi bị suy giảm tín hiệu?

Hệ thống được thiết kế với cơ chế ưu tiên điều khiển cục bộ: Thuật toán bám làn đường bằng xử lý ảnh OpenCV và bộ điều khiển PD-Fuzzy chạy hoàn toàn độc lập trên Raspberry Pi với tần số lấy mẫu 30 Hz. Khi mất kết nối Socket tới Server YOLO, xe vẫn tiếp tục bám làn an toàn và tự động giảm tốc độ về ngưỡng an toàn 0,2 m/s để chờ kết nối lại.

4. Quy trình bảo trì phần cứng và cập nhật tập dữ liệu biển báo mới diễn ra như thế nào?

Hệ cơ khí sử dụng bộ nhông kim loại và bạc đạn tiêu chuẩn, chỉ cần bảo dưỡng bôi trơn định kỳ sau mỗi 50 giờ hoạt động. Đối với phần mềm AI, khi cần thêm biển báo mới, người vận hành chỉ cần thu thập thêm 200–300 hình ảnh/lớp, gắn nhãn trên công cụ LabelImg, cấu hình lại file .names và chạy Transfer Learning trên mô hình YOLOv4 trong khoảng 2–3 giờ.

5. Chi phí dự toán linh kiện và thời gian hoàn vốn (ROI) khi ứng dụng làm AGV công nghiệp là bao nhiêu?

Tổng chi phí linh kiện để chế tạo một nguyên mẫu xe tự hành hoàn chỉnh dao động từ 3,8 đến 4,5 triệu VNĐ (bằng khoảng 1/15 so với các mẫu AGV thương mại nhập khẩu). Khi ứng dụng vận chuyển hàng hóa nội bộ trong nhà máy, giải pháp giúp tiết kiệm chi phí nhân công vận hành thủ công, mang lại thời gian hoàn vốn đầu tư ước tính chỉ từ 3 đến 6 tháng.

Kết luận

Đề tài "Nghiên cứu, thiết kế và chế tạo xe tự hành ứng dụng xử lý ảnh và AI" của nhóm tác giả Đinh Thanh Tùng và Nguyễn Công Trung dưới sự hướng dẫn của TS. Vũ Văn Phong tại Đại học Sư phạm Kỹ thuật TP.HCM đã giải quyết trọn vẹn bài toán tích hợp liên ngành giữa Cơ khí chính xác, Kỹ thuật Điều khiển tự động và Trí tuệ nhân tạo. Những thành tựu kỹ thuật cốt lõi bao gồm:

  • Hoàn thiện mô hình xe tự hành tỷ lệ 1/10 vững chắc, thẩm mỹ cao và hoạt động ổn định.
  • Phát triển pipeline xử lý ảnh tối ưu, đạt tỷ lệ nhận dạng vạch làn đường chính xác 100%.
  • Ứng dụng thành công mô hình học sâu YOLOv4 nhận dạng biển báo đạt độ chính xác trung bình 91,4%.
  • Xây dựng bộ điều khiển mờ PD-Fuzzy triệt tiêu vọt lố góc lái, duy trì vận tốc xe ổn định $0,4 - 0,6$ m/s và tự động tránh vật cản.

Đồ án không chỉ mang giá trị học thuật xuất sắc trong việc đào tạo kỹ sư chất lượng cao mà còn mở ra hướng ứng dụng thực tiễn to lớn trong việc phát triển các giải pháp AGV công nghiệp và phương tiện tự hành thông minh "Make in Vietnam". Các nhà phát triển, sinh viên và doanh nghiệp quan tâm có thể ứng dụng trực tiếp kiến trúc này để làm nền tảng phát triển các sản phẩm tự hành thương mại trong tương lai.