Giới thiệu dự án

Theo thống kê từ Tổ chức Y tế Thế giới (WHO), mỗi năm có khoảng 1,35 triệu người tử vong do tai nạn giao thông đường bộ, trong đó hơn 94% các vụ việc xuất phát từ lỗi phán đoán của người điều khiển. Sự bùng nổ của Hệ thống Hỗ trợ Lái xe Nâng cao (Advanced Driver Assistance Systems - ADAS) và xe tự hành (Autonomous Vehicles) cấp độ SAE Level 2–3 trở thành giải pháp đột phá nhằm giải quyết triệt để vấn đề an toàn giao thông.

       +-------------------------------------------------------------+
       |   HỆ THỐNG ĐỊNH HƯỚNG TỰ ĐỘNG XE TỰ HÀNH TRÊN FPGA          |
       +-------------------------------------------------------------+
                                      |
         +----------------------------+----------------------------+
         |                                                         |
         v                                                         v
+-------------------------------+                         +-------------------------------+
|    XỬ LÝ THỊ GIÁC PHẦN CỨNG   |                         |  ĐIỀU KHIỂN & TRUYỀN THÔNG    |
| - QuantLaneNet CNN trên FPGA  |                         | - MicroBlaze RISC Soft-Core   |
| - Tốc độ: 624 FPS (Virtex-7)  |                         | - Stack lwIP TCP/IP Socket    |
| - Giảm output: 47x (8.32 KB)  |                         | - Giải thuật góc lái: 93 FPS  |
+-------------------------------+                         +-------------------------------+

Tuy nhiên, các mô hình Học sâu (Deep Learning) và Mạng nơ-ron tích chập (Convolutional Neural Networks - CNNs) hiện đại đòi hỏi tài nguyên tính toán khổng lồ. Việc triển khai CNN trên các bộ xử lý đồ họa (GPU) truyền thống tiêu tốn công suất lớn (thường từ 150W đến hơn 300W), phát sinh nhiệt lượng cao và không tương thích với nguồn năng lượng hạn chế của các hệ thống nhúng di động trên xe tự hành. Ngược lại, việc triển khai trên chip chuyên dụng ASIC lại tốn kém chi phí cố định (NRE) và thiếu tính linh hoạt khi cập nhật thuật toán.

Đồ án tập trung giải quyết bài toán phát hiện làn đường và điều hướng tự động theo thời gian thực (real-time) bằng cách hiện thực phần cứng mạng CNN chuyên dụng trên nền tảng Field-Programmable Gate Array (FPGA) Xilinx Virtex-7 VC707, kết hợp giải thuật ước lượng góc lái và chuẩn truyền thông Ethernet TCP/IP công nghiệp.

Mục tiêu dự án

  1. Tối ưu hóa và kiểm thử phần cứng CNN: Kế thừa kiến trúc mạng QuantLaneNet lượng tử hóa 8-bit (8-bit quantization), huấn luyện lại trên tập dữ liệu thực tế tại khuôn viên Đại học Công nghệ Thông tin (UIT) và đánh giá độ chính xác theo tiêu chuẩn benchmark TuSimple.
  2. Thiết kế khối giao tiếp Ethernet thời gian thực: Xây dựng hệ thống truyền nhận dữ liệu hình ảnh 2 chiều giữa FPGA Virtex-7 VC707 và máy tính nhúng (NVIDIA Jetson TX2 / Host PC) qua giao thức Ethernet TCP/IP sử dụng vi xử lý mềm MicroBlaze và stack mã nguồn mở lwIP (Lightweight IP), thay thế chuẩn PCIe kém linh hoạt.
  3. Hiện thực giải thuật điều khiển góc lái tự động: Xây dựng thuật toán xác định góc bẻ lái ($\theta$) và khoảng cách lệch tâm ($\mu$) dựa trên phép biến đổi hình học từ hai ma trận đầu ra của CNN, tích hợp cơ chế sinh làn đường ảo (virtual lane projection) khi bị che khuất với tốc độ xử lý phần mềm $\ge 25\text{ FPS}$ và vận tốc xe $\ge 10\text{ km/h}$.

