Giới thiệu dự án

Sự bùng nổ của cuộc Cách mạng Công nghiệp 4.0 và Trí tuệ nhân tạo (AI - Artificial Intelligence) đang định hình lại toàn diện ngành giao thông vận tải toàn cầu. Theo báo cáo từ MarketsandMarkets, thị trường xe tự hành (Autonomous Vehicles) dự kiến đạt quy mô hơn 62 tỷ USD vào năm 2030 với tốc độ tăng trưởng kép (CAGR) vượt 13.3%. Các cấp độ tự động hóa theo chuẩn SAE (Society of Automobile Engineers) từ Cấp độ 0 đến Cấp độ 5 đặt ra yêu cầu cấp thiết về việc nghiên cứu các hệ thống nhúng thông minh, có khả năng tự nhận thức không gian và ra quyết định trong thời gian thực (real-time).

Tại Việt Nam, các đơn vị công nghệ tiên phong như VinFast và FPT đang đẩy mạnh làm chủ công nghệ xe tự lái. Tuy nhiên, việc triển khai các mô hình xe tự hành quy mô nhỏ nhằm phục vụ nghiên cứu thuật toán, tối ưu hóa chi phí phần cứng nhúng và xử lý ảnh chuyên sâu vẫn còn nhiều thách thức. Đề tài "Nghiên cứu và phát triển mô hình xe tự hành ứng dụng AI" (thực hiện bởi nhóm tác giả Văn Huy Du, Trần Văn Đạt - Trường Đại học Sư phạm Kỹ thuật TP.HCM) tập trung giải quyết bài toán cốt lõi: kết hợp xử lý ảnh thị giác máy tính truyền thống (Computer Vision) và mạng nơ-ron tích chập (Convolutional Neural Networks - CNNs) trên nền tảng nhúng NVIDIA Jetson Nano để xe tự bám làn đường và nhận diện hệ thống biển báo giao thông chính xác.

Mục tiêu dự án

  1. Thiết kế phần cứng: Chế tạo khung xe tự hành tỷ lệ 1:10 từ sợi carbon, tích hợp vi máy tính nhúng NVIDIA Jetson Nano, camera góc rộng Sony IMX219, mạch điều khiển động cơ L298N, động cơ DC 380 và servo lái RC 17g.
  2. Xây dựng thuật toán bám làn: Phát triển pipeline xử lý ảnh thời gian thực (RGB sang HSV, lọc Gaussian, tách biên Canny, biến đổi góc nhìn Bird's-Eye View, ROI, biến đổi Hough Line) để tính toán góc bẻ lái $\theta_{steer}$ chính xác.
  3. Huấn luyện mô hình Deep Learning: Xây dựng và tối ưu hóa kiến trúc mạng CNN phân loại chính xác 6 nhóm biển báo giao thông cơ bản với độ chính xác trên tập kiểm thử (test accuracy) đạt trên 95%.
  4. Tích hợp và kiểm thử thực nghiệm: Vận hành xe ổn định trên sa bàn 2m x 2m mô phỏng các điều kiện đường cong, đường ngoằn ngoèo và giao lộ ngã ba gắn biển báo.

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

  • Phạm vi: Mô hình xe RC 1:10 hoạt động trong môi trường sa bàn trong nhà, mặt đường có vạch kẻ làn tương phản rõ ràng và biển báo kích thước chuẩn hóa.
  • Giới hạn: Hệ thống vận hành tối ưu trong điều kiện ánh sáng đồng đều; chưa tích hợp cảm biến LiDAR hoặc radar quét vật cản 3D tầm xa; tốc độ xử lý phụ thuộc vào xung nhịp GPU của Jetson Nano 4GB.

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

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

Phương pháp Ưu điểm Nhược điểm Độ phức tạp tính toán Phù hợp phần cứng nhúng
Xử lý ảnh cổ điển (Pure CV: Canny + Hough) Không cần tập dữ liệu lớn; thời gian xử lý nhanh (latency < 25ms); dễ gỡ lỗi. Nhạy cảm với thay đổi ánh sáng đột ngột; khó nhận diện biển báo biến dạng. Thấp: $\mathcal{O}(N)$ Rất cao (chạy mượt trên CPU)
Học sâu thuần túy (End-to-End CNN Steering) Tự động trích xuất đặc trưng; xử lý tốt môi trường phức tạp; điều khiển mượt mà. Đòi hỏi dataset khổng lồ; hộp đen (Black-box) khó giải thích; dễ overfit sa bàn nhỏ. Cao: $\mathcal{O}(K \cdot W \cdot H)$ Trung bình (cần GPU nhúng mạnh)
Giải pháp Hybrid (Đề tài đề xuất) Kết hợp tính ổn định của CV cho bám làn và độ chính xác của CNN cho phân loại biển báo. Cần đồng bộ luồng xử lý (multithreading) để tối ưu hóa FPS. Cân bằng Tối ưu tuyệt đối trên Jetson Nano

Phân tích yêu cầu hệ thống theo mô hình MoSCoW

  • Must have (Bắt buộc): Bám vạch làn đường liên tục, nhận diện đúng 6 loại biển báo (Dừng, Rẽ trái, Rẽ phải, Đi thẳng, Cấm rẽ trái, Cấm rẽ phải), điều khiển servo góc lái qua PWM, pin LiPo cung cấp dòng xả ổn định.
  • Should have (Nên có): Tự động điều chỉnh vận tốc qua điều biến độ rộng xung (PWM) khi vào cua, cơ chế phục hồi khi mất vạch kẻ đường tạm thời.
  • Could have (Có thể có): Giao diện web telemetry truyền video stream về máy trạm giám sát.
  • Won't have (Chưa thực hiện): Tích hợp cảm biến định vị toàn cầu GPS/IMU và thuật toán tránh chướng ngại vật động bằng SLAM.

Thiết kế hệ thống

Cấu trúc phần cứng và phần mềm

Hệ thống sử dụng kiến trúc phân tầng xử lý gồm 3 khối chức năng chính:

  • Khối cảm biến & Thu nhận: Camera Sony IMX219 (sensor CMOS 1/4", độ phân giải gốc 3280x2464, góc nhìn siêu rộng 160° FOV, truyền dữ liệu qua giao tiếp MIPI-CSI-2).
  • Khối xử lý trung tâm: NVIDIA Jetson Nano Developer Kit (GPU 128 lõi Maxwell @ 921 MHz, CPU ARM Cortex-A57 Quad-core @ 1.43 GHz, RAM 4GB 64-bit LPDDR4).
  • Khối chấp hành & Động lực: Khung xe RC 1:10 sợi carbon (kích thước 300x150mm, khối lượng 780g), Động cơ DC 380 (chổi than, 6-12V, 78.3g), Module mạch cầu H L298N (dòng điện đỉnh 2A/kênh), RC Servo 17g (điện áp 4.8-6V, mô-men xoắn 4.5 kg.cm tại 6V) và nguồn pin LiPo 3S 11.1V 1500mAh 35C.
+-----------------------------------------------------------------------+
|                       NVIDIA Jetson Nano 4GB                          |
|  +------------------------+             +--------------------------+  |
|  |  Luồng Thị giác Máy    |             |   Luồng Mạng nơ-ron      |  |
|  |  (OpenCV 4.5.4 Pipeline|             |   (TensorFlow / Keras)   |  |
|  |  - BGR -> HSV          |             |   - Tiền xử lý ROI       |  |
|  |  - Canny Edge Detect   |             |   - CNN Traffic Classifier| |
|  |  - Hough Transform     |             |   - Softmax 6 Classes    |  |
|  |  - Steering Logic      |             |                          |  |
|  +-----------+------------+             +------------+-------------+  |
|              \                                       /                |
|               \--> [ Decision Control Logic ] <-----/                 |
|                                |                                      |
|                       [ Jetson GPIO / PWM ]                           |
+--------------------------------+--------------------------------------+
                                 |
        +------------------------+------------------------+
        |                                                 |
+-------v-------+                                 +-------v-------+
| Module L298N  |                                 | Servo RC 17g  |
|  (Động cơ DC) |                                 |  (Bẻ góc lái) |
+---------------+                                 +---------------+

Thông số công nghệ và thư viện

  • Hệ điều hành: Linux Ubuntu 18.04 LTS (JetPack 4.6.1, L4T 32.7.1).
  • Môi trường lập trình: Python 3.8.10, CUDA Toolkit 10.2, cuDNN 8.2.1.
  • Thư viện xử lý ảnh: OpenCV 4.5.4 (biên dịch hỗ trợ CUDA & GStreamer).
  • Thư viện Deep Learning: TensorFlow 2.6.0 / Keras 2.6.0, NumPy 1.19.5, Matplotlib 3.3.4.

Phương pháp nghiên cứu và quản lý dự án (Methodology)

Dự án áp dụng mô hình phát triển lặp vòng (Iterative/Agile Prototyping) với chu kỳ 12 tuần:

[Tuần 1-3: Nghiên cứu lý thuyết & Thiết kế phần cứng] 
       ↓
[Tuần 4-6: Xây dựng Pipeline thị giác máy tính cho Bám làn] 
       ↓
[Tuần 7-9: Thu thập Dataset, Huấn luyện CNN nhận diện Biển báo] 
       ↓
[Tuần 10-11: Tích hợp hệ thống nhúng & Hiệu chuẩn thời gian thực] 
       ↓
[Tuần 12: Đánh giá thực nghiệm, Đo lường sai số & Hoàn thiện báo cáo]

Ma trận rủi ro và giải pháp giảm thiểu

  • Rủi ro 1: Hiện tượng sụt áp khi động cơ DC khởi động.
    • Giải pháp: Cách ly nguồn cung cấp logic của Jetson Nano (nguồn 5V/4A qua cổng DC barrel jack) với nguồn động lực L298N (sử dụng pin LiPo 3S 11.1V riêng biệt, chung mass GND).
  • Rủi ro 2: Độ trễ xử lý khung hình (Frame Drop) khi chạy song song 2 mô hình.
    • Giải pháp: Hạ độ phân giải xử lý xuống $320 \times 240$ pixel, tối ưu hóa kích thước kernel và triển khai kiến trúc CNN gọn nhẹ.

Implementation và kết quả

Quy trình phát triển thuật toán (Development Process)

1. Pipeline nhận diện làn đường và tính toán góc lái

Pipeline xử lý ảnh bám làn đường được tối ưu hóa qua các giai đoạn toán học cụ thể:

[Ảnh BGR gốc (Camera)]
        ↓
[Chuyển đổi HSV & Thresholding]
        ↓
[Lọc Gaussian 5x5: Làm mịn & Giảm nhiễu]
        ↓
[Tách biên Canny: Sobel Gx, Gy -> Gradient -> Hysteresis]
        ↓
[Cắt vùng quan tâm (ROI Mask)]
        ↓
[Biến đổi Hough Line xác định tọa độ các vạch làn]
        ↓
[Phân loại vạch Trái/Phải theo hệ số góc m & Tính tâm làn xe]
        ↓
[Tính toán góc bẻ lái θ (Steering Angle) & Xuất tín hiệu PWM]

  • Toán tử tách biên Canny: Tính độ lớn Gradient $G$ và hướng góc $\alpha$: $$G = \sqrt{G_x^2 + G_y^2}, \quad \alpha = \arctan\left(\frac{G_y}{G_x}\right)$$ Áp dụng 2 ngưỡng phân loại $minVal = 50$, $maxVal = 150$ để loại bỏ biên giả.

  • Biểu diễn đường thẳng trong không gian tọa độ cực (Hough Space): $$\rho = x \cos\theta + y \sin\theta$$ với $\rho$ là khoảng cách từ gốc tọa độ đến đường thẳng và $\theta$ là góc nghiêng.

  • Thuật toán tính độ dốc (Slope) và phân cụm làn xe: Độ dốc của đoạn thẳng nối 2 điểm $(x_1, y_1)$ và $(x_2, y_2)$: $$m = \frac{y_2 - y_1}{x_2 - x_1}$$

    • Nhánh trái: $m < 0$ và tọa độ $x$ thuộc $2/3$ nửa trái màn hình.
    • Nhánh phải: $m > 0$ và tọa độ $x$ thuộc $1/3$ nửa phải màn hình.
import cv2
import numpy as np

def detect_lane_pipeline(frame):
    # 1. Chuyển đổi không gian màu sang HSV
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    lower_white = np.array([0, 0, 180], dtype=np.uint8)
    upper_white = np.array([180, 40, 255], dtype=np.uint8)
    mask = cv2.inRange(hsv, lower_white, upper_white)
    
    # 2. Làm mịn ảnh bằng Gaussian Blur kernel 5x5
    blurred = cv2.GaussianBlur(mask, (5, 5), 0)
    
    # 3. Tách biên Canny Edge Detection
    edges = cv2.Canny(blurred, 50, 150)
    
    # 4. Định nghĩa Vùng quan tâm (Region of Interest - ROI)
    height, width = edges.shape
    roi_vertices = np.array([[
        (0, height),
        (width // 4, height // 2),
        (3 * width // 4, height // 2),
        (width, height)
    ]], dtype=np.int32)
    
    mask_roi = np.zeros_like(edges)
    cv2.fillPoly(mask_roi, roi_vertices, 255)
    masked_edges = cv2.bitwise_and(edges, mask_roi)
    
    # 5. Biến đổi Probabilistic Hough Line Transform
    lines = cv2.HoughLinesP(masked_edges, rho=1, theta=np.pi/180, 
                            threshold=20, minLineLength=20, maxLineGap=10)
    return lines
  • Công thức tính góc lái từ độ lệch tâm ($x_{offset}$): $$x_{offset} = \frac{x_{left_bottom} + x_{right_bottom}}{2} - \frac{W_{frame}}{2}$$ $$\theta_{steer} = \arctan\left(\frac{x_{offset}}{y_{offset}}\right) \times \frac{180^\circ}{\pi}$$
def calculate_steering_angle(lines, frame_shape):
    height, width, _ = frame_shape
    if lines is None:
        return 90  # Đi thẳng mặc định
    
    left_lines, right_lines = [], []
    for line in lines:
        x1, y1, x2, y2 = line[0]
        if x2 == x1:
            continue
        slope = (y2 - y1) / (x2 - x1)
        if slope < -0.3 and x1 < width * 0.65:
            left_lines.append((x1, y1, x2, y2))
        elif slope > 0.3 and x2 > width * 0.35:
            right_lines.append((x1, y1, x2, y2))
            
    # Tính tọa độ trung bình và xác định góc lệch
    mid_frame_x = width // 2
    if len(left_lines) > 0 and len(right_lines) > 0:
        left_x = np.mean([l[2] for l in left_lines])
        right_x = np.mean([r[0] for r in right_lines])
        lane_center = (left_x + right_x) / 2.0
    elif len(left_lines) > 0:
        lane_center = np.mean([l[2] for l in left_lines]) + 80
    elif len(right_lines) > 0:
        lane_center = np.mean([r[0] for r in right_lines]) - 80
    else:
        lane_center = mid_frame_x

    x_offset = lane_center - mid_frame_x
    y_offset = int(height * 0.6)
    angle_rad = np.arctan2(x_offset, y_offset)
    angle_deg = int(angle_rad * 180.0 / np.pi) + 90
    return np.clip(angle_deg, 45, 135)

2. Kiến trúc mạng nơ-ron tích chập (CNN) phân loại biển báo

Mô hình CNN được xây dựng với cấu trúc đa tầng có trọng số gọn nhẹ để đạt tốc độ suy luận cao trên Jetson Nano:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout

def build_traffic_sign_cnn(input_shape=(64, 64, 3), num_classes=6):
    model = Sequential([
        # Khối Conv 1
        Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=input_shape),
        MaxPooling2D(pool_size=(2, 2)),
        
        # Khối Conv 2
        Conv2D(64, (3, 3), activation='relu', padding='same'),
        MaxPooling2D(pool_size=(2, 2)),
        
        # Khối Conv 3
        Conv2D(128, (3, 3), activation='relu', padding='same'),
        MaxPooling2D(pool_size=(2, 2)),
        
        # Lớp Flatten & Phân loại
        Flatten(),
        Dense(128, activation='relu'),
        Dropout(0.5),  # Chống hiện tượng Overfitting
        Dense(num_classes, activation='softmax')  # 6 nhãn biển báo
    ])
    model.compile(optimizer='adam', 
                  loss='categorical_crossentropy', 
                  metrics=['accuracy'])
    return model
  • Dataset: 3.600 ảnh thực tế thu thập từ camera IMX219 trên sa bàn gồm 6 lớp: No Turn Left (NTL), No Turn Right (NTR), Turn Left (TL), Turn Right (TR), Go Straight (GS), Stop. Tập dữ liệu được phân chia 70% Train, 15% Validation, 15% Test.

Thử nghiệm và đánh giá định lượng (Testing & Validation)

Hệ thống được kiểm thử thực tế qua hơn 50 lượt chạy trên 3 sa bàn thử nghiệm: Sa bàn đường cong tiêu chuẩn, Sa bàn giao lộ ngã ba gắn biển báo và Sa bàn đường ngoằn ngoèo liên tục.

Kịch bản kiểm thử Tổng số lần chạy Số lần bám làn thành công Tỷ lệ chính xác (%) Sai số lệch tâm trung bình ($e_{center}$)
Đoạn đường cong (R = 50cm) 20 19 95.0% $\pm 1.2\text{ cm}$
Đường ngoằn ngoèo (S-Curve) 15 13 86.7% $\pm 2.1\text{ cm}$
Ngã ba nhận diện Biển báo 20 19 95.0% $\pm 1.5\text{ cm}$

Benchmark hiệu năng và độ chính xác nhận diện biển báo

+-------------------------------------------------------------+
|               KẾT QUẢ HUẤN LUYỆN MÔ HÌNH CNN                |
|                                                             |
|   Epochs: 30            |   Training Accuracy:   98.4%      |
|   Batch size: 32        |   Validation Accuracy: 96.2%      |
|   Loss Function: 0.082  |   Test Accuracy:       95.5%      |
+-------------------------------------------------------------+
Loại biển báo Precision (%) Recall (%) F1-Score (%) Độ trễ suy luận trên Jetson Nano (ms)
Stop (Dừng lại) 98.2% 97.5% 97.8% 18.2 ms
Turn Left (Rẽ trái) 95.1% 94.8% 94.9% 18.5 ms
Turn Right (Rẽ phải) 96.0% 95.2% 95.6% 18.1 ms
No Turn Left (Cấm rẽ trái) 93.8% 92.5% 93.1% 19.0 ms
No Turn Right (Cấm rẽ phải) 94.2% 93.0% 93.6% 18.8 ms
Go Straight (Đi thẳng) 96.5% 97.0% 96.7% 17.9 ms
Trung bình toàn hệ thống 95.6% 95.0% 95.3% 18.4 ms (~28 FPS)

Đổi mới và đóng góp kỹ thuật

  1. Phương pháp kết hợp linh hoạt (Hybrid CV-CNN Architecture): Thay vì sử dụng mạng Deep Learning nguyên khối tiêu tốn tài nguyên GPU, mô hình tách biệt bài toán: sử dụng thị giác hình học Canny/Hough để xác định góc lái thời gian thực với độ trễ cực thấp (< 15ms), kết hợp mạng CNN cục bộ chỉ kích hoạt khi vùng ROI xuất hiện biển báo, giảm tải tính toán 42% cho GPU nhúng.
  2. Tự động hóa gán nhãn dữ liệu (Automated Data Labeling): Nhóm đã xây dựng script tự động trích xuất vùng đặc trưng của biển báo từ luồng video dựa trên chuyển đổi không gian màu HSV và bộ lọc hình thái học (Morphological transformations), tăng tốc độ tạo dataset gấp 5 lần so với dán nhãn thủ công.
  3. Cơ chế lọc nhiễu phân đoạn vạch kép: Sử dụng thuật toán phân chia khung hình 2 vùng (2/3 trái và 1/3 phải) kết hợp ngưỡng độ dốc âm/dương để loại trừ hoàn toàn các đường viền nền ngoài đường chạy.

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

Triển khai hệ thống phần cứng và vận hành

  • Yêu cầu triển khai: Nạp hệ điều hành JetPack lên thẻ nhớ MicroSD 64GB UHS-I U3; cấp nguồn 5V/4A qua cổng Jack nguồn ngoài của Jetson Nano.
  • Chi phí ước tính phần cứng: Khoảng 6.500.000 VNĐ - 8.000.000 VNĐ (giảm hơn 75% so với việc trang bị các kit xe tự hành công nghiệp sử dụng cảm biến LiDAR đa tầng).

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

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

  • Hệ thống xử lý ảnh bám làn dựa trên không gian màu HSV vẫn chịu ảnh hưởng nếu cường độ ánh sáng môi trường thay đổi đột ngột (dưới 150 lux hoặc trên 1200 lux).
  • Tác vụ dự đoán góc lái và nhận diện biển báo hiện chạy trên 2 luồng độc lập, chưa gom chung thành một mạng nơ-ron đa nhiệm (Multi-task Learning Network) đồng nhất.

Kế hoạch phát triển tiếp theo

  • Chuyển đổi mô hình CNN sang định dạng NVIDIA TensorRT (FP16/INT8) để tăng tốc độ suy luận từ 28 FPS lên 50+ FPS trên Jetson Nano.
  • Tích hợp thêm cảm biến siêu âm Ultrasonic HC-SR04 hoặc LiDAR 2D RPLiDAR A1 để kích hoạt tính năng phanh khẩn cấp chủ động (Autonomous Emergency Braking - AEB).
  • Ứng dụng mạng nơ-ron phân đoạn ảnh thời gian thực như MobileNet-UNet để nhận diện làn đường tự động trong mọi điều kiện ánh sáng phức tạp.

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

  • Sinh viên ngành Kỹ thuật Máy tính, Điện tử & Tự động hóa: Tài liệu tham khảo toàn diện từ thiết kế phần cứng, lập trình PWM, điều khiển servo đến xử lý ảnh OpenCV và triển khai mô hình học sâu trên Jetson Nano.
  • Kỹ sư và lập trình viên nhúng: Nắm vững mẫu thiết kế (design pattern) tối ưu hóa pipeline thị giác máy tính trên hệ thống nhúng có tài nguyên giới hạn.
  • Doanh nghiệp sản xuất Robot/AGV: Khung kiến trúc giá thành thấp, độ tin cậy cao để ứng dụng vào xe tự hành vận chuyển linh kiện trong nhà xưởng nội bộ.

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

1. Yêu cầu kỹ thuật tối thiểu để triển khai lại hệ thống này là gì?

Cần một máy tính nhúng NVIDIA Jetson Nano (khuyến nghị bản 4GB RAM B01), Camera IMX219 góc rộng, khung xe RC 1:10 tích hợp Servo lái và Động cơ DC, mạch điều khiển L298N và nguồn cấp độc lập (pin LiPo 3S 11.1V). Về phần mềm, cần cài đặt JetPack 4.6.1, OpenCV 4.5.4 hỗ trợ CUDA và TensorFlow 2.x.

2. Tại sao hệ thống sử dụng không gian màu HSV thay vì RGB để xử lý vạch làn?

Không gian màu HSV tách biệt rõ ràng giữa thành phần màu sắc (Hue - Sắc độ) và cường độ ánh sáng (Value - Giá trị sáng). Điều này giúp thuật toán phân ngưỡng màu trắng/vàng của vạch kẻ đường ổn định hơn rất nhiều khi xe di chuyển qua các vùng có độ sáng không đồng đều hoặc có bóng râm.

3. Làm thế nào để xe không bị giật lái khi góc cua thay đổi liên tục?

Góc lái $\theta_{steer}$ sau khi tính từ độ lệch tâm $x_{offset}$ được đưa qua một bộ lọc làm mượt (Moving Average Filter) hoặc bộ điều khiển tỉ lệ vi tích phân (PID Controller) trước khi xuất xung PWM tới servo, giúp triệt tiêu hiện tượng dao động góc lái đột ngột.

4. Hệ thống có khả năng nhận diện biển báo khi bị che khuất một phần không?

Mô hình CNN được huấn luyện với kỹ thuật tăng cường dữ liệu (Data Augmentation) bao gồm xoay góc ($\pm 15^\circ$), thay đổi độ sáng và crop một phần ảnh. Do đó, mô hình vẫn đạt độ chính xác trên 88% khi biển báo bị che khuất nhẹ dưới 15% diện tích bề mặt.

5. Chi phí chế tạo mô hình này có đắt không và thời gian sử dụng của pin là bao lâu?

Tổng chi phí linh kiện dao động từ 6.5 đến 8 triệu VNĐ. Với pin LiPo 3S 1500mAh 35C, xe có thể vận hành liên tục trong khoảng 35-45 phút ở chế độ xử lý toàn tải (GPU & Động cơ hoạt động liên tục).

Kết luận

Đề tài "Nghiên cứu và phát triển mô hình xe tự hành ứng dụng AI" đã hoàn thành xuất sắc các mục tiêu nghiên cứu và ứng dụng kỹ thuật đặt ra:

  • Thiết kế và chế tạo thành công mô hình xe tự hành tỷ lệ 1:10 cứng cáp, linh hoạt trên nền tảng Jetson Nano.
  • Xây dựng pipeline xử lý ảnh bám làn đường hiệu quả với sai số lệch tâm trung bình chỉ $\pm 1.2\text{ cm}$ trên sa bàn thực nghiệm.
  • Triển khai mạng CNN nhận diện 6 nhóm biển báo giao thông cơ bản đạt độ chính xác thực nghiệm 95.3% với tốc độ xử lý thời gian thực ~28 FPS.

Công trình là minh chứng rõ ràng cho tính khả thi của việc tích hợp Trí tuệ nhân tạo và Thị giác máy tính lên các hệ thống nhúng chi phí thấp, mở ra hướng ứng dụng thiết thực trong đào tạo kỹ thuật cao và công nghệ xe tự lái tại Việt Nam.

Trích dẫn đề tài: Văn Huy Du, Trần Văn Đạt (2024). Nghiên cứu và phát triển mô hình xe tự hành ứng dụng AI. Đồ án tốt nghiệp ngành Công nghệ Kỹ thuật Máy tính, Trường Đại học Sư phạm Kỹ thuật TP. Hồ Chí Minh. Giảng viên hướng dẫn: TS. Trần Vũ Hoàng.