Giới thiệu dự án

Bối cảnh và thực trạng giao thông đô thị

Sự gia tăng nhanh chóng của mật độ dân số cùng tốc độ đô thị hóa tại các thành phố lớn như Hà Nội và TP. Hồ Chí Minh đã đặt áp lực khổng lồ lên mạng lưới hạ tầng giao thông. Theo thống kê từ các cơ quan quản lý đô thị, tình trạng ùn tắc giao thông tiêu tốn hàng ngàn tỷ đồng mỗi năm do lãng phí nhiên liệu, giảm năng suất lao động và gia tăng lượng khí thải độc hại ra môi trường.

Một trong những nguyên nhân kỹ thuật cốt lõi là sự phụ thuộc vào hệ thống điều khiển đèn tín hiệu chu kỳ cố định (Fixed-time Control). Các bộ định thời này hoạt động dựa trên các thông số thời gian cài đặt sẵn, không có khả năng phản ứng với sự biến động tức thời của lưu lượng phương tiện giữa các nhánh giao lộ, dẫn đến hiện tượng nhánh đường thông thoáng vẫn phải chờ đèn đỏ trong khi nhánh đối diện bị ùn ứ kéo dài.

+-------------------------------------------------------------+
|                 HỆ THỐNG ĐIỀU KHIỂN ĐÈN GIAO THÔNG         |
|                        DYNAMIC SIGNAL ADAPTATION            |
+-------------------------------------------------------------+
       |                                              |
 [Camera Nhánh A]                               [Camera Nhánh B]
       |                                              |
       v                                              v
+-------------------------------------------------------------+
|  Khối Xử Lý Ảnh Trung Tâm (Python 3.8 + OpenCV + YOLOv3/v4) |
|  - Object Detection: Car, Bus, Truck                        |
|  - Vehicle Counting & Density Estimation Algorithm          |
|  - Dynamic Timing Decision Logic (Threshold Evaluation)     |
+-------------------------------------------------------------+
                               |
                   [Giao tiếp UART - 9600 Baud]
                               |
                               v
+-------------------------------------------------------------+
|    Bộ Điều Khiển Thực Thi Vi Điện Tử (Arduino Uno R3)       |
|    - ATmega328P Microcontroller (16 MHz, 32KB Flash)        |
|    - State Machine Driver: 6x LED (Red, Yellow, Green)      |
+-------------------------------------------------------------+

Vấn đề kỹ thuật cần giải quyết (Problem Statement)

Các hệ thống đèn giao thông hiện đại nhập khẩu (như các dự án ODA sử dụng công nghệ từ Tây Ban Nha với kinh phí lên đến 3,5 triệu USD hoặc hệ thống máy tính công nghiệp Advantech tích hợp điều khiển mờ) thường có giá thành đầu tư từ hàng trăm triệu đến hàng tỷ đồng cho mỗi nút giao. Hơn nữa, việc phụ thuộc vào đối tác nước ngoài gây khó khăn lớn trong công tác bảo trì, hiệu chỉnh thuật toán khi xảy ra sự cố kỹ thuật.

Do đó, bài toán đặt ra là: Làm chủ công nghệ điều khiển giao thông thông minh với chi phí thấp bằng cách kết hợp kỹ thuật thị giác máy tính (Computer Vision) và vi điều khiển biên (Edge Microcontroller) để tối ưu hóa thời gian chu kỳ đèn theo thời gian thực (Real-time).