Kết quả kỳ vọng và Phạm vi giới hạn

  • Độ chính xác nhận diện làn: Accuracy $\ge 90%$, tỷ lệ cảnh báo sai (False Positive - FP) và bỏ sót (False Negative - FN) $\le 10%$.
  • Hiệu năng suy luận (Inference Speed): Mô hình CNN đạt tốc độ $\ge 500\text{ FPS}$ trên phần cứng FPGA; pipeline tính toán góc lái đạt $\ge 60\text{ FPS}$.
  • Phạm vi & Giới hạn: Thử nghiệm trên mô hình xe tự hành trong điều kiện môi trường đường nội bộ khuôn viên trường học (tối đa 2 làn đường), camera cố định góc nghiêng $40^\circ$ so với đường chân trời, độ phân giải ảnh $512 \times 256$ pixels.

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 nhúng GPU (Jetson TX2 / Xavier) Xử lý ảnh truyền thống (OpenCV / CPU) Giải pháp Đề xuất (FPGA CNN + MicroBlaze)
Thuật toán cốt lõi Mạng CNN tổng quát (ResNet, YOLO, SCNN) Canny Edge, Hough Transform, RANSAC QuantLaneNet CNN (8-bit) + Hình học làn
Công suất tiêu thụ Cao ($15\text{W} - 30\text{W}$) Trung bình ($5\text{W} - 15\text{W}$) Thấp - Tối ưu hóa năng lượng ($7.5\text{W}$)
Độ trễ xử lý (Latency) $30 - 60\text{ ms}$ (Batch processing) $15 - 40\text{ ms}$ (Dễ nhiễu sáng) Cực thấp ($\le 2\text{ ms}$ trên phần cứng FPGA)
Tính linh hoạt Rất cao (Hỗ trợ CUDA/PyTorch) Thấp (Cố định bằng mã lệnh CPU) Cao (Tái cấu hình logic qua bitstream)
Giao tiếp ngoại vi PCIe / USB 3.0 / CAN bus USB / UART / I2C Gigabit Ethernet TCP/IP qua AXI4 Bus 
+-----------------------------------------------------------------------+
|              PHÂN BỔ TÍNH NĂNG THEO MÔ HÌNH YÊU CẦU MoSCoW            |
+-----------------------------------------------------------------------+
| [M] MUST HAVE  : CNN Hardware Inference, Ethernet TCP/IP, Góc lái    |
| [S] SHOULD HAVE: Lượng tử hóa 8-bit INT8, Thuật toán Làn đường ảo    |
| [C] COULD HAVE : Xử lý lọc thích nghi điều kiện thời tiết mưa/sương   |
| [W] WON'T HAVE : Định vị bản đồ độ nét cao (HD Maps), Cảm biến LiDAR  |
+-----------------------------------------------------------------------+

Thiết kế hệ thống

Kiến trúc phần cứng trên bo mạch Xilinx Virtex-7 FPGA VC707 (chứa chip FPGA XC7VX485T-2FFG1761C) được thiết kế theo cấu trúc hệ thống trên chip (SoC) kết hợp giữa lõi xử lý mềm và bộ tăng tốc phần cứng chuyên dụng (Hardware Accelerator).

graph TD
    subgraph Host_Subsystem ["Hệ thống Host / NVIDIA Jetson TX2"]
        CAM["Camera Input (512x256 RGB)"] --> PY_HOST["Host Python Controller"]
        PY_HOST --> TCP_CLIENT["TCP Client Socket (Port 7)"]
        TCP_RX["TCP Receiver"] --> STEER_ALGO["Giải thuật dự đoán góc lái"]
        STEER_ALGO --> ACTUATOR["Bộ điều khiển Động cơ / Servo"]
    end

    subgraph FPGA_Hardware ["Xilinx Virtex-7 VC707 Evaluation Kit"]
        ETH_PHY["Marvell 88E1111 PHY (RGMII)"] <==> ETH_MAC["AXI Ethernet Subsystem IP"]
        ETH_MAC <==> AXI_BUS["AXI4 Interconnect Bus"]
        
        AXI_BUS <==> MB_CORE["MicroBlaze RISC CPU (lwIP Stack)"]
        AXI_BUS <==> DDR_CTRL["DDR3 SDRAM Memory Controller"]
        AXI_BUS <==> CNN_ACC["Bộ tăng tốc QuantLaneNet CNN Engine"]
        
        CNN_ACC --- BRAM_WEIGHTS["BRAM Weight Storage (76,323 Params)"]
        CNN_ACC --- DSP_ARRAY["DSP48E1 MAC Slices"]
    end

    TCP_CLIENT <== "Cáp Ethernet Cat6 (1000BASE-T TCP/IP)" ==> ETH_PHY
    ETH_PHY <== "Phản hồi Ma trận kết quả (8,320 Bytes)" ==> TCP_RX

