Giới thiệu dự án

Thị trường xe tự hành toàn cầu (Autonomous Vehicles - AVs) đang bước vào giai đoạn tăng trưởng bùng nổ với tốc độ tăng trưởng kép hàng năm (CAGR) dự báo đạt trên 31.3% trong giai đoạn 2023–2030. Trong quá trình nghiên cứu và phát triển xe tự hành, việc thử nghiệm trực tiếp trên đường thực tế đòi hỏi chi phí đầu tư hạ tầng phần cứng đắt đỏ, tiềm ẩn rủi ro tai nạn giao thông và vướng mắc về khung pháp lý. Mô phỏng ảo (Virtual Simulation) là giải pháp tiên quyết, giúp các kỹ sư kiểm thử an toàn các thuật toán điều khiển phương tiện trước khi nạp vào bộ điều khiển thực tế (Microcontroller Unit - MCU / Electronic Control Unit - ECU).

Tuy nhiên, các nền tảng mô phỏng phổ biến trên thế giới hiện nay đặt ra rào cản lớn:

  • CARLA Simulator: Nền tảng mã nguồn mở trên Unreal Engine đòi hỏi phần cứng cấu hình cao (tối thiểu Intel Core i7/i9 thế hệ 9–11, GPU NVIDIA RTX 2070/3070 trở lên), khiến các máy tính cấu hình phổ thông không thể vận hành mượt mà (sụt giảm dưới 15 FPS hoặc không thể khởi chạy).
  • Morai.ai & PreScan: Các giải pháp thương mại độc quyền có chi phí bản quyền đắt đỏ, khó tiếp cận đối với các phòng thí nghiệm, trường đại học và nhóm nghiên cứu vừa và nhỏ.
  • Apollo Simulator: Yêu cầu quy trình cài đặt phức tạp, phụ thuộc vào cơ sở hạ tầng đám mây và hệ sinh thái phần cứng chuyên biệt.

Đề tài "Thiết kế phần mềm mô phỏng chuyển động của xe tự hành" (Design Platform for Simulation of Autonomous Vehicles) do sinh viên Cao Phan Tiến Dũng thực hiện dưới sự hướng dẫn của ThS. Phạm Minh Quân tại Khoa Kỹ thuật Máy tính – Trường Đại học Công nghệ Thông tin, ĐHQG-HCM giải quyết triệt để bài toán chi phí và rào cản phần cứng. Dự án phát triển một nền tảng mô phỏng chuyển động xe tự hành tối ưu, độc lập trên nền tảng Unity Engine kết hợp công cụ tạo hình 3D Blender, cho phép giao tiếp thuật toán điều khiển thời gian thực qua giao thức Socket.

graph LR
    A["Thuật toán điều khiển<br/>(PID, A*, CV, Deep Learning)"] <-->|"Giao thức Socket<br/>(TCP/IP Protocol)"| B["Unity Simulation Platform<br/>(Physics Engine & Rendering)"]
    B --> C["Mô hình xe 3D & Môi trường<br/>(Blender Optimized Assets)"]
    B --> D["Dữ liệu cảm biến ảo<br/>(Camera, Sensor Data)"]

Mục tiêu nghiên cứu cụ thể

  1. Xây dựng môi trường mô phỏng 3D hoàn chỉnh trên Unity Engine: Tái tạo không gian đô thị chi tiết (đường sá, làn đường, biển báo, công trình kiến trúc) với kích thước và tỷ lệ hình học chuẩn xác so với thực tế.
  2. Mô hình hóa động lực học và vật lý chuyển động: Tính toán lực kéo, lực ma sát lốp, gia tốc, góc lái và xử lý va chạm dựa trên số lượng bánh xe tiếp đất (2 bánh trước, 2 bánh sau, bánh hai bên hoặc toàn bộ 4 bánh).
  3. Phát triển cơ chế giao tiếp Socket Protocol: Thiết lập đường truyền dữ liệu hai chiều giữa phần mềm mô phỏng và code giải thuật bên ngoài với độ trễ thấp (< 10ms).
  4. Tối ưu hóa hiệu năng phần cứng: Đảm bảo hệ thống vận hành ổn định ở mức 60 FPS trên các máy tính cá nhân cấu hình tầm trung và phổ thông.

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

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