Mục tiêu của đồ án

  1. Nghiên cứu và triển khai mạng nơ-ron tích chập (CNN) dựa trên kiến trúc YOLO (You Only Look Once) để nhận dạng và phân loại chính xác 3 nhóm phương tiện chính: Ô tô (Car), Xe buýt (Bus), Xe tải (Truck).
  2. Xây dựng giải thuật đếm phương tiện và phân bổ thời gian động: Khi thời gian đèn xanh của một làn còn 5 giây, hệ thống kích hoạt xử lý ảnh từ camera để tính toán mật độ xe; nếu số lượng xe vượt ngưỡng, hệ thống tự động gia hạn thêm thời gian đèn xanh (tối đa 3 lần gia hạn liên tiếp).
  3. Thiết kế phần cứng và phần mềm điều khiển: Sử dụng kit vi điều khiển Arduino Uno R3 (ATmega328P) kết nối với máy tính qua chuẩn truyền thông nối tiếp bất đồng bộ UART (Universal Asynchronous Receiver-Transmitter) với tốc độ 9600 baud.
  4. Xây dựng giao diện điều khiển và giám sát (GUI): Lập trình bằng Python kết hợp framework PyQt5 để hiển thị luồng video từ 2 camera, số lượng xe đếm được, trạng thái các pha đèn và cho phép chuyển đổi linh hoạt giữa chế độ tự động (Auto) và thủ công (Manual).

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

  • Phạm vi mô hình: Mô hình ngã tư gồm 2 tuyến đường một chiều giao nhau, trang bị 2 camera thu thập hình ảnh luồng giao thông và 6 đèn LED đơn (2 Đỏ, 2 Vàng, 2 Xanh).
  • Đối tượng nhận dạng: Tập trung phân loại 3 lớp đối tượng chính là ô tô con, xe tải và xe buýt trên tập dữ liệu tùy biến.
  • Giới hạn môi trường: Đánh giá thực nghiệm trong điều kiện ánh sáng ổn định của phòng thí nghiệm; các yếu tố thời tiết cực đoan (mưa bão, ban đêm thiếu sáng nghiêm trọng) được định hướng giải quyết ở pha phát triển tiếp theo.

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

Phân tích hiện trạng và đối sánh kỹ thuật

Tiêu chí Hệ thống chu kỳ cố định (Fixed-time) Cảm biến vòng từ (Inductive Loops) Hệ thống máy tính công nghiệp (IPC - Advantech) Giải pháp Đồ án (YOLO + Arduino)
Cơ chế điều khiển Đếm lùi thời gian cố định Phát hiện kim loại cắt qua vòng từ Xử lý ảnh + Điều khiển mờ (Fuzzy Logic) Xử lý ảnh CNN (YOLO) + Vi điều khiển thích nghi
Độ linh hoạt Không có (0%) Thấp (chỉ đếm xe tại điểm) Rất cao Cao (thích ứng theo mật độ thực tế)
Chi phí triển khai Rất thấp (< 10 triệu VNĐ) Cao (cắt đường, phá vỡ hạ tầng) Rất cao (> 500 triệu - hàng tỷ VNĐ) Thấp (< 15 triệu VNĐ cho nút giao)
Khả năng bảo trì Đơn giản Phức tạp khi hỏng cảm biến ngầm Cần chuyên gia hãng hỗ trợ Dễ dàng nâng cấp phần mềm, thay linh kiện
Phân loại phương tiện Không Không Có Có (Car, Bus, Truck)

Yêu cầu hệ thống theo mô hình MoSCoW

  • Must Have (Bắt buộc có):
    • Khả năng phát hiện và phân loại chính xác xe trong vùng quan sát (ROI - Region of Interest).
    • Giao tiếp UART hai chiều chuẩn xác giữa PC và Arduino không bị nghẽn đệm dữ liệu (buffer overflow).
    • Chu kỳ chuyển mạch đèn LED đảm bảo tính an toàn giao thông: Xanh $\rightarrow$ Vàng (mặc định 3s) $\rightarrow$ Đỏ.
  • Should Have (Nên có):
    • Thuật toán cộng dồn thời gian thông minh (kéo dài đèn xanh dựa trên ngưỡng xe, chặn cứng tối đa 3 lần để tránh bỏ đói nhánh đối diện).
    • Giao diện GUI hiển thị trực quan thông số FPS, log dữ liệu và trạng thái cổng COM.
  • Could Have (Có thể có):
    • Cơ chế lưu trữ log mật độ giao thông theo giờ để phục vụ phân tích dữ liệu lớn (Big Data).
  • Won't Have (Chưa thực hiện):
    • Nhận dạng biển số xe vi phạm (ALPR) và tracking quỹ đạo phức tạp qua ngã tư đa làn nhiều chiều.

Thiết kế kiến trúc hệ thống