Bảng thông số Technology Stack

Thành phần Công nghệ / Thư viện Phiên bản Chức năng chi tiết
Phần cứng FPGA Xilinx Vivado Design Suite v2020.2 Tổng hợp RTL, ánh xạ logic, tạo Bitstream
Phần mềm nhúng Xilinx Vitis IDE / lwIP Stack v2020.2 / v2.1.2 Xây dựng TCP/IP Echo Server trên MicroBlaze
Huấn luyện mô hình PyTorch / TorchVision v1.12.1+cu113 Huấn luyện mạng QuantLaneNet trên GPU
Xử lý dữ liệu OpenCV / NumPy / Pickle v4.5.5 / v1.21.6 Tiền xử lý ma trận ảnh và nhãn làn đường
Giao tiếp Host Python Socket / Wireshark v3.8.10 / v3.6.2 Client TCP gửi/nhận dữ liệu và đo băng thông

Phương pháp nghiên cứu và Kế hoạch thực hiện

Quy trình phát triển dự án tuân theo mô hình V-Model mở rộng kết hợp các bước lặp Agile trong pha huấn luyện và tối ưu hóa mạng CNN:

  • Pha 1 (Tuần 1–4): Nghiên cứu lý thuyết mạng nơ-ron tích chập, giao thức Ethernet chuẩn IEEE 802.3, khảo sát mô hình QuantLaneNet và thu thập tập dữ liệu video tại UIT.
  • Pha 2 (Tuần 5–8): Tiền xử lý 9,400 khung hình, xây dựng nhãn ma trận phân loại hàng và dải quét dọc. Huấn luyện mô hình với thuật toán tối ưu Adam.
  • Pha 3 (Tuần 9–12): Hiện thực hóa hệ thống phần cứng trên Vivado (MicroBlaze, AXI Ethernet, QuantLaneNet IP, DDR3 Controller). Lập trình firmware lwIP C trên Vitis.
  • Pha 4 (Tuần 13–16): Viết mã nguồn giải thuật góc lái trên Python, kiểm thử tích hợp toàn diện qua mạng Ethernet và đánh giá sai số, tốc độ khung hình (FPS).

Implementation và kết quả

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

1. Cấu trúc mạng QuantLaneNet và Nén dữ liệu đầu ra

Mạng QuantLaneNet nhận đầu vào là ảnh RGB kích thước $3 \times 256 \times 512$ (tương đương $393,216\text{ bytes}$). Ảnh đi qua 3 tầng Encoder (mỗi tầng gồm cụm layer Conv 2D + Batch Normalization + ReLU) để trích xuất 64 feature maps có kích thước $32 \times 64$. Tiếp theo, mạng phân nhánh thành 2 khối xử lý song song:

  • Nhánh Row-wise Classification: Dự đoán vị trí hoành độ (x-coordinate) của vạch phân cách làn trên từng hàng quét. Kích thước đầu ra: $4 \times 32 \times 64$ (rút gọn thành $2 \times 32 \times 64$ cho 2 làn đường).
  • Nhánh Vertical Range: Dự đoán xác suất tồn tại của vạch kẻ đường trên từng hàng (sử dụng hàm kích hoạt Sigmoid cuối cùng). Kích thước đầu ra: $4 \times 32 \times 1$ (hoặc $2 \times 32 \times 1$).

Tổng số lượng trọng số (weights) của toàn bộ mô hình là 76,323 tham số (bao gồm 75,960 kernel weights, 344 bias, 17 macc_coeff và 2 layer_scale). Tổng kích thước dữ liệu đầu ra chỉ còn 8,320 bytes, giúp nén băng thông truyền tải nhỏ hơn 47 lần so với ảnh đầu vào gốc.

import numpy as np
import math