Tiêu chí CARLA Simulator Morai.ai Apollo Simulator Đề tài (Unity AV Platform)
Bản quyền Open Source (GPL) Thương mại (Trả phí) Open Source / Cloud Mã nguồn mở (Open Source)
Engine đồ họa Unreal Engine 4/5 Proprietary Engine Unity / Dreamview Unity Engine 2021.4 LTS
Yêu cầu phần cứng Rất cao (RTX 2070+) Cao (Card đồ họa rời) Cao (Yêu cầu Server/Docker) Thấp đến Trung bình (GTX 1050+)
Khả năng tùy biến Phức tạp (C++/Python) Đóng (Hạn chế) Trung bình (Module hóa) Rất cao (C# / Socket TCP)
Hiệu năng máy yếu Thường xuyên giật/lag Không hỗ trợ tối ưu Giới hạn tài nguyên Tối ưu hóa mượt mà (60 FPS)

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

  • Must-have (Bắt buộc): Mô hình động học 4 bánh xe; truyền nhận dữ liệu điều khiển qua Socket (vận tốc mục tiêu, góc bẻ lái); xuất luồng dữ liệu camera và vận tốc thực; xử lý va chạm vật lý cơ bản.
  • Should-have (Cần có): Mô hình hóa lực ma sát phụ thuộc vào trạng thái tiếp đất của từng bánh xe; công cụ tùy chỉnh tỷ lệ xe dựa trên thông số các dòng sedan thực tế (Toyota Camry, Mazda6, Hyundai Sonata); giao diện UI hiển thị HUD (Heads-Up Display).
  • Could-have (Có thể thêm): Cảm biến khoảng cách (LIDAR/Ultrasonic giả lập); kịch bản giao thông thời gian thực với chướng ngại vật động.
  • Won't-have (Tạm dừng): Mô phỏng biến đổi thời tiết động phức tạp (bão cát, tuyết rơi dày) và ray-tracing thời gian thực nhằm giữ mức tiêu thụ phần cứng ở mức thấp nhất.

Thiết kế hệ thống

classDiagram
    class VehiclePhysicsController {
        +float currentSpeed
        +float targetSpeed
        +float steerAngle
        +float accelerationRate
        +WheelCollider[] wheels
        +CalculateFriction()
        +ApplyDriveForce()
        +UpdateTransform()
    }
    class SocketServerBridge {
        +int port
        +string ipAddress
        +StartServer()
        +ListenClient()
        +SendSensorData()
        +ReceiveControlCommand()
    }
    class EnvironmentManager {
        +GameObject[] roadMesh
        +GameObject[] obstacles
        +CheckCollisions()
    }
    SocketServerBridge --> VehiclePhysicsController : Truyền lệnh điều khiển (Speed, Steer)
    VehiclePhysicsController --> SocketServerBridge : Phản hồi trạng thái (Telemetry)
    EnvironmentManager --> VehiclePhysicsController : Tác động tương tác vật lý

Ngăn xếp công nghệ (Technology Stack)

  • Engine mô phỏng: Unity Engine (phiên bản 2021.4f1 Personal LTS), tận dụng PhysX Engine tích hợp để tính toán va chạm và gia tốc.
  • Công cụ thiết kế 3D: Blender 3.x để dựng mesh đa giác (Vertices, Edges, Faces, Topology) cho thân xe, khung gầm và bản đồ đô thị. Định dạng xuất tài nguyên: .fbx và .obj.
  • Ngôn ngữ lập trình cốt lõi: C# (.NET Standard 2.1) trên Unity; Python 3.9+ cho các module giải thuật điều khiển ngoại vi (PID Controller, Lane Detection).
  • Giao thức mạng: TCP/IP Socket (chuẩn truyền tin Client-Server đồng bộ hóa dữ liệu telemetry và control signal).

Implementation và kết quả

Quy trình phát triển và thuật toán cốt lõi

Quy trình phát triển được chia làm 3 giai đoạn:

  1. Thiết kế hình học và Topology (Blender): Dựng mô hình xe chuẩn kích thước phân khúc sedan (Dài: 4.8m – 4.9m, Rộng: 1.7m – 1.8m). Tối ưu hóa số lượng đa giác (Low-poly topology) để giảm thiểu áp lực render lên GPU.
  2. Cấu hình Động lực học (Unity): Gán Rigidbody và WheelCollider cho các trục bánh xe. Tính toán phân bổ khối lượng tâm xe (Center of Mass) để tránh hiện tượng lật xe khi bẻ lái ở vận tốc cao.
  3. Xây dựng hệ thống giao tiếp Socket: Server Socket chạy ngầm trong Unity lắng nghe luồng điều khiển từ thuật toán Client.
// VehiclePhysicsController.cs - Module tính toán chuyển động và lực ma sát trong Unity
using System;
using UnityEngine;

public class VehiclePhysicsController : MonoBehaviour 
{
    [SerializeField] private WheelCollider[] wheelColliders; // 0,1: Trước | 2,3: Sau
    [SerializeField] private float maxMotorTorque = 400f;
    [SerializeField] private float maxSteeringAngle = 30f;
    
    public float CurrentSpeed { get; private set; }
    public float TargetSpeed { get; set; }
    public float SteerInput { get; set; }

    private Rigidbody rb;

    void Start() {
        rb = GetComponent<Rigidbody>();
        rb.centerOfMass = new Vector3(0, -0.5f, 0); // Hạ thấp trọng tâm
    }

    void FixedUpdate() {
        CurrentSpeed = rb.velocity.magnitude * 3.6f; // Chuyển đổi sang km/h
        ApplyMovementLogic();
    }

    private void ApplyMovementLogic() {
        // Tính toán số lượng bánh xe tiếp xúc mặt đường để phân bổ lực ma sát
        int groundedWheels = 0;
        foreach (var wheel in wheelColliders) {
            if (wheel.isGrounded) groundedWheels++;
        }

        if (groundedWheels == 0) return; // Mất tiếp xúc hoàn toàn

        // Điều khiển góc lái 2 bánh trước
        float steer = SteerInput * maxSteeringAngle;
        wheelColliders[0].steerAngle = steer;
        wheelColliders[1].steerAngle = steer;

        // Bộ bù gia tốc tuyến tính hướng tới vận tốc mục tiêu
        float speedError = TargetSpeed - CurrentSpeed;
        float motorTorque = Mathf.Clamp(speedError * 20f, -maxMotorTorque, maxMotorTorque);

        // Truyền động lực kéo cho các bánh xe tiếp đất
        for (int i = 0; i < wheelColliders.Length; i++) {
            if (wheelColliders[i].isGrounded) {
                wheelColliders[i].motorTorque = motorTorque / groundedWheels;
            }
        }
    }
}

# autonomous_client.py - Thuật toán điều khiển PID vận tốc và giao tiếp Socket từ phía Client
import socket
import json
import time

class PIDController:
    def __init__(self, kp: float, ki: float, kd: float):
        self.kp, self.ki, self.kd = kp, ki, kd
        self.prev_error = 0.0
        self.integral = 0.0

    def compute(self, setpoint: float, current_val: float, dt: float) -> float:
        error = setpoint - current_val
        self.integral += error * dt
        derivative = (error - self.prev_error) / dt if dt > 0 else 0.0
        self.prev_error = error
        return (self.kp * error) + (self.ki * self.integral) + (self.kd * derivative)

def start_client():
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect(('127.0.0.1', 8888))
    pid = PIDController(kp=1.2, ki=0.05, kd=0.1)
    target_speed = 40.0 # km/h
    last_time = time.time()

    try:
        while True:
            raw_data = client.recv(1024).decode('utf-8')
            if not raw_data:
                break
            
            telemetry = json.loads(raw_data)
            current_speed = telemetry.get("current_speed", 0.0)
            
            dt = time.time() - last_time
            last_time = time.time()
            
            throttle_signal = pid.compute(target_speed, current_speed, dt)
            steer_signal = 0.0 # Bám làn thẳng

            command = {
                "target_speed": target_speed,
                "steer_angle": steer_signal,
                "throttle": max(-1.0, min(1.0, throttle_signal))
            }
            client.sendall(json.dumps(command).encode('utf-8'))
    finally:
        client.close()

Kết quả đo lường và kiểm thử hiệu năng

Thử nghiệm so sánh hiệu năng được thực hiện giữa CARLA Simulator và Phần mềm mô phỏng Unity trên hai cấu hình máy tính:

  • Cấu hình thấp (Low-end): CPU Intel Core i5-8250U, RAM 8GB, GPU Intel UHD 620 / NVIDIA MX150.
  • Cấu hình cao (High-end): CPU Intel Core i7-10750H, RAM 16GB, GPU NVIDIA RTX 2070.
Khả năng duy trì FPS trên các cấu hình phần cứng:

Cấu hình cao (RTX 2070):
CARLA Simulator : [========================] 60 FPS (VRAM: 5.8 GB)
Unity Simulator : [========================] 60 FPS (VRAM: 1.2 GB)

Cấu hình thấp (GTX 1050/MX150):
CARLA Simulator : [==] 8-14 FPS (Crash / Không ổn định)
Unity Simulator : [========================] 58-60 FPS (Mượt mà, ổn định)
Thông số đánh giá CARLA Simulator Unity AV Platform (Đề tài) Mức cải thiện (%)
FPS trên máy cấu hình thấp 10 FPS (Không khả dụng) 58 - 60 FPS +480% (Vận hành mượt)
Tiêu thụ bộ nhớ VRAM 5.8 GB 1.2 GB Giảm 79.3%
Thời gian khởi động hệ thống ~45 giây ~3.5 giây Nhanh hơn 92.2%
Độ trễ truyền gói tin Socket 15 - 25 ms 4 - 8 ms Giảm 68% độ trễ
Tỷ lệ kiểm thử bám làn thành công 96.2% 95.8% Tương đương chuẩn thực tế

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

  1. Kiến trúc mô phỏng tối ưu hóa cho phần cứng phổ thông: Giảm thiểu việc lãng phí tài nguyên tính toán bằng cách chuẩn hóa số lượng đa giác (Polygon Mesh) trong Blender và cấu hình PhysX Collider tối giản, cho phép sinh viên và nhà nghiên cứu tại Việt Nam thử nghiệm thuật toán trên máy tính cá nhân thông thường.
  2. Mô hình tính toán ma sát đa điểm chạm: Không áp dụng công thức chuyển động tịnh tiến đơn giản, hệ thống kiểm tra trạng thái tiếp xúc độc lập của từng bánh xe để phản ánh chính xác lực bám đường khi xe tăng tốc, phanh gấp hoặc vào cua nghiêng.
  3. Hệ thống kết nối Socket tách rời (Decoupled Architecture): Môi trường mô phỏng (Unity C#) và bộ não giải thuật (Python/C++) hoạt động hoàn toàn độc lập, giúp nhà phát triển dễ dàng cắm rút và thử nghiệm nhiều giải thuật khác nhau (PID, Học máy, Học tăng cường Deep RL) mà không cần can thiệp vào mã nguồn đồ họa.

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

Trường hợp sử dụng thực tế (Real-world Use Cases)

  • Phòng thí nghiệm Kỹ thuật Ô tô & Máy tính: Làm môi trường giảng dạy thực hành các môn học Hệ thống nhúng cho ô tô, Xử lý ảnh xe tự hành và Điều khiển tự động.
  • Thử nghiệm thuật toán học máy (AI Training): Thu thập dữ liệu hình ảnh từ Camera ảo trong các điều kiện góc lái khác nhau để huấn luyện mô hình End-to-End Deep Learning điều khiển vô lăng.
  • Tiền kiểm thử xe tự hành quy mô nhỏ (Scale-1:10 Autonomous Cars): Kiểm tra mã nguồn điều khiển trên mô phỏng trước khi nạp xuống kit vi điều khiển (STM32, Raspberry Pi, Jetson Nano).
graph TD
    A["Yêu cầu triển khai"] --> B["Cài đặt Unity Hub & Unity 2021.4 LTS"]
    A --> C["Cài đặt môi trường Python 3.9+"]
    B --> D["Mở Project Unity & Khởi chạy Scene Chính"]
    C --> E["Cài đặt thư viện: numpy, opencv-python"]
    D <-->|"Kết nối qua Port 8888 (Localhost)"| F["Chạy Script: python autonomous_client.py"]
    F --> G["Quan sát xe tự bám làn & ghi nhận Telemetry"]

Yêu cầu cấu hình triển khai

  • Cấu hình tối thiểu: CPU Intel Core i3 thế hệ 6 hoặc tương đương; RAM 4GB; GPU tích hợp Intel HD Graphics 520 trở lên; 2GB dung lượng ổ cứng trống; Hệ điều hành Windows 10/11 hoặc Ubuntu Linux 20.04+.
  • Cấu hình đề xuất: CPU Intel Core i5 / AMD Ryzen 5; RAM 8GB; GPU rời NVIDIA GeForce GTX 1050 Ti trở lên.

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

  • Hạn chế kỹ thuật hiện tại:
    • Cảm biến môi trường chủ yếu tập trung vào Camera RGB và đo khoảng cách cơ bản; chưa tích hợp Point-Cloud LiDAR 3D phức tạp với hàng triệu điểm quét mỗi giây.
    • Kịch bản giao thông chưa có hệ thống AI cho các phương tiện và người đi bộ xung quanh (NPC Traffic Agents).
  • Hướng nâng cấp trong tương lai:
    • Tích hợp chuẩn giao tiếp ROS / ROS2 Bridge (Robot Operating System) để kết nối trực tiếp với các framework xe tự hành công nghiệp như Autoware.
    • Bổ sung cảm biến giả lập IMU, GPS thời gian thực với độ nhiễu trắng (Gaussian Noise) sát với thực tế phần cứng.
    • Xây dựng hệ thống điều kiện thời tiết động (mưa, sương mù, trơn trượt mặt đường) bằng shader tùy biến.

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

  • Sinh viên & Học viên: Tiếp cận công cụ học tập và nghiên cứu xe tự hành trực quan, loại bỏ rào cản tài chính khi không có máy tính cấu hình mạnh.
  • Kỹ sư & Lập trình viên nhúng: Có sẵn môi trường test-bench nhanh để kiểm thử phản hồi của các thuật toán PID, lọc Kalman (EKF), điều khiển bám làn (Lane Following) chỉ trong vài giây.
  • Các nhóm nghiên cứu đại học: Tiết kiệm 100% chi phí bản quyền so với các phần mềm mô phỏng thương mại, rút ngắn chu kỳ nghiên cứu từ ý tưởng đến thực nghiệm.

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

1. Phần mềm mô phỏng này có thể thay thế hoàn toàn việc thử nghiệm trên xe thật không?

Phần mềm đóng vai trò là môi trường tiền kiểm thử (Pre-validation). Nó giúp loại bỏ hơn 80% các lỗi logic và thuật toán điều khiển cơ bản, giúp tiết kiệm chi phí và đảm bảo an toàn trước khi nạp mã nguồn vào xe thực nghiệm.

2. Làm thế nào để kết nối thuật toán viết bằng ngôn ngữ khác (C++, Rust) với phần mềm?

Chỉ cần ngôn ngữ đó hỗ trợ giao tiếp mạng chuẩn TCP/IP Socket. Bạn chỉ cần khởi tạo một TCP Client gửi dữ liệu định dạng chuỗi JSON hoặc Byte Array đến IP/Port của Unity Server.

3. Tại sao nền tảng chọn Unity thay vì Unreal Engine?

Unity có dung lượng nhẹ, thời gian khởi động nhanh, hiệu năng render tối ưu tốt trên các máy tính cấu hình văn phòng/phổ thông, và ngôn ngữ C# thân thiện, dễ cấu hình physics hơn Unreal Engine trong khuôn khổ nghiên cứu học thuật.

4. Độ trễ giao tiếp qua Socket có ảnh hưởng đến độ chính xác khi xe chạy tốc độ cao không?

Trên môi trường localhost, độ trễ giao thức TCP dao động từ 4–8ms. Mức trễ này hoàn toàn đáp ứng được tần số lấy mẫu điều khiển thông thường của xe tự hành (20Hz – 50Hz) mà không gây trượt quỹ đạo.

5. Dự án có hỗ trợ xuất dữ liệu camera ảo để train mô hình AI không?

Có. Unity hỗ trợ cơ chế RenderTexture cho phép đọc mảng byte hình ảnh từ Camera và đóng gói gửi trực tiếp qua Socket hoặc lưu thành dataset hình ảnh trên ổ đĩa.

Kết luận

Đề tài "Thiết kế phần mềm mô phỏng chuyển động của xe tự hành" của tác giả Cao Phan Tiến Dũng đã chứng minh tính khả thi và hiệu quả vượt trội trong việc xây dựng môi trường kiểm thử ảo gọn nhẹ, chính xác và dễ tiếp cận. Bằng sự kết hợp giữa mô hình hóa hình học trong Blender, công cụ vật lý chân thực của Unity Engine và giao thức truyền thông Socket linh hoạt, công trình đã giải quyết thành công bài toán thắt nút cổ chai về cấu hình phần cứng và chi phí nghiên cứu xe tự hành tại Việt Nam. Đây là nền tảng vững chắc để mở rộng sang các hệ thống giao thông thông minh phức tạp hơn trong tương lai.