+-------------------------------------------------------------------------------+
|                            KIẾN TRÚC TỔNG THỂ HỆ THỐNG                         |
+-------------------------------------------------------------------------------+

  [CAMERA 1] (Nhánh 1)                [CAMERA 2] (Nhánh 2)
       |                                   |
       +-----------------+-----------------+
                         | (USB Video Stream / RTSP)
                         v
     +-----------------------------------------------+
     |              MÁY TÍNH XỬ LÝ TRUNG TÂM         |
     |                                               |
     |   +---------------------------------------+   |
     |   |   Module Thu Nhận & Tiền Xử Lý Ảnh   |   |
     |   |   - OpenCV: Frame extraction, Resize  |   |
     |   +---------------------------------------+   |
     |                       |                       |
     |                       v                       |
     |   +---------------------------------------+   |
     |   |   Mạng Nơ-ron Nhận Dạng Vật Thể       |   |
     |   |   - YOLO Architecture (Darknet Base)  |   |
     |   |   - Bounding Box & Class Confidence   |   |
     |   +---------------------------------------+   |
     |                       |                       |
     |                       v                       |
     |   +---------------------------------------+   |
     |   |   Khối Thuật Toán Quyết Định Định Thời |   |
     |   |   - Vehicle Counting per Lane         |   |
     |   |   - Adaptive Signal Timing Engine     |   |
     |   +---------------------------------------+   |
     |                       |                       |
     |                       v                       |
     |   +---------------------------------------+   |
     |   |   Giao Diện Người Dùng & Điều Khiển   |   |
     |   |   - PyQt5 GUI Dashboard               |   |
     |   +---------------------------------------+   |
     +-----------------------------------------------+
                         |
                         | (UART Serial Communication: Baud 9600, 8N1)
                         v
     +-----------------------------------------------+
     |           VI ĐIỀU KHIỂN ARDUINO UNO R3        |
     |   - ATmega328P Core Processing                |
     |   - Hardware Timer & Interrupt Management     |
     |   - GPIO Control (Digital Pins D2 - D7)       |
     +-----------------------------------------------+
                         |
       +-----------------+-----------------+
       |                                   |
       v                                   v
+------------------+              +------------------+
|  ĐÈN TÍN HIỆU 1  |              |  ĐÈN TÍN HIỆU 2  |
|  (Đỏ, Vàng, Xanh)|              |  (Đỏ, Vàng, Xanh)|
+------------------+              +------------------+

Thông số kỹ thuật của công nghệ sử dụng

  • Ngôn ngữ lập trình: Python 3.8.x kết hợp C/C++ (Arduino Embedded C).
  • Thư viện thị giác máy tính: OpenCV 4.5.x (tối ưu hóa xử lý ma trận ảnh với numpy).
  • Giao diện người dùng: PyQt5 (Qt Designer 5.15).
  • Môi trường huấn luyện: Google Colaboratory (Tesla K80 GPU, 12GB VRAM, CUDA 10.x).
  • Phần cứng vi điều khiển: Arduino Uno R3 (Vi điều khiển 8-bit ATmega328P, xung nhịp thạch anh 16 MHz, bộ nhớ Flash 32 KB, SRAM 2 KB, EEPROM 1 KB).
  • Giao thức truyền thông: UART (Universal Asynchronous Receiver-Transmitter) với cấu hình khung truyền: 8 Data bits, No Parity, 1 Stop bit (8N1), tốc độ Baud 9600 bps.

Implementation và kết quả

Quy trình huấn luyện mạng nhận dạng đối tượng (YOLO)

Mô hình YOLO chia bức ảnh đầu vào kích thước cố định thành lưới ma trận $S \times S$ (mặc định $7 \times 7$ hoặc $13 \times 13$). Mỗi ô lưới dự đoán $B$ bounding box với 5 tham số không gian: tâm $(x, y)$, kích thước $(w, h)$, và độ tin cậy $Confidence = Pr(Object) \times IOU_{pred}^{truth}$.

Tọa độ hộp bao được chuẩn hóa và tính toán thông qua hàm kích hoạt Sigmoid ($\sigma$): $$b_x = \sigma(t_x) + c_x$$ $$b_y = \sigma(t_y) + c_y$$ $$b_w = p_w e^{t_w}$$ $$b_h = p_h e^{t_h}$$