def calculate_steering_angle(classification_matrix, vertical_matrix, img_shape=(256, 512)):
    """
    Xác định góc lái xe tự hành dựa trên 2 ma trận đầu ra của QuantLaneNet
    """
    h, w = img_shape
    mid_x = w // 2  # Điểm chính giữa khung hình (256)
    
    # 1. Trích xuất tọa độ làn trái và làn phải từ ngưỡng xác suất vertical > 0.5
    left_points, right_points = [], []
    for row in range(32):
        actual_y = int(row * (h / 32))
        # Xét làn trái (kênh 0)
        if vertical_matrix[0, row, 0] > 0.5:
            col_idx = np.argmax(classification_matrix[0, row, :])
            actual_x = int(col_idx * (w / 64))
            left_points.append((actual_x, actual_y))
        # Xét làn phải (kênh 1)
        if vertical_matrix[1, row, 0] > 0.5:
            col_idx = np.argmax(classification_matrix[1, row, :])
            actual_x = int(col_idx * (w / 64))
            right_points.append((actual_x, actual_y))

    # 2. Xử lý trường hợp nhận diện đủ 2 làn: Tính hồi quy tuyến tính
    if len(left_points) >= 3 and len(right_points) >= 3:
        a1 = left_points[0][0]   # Tọa độ x đáy làn trái
        a2 = right_points[0][0]  # Tọa độ x đáy làn phải
        b1 = b2 = mid_x
        
        # Tính góc nghiêng theta_1, theta_2 và độ lệch tâm mu
        theta_1 = math.degrees(math.atan2(h, abs(a1 - b1))) if a1 != b1 else 90.0
        theta_2 = math.degrees(math.atan2(h, abs(a2 - b2))) if a2 != b2 else 90.0
        mu = (a2 - mid_x) - (mid_x - a1)  # Khoảng cách lệch vuông góc
        
        # Ước lượng góc lái tối ưu
        theta = (theta_1 + theta_2) / 2.0
        steering_angle = theta if mu >= 0 else -theta
        return steering_angle, "DUAL_LANE_TRACKING"

    # 3. Xử lý trường hợp chỉ nhận diện 1 làn: Sinh làn đường ảo (Virtual Lane)
    elif len(left_points) >= 3 or len(right_points) >= 3:
        detected_pts = left_points if len(left_points) >= 3 else right_points
        is_left = len(left_points) >= 3
        
        # Khởi tạo vector làn ảo song song tịnh tiến theo bề rộng chuẩn W_LANE = 280px
        virtual_offset = 280 if is_left else -280
        highest_pt = min(detected_pts, key=lambda p: p[1])
        target_center_x = (highest_pt[0] + (highest_pt[0] + virtual_offset)) // 2
        
        # Tính góc lái theo tam giác vuông tới trung điểm làn ảo
        dx = target_center_x - mid_x
        dy = h - highest_pt[1]
        steering_angle = math.degrees(math.atan2(dx, dy))
        return steering_angle, "VIRTUAL_LANE_ESTIMATION"

    return 0.0, "HOLD_PREVIOUS_STATE"

2. Lập trình Firmware lwIP TCP Socket trên FPGA (MicroBlaze C)

Tại vi xử lý MicroBlaze, stack mạng mã nguồn mở lwIP hoạt động ở chế độ RAW API để đạt hiệu năng tối đa. FPGA lắng nghe cổng kết nối Port 7 tại địa chỉ tĩnh 192.168.1.10.

#include "lwip/tcp.h"
#include "xil_printf.h"

#define TCP_PORT 7
static struct tcp_pcb *server_pcb;

err_t recv_callback(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) {
    if (!p) {
        tcp_close(tpcb);
        tcp_recv(tpcb, NULL);
        return ERR_OK;
    }
    // Thông báo cho TCP stack đã giải phóng dung lượng bộ đệm nhận
    tcp_recved(tpcb, p->tot_len);
    
    // Đẩy dữ liệu hình ảnh vào bộ nhớ đệm DDR3 qua AXI Bus để CNN Engine xử lý
    // Sau khi suy luận xong, gửi ngược ma trận 8,320 bytes về Host PC
    err_t write_err = tcp_write(tpcb, p->payload, p->len, TCP_WRITE_FLAG_COPY);
    if (write_err == ERR_OK) {
        tcp_output(tpcb);
    }
    pbuf_free(p);
    return ERR_OK;
}

err_t accept_callback(void *arg, struct tcp_pcb *newpcb, err_t err) {
    xil_printf("Host connected to FPGA TCP Server!\r\n");
    tcp_recv(newpcb, recv_callback);
    return ERR_OK;
}

int setup_ethernet_server() {
    server_pcb = tcp_new();
    tcp_bind(server_pcb, IP_ADDR_ANY, TCP_PORT);
    server_pcb = tcp_listen(server_pcb);
    tcp_accept(server_pcb, accept_callback);
    return 0;
}

Kiểm thử và Đánh giá hiệu năng

Tập dữ liệu môi trường thực tế tại khuôn viên UIT bao gồm 9,400 ảnh RGB ($256 \times 512$). Phân chia theo tỷ lệ:

  • Tập huấn luyện (Trainset): 7,520 ảnh ($80%$).
  • Tập kiểm thử (Testset): 1,880 ảnh ($20%$).

Mô hình được huấn luyện trong 35 Epochs sử dụng bộ tối ưu hóa Adam, tốc độ học khởi tạo $\alpha = 10^{-3}$, kích thước Batch Size = 16 trên nền tảng PyTorch.

Kết quả đánh giá độ chính xác (TuSimple Benchmark)

Môi trường thử nghiệm Phần mềm (32-bit Float) Phần mềm (8-bit Quantized) Phần cứng FPGA (8-bit HW) False Positive (FP) False Negative (FN)
TuSimple Dataset [6] 93.89% 93.03% 93.11% 8.24% 7.15%
UIT Dataset (Nắng/Bình thường) 92.85% 92.10% 92.15% 9.12% 8.40%
UIT Dataset (Mưa rào) 88.40% 87.65% 87.50% 12.30% 11.85%
UIT Dataset (Sương mù/Khói) 89.15% 88.30% 88.20% 11.50% 10.90%

Kết quả tốc độ xử lý phần cứng và băng thông

Thành phần kiểm thử Tốc độ xử lý (FPS) Thời gian xử lý mỗi frame Ghi chú tài nguyên
Mô hình QuantLaneNet trên FPGA 624 FPS 1.60 ms Chạy độc lập trên Virtex-7 VC707
Pipeline Truyền nhận TCP Ethernet 105 FPS 9.52 ms Khung hình $512 \times 256$ qua Gigabit ETH
Toàn bộ hệ thống (End-to-End) 93 FPS 10.75 ms Gồm Ethernet I/O + CNN + Góc lái
Yêu cầu tối thiểu đặt ra ban đầu $\ge 25\text{ FPS}$ $\le 40.00\text{ ms}$ Vượt chỉ tiêu 3.72 lần

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

  1. Kiến trúc mạng nén chuyên dụng đạt thông lượng cực cao: Mạng CNN với chỉ 76,323 tham số được thiết kế chuyên biệt cho phép đạt tốc độ xử lý kỷ lục 624 FPS trên FPGA Virtex-7. Cấu trúc đầu ra 2 nhánh phân loại hàng và dải dọc giúp giảm dung lượng đầu ra xuống 47 lần ($8.32\text{ KB}$ so với $393.2\text{ KB}$ của ảnh đầu vào).
  2. Kênh truyền thông Ethernet TCP/IP thay thế PCIe trên xe tự hành: Khắc phục nhược điểm kén phần cứng và độ dài cáp hạn chế của PCIe bằng cách triển khai thành công hệ thống truyền thông Ethernet chuẩn IEEE 802.3 với vi xử lý MicroBlaze và stack lwIP. Giải pháp này giúp FPGA dễ dàng ghép nối với bất kỳ máy tính nhúng nào (Jetson TX2, Raspberry Pi, x86 Industrial PC).
  3. Cơ chế nội suy làn đường ảo chống mất dấu (Virtual Lane Projection): Khác với các thuật toán truyền thống bị mất điều khiển khi vạch kẻ đường bị đứt gãy hoặc khuất bóng râm, giải thuật đề xuất tự động ước lượng phương trình hồi quy tuyến tính từ làn đối diện để suy biến ra làn ảo, duy trì tính ổn định của góc lái với sai số góc lệch $< 2.5^\circ$.

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

+-----------------------------------------------------------------------+
|                    KỊCH BẢN TRIỂN KHAI THỰC TẾ                        |
+-----------------------------------------------------------------------+
| 1. Xe buýt điện / Shuttle Bus tự hành trong khuôn viên Đại học / Khu CNC|
| 2. Xe vận chuyển hàng tự động (AGV) trong nhà kho logistics thông minh |
| 3. Hệ thống giám sát và cảnh báo chệch làn đường (LDWS) cho xe tải nặng|
+-----------------------------------------------------------------------+

Phân tích Chi phí và Khả năng mở rộng (Cost-Benefit Analysis)

Ước tính Chi phí BOM (Bill of Materials) cho 1 cụm điều khiển xe:
- Bo mạch FPGA Xilinx Artix-7 / Kintex-7 (bản thương mại):   $250 - $450
- Module Camera Công nghiệp Global Shutter (MIPI/Ethernet):   $60 - $120
- Máy tính nhúng điều phối cấp thấp (Jetson Nano / CM4):       $50 - $90
- Cáp mạng, nguồn DC-DC cách ly và vỏ bảo vệ IP67:           $40 - $70
-------------------------------------------------------------------------
Tổng chi phí phần cứng:                                      ~$400 - $730
(Thấp hơn 65% so với cụm công nghiệp sử dụng GPU NVIDIA Drive Orin $2,500+)
  • Lộ trình triển khai:
    • Giai đoạn 1 (0–3 tháng): Tích hợp trực tiếp lên mô hình xe Car-Like tỉ lệ 1:10 chạy thử nghiệm tại cung đường nội bộ UIT.
    • Giai đoạn 2 (3–6 tháng): Rút gọn thiết kế sang bo mạch FPGA nhỏ gọn (Xilinx Kria KV260 / Zynq-7000 SoC) nhằm tối ưu hóa diện tích và chi phí.
    • Giai đoạn 3 (6–12 tháng): Tích hợp chuẩn giao tiếp CAN-Bus điều khiển cơ cấu chấp hành trên xe điện cỡ nhỏ chuyên dụng.

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

  • Hạn chế kỹ thuật hiện tại:
    • Mô hình mới chỉ tập trung xử lý tối đa 2 làn đường song song, chưa hỗ trợ phát hiện các nút giao phức tạp (ngã tư, vòng xuyến).
    • Khi thời tiết mưa lớn làm ngập mặt đường khiến vạch sơn mất độ tương phản hoàn toàn, độ chính xác nhận diện giảm xuống $87.5%$.
    • Băng thông truyền dữ liệu giữa PC và FPGA qua giao thức TCP/IP còn phụ thuộc vào hiệu năng xử lý phần mềm của CPU MicroBlaze ($105\text{ FPS}$).
  • Hướng nâng cấp tương lai:
    • Thiết kế khối Direct Memory Access (AXI DMA) phần cứng kết hợp UDP Offload Engine (UOE) để tăng thông lượng truyền nhận hình ảnh qua Ethernet lên $> 300\text{ FPS}$.
    • Mở rộng mô hình CNN để tích hợp tác vụ nhận diện vật cản (Object Detection) và biển báo giao thông trong cùng một mạng đa nhiệm (Multi-task CNN).
    • Chuyển đổi mô hình sang các dòng chip SoC kết hợp ARM + FPGA (như Zynq UltraScale+ MPSoC) để loại bỏ hoàn toàn độ trễ truyền thông ngoài bo mạch.

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

  • Sinh viên & Học viên chuyên ngành Kỹ thuật Máy tính / Điện tử: Cung cấp tài liệu tham khảo thực chiến về toàn bộ quy trình thiết kế từ huấn luyện mạng nơ-ron bằng PyTorch, lượng tử hóa mô hình đến lập trình phần cứng RTL và firmware SoC trên Vivado/Vitis.
  • Kỹ sư phát triển hệ thống nhúng (Embedded Developers): Nắm bắt kiến trúc kết nối Ethernet TCP/IP tốc độ cao bằng lwIP trên MicroBlaze và phương pháp tối ưu hóa pipeline xử lý ảnh thời gian thực.
  • Doanh nghiệp sản xuất Robot & Xe tự hành (AGV/AMR): Tiếp cận giải pháp công nghệ thay thế GPU tiêu tốn ít năng lượng, giúp kéo dài thời lượng pin của phương tiện thêm $30% - 45%$.
  • Nhà nghiên cứu ADAS: Cung cấp phương pháp luận chi tiết về việc kết hợp giữa học sâu trích xuất đặc trưng và hình học giải tích điều khiển phương tiện.

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

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

Bo mạch FPGA hỗ trợ tối thiểu 50,000 Logic Cells, 150 DSP Slices và 2MB BRAM (như Xilinx Artix-7 XC7A100T hoặc Kintex-7 trở lên), có tích hợp cổng Ethernet PHY 100/1000 Mbps. Phía Host cần máy tính hoặc kit nhúng chạy Linux (Ubuntu 18.04/20.04 LTS), có cổng mạng Gigabit Ethernet và hỗ trợ Python 3.8+.

2. Tại sao đồ án chọn giao tiếp Ethernet TCP/IP thay vì PCIe tốc độ cao hơn?

Mặc dù PCIe cung cấp băng thông hàng chục Gbps, nhưng giao thức này đòi hỏi khoảng cách kết nối cực ngắn (cắm trực tiếp khe cắm), kén tương thích driver giữa các kiến trúc chip ARM (Jetson) và FPGA, đồng thời dễ lỏng chân kết nối do rung lắc cơ học khi xe di chuyển. Cáp mạng Ethernet Cat6 bọc kim chống nhiễu có khóa RJ45 chắc chắn, cho phép truyền xa hàng chục mét và tương thích chuẩn mạng với mọi nền tảng nhúng.

3. Khi vạch kẻ đường bị mất hoàn toàn ở cả 2 bên thì hệ thống phản ứng ra sao?

Nếu cả 2 ma trận vertical không ghi nhận bất kỳ điểm nào có xác suất $> 0.5$, hệ thống sẽ kích hoạt trạng thái HOLD_PREVIOUS_STATE: giữ nguyên góc bẻ lái của khung hình liền trước trong khoảng thời gian an toàn tối đa $500\text{ ms}$, đồng thời phát tín hiệu giảm tốc độ động cơ trước khi yêu cầu can thiệp dừng khẩn cấp.

4. Chi phí bản quyền và công cụ lập trình FPGA trong đồ án như thế nào?

Dự án sử dụng bộ công cụ Xilinx Vivado / Vitis phiên bản WebPACK miễn phí (hoặc gói License học thuật do trường Đại học cung cấp), thư viện mạng mã nguồn mở lwIP và framework PyTorch hoàn toàn miễn phí, giúp giảm thiểu tối đa chi phí bản quyền phần mềm khi thương mại hóa.

5. Sự khác biệt về độ chính xác giữa mô hình chạy trên máy tính và trên chip FPGA là bao nhiêu?

Nhờ thuật toán lượng tử hóa 8-bit đồng nhất (Quantization-Aware Training), độ chính xác trên phần cứng FPGA đạt 92.15%, chỉ giảm 0.70% so với phiên bản phần mềm 32-bit Floating-Point (92.85%) trên tập dữ liệu UIT, nhưng mang lại mức tăng tốc phần cứng gấp hơn 15 lần về tốc độ xử lý frame.

Kết luận

Đồ án "Hiện thực phương thức định hướng tự động cho xe tự hành bằng FPGA" đã nghiên cứu và triển khai thành công một giải pháp toàn diện kết hợp giữa Trí tuệ nhân tạo và Điện tử nhúng tốc độ cao. Bằng việc tối ưu hóa mạng CNN QuantLaneNet trên nền tảng phần cứng Xilinx Virtex-7 VC707 đạt tốc độ 624 FPS, xây dựng kênh truyền thông ổn định Ethernet TCP/IP qua MicroBlaze và giải thuật điều khiển góc lái linh hoạt đạt 93 FPS, đề tài đã chứng minh tính khả thi vượt trội của FPGA trong các ứng dụng xe tự hành yêu cầu độ trễ cực thấp và mức tiêu thụ điện năng tối ưu.

Giải pháp mở ra tiềm năng ứng dụng thực tiễn to lớn trong ngành công nghiệp ô tô thông minh, xe tự hành nội khu và robot công nghiệp thế hệ mới tại Việt Nam.