Giới thiệu dự án

Trong kỷ nguyên phát triển mạnh mẽ của các phương tiện giao thông thông minh và xe tự hành, hệ thống hỗ trợ người lái nâng cao (ADAS - Advanced Driver Assistance Systems) đóng vai trò then chốt nhằm giảm thiểu rủi ro tai nạn. Theo số liệu thống kê từ Cục Cảnh sát Giao thông, trong 10 tháng năm 2023, cả nước đã xảy ra 9.829 vụ tai nạn giao thông đường bộ, làm chết 5.496 người và làm bị thương hàng ngàn người. Một trong những nguyên nhân hàng đầu dẫn đến các sự cố nghiêm trọng này xuất phát từ việc người điều khiển phương tiện không quan sát hoặc không tuân thủ kịp thời hiệu lệnh của biển báo giao thông.

       +----------------------------------------------------------------+
       |             HỆ THỐNG ADAS TRÊN Ô TÔ / XE TỰ HÀNH               |
       +-------------------------------+--------------------------------+
                                       |
                     +-----------------+-----------------+
                     |                                   |
       +-------------v-------------+       +-------------v-------------+
       |   TSD (Traffic Sign       |       |   TSR (Traffic Sign       |
       |   Detection)              |       |   Recognition)            |
       |   -> Định vị Bounding Box |       |   -> Phân loại nhãn biển  |
       +-------------+-------------+       +-------------+-------------+
                     |                                   |
                     +-----------------+-----------------+
                                       |
       +-------------------------------v--------------------------------+
       |     Xilinx Zynq UltraScale+ MPSoC (Ultra96-V2 FPGA)            |
       |     Gia tốc phần cứng YOLOv4-Tiny qua PYNQ Framework           |
       +----------------------------------------------------------------+

Bài toán phát hiện biển báo giao thông (TSD - Traffic Sign Detection) và nhận diện biển báo giao thông (TSR - Traffic Sign Recognition) đối mặt với nhiều thách thức đặc thù tại Việt Nam:

  • Mật độ giao thông cao, biển báo bị che khuất một phần bởi phương tiện hoặc cây cối.
  • Điều kiện môi trường và ánh sáng biến thiên phức tạp từ ngày (cường độ sáng $\approx 1500\text{ Lux}$) đến đêm ($\approx 335\text{ Lux}$).
  • Tình trạng vật lý của biển báo (cũ, mờ, biến dạng) và khoảng cách nhận diện thay đổi liên tục từ $30\text{ m}$ đến $120\text{ m}$.
  • Rào cản phần cứng nhúng: Các vi xử lý CPU truyền thống không đủ năng lực tính toán mạng nơ-ron tích chập (CNN) theo thời gian thực, trong khi các bộ gia tốc GPU hiệu năng cao (như NVIDIA Jetson) tiêu tốn nhiều năng lượng ($15\text{ W} - 30\text{ W}$), sinh nhiệt lớn và chi phí sản xuất cao.

Nhằm giải quyết triệt để các hạn chế trên, đề tài khóa luận "Hệ thống nhận diện biển báo giao thông ứng dụng công nghệ SoC" (thực hiện bởi sinh viên Phan Công Duy Khiêm, dưới sự hướng dẫn của TS. Nguyễn Minh Sơn tại Trường Đại học Công nghệ Thông tin – ĐHQG-HCM) tập trung vào các mục tiêu cụ thể:

  1. Xây dựng tập dữ liệu biển báo giao thông Việt Nam: Thu thập, phân loại và gán nhãn các nhóm biển báo phổ biến (biển cấm, biển cảnh báo, biển chỉ dẫn) trong các điều kiện môi trường thực tế.
  2. Huấn luyện mô hình thị giác máy tính rút gọn: Ứng dụng kiến trúc mạng YOLOv4-Tiny để cân bằng giữa độ chính xác nhận diện ($mAP \ge 70%$) và độ phức tạp thuật toán.
  3. Thiết kế phần cứng chuyên dụng trên FPGA SoC: Hiện thực hóa khối IP Core YOLOv4-Tiny trên kit phát triển Avnet Ultra96-V2 tích hợp vi mạch Xilinx Zynq UltraScale+ MPSoC (XCZU3EG).
  4. Tích hợp hệ sinh thái PYNQ Framework: Kết nối và điều khiển luồng dữ liệu hình ảnh trực tiếp từ USB Webcam qua giao tiếp AXI DMA tốc độ cao, xuất kết quả nhận diện ra màn hình DisplayPort với độ trễ thấp và mức tiêu thụ điện năng tối ưu ($< 5\text{ W}$).

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

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

Trước khi tiếp cận công nghệ học sâu (Deep Learning) trên SoC, các hệ thống nhận diện biển báo thường dựa trên kỹ thuật phân đoạn màu sắc (Color Segmentation) kết hợp trích xuất đặc trưng hình học truyền thống (như biến đổi Hough, Canny Edge Detector, Freeman Chain Code).

Tiêu chí so sánh Phương pháp xử lý ảnh truyền thống (Color/Shape Segmentation) Mô hình Deep Learning trên GPU (YOLOv4 / Faster R-CNN) Đề xuất: YOLOv4-Tiny trên Xilinx Zynq MPSoC FPGA
Độ chính xác trong môi trường phức tạp Thấp ($< 60%$), dễ bị nhiễu do ánh sáng biến thiên Rất cao ($80% - 95%$) Cao ($70% - 85%$), ổn định theo điều kiện ánh sáng thực nghiệm
Tốc độ xử lý (Frame Rate) Cao ($30 - 60\text{ FPS}$) nhưng tỷ lệ nhận diện sai lớn Rất cao ($30 - 100\text{ FPS}$ trên GPU rời) Đạt chuẩn thời gian thực ($15 - 35\text{ FPS}$) trên phần cứng nhúng
Năng lượng tiêu thụ (Power Consumption) Thấp ($2 - 5\text{ W}$) Rất cao ($15 - 75\text{ W}$) Rất thấp ($3 - 7\text{ W}$)
Khả năng tùy biến phần cứng Không có (phụ thuộc tập lệnh CPU) Cố định trên vi kiến trúc GPU CUDA Cao (tái cấu trúc logic qua RTL/HLS trên PL)
Chi phí triển khai hàng loạt Thấp Rất cao Tối ưu khi tích hợp thành vi mạch chuyên dụng

Yêu cầu hệ thống được lượng hóa và phân loại theo mô hình MoSCoW:

  • Must Have (Bắt buộc có): Khối IP Core Convolution $3\times3$ và Max Pooling $2\times2$ hiện thực trên Programmable Logic (PL); pipeline PYNQ load Overlay Bitstream; nhận diện chính xác các biển báo cấm cơ bản (Cấm xe tải, Cấm đỗ xe ngày chẵn,...); xuất tín hiệu bounding box qua DisplayPort.
  • Should Have (Nên có): Hoạt động ổn định ở khoảng cách phát hiện $30\text{ m} - 120\text{ m}$; hỗ trợ xử lý độ phân giải từ $416\times416$ đến $1280\times720$; công suất tiêu thụ toàn hệ thống $\le 6\text{ W}$.
  • Could Have (Có thể có): Chuyển đổi mô hình sang định dạng ONNX/TensorFlow Graph để tối ưu hóa đồ thị tính toán (Dataflow Graph).
  • Won't Have (Chưa thực hiện trong phạm vi này): Nhận diện đa mục tiêu với hơn 50 lớp biển báo cùng lúc ở tốc độ xe $> 60\text{ km/h}$.

Thiết kế hệ thống

Kiến trúc hệ thống được xây dựng trên nền tảng Xilinx Zynq UltraScale+ MPSoC XCZU3EG, phân chia nhiệm vụ tối ưu giữa hệ thống vi xử lý (Processing System - PS) và logic khả trình (Programmable Logic - PL):

graph TD
    subgraph PS["Processing System (PS) - ARM Cortex-A53"]
        CAM["USB Webcam (Video Stream)"] -->|USB 3.0| PYNQ_DRV["PYNQ Framework / OpenCV"]
        PYNQ_DRV -->|Frame Buffer| DDR4["2GB LPDDR4 Memory"]
        DDR4 -->|Control Signals| CTRL["AXI Master / AXI-Lite"]
        RES["Bounding Box / Output Render"] -->|DP Native Protocol| DP["Mini DisplayPort (Monitor)"]
    end

    subgraph PL["Programmable Logic (PL) - Custom IP Accelerator"]
        CTRL -->|Trigger Inference| IP_YOLO["YOLOv4-Tiny IP Core"]
        DDR4 <-->|High-Throughput Frame Data via AXI DMA / S_AXI_HP| IP_YOLO
        IP_YOLO -->|Compute Feature Maps: Conv 3x3 + Pool 2x2| IP_YOLO
        IP_YOLO -->|Write Back Tensor Predictions| DDR4
    end

    IP_YOLO -->|Interrupt / Done Signal| PYNQ_DRV

  • Technology Stack:

    • Phần cứng: Avnet Ultra96-V2, vi mạch Zynq UltraScale+ XCZU3EG SBVA484, bộ nhớ 2GB LPDDR4 Micron (512M x 32), nguồn quản lý Infineon PMIC.
    • Môi trường phát triển & EDA Tools: Xilinx Vivado Design Suite 2019.2 (RTL Synthesis, Block Design, Place & Route), Vivado HLS, PetaLinux OS.
    • Nền tảng phần mềm & AI Frameworks: PYNQ Framework (Python 3.8 / Jupyter Kernel), OpenCV 4.5, TensorFlow 2.x, ONNX Runtime, Darknet Framework.
    • Công cụ gán nhãn: Roboflow, LabelImg.

  • Cấu trúc mạng YOLOv4-Tiny: Mô hình bao gồm 29 lớp Convolution, sử dụng kiến trúc CSPDarknet53 thu gọn (Cross Stage Partial Block) giúp chia tách luồng gradient, cắt giảm 50% tính toán dư thừa so với mạng DenseNet thông thường nhưng vẫn bảo toàn đặc trưng phân giải cao.

Methodology

Dự án áp dụng phương pháp thiết kế đồng bộ phần cứng / phần mềm (Hardware/Software Co-design):

+-------------------------------------------------------------------------------+
|                      QUY TRÌNH HIỆN THỰC ĐỒNG BỘ HW/SW                        |
+-------------------------------------------------------------------------------+
  [Thu thập Dataset] ---> [Gán nhãn LabelImg] ---> [Train Darknet YOLOv4-Tiny]
                                                              |
                                           +------------------+------------------+
                                           |                                     |
                                   [Export Model Weights]                 [Tối ưu ONNX Graph]
                                           |                                     |
                                [Vivado HLS: C++ to RTL]                         |
                                           |                                     |
                                [Vivado Block Design / IP]                       |
                                           |                                     |
                                  [Generate Bitstream]                           |
                                           |                                     |
                                           +------------------+------------------+
                                                              |
                                                    [PYNQ Overlay Integration]
                                                              |
                                                    [Real-time Evaluation]
  1. Giai đoạn 1 (Milestone 1 - Thu thập dữ liệu & Huấn luyện): Thu thập dữ liệu thực địa bằng camera độ phân giải HD, phân loại ảnh theo điều kiện ánh sáng (Lux) và khoảng cách ($30\text{ m} - 120\text{ m}$). Huấn luyện mô hình YOLOv4-Tiny trên GPU Host Computer.
  2. Giai đoạn 2 (Milestone 2 - Thiết kế IP phần cứng): Xây dựng khối gia tốc tính toán tích chập $3\times3$ và tổng hợp Max Pooling $2\times2$ trên Vivado. Đóng gói IP theo chuẩn giao tiếp AXI4-Stream và AXI-Lite.
  3. Giai đoạn 3 (Milestone 3 - Hiện thực hệ thống SoC & PYNQ): Tạo hệ thống phần cứng trên Vivado Block Design, cấu hình Zynq MPSoC, kết nối các đường truyền DMA và tổng hợp tạo file Bitstream. Cấu hình boot Linux PetaLinux cho Ultra96-V2.
  4. Giai đoạn 4 (Milestone 4 - Tích hợp & Kiểm thử thực địa): Viết driver Python trên giao diện PYNQ Jupyter Notebook để nạp Bitstream, xử lý luồng ảnh từ Webcam USB, thực hiện Non-Max Suppression và render kết quả lên màn hình qua cổng DisplayPort.

Implementation và kết quả

Development process

Quá trình phát triển tập trung vào việc hiện thực hóa các giải thuật cốt lõi và tối ưu hóa luồng dữ liệu phần cứng.

# pynq_yolov4_tiny_inference.py
# Module giải mã Output Tensor và thuật toán Non-Max Suppression (NMS) trên PYNQ

import numpy as np
from pynq import Overlay, allocate

class YOLOv4TinyAccelerator:
    def __init__(self, bitstream_path, conf_threshold=0.5, iou_threshold=0.4):
        # 1. Nạp file Bitstream cấu hình lại mảng logic khả trình (PL)
        self.overlay = Overlay(bitstream_path)
        self.dma = self.overlay.axi_dma_0
        self.conf_threshold = conf_threshold
        self.iou_threshold = iou_threshold
        
    def calculate_iou(self, box1, box2):
        """Tính toán Intersection over Union (IoU) giữa 2 Bounding Box"""
        x1 = max(box1[0], box2[0])
        y1 = max(box1[1], box2[1])
        x2 = min(box1[2], box2[2])
        y2 = min(box1[3], box2[3])
        
        intersection = max(0, x2 - x1) * max(0, y2 - y1)
        area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
        area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])
        union = area1 + area2 - intersection
        return intersection / union if union > 0 else 0

    def non_max_suppression(self, boxes, scores):
        """Kỹ thuật Non-Max Suppression loại bỏ các hộp dự đoán trùng lặp"""
        if len(boxes) == 0:
            return []
            
        selected_indices = []
        order = np.argsort(scores)[::-1]
        
        while len(order) > 0:
            idx = order[0]
            selected_indices.append(idx)
            if len(order) == 1:
                break
            ious = np.array([self.calculate_iou(boxes[idx], boxes[i]) for i in order[1:]])
            remaining = np.where(ious < self.iou_threshold)[0]
            order = order[remaining + 1]
            
        return selected_indices

Khối tính toán tích chập phần cứng được thiết kế theo cấu trúc song song mức thanh ghi (Register-Transfer Level - RTL) nhằm tăng tối đa thông lượng tính toán phép nhân-cộng (MAC - Multiply-Accumulate):

// conv3x3_mac_engine.v
// Module phần cứng tính toán tích chập 3x3 song song sử dụng DSP48E2 Slices

module conv3x3_mac_engine #(
    parameter DATA_WIDTH = 16,
    parameter ACCUM_WIDTH = 32
)(
    input  wire                   clk,
    input  wire                   rst_n,
    input  wire                   valid_in,
    input  wire signed [DATA_WIDTH-1:0]  pixel_window [0:8], // Ma trận 3x3 điểm ảnh
    input  wire signed [DATA_WIDTH-1:0]  weight_kernel[0:8], // Ma trận 3x3 trọng số
    input  wire signed [DATA_WIDTH-1:0]  bias,
    output reg  signed [ACCUM_WIDTH-1:0] feature_out,
    output reg                    valid_out
);

    reg signed [ACCUM_WIDTH-1:0] mult_stage [0:8];
    integer i;

    // Pipeline Stage 1: Thực thi song song 9 phép nhân trên DSP Slices
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            for (i = 0; i < 9; i = i + 1) mult_stage[i] <= 0;
        end else if (valid_in) begin
            for (i = 0; i < 9; i = i + 1) begin
                mult_stage[i] <= pixel_window[i] * weight_kernel[i];
            end
        end
    end

    // Pipeline Stage 2: Cây cộng dồn (Adder Tree) kết hợp Bias
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            feature_out <= 0;
            valid_out   <= 1'b0;
        end else begin
            feature_out <= mult_stage[0] + mult_stage[1] + mult_stage[2] +
                           mult_stage[3] + mult_stage[4] + mult_stage[5] +
                           mult_stage[6] + mult_stage[7] + mult_stage[8] + bias;
            valid_out   <= valid_in;
        end
    end
endmodule

Testing và validation

Hệ thống được kiểm thử qua 3 giai đoạn:

  1. Kiểm thử mô hình trên máy tính chủ (Host Computer): Đo lường độ chính xác trung bình (Average Precision - AP) trên từng lớp biển báo.
  2. Kiểm thử mô phỏng phần cứng (Vivado Hardware Simulation): Xác thực dạng sóng tín hiệu các bus AXI DMA, đảm bảo không có tranh chấp bộ nhớ hay tràn dữ liệu bộ đệm (FIFO overflow).
  3. Kiểm thử thực địa (Real-world Live Test): Thu nhận hình ảnh trực tiếp từ webcam gắn trên xe thử nghiệm với các kịch bản khoảng cách và thời gian khác nhau.
Lớp đối tượng biển báo (Class Name) Số lượng mẫu (Images) Độ chính xác trung bình (AP @ IoU=0.5) Tốc độ suy luận trên GPU (ms) Tốc độ trên Zynq Ultra96-V2 (ms)
Biển cấm đỗ xe ngày chẵn 350 76.4% 4.2 ms 38.5 ms
Biển cấm xe tải 420 74.8% 4.1 ms 37.9 ms
Biển cảnh báo nguy hiểm 380 72.1% 4.3 ms 39.2 ms
Biển giới hạn tốc độ 410 75.3% 4.0 ms 36.8 ms
Trung bình toàn hệ thống ($mAP$) 1,560 74.65% 4.15 ms 38.10 ms ($\approx 26.2\text{ FPS}$)

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

Tài nguyên phần cứng sử dụng trên chip Xilinx Zynq UltraScale+ XCZU3EG sau quá trình tổng hợp (Synthesis) và định tuyến (Implementation) trong Vivado 2019.2:

+-------------------------------------------------------------------------------+
|              TÀI NGUYÊN PHẦN CỨNG TIÊU THỤ TRÊN XCZU3EG MPSoC                 |
+-------------------+--------------------+--------------------+-----------------+
| Resource          | Used               | Available          | Utilization (%) |
+-------------------+--------------------+--------------------+-----------------+
| LUT (Logic)       | 42,180             | 70,560             | 59.78%          |
| Flip-Flop (FF)    | 53,410             | 141,120            | 37.85%          |
| BRAM (Block RAM)  | 148                | 216                | 68.52%          |
| DSP48E2 Slices    | 252                | 360                | 70.00%          |
+-------------------+--------------------+--------------------+-----------------+
  • Công suất tiêu thụ đo đạc thực tế: Mức tiêu thụ điện toàn hệ thống trên Ultra96-V2 đạt mức $4.35\text{ W}$, giảm hơn $70%$ so với nền tảng nhúng GPU NVIDIA Jetson TX2 ($\approx 15\text{ W}$).
  • Hiệu suất hoạt động thực tế: Hệ thống nhận diện ổn định biển báo ở khoảng cách từ $30\text{ m}$ đến $120\text{ m}$, đạt tốc độ xử lý $26.2\text{ FPS}$ ở độ phân giải $416\times416$, hoàn toàn đáp ứng tiêu chuẩn xử lý thời gian thực cho phương tiện di chuyển ở tốc độ nội đô ($30 - 50\text{ km/h}$).

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

  • Tối ưu hóa kiến trúc mạng YOLOv4-Tiny cho SoC: Khóa luận đã tinh giản cấu trúc mạng xuống còn 29 lớp Convolution và tích hợp khối CSPDarknet53, cho phép giảm đáng kể kích thước mô hình bộ nhớ trọng số mà không làm suy giảm nghiêm trọng độ chính xác nhận diện ($mAP$ đạt $74.65%$, vượt chỉ tiêu đặt ra $\ge 70%$).
  • Xây dựng bộ gia tốc phần cứng chuyên biệt trên FPGA: Thay vì chạy mô hình thông qua phần mềm thuần túy trên CPU ARM, đề tài đã thiết kế các khối IP Core tính toán tích chập và pooling xử lý song song trên mảng logic PL, khai thác tối đa 252 khối DSP48E2 để đạt tốc độ xử lý $26.2\text{ FPS}$.
  • Khắc phục hạn chế của phương pháp phân đoạn màu truyền thống: Hệ thống có khả năng nhận diện ổn định trong điều kiện chiếu sáng biến thiên mạnh từ đêm tối ($335\text{ Lux}$) đến ban ngày rực nắng ($1500\text{ Lux}$), loại bỏ hoàn toàn các lỗi nhận diện sai do bóng đổ hay nhiễu màu.
  • Cung cấp tập dữ liệu thực tế về biển báo Việt Nam: Xây dựng tập dữ liệu biển báo chuẩn hóa, làm tiền đề nghiên cứu mở rộng cho cộng đồng phát triển ADAS trong nước.

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

+-------------------------------------------------------------------------------+
|                    MÔ HÌNH TRIỂN KHAI THỰC TẾ TRÊN XE Ô TÔ                    |
+-------------------------------------------------------------------------------+

     [Camera gắn kính lái]
              |
              | (USB 3.0 Interface)
              v
     +-------------------------------------------------------------+
     | Hộp điều khiển trung tâm (Embedded ECU Case)                |
     |  - Board mạch: Avnet Ultra96-V2 (Zynq MPSoC XCZU3EG)        |
     |  - Nguồn cung cấp: Buck Converter 12V xe hơi -> 12V/2A DC   |
     |  - Lưu trữ: Thẻ MicroSD chứa PetaLinux OS + PYNQ Overlay    |
     +------------------------------+------------------------------+
                                    |
                                    | (Mini DisplayPort / CAN Bus)
                                    v
     +-------------------------------------------------------------+
     | Bảng điều khiển trung tâm (Head-Up Display / Dashboard)     |
     |  - Cảnh báo âm thanh khi phát hiện biển cấm                 |
     |  - Hiển thị Bounding Box & nhãn biển báo thời gian thực     |
     +-------------------------------------------------------------+

Hướng dẫn triển khai hệ thống (Step-by-Step Deployment)

  1. Chuẩn bị phần cứng: Kit Avnet Ultra96-V2, thẻ nhớ MicroSD SanDisk Extreme 32GB (Class 10), Webcam chuẩn USB UVC (Logitech C920 hoặc tương đương), cáp Mini DisplayPort to HDMI, màn hình hiển thị.
  2. Ghi Image hệ điều hành: Sử dụng công cụ Balena Etcher nạp file PYNQ v2.6 Image cho Ultra96-V2 vào thẻ nhớ MicroSD.
  3. Cấu hình Boot Mode: Gạt switch SW3 trên board Ultra96-V2 về chế độ SD Boot (0100).
  4. Nạp Overlay & Chạy ứng dụng: 
    # Kết nối SSH vào Ultra96-V2 qua Wi-Fi Access Point mặc định
ssh xilinx@192.168.2.1
# Password mặc định: xilinx

# Di chuyển vào thư mục dự án và khởi chạy Notebook
cd /home/xilinx/jupyter_notebooks/traffic_sign_tsr/
python3 run_realtime_detection.py --bitstream yolo_top.bit --classes vietnamese_signs.names
  5. Hiệu chỉnh camera: Đặt camera tại vị trí trung tâm phía sau gương chiếu hậu trong cabin ô tô, đảm bảo góc quét bao phủ làn đường từ $30\text{ m} - 120\text{ m}$.

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

Hạn chế kỹ thuật

  • Tài nguyên phần cứng trên dòng ZU3EG còn eo hẹp: Số lượng khối DSP ($360$) và BRAM ($216$) trên chip XCZU3EG giới hạn khả năng mở rộng các mạng nơ-ron có kích thước lớn hơn hoặc xử lý đồng thời nhiều luồng camera độ phân giải $4\text{K}$.
  • Tập dữ liệu chưa bao quát thời tiết khắc nghiệt: Dữ liệu huấn luyện chưa bao gồm các điều kiện mưa bão lớn, sương mù dày đặc hoặc ban đêm hoàn toàn không có đèn đường.
  • Chưa tích hợp giao tiếp mạng CAN Bus: Tín hiệu cảnh báo hiện tại chỉ xuất trực tiếp qua màn hình DisplayPort, chưa truyền bản tin cảnh báo vào mạng giao tiếp nội bộ ECU của xe để can thiệp trực tiếp vào hệ thống phanh tự động.

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

  • Áp dụng kỹ thuật Lượng tử hóa INT8 (Quantization-Aware Training): Chuyển đổi trọng số từ Float32 sang Fixed-point INT8 nhằm giảm $75%$ dung lượng bộ nhớ và tăng tốc độ suy luận lên gấp $2 - 3$ lần trên FPGA.
  • Nâng cấp lên nền tảng phần cứng cao cấp hơn: Triển khai trên các dòng Xilinx Kria KV260 Vision AI Starter Kit hoặc Zynq UltraScale+ ZU9EG để tích hợp nhân Xilinx DPU (Deep Learning Processing Unit) chuyên dụng.
  • Mở rộng bài toán đa tác vụ (Multi-task Learning): Tích hợp thêm các bài toán nhận diện làn đường (Lane Detection), phát hiện người đi bộ và nhận diện đèn tín hiệu giao thông trong cùng một kiến trúc phần cứng duy nhất.

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

  • Sinh viên & Học viên Cao học ngành Kỹ thuật Máy tính / Điện tử: Cung cấp tài liệu tham khảo thực tiễn và mã nguồn mẫu hoàn chỉnh về quy trình thiết kế phần cứng / phần mềm đồng bộ trên FPGA SoC sử dụng PYNQ Framework.
  • Kỹ sư Embedded AI & FPGA Developers: Nắm bắt được phương pháp tối ưu hóa mạng CNN, kỹ thuật ánh xạ giải thuật tính toán tích chập lên tài nguyên logic PL và phương thức quản lý luồng dữ liệu DMA tốc độ cao.
  • Các doanh nghiệp sản xuất thiết bị IoT & Phụ kiện Ô tô: Sở hữu thiết kế mẫu có tính khả thi thương mại cao cho dòng sản phẩm camera hành trình AI thông minh, tiêu thụ ít điện năng, giá thành phần cứng hợp lý.
  • Các nhà nghiên cứu trong lĩnh vực Giao thông Thông minh (ITS): Khai thác tập dữ liệu biển báo giao thông Việt Nam đã được gán nhãn chuẩn hóa phục vụ các công trình nghiên cứu tiếp theo.

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

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

Hệ thống yêu cầu một kit mạch nhúng hỗ trợ SoC/FPGA (khuyến nghị từ dòng Zynq UltraScale+ ZU3EG trở lên với tối thiểu 2GB LPDDR4), một thẻ nhớ MicroSD tối thiểu 16GB Class 10, một camera USB chuẩn UVC hỗ trợ độ phân giải tối thiểu 720p @ 30 FPS và nguồn cấp điện chuyển đổi DC-DC $12\text{V} \rightarrow 12\text{V}/2\text{A}$ ổn định từ bình ắc quy xe.

2. Giới hạn mở rộng (Scalability) của hệ thống khi tăng số lượng lớp biển báo là bao nhiêu?

Khi tăng số lớp nhận diện từ 10 lớp lên 50 hoặc 100 lớp, cấu trúc các lớp trích xuất đặc trưng (Backbone & Neck) trên phần cứng PL không thay đổi. Chỉ có kích thước của lớp Fully Connected / Detection Head cuối cùng thay đổi, làm tăng nhẹ dung lượng bộ nhớ chứa file trọng số ($< 5\text{ MB}$) mà không làm suy giảm đáng kể tốc độ khung hình (FPS chỉ dao động trong khoảng $\pm 3%$).

3. Hệ thống có thể tích hợp với các hệ thống điều khiển có sẵn trên ô tô không?

Hoàn toàn có thể. Zynq MPSoC tích hợp sẵn các bộ điều khiển CAN Controller, I2C, SPI và UART trên phần PS. Người phát triển có thể cấu hình module giao tiếp CAN Bus trong Linux Kernel để gửi mã hiệu cảnh báo (Warning Code) trực tiếp đến mạng điều khiển ECU trung tâm của xe.

4. Tại sao lại chọn FPGA UltraScale+ thay vì chip GPU nhúng chuyên dụng như NVIDIA Jetson Nano?

FPGA có ưu thế vượt trội về tính tiền định (deterministic latency), khả năng tùy biến luồng dữ liệu phần cứng ở mức bit/thanh ghi, mức tiêu thụ năng lượng thấp ($< 5\text{ W}$ so với $10 - 15\text{ W}$ của Jetson) và độ bền công nghiệp cao, phù hợp với các tiêu chuẩn khắt khe trong môi trường ô tô (Automotive Grade).

5. Chi phí phần cứng và thời gian hoàn vốn (ROI) khi thương mại hóa như thế nào?

Chi phí linh kiện cho một module hoàn chỉnh ở quy mô thử nghiệm ước tính khoảng $$150 - $250$. Khi tiến hành sản xuất hàng loạt dạng vi mạch tích hợp chuyên dụng (ASIC/System-on-Module), chi phí có thể giảm xuống dưới $$50/\text{thiết bị}$. Đối với các hãng vận tải hoặc xe dịch vụ, việc trang bị hệ thống giúp ngăn ngừa các lỗi vi phạm giao thông và giảm thiểu tai nạn có thể mang lại thời gian thu hồi vốn đầu tư trong vòng dưới 6 tháng vận hành.

Kết luận

Đề tài "Hệ thống nhận diện biển báo giao thông ứng dụng công nghệ SoC" đã giải quyết trọn vẹn bài toán ứng dụng kỹ thuật học sâu tiên tiến trên nền tảng phần cứng nhúng khả trình. Bằng việc kết hợp kiến trúc mạng YOLOv4-Tiny rút gọn với năng lực xử lý song song mạnh mẽ của Xilinx Zynq UltraScale+ MPSoC (Ultra96-V2) thông qua PYNQ Framework, hệ thống đã đạt độ chính xác nhận diện $mAP = 74.65%$, tốc độ xử lý thời gian thực $26.2\text{ FPS}$ với mức tiêu thụ năng lượng chỉ $4.35\text{ W}$.

Thành công của đề tài không chỉ khẳng định tính khả thi của phương pháp thiết kế đồng bộ phần cứng / phần mềm trong lĩnh vực thị giác máy tính nhúng, mà còn mở ra tiềm năng ứng dụng to lớn trong việc nội địa hóa các giải pháp an toàn giao thông thông minh và hệ thống ADAS cho ngành công nghiệp ô tô tại Việt Nam.