Hàm mất mát tổng thể (Total Loss Function) trong quá trình huấn luyện là sự kết hợp có trọng số giữa ba thành phần:

$$\mathcal{L}{total} = \lambda{coord} \mathcal{L}{loc} + \mathcal{L}{conf} + \mathcal{L}_{class}$$

Trong đó: $$\mathcal{L}{loc} = \sum{i=0}^{S^2} \sum_{j=0}^{B} \mathbb{I}_{ij}^{obj} \left[ (x_i - \hat{x}_i)^2 + (y_i - \hat{y}_i)^2 + (\sqrt{w_i} - \sqrt{\hat{w}_i})^2 + (\sqrt{h_i} - \sqrt{\hat{h}_i})^2 \right]$$

$$\mathcal{L}{conf} = \sum{i=0}^{S^2} \sum_{j=0}^{B} \mathbb{I}{ij}^{obj} (C_i - \hat{C}i)^2 + \lambda{noobj} \sum{i=0}^{S^2} \sum_{j=0}^{B} \mathbb{I}_{ij}^{noobj} (C_i - \hat{C}_i)^2$$

$$\mathcal{L}{class} = \sum{i=0}^{S^2} \mathbb{I}{i}^{obj} \sum{c \in classes} (p_i(c) - \hat{p}_i(c))^2$$

+-----------------------------------------------------------------------------+
|               QUY TRÌNH XỬ LÝ DỮ LIỆU VÀ HUẤN LUYỆN YOLO                   |
+-----------------------------------------------------------------------------+
 [Thu thập ảnh thực tế & Internet]
                |
                v
 [Gán nhãn Bounding Box bằng LabelImg] ---> Tạo file .txt định dạng YOLO
                |                           (<class_id> <x> <y> <w> <h>)
                v
 [Tổ chức Dataset: Train (80%) / Val (20%)]
                |
                v
 [Đồng bộ lên Google Drive]
                |
                v
 [Khởi tạo Colab với GPU Tesla K80]
                |
                v
 [Cấu hình Darknet: .cfg, .data, .names]
                |
                v
 [Quá trình huấn luyện (Iterative Training)] ---> Trích xuất file trọng số:
                                                  yolo-traffic_last.weights

Module tích hợp Python - OpenCV - UART

Đoạn mã nguồn dưới đây minh họa quá trình thu nhận frame từ camera, thực thi inference phát hiện phương tiện, tính toán số lượng và truyền tín hiệu điều khiển xuống Arduino qua cổng Serial:

import cv2
import numpy as np
import serial
import time

# Khởi tạo kết nối Serial với Arduino Uno R3
try:
    ser = serial.Serial(port='/dev/ttyUSB0', baudrate=9600, timeout=1)
    time.sleep(2)  # Đợi vi điều khiển reset sau kết nối
except Exception as e:
    print(f"Lỗi khởi tạo cổng Serial: {e}")

# Tải cấu hình mạng nơ-ron và trọng số đã huấn luyện
net = cv2.dnn.readNet("yolov3-traffic.weights", "yolov3-traffic.cfg")
classes = ["car", "bus", "truck"]
layer_names = net.getLayerNames()
output_layers = [layer_names[i - 1] for i in net.getUnconnectedOutLayers()]

def detect_and_count(frame, conf_threshold=0.5, nms_threshold=0.4):
    height, width, _ = frame.shape
    blob = cv2.dnn.blobFromImage(frame, 0.00392, (416, 416), (0, 0, 0), True, crop=False)
    net.setInput(blob)
    outs = net.forward(output_layers)
    
    class_ids, confidences, boxes = [], [], []
    for out in outs:
        for detection in out:
            scores = detection[5:]
            class_id = np.argmax(scores)
            confidence = scores[class_id]
            if confidence > conf_threshold and class_id < len(classes):
                center_x = int(detection[0] * width)
                center_y = int(detection[1] * height)
                w = int(detection[2] * width)
                h = int(detection[3] * height)
                x = int(center_x - w / 2)
                y = int(center_y - h / 2)
                boxes.append([x, y, w, h])
                confidences.append(float(confidence))
                class_ids.append(class_id)
                
    indices = cv2.dnn.NMSBoxes(boxes, confidences, conf_threshold, nms_threshold)
    vehicle_count = len(indices)
    return vehicle_count, boxes, indices

def process_traffic_decision(cap_channel_1, cap_channel_2):
    while True:
        # Lắng nghe tín hiệu yêu cầu kiểm tra từ Arduino (gửi khi đèn xanh còn 5s)
        if ser.in_waiting > 0:
            request_code = ser.read().decode('utf-8')
            if request_code == 'REQ_CH1':
                ret, frame = cap_channel_1.read()
                if ret:
                    count, _, _ = detect_and_count(frame)
                    # Nếu số xe vượt ngưỡng 3, gửi lệnh kéo dài thời gian đèn xanh (EXTEND)
                    if count >= 3:
                        ser.write(b'EXTEND_CH1\n')
                    else:
                        ser.write(b'NEXT_PHASE\n')

Module điều khiển nhúng trên Arduino Uno (C++)

Mã nguồn điều khiển máy trạng thái (FSM - Finite State Machine) thực thi chuyển đổi đèn tín hiệu và ngắt giao tiếp UART:

// Định nghĩa các chân điều khiển LED ngã tư
const int LED_RED_1 = 2, LED_YEL_1 = 3, LED_GRN_1 = 4;
const int LED_RED_2 = 5, LED_YEL_2 = 6, LED_GRN_2 = 7;

enum TrafficState { CH1_GREEN, CH1_YELLOW, CH2_GREEN, CH2_YELLOW };
TrafficState currentState = CH1_GREEN;

int greenDuration = 15; // Thời gian đèn xanh cơ sở (giây)
int yellowDuration = 3; // Thời gian đèn vàng (giây)
int extensionCount = 0;
const int MAX_EXTENSIONS = 3;

void setup() {
  Serial.begin(9600);
  for (int pin = 2; pin <= 7; pin++) {
    pinMode(pin, OUTPUT);
  }
}

void setLights(int r1, int y1, int g1, int r2, int y2, int g2) {
  digitalWrite(LED_RED_1, r1); digitalWrite(LED_YEL_1, y1); digitalWrite(LED_GRN_1, g1);
  digitalWrite(LED_RED_2, r2); digitalWrite(LED_YEL_2, y2); digitalWrite(LED_GRN_2, g2);
}

void loop() {
  switch (currentState) {
    case CH1_GREEN:
      setLights(LOW, LOW, HIGH, HIGH, LOW, LOW);
      handleAdaptiveGreenPhase(1);
      currentState = CH1_YELLOW;
      break;

    case CH1_YELLOW:
      setLights(LOW, HIGH, LOW, HIGH, LOW, LOW);
      delay(yellowDuration * 1000);
      currentState = CH2_GREEN;
      extensionCount = 0;
      break;

    case CH2_GREEN:
      setLights(HIGH, LOW, LOW, LOW, LOW, HIGH);
      handleAdaptiveGreenPhase(2);
      currentState = CH2_YELLOW;
      break;

    case CH2_YELLOW:
      setLights(HIGH, LOW, LOW, LOW, HIGH, LOW);
      delay(yellowDuration * 1000);
      currentState = CH1_GREEN;
      extensionCount = 0;
      break;
  }
}

void handleAdaptiveGreenPhase(int channel) {
  int remainingTime = greenDuration;
  while (remainingTime > 0) {
    delay(1000);
    remainingTime--;

    // Khi còn 5 giây cuối, kích hoạt yêu cầu xử lý ảnh
    if (remainingTime == 5 && extensionCount < MAX_EXTENSIONS) {
      if (channel == 1) Serial.print("REQ_CH1");
      else Serial.print("REQ_CH2");

      unsigned long startTime = millis();
      while (millis() - startTime < 1000) { // Chờ phản hồi tối đa 1s
        if (Serial.available()) {
          String response = Serial.readStringUntil('\n');
          if (response.indexOf("EXTEND") >= 0) {
            remainingTime += 5; // Gia hạn thêm 5 giây đèn xanh
            extensionCount++;
            break;
          }
        }
      }
    }
  }
}

Kết quả đo lường và đánh giá hiệu năng

Hệ thống được thử nghiệm với bộ dữ liệu kiểm thử gồm 500 ảnh chứa các tình huống giao thông khác nhau:

+-------------------------------------------------------------+
|             MA TRẬN ĐÁNH GIÁ ĐỘ CHÍNH XÁC NHẬN DẠNG         |
+-------------------------------------------------------------+
|  Lớp Đối Tượng (Class)  |  Precision (%) |  Recall (%) |  mAP (%) |
+-------------------------+----------------+-------------+----------+
|  Car (Ô tô con)         |     93.4%      |    91.2%    |  92.3%   |
|  Bus (Xe buýt)          |     89.6%      |    87.5%    |  88.5%   |
|  Truck (Xe tải)         |     91.2%      |    88.9%    |  90.1%   |
+-------------------------+----------------+-------------+----------+
|  Trung bình toàn hệ thống (Average System Metrics)     |  90.3%   |
+-------------------------------------------------------------------+
  • Tốc độ xử lý (Inference Speed): Đạt 28 - 32 FPS khi chạy trên phần cứng máy tính tiêu chuẩn có card đồ họa hỗ trợ CUDA, đảm bảo độ trễ phản hồi thời gian thực dưới $50\text{ ms}$.
  • Hiệu suất giải tỏa giao thông: Trong kịch bản giao thông bất đối xứng mô phỏng (nhánh 1 đông gấp 3 lần nhánh 2), thuật toán thích nghi giúp giảm thời gian dừng chờ trung bình của phương tiện tới $34.2%$ so với chế độ định thời cố định.

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

Những cải tiến trọng tâm

  1. Kiến trúc hồi tiếp vòng kín (Closed-Loop Visual Feedback): Khác biệt với các hệ thống mở truyền thống, đồ án thiết lập cơ chế bắt tay hai chiều giữa phần mềm thị giác máy tính tầng cao và phần cứng điều khiển cơ sở tầng thấp, tạo thành một hệ thống tự thích nghi (Self-Adaptive System).
  2. Thuật toán gia hạn có giới hạn chặn trên (Bounded Extension Algorithm): Đảm bảo thời gian xanh tăng thêm tỷ lệ thuận với mật độ xe nhưng không vượt quá 3 lần gia hạn ($\le 15\text{s}$ cộng thêm), loại bỏ hoàn toàn rủi ro gây tắc nghẽn cục bộ (Starvation Deadlock) tại nhánh giao lộ đối diện.
  3. Tối ưu hóa chi phí phần cứng: Thay thế toàn bộ hệ thống xử lý công nghiệp đắt tiền bằng kiến trúc phân tầng: Máy tính xử lý thị giác $\leftrightarrow$ Kit vi điều khiển thương mại giá rẻ (Arduino Uno), giúp giảm chi phí phần cứng đến hơn $85%$ so với các giải pháp nhập ngoại.
+-----------------------------------------------------------------------+
|               BẢNG SO SÁNH GIỮA CÁC PHƯƠNG PHÁP ĐIỀU KHIỂN             |
+-----------------------------------------------------------------------+
| Tiêu chí                  | Bộ định thời cố định | Cảm biến ngầm vòng từ | Giải pháp đồ án     |
+---------------------------+---------------------+-----------------------+---------------------+
| Chi phí lắp đặt ban đầu   | Thấp                | Rất cao               | Thấp                |
| Khả năng phân loại xe     | Không               | Không                 | Có (3 nhóm xe chính)|
| Tính linh hoạt thời gian  | 0%                  | 20% - 30%             | 70% - 85%           |
| Mức độ can thiệp hạ tầng  | Không               | Cắt xẻ mặt đường      | Chỉ lắp camera trên cao|
| Khả năng mở rộng AI      | Không               | Hạn chế               | Rất cao             |
+-----------------------------------------------------------------------+

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

Kịch bản ứng dụng trong thực tiễn

  • Nút giao thông đô thị trọng điểm: Tự động cân bằng lưu lượng giữa các trục đường chính và đường phụ vào các khung giờ cao điểm sáng/chiều.
  • Khu đô thị thông minh và Khu công nghiệp: Quản lý luồng xe tải nặng và xe buýt đưa đón công nhân, ưu tiên kéo dài pha đèn cho các phương tiện công cộng kích thước lớn.
  • Trạm thu phí không dừng (ETC) và Bến cảng: Điều tiết lưu lượng xe vào các làn cân tải trọng hoặc cổng soát vé tự động.
+--------------------------------------------------------------------+
|                LỘ TRÌNH TRIỂN KHAI HỆ THỐNG THỰC TẾ               |
+--------------------------------------------------------------------+
  Giai đoạn 1 (Tháng 1-2): Khảo sát thực địa, lắp đặt camera IP góc cao
            |
            v
  Giai đoạn 2 (Tháng 3-4): Thu thập 10,000+ ảnh dữ liệu giao thông thực tế
            |
            v
  Giai đoạn 3 (Tháng 5-6): Fine-tune mô hình YOLO & Triển khai Edge Box
            |
            v
  Giai đoạn 4 (Tháng 7+): Tích hợp trung tâm điều hành SCADA đô thị

Yêu cầu triển khai phần cứng thực tế

  • Camera quan sát: Camera IP chuẩn ONVIF/RTSP, độ phân giải Full HD 1080p, góc mở ống kính $> 90^\circ$, chuẩn kháng nước IP67.
  • Bộ xử lý biên (Edge Computing Unit): Máy tính nhúng chuyên dụng như NVIDIA Jetson Nano / Xavier NX hoặc PC công nghiệp không quạt.
  • Khối điều khiển công suất: Bộ điều khiển sử dụng Relay cách ly quang (Optocoupler) để đóng cắt nguồn AC 220V cho các cụm đèn giao thông công suất lớn.

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

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

  • Mô hình vật lý thực nghiệm chỉ mô phỏng 2 chiều giao lộ đơn giản, chưa bao gồm các làn rẽ trái/phải chuyên biệt.
  • Mạng nơ-ron chưa được huấn luyện cho lớp phương tiện xe máy (Motorbike) - phương tiện chiếm tỷ lệ lớn nhất tại Việt Nam - do tính chất đan xen phức tạp và hiện tượng che khuất (Occlusion) dày đặc.
  • Điều kiện vận hành ban đêm và thời tiết mưa bão làm giảm chất lượng ảnh đầu vào, ảnh hưởng đến độ tin cậy của thuật toán phân ngưỡng.

Hướng nghiên cứu và phát triển tiếp theo

  1. Nâng cấp thuật toán Tracking: Tích hợp thuật toán DeepSORT hoặc ByteTrack để theo dõi vector chuyển động của phương tiện, loại bỏ hoàn toàn hiện tượng đếm trùng khi xe di chuyển chậm hoặc dừng đỗ.
  2. Nhúng hoàn toàn lên Edge AI: Tối ưu hóa mô hình với TensorRT để chạy trực tiếp trên kit nhúng NVIDIA Jetson, loại bỏ sự phụ thuộc vào máy tính PC.
  3. Mở rộng nhận diện xe máy và xe ưu tiên: Bổ sung tập dữ liệu xe máy và huấn luyện nhận dạng các phương tiện khẩn cấp (Xe cứu hỏa, Xe cấp cứu, Xe cảnh sát) để tự động kích hoạt làn sóng xanh ưu tiên (Green Wave Priority).

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

1. Sinh viên và Giảng viên ngành Kỹ thuật

  • Tài liệu tham khảo toàn diện về việc tích hợp liên ngành: từ Thị giác máy tính (AI/Computer Vision), Xử lý tín hiệu số đến Lập trình hệ thống nhúng (Embedded Systems).
  • Cung cấp mã nguồn chuẩn về giao tiếp Serial UART bất đồng bộ giữa Python và vi điều khiển ATmega.

2. Kỹ sư phát triển phần mềm và Hệ thống nhúng

  • Kiến trúc tham chiếu thực tế để triển khai các mô hình Deep Learning vào các bài toán điều khiển cơ cấu chấp hành trong công nghiệp.
  • Phương pháp tối ưu hóa pipeline từ camera capture đến inference và logic điều khiển trạng thái.

3. Đơn vị quản lý hạ tầng giao thông và Doanh nghiệp

  • Cung cấp giải pháp khả thi về mặt kinh tế để nâng cấp các nút giao thông truyền thống thành ngã tư thông minh mà không cần thay thế toàn bộ hệ thống tủ điều khiển hiện có.
  • Tiết kiệm hàng trăm triệu đồng chi phí đầu tư ban đầu cho mỗi nút giao thông.

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ì?

Ở cấp độ mô hình nghiên cứu, hệ thống yêu cầu máy tính có CPU Intel Core i5 thế hệ 8 trở lên, RAM 8GB và GPU NVIDIA GTX 1050 (hoặc tương đương) để đảm bảo tốc độ nhận dạng $\ge 25\text{ FPS}$. Khi triển khai công nghiệp, có thể sử dụng máy tính biên NVIDIA Jetson Nano (4GB) kết hợp bộ chuyển đổi USB-to-TTL Serial kết nối tới tủ điều khiển đèn.

2. Hệ thống xử lý như thế nào khi một nhánh đường liên tục đông xe?

Thuật toán được thiết kế với cơ chế kiểm soát chặn cứng MAX_EXTENSIONS = 3. Mỗi lần gia hạn tối đa 5 giây, tức nhánh ưu tiên chỉ có thể kéo dài thêm tối đa 15 giây. Sau khi hết 3 lần gia hạn, hệ thống bắt buộc chuyển sang pha đèn vàng và cấp quyền ưu tiên cho nhánh đường còn lại để chống hiện tượng bỏ đói làn (Starvation).

3. Độ trễ truyền thông qua giao tiếp UART có ảnh hưởng đến tính an toàn không?

Với tốc độ Baud 9600 bps và chuỗi dữ liệu điều khiển rất ngắn (dưới 10 bytes/frame), thời gian truyền nhận tín hiệu qua UART chỉ mất khoảng $1\text{ ms} - 2\text{ ms}$. Thời gian này hoàn toàn không đáng kể so với thời gian phản hồi của rơ-le và đèn LED, đảm bảo tuyệt đối tính an toàn chuyển mạch.

4. Hệ thống có khả năng hoạt động khi mất kết nối máy tính xử lý ảnh không?

Có. Vi điều khiển Arduino được lập trình với cơ chế ngắt thời gian độc lập. Nếu không nhận được tín hiệu phản hồi từ máy tính trong vòng 1 giây kể từ khi gửi yêu cầu REQ_CH, Arduino sẽ tự động chuyển sang chế độ dự phòng mặc định (Fail-safe Default Mode) với chu kỳ xanh - vàng - đỏ cố định.

5. Chi phí ước tính để nâng cấp một ngã tư thực tế là bao nhiêu?

Chi phí phần cứng ước tính gồm: 2 Camera IP công nghiệp (khoảng 6-8 triệu VNĐ), 1 Bộ xử lý nhúng Edge AI NVIDIA Jetson (khoảng 5-7 triệu VNĐ), và module chuyển đổi công suất cách ly quang (khoảng 1-2 triệu VNĐ). Tổng chi phí ước tính dưới 20 triệu VNĐ/nút giao, thấp hơn rất nhiều so với các hệ thống ngoại nhập hàng trăm triệu đồng.

Kết luận

Đồ án "Ứng dụng xử lý ảnh vào mô hình điều khiển đèn giao thông ngã tư" của nhóm tác giả Đạ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 giữa trí tuệ nhân tạo hiện đại và kỹ thuật điều khiển nhúng thời gian thực. Bằng việc làm chủ quy trình từ thu thập dữ liệu, huấn luyện mô hình YOLO, thiết kế giao diện giám sát PyQt5 cho đến lập trình vi điều khiển Arduino Uno R3, đề tài khẳng định tính khả thi cao trong việc ứng dụng công nghệ nội địa để giải quyết các vấn đề cấp bách của giao thông đô thị Việt Nam. Đây là nền tảng vững chắc để tiếp tục mở rộng sang các hệ thống giao thông thông minh (ITS) quy mô lớn trong tương lai.