Giới thiệu dự án

Ùn tắc giao thông và tai nạn đường bộ là những thách thức nghiêm trọng tại các đô thị đang phát triển nhanh như Hà Nội và TP. Hồ Chí Minh. Theo thống kê từ Bộ Giao thông Vận tải và Ủy ban An toàn Giao thông Quốc gia, thiệt hại kinh tế do ùn tắc tại các đô thị lớn chiếm từ 1-3% GDP hàng năm, đồng thời làm gia tăng lượng phát thải khí nhà kính và suy giảm chất lượng sống của người dân. Phần lớn hệ thống điều khiển tín hiệu đèn giao thông hiện nay vẫn vận hành theo chu kỳ thời gian cố định (pre-timed control), hoàn toàn không có khả năng tự động thích ứng theo lưu lượng xe thực tế tại từng thời điểm. Bên cạnh đó, việc đo đạc tốc độ phương tiện chủ yếu dựa vào máy bắn tốc độ cầm tay hoặc radar đắt đỏ, thiếu tính năng cảnh báo sớm diện rộng cho người điều khiển phương tiện trước khi đi vào khu vực xung đột giao thông.

Đồ án tốt nghiệp ngành Công nghệ Kỹ thuật Máy tính (Khoa Điện - Điện tử, Trường Đại học Sư phạm Kỹ thuật TP.HCM) với đề tài "Xây Dựng Mô Hình Giám Sát Giao Thông" do sinh viên Phạm Hồng Đạt và Lê Khắc Anh Khoa thực hiện, dưới sự hướng dẫn của Th.S Trương Quang Phúc, tập trung giải quyết triệt để bài toán giám sát và điều tiết giao thông tự động hóa với chi phí tối ưu.

                    HỆ THỐNG GIÁM SÁT GIAO THÔNG THÔNG MINH
+-----------------------------------------------------------------------------+
|  [Camera 5MP] --> [Raspberry Pi 3: Optical Flow] --> [Google Cloud Server]  |
|                                                                    |        |
|  [Bảng LED P10 / Đèn tín hiệu] <-- [Arduino Uno] <-- [ESP8266 NodeMCU]      |
+-----------------------------------------------------------------------------+

Mục tiêu dự án

  1. Thu nhận và xử lý video luồng: Thiết kế module xử lý ảnh cạnh (Edge Vision) trên kit nhúng Raspberry Pi 3 kết hợp camera góc rộng để nhận diện và theo dõi quỹ đạo phương tiện.
  2. Ước lượng vận tốc và mật độ: Ứng dụng thuật toán luồng quang lượng Lucas-Kanade để tính toán tốc độ di chuyển trung bình ($V$) và mật độ tương đối của phương tiện theo thời gian thực.
  3. Truyền thông dữ liệu đám mây: Xây dựng cầu nối truyền nhận dữ liệu qua giao thức HTTPS API giữa hệ thống xử lý biên và máy chủ đám mây (Google Cloud Platform / Google Spreadsheet Webhook).
  4. Hiển thị quang báo và điều khiển tín hiệu thích ứng: Tích hợp bộ thu phát Wi-Fi ESP8266 NodeMCU truyền dữ liệu qua UART tới Arduino Uno R3, từ đó điều khiển bảng quang báo ma trận LED P10 để hiển thị khuyến nghị lộ trình và tự động tối ưu hóa chu kỳ đèn tín hiệu giao thông qua mạch chốt ghi dịch 74HC595.
  5. Đánh giá thực nghiệm mô hình: Lắp đặt sa bàn thử nghiệm mô phỏng nút giao cắt thực tế, đo đạc sai số vận tốc và độ trễ truyền thông của toàn hệ thống.

Phương pháp tiếp cận và kết quả kỳ vọng

Giải pháp kết hợp tính toán biên (Edge Computing) và Internet of Things (IoT) giúp giảm tải xử lý tập trung, tiết kiệm băng thông mạng và hạ giá thành triển khai so với các hệ thống SCADA/ITS chuyên dụng. Hệ thống kỳ vọng đạt độ chính xác đo tốc độ trên 90%, thời gian trễ cập nhật bảng quang báo dưới 3 giây và khả năng điều tiết pha đèn linh hoạt theo 3 mức lưu lượng (thông thoáng, trung bình, ùn ứ).

Phạm vi và giới hạn nghiên cứu

  • Phạm vi: Mô hình sa bàn thực nghiệm mô phỏng giao lộ ngã tư với camera đặt góc nghiêng $53^\circ$, quan sát mặt đường từ độ cao quy đổi $10-20\text{ m}$ (trên sa bàn là $25\text{ cm}$).
  • Giới hạn: Module camera Raspberry Pi V1 (OV5647) chưa tích hợp bộ lọc hồng ngoại chuyên dụng ban đêm; giải thuật Lucas-Kanade phụ thuộc vào điều kiện ánh sáng ổn định và nền đường ít bị bóng cây che khuất cục bộ.

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

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

Tiêu chí so sánh Vòng từ cảm ứng (Inductive Loop) Cảm biến Radar / Sóng Milimet Hệ thống Thị giác Nhúng (Đồ án)
Chi phí triển khai Rất cao (cắt đường, phá hủy kết cấu mặt đường) Cao ($2.000 - $5.000 / nút giao) Rất thấp ($80 - $120 / nút giao)
Bảo trì, nâng cấp Phức tạp, dễ đứt cáp do tải trọng xe nặng Đòi hỏi thiết bị chuyên dụng Dễ dàng nâng cấp qua OTA / Firmware
Tính đa năng Chỉ đếm xe, đo vận tốc điểm Đo vận tốc, khoảng cách Đo vận tốc, mật độ, nhận dạng loại xe, quan sát tổng quan
Ảnh hưởng mặt đường Gây hư hỏng hạ tầng đường bộ Không tiếp xúc Không tiếp xúc, lắp trên cột đèn chiếu sáng

Ma trận ưu tiên yêu cầu hệ thống (MoSCoW)

  • Must have (Bắt buộc): Đo tốc độ thời gian thực bằng camera nhúng; đẩy dữ liệu lên Web Server; hiển thị cảnh báo lên LED P10; điều khiển chu kỳ đèn giao thông theo 3 trạng thái.
  • Should have (Nên có): Bộ nhớ đệm EEPROM trên ESP8266 để lưu trữ trạng thái khi mất kết nối Wi-Fi tạm thời; thuật toán lọc nhiễu khung hình xám.
  • Could have (Có thể mở rộng): Nhận diện biển số xe vi phạm quá tốc độ (ANPR); mở rộng bảng LED ma trận full-color P10 RGB.
  • Won't have (Chưa thực hiện): Nhận diện phân loại 10+ dòng phương tiện bằng mô hình Deep Learning nặng (do hạn chế phần cứng Raspberry Pi 3 Model B).

Thiết kế hệ thống

graph TD
    A[Camera Raspberry Pi V1 5MP] -->|CSI Bus / Video 25 FPS| B(Raspberry Pi 3 Model B)
    B -->|Grayscale + Optical Flow Lucas-Kanade| C{Tính vận tốc V & Mật độ}
    C -->|HTTPS POST / JSON API| D[Google Cloud Web Server / Spreadsheet]
    D -->|HTTPS GET API| E[ESP8266 NodeMCU v1.0]
    E -->|Lưu cấu hình tạm| F[(EEPROM)]
    E -->|UART Serial 9600 bps| G(Arduino Uno R3)
    G -->|HUB12 SPI-like Protocol| H[Bảng LED Ma Trận P10 Outdoor]
    E -->|GPIO Control via 5x 74HC595| I[Hệ thống Đèn Giao Thông & LED 7 đoạn]

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

  • Edge Computing Hardware:
    • Raspberry Pi 3 Model B (SoC Broadcom BCM2837 64-bit Quad-Core ARM Cortex-A53 @ 1.2GHz, 1GB LPDDR2 RAM).
    • Module Camera V1 (Cảm biến OmniVision OV5647 5MP, Video 1080p@30fps, 720p@60fps, 640x480@90fps).
  • Communication & Controller Hardware:
    • ESP8266 NodeMCU v1.0 (SoC Wi-Fi Tensilica L106 32-bit @ 80MHz, 4MB Flash, hỗ trợ WPA/WPA2).
    • Arduino Uno R3 (Vi điều khiển ATmega328P 8-bit AVR @ 16MHz, 32KB Flash, 2KB SRAM).
    • IC ghi dịch chốt 74HC595 (8-bit Serial-In Parallel-Out Shift Register) ghép nối tầng điều khiển đèn tín hiệu và LED 7 đoạn.
    • Bảng ma trận P10 Single Red (32x16 LEDs, quét 1/4, chuẩn giao tiếp HUB12, độ sáng 4500 mcd).
  • Software & Libraries:
    • Hệ điều hành: Raspbian OS (Debian GNU/Linux 8.0 Jessie / 9.0 Stretch).
    • Ngôn ngữ: Python 2.7 / 3.x trên Raspberry Pi; C/C++ trên Arduino IDE v1.8.x.
    • Thư viện Thị giác Máy tính: OpenCV v3.3.0 (cv2), NumPy, SciPy.
    • Cloud Webhook & Backend: Google Apps Script API v1, Google Sheets REST Engine, giao thức HTTPS JSON Payload.

Thiết kế giao tiếp và API

  • Endpoint Webhook (Google Apps Script Web App):
    • POST /exec: Gửi dữ liệu tốc độ và mật độ phương tiện từ Raspberry Pi 3.
    • Payload format: 
      {
  "timestamp": "2026-09-01T14:30:00Z",
  "average_speed": 42.5,
  "density_level": 2,
  "traffic_status": "MODERATE"
}
    • GET /exec?read=latest: ESP8266 truy vấn bản ghi mới nhất dưới dạng chuỗi phân tách byte gọn nhẹ (Compact String: SPEED:42.5;STATUS:2;TIME_GREEN:35) để tối ưu hóa bộ nhớ SRAM hạn chế của vi điều khiển.

Phương pháp nghiên cứu (Methodology)

Quy trình phát triển hệ thống áp dụng mô hình lai Agile - V-Model dành cho hệ thống nhúng:

Phân tích yêu cầu --> Thiết kế mạch & thuật toán --> Lập trình module --> Tích hợp Hardware-in-the-Loop --> Đánh giá sa bàn
Cột mốc (Milestones) Thời lượng Nội dung thực hiện Sản phẩm bàn giao
M1: Nghiên cứu lý thuyết Tuần 1 - 3 Khảo sát OpenCV, thuật toán Optical Flow, giao thức IoT Tài liệu đặc tả kỹ thuật
M2: Xử lý ảnh cạnh Tuần 4 - 7 Lập trình Python tính vận tốc trên Raspberry Pi 3 Script xử lý video đạt 25 FPS
M3: Thiết kế mạch điều khiển Tuần 8 - 10 Thi công mạch in 74HC595, kết nối ESP8266 - Arduino PCB hoàn chỉnh, chạy thử LED
M4: Tích hợp Đám mây Tuần 11 - 13 Viết Google Apps Script, đồng bộ hóa dữ liệu qua Wi-Fi API Endpoint hoạt động 24/7
M5: Thử nghiệm sa bàn Tuần 14 - 16 Hiệu chuẩn hệ số $k$, đo lường sai số tốc độ và độ trễ Báo cáo thử nghiệm & nghiệm thu

Implementation và kết quả

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

Thuật toán đo tốc độ phương tiện được xây dựng trên nền tảng kỹ thuật Luồng quang học Lucas-Kanade (Lucas-Kanade Optical Flow). Giả định cơ bản là cường độ sáng của điểm ảnh không thay đổi giữa hai khung hình liên tiếp tại thời điểm $t$ và $t + \Delta t$:

$$I(x, y, t) = I(x + \Delta x, y + \Delta y, t + \Delta t)$$

Khai triển chuỗi Taylor bậc nhất:

$$I(x + \Delta x, y + \Delta y, t + \Delta t) \approx I(x, y, t) + \frac{\partial I}{\partial x}\Delta x + \frac{\partial I}{\partial y}\Delta y + \frac{\partial I}{\partial t}\Delta t$$

Triệt tiêu hai vế và chia cho $\Delta t$, ta thu được phương trình ràng buộc luồng quang:

$$I_x u + I_y v + I_t = 0$$

Trong đó:

  • $I_x = \frac{\partial I}{\partial x}$, $I_y = \frac{\partial I}{\partial y}$, $I_t = \frac{\partial I}{\partial t}$ là các đạo hàm riêng của cường độ sáng.
  • $u = \frac{\Delta x}{\Delta t}$, $v = \frac{\Delta y}{\Delta t}$ là các thành phần vận tốc theo trục ngang và dọc.

Để giải hệ phương trình với cửa sổ lân cận kích thước $n \times n$ ($n$ điểm ảnh), phương pháp bình phương tối thiểu (Least Squares Method) được áp dụng:

$$A = \begin{bmatrix} I_{x1} & I_{y1} \ I_{x2} & I_{y2} \ \vdots & \vdots \ I_{xn} & I_{yn} \end{bmatrix}, \quad b = -\begin{bmatrix} I_{t1} \ I_{t2} \ \vdots \ I_{tn} \end{bmatrix}, \quad v = \begin{bmatrix} u \ v \end{bmatrix}$$

Vector vận tốc được xác định bằng:

$$v = (A^T A)^{-1} A^T b$$

Tính toán khoảng cách và vận tốc thực tế

Sau khi trích xuất tọa độ quỹ tâm đối tượng $(a, b)$ ở khung hình thứ $i-1$ và $(e, f)$ ở khung hình thứ $i$, khoảng cách di chuyển trên không gian ảnh (pixel) là:

$$D_{\text{pixel}} = \sqrt{(a - e)^2 + (b - f)^2}$$

Với tần số lấy mẫu camera $f = 25\text{ FPS}$ ($\Delta t = 0.04\text{ s}$) và hệ số tỉ lệ hiệu chuẩn pixel-to-meter $k$ ($\text{mét/pixel}$), vận tốc thực tế của phương tiện được tính theo công thức:

$$V = \frac{k \cdot D_{\text{pixel}}}{\Delta t} = 25 \cdot k \cdot D_{\text{pixel}} \quad (\text{m/s})$$

import cv2
import numpy as np
import time
import requests
import json

# Cấu hình tham số phát hiện điểm đặc trưng Shi-Tomasi
feature_params = dict(maxCorners=100, qualityLevel=0.3, minDistance=7, blockSize=7)

# Cấu hình tham số Lucas-Kanade Optical Flow
lk_params = dict(winSize=(15, 15), maxLevel=2,
                criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))

# Khởi tạo camera Pi và tham số hiệu chuẩn
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
cap.set(cv2.CAP_PROP_FPS, 25)

CALIBRATION_K = 0.035  # 1 pixel tương ứng 0.035 met ngoai thuc te
FRAME_DELTA_T = 0.04   # 25 FPS -> dt = 0.04s

ret, old_frame = cap.read()
old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)
p0 = cv2.goodFeaturesToTrack(old_gray, mask=None, **feature_params)

while True:
    ret, frame = cap.read()
    if not ret:
        break
    frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # Tính toán luồng quang học
    if p0 is not None and len(p0) > 0:
        p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None, **lk_params)
        
        good_new = p1[st == 1]
        good_old = p0[st == 1]
        
        speeds = []
        for i, (new, old) in enumerate(zip(good_new, good_old)):
            a, b = new.ravel()
            e, f = old.ravel()
            # Tính khoảng cách Euclidean
            dist_pixel = np.sqrt((a - e)**2 + (b - f)**2)
            if dist_pixel > 2.0: # Lọc rung lắc camera
                speed_mps = (dist_pixel * CALIBRATION_K) / FRAME_DELTA_T
                speed_kmh = speed_mps * 3.6
                speeds.append(speed_kmh)
                
        if len(speeds) > 0:
            avg_speed = np.mean(speeds)
            density = len(good_new)
            # Gửi dữ liệu không đồng bộ lên Cloud
            payload = {'speed': round(avg_speed, 2), 'density': density}
            # requests.post(WEB_APP_URL, json=payload, timeout=0.5)

    old_gray = frame_gray.copy()
    p0 = cv2.goodFeaturesToTrack(old_gray, mask=None, **feature_params)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

Giao tiếp vi điều khiển và quét LED ma trận P10

Đoạn mã C++ nạp trên Arduino Uno nhận chuỗi dữ liệu từ chân UART phần cứng (RX/TX) để điều khiển bảng quang báo P10 và kích hoạt các chân điều khiển IC 74HC595:

#include <DMD.h>
#include <TimerOne.h>
#include <SystemFont5x7.h>

#define DISPLAYS_ACROSS 1
#define DISPLAYS_DOWN 1
DMD dmd(DISPLAYS_ACROSS, DISPLAYS_DOWN);

// Hàm ngắt timer quét màn hình P10 tần số 1000Hz
void ScanDMD() {
  dmd.scanDisplayBySPI();
}

void setup() {
  Serial.begin(9600);
  Timer1.initialize(1000);
  Timer1.attachInterrupt(ScanDMD);
  dmd.clearScreen(true);
  dmd.selectFont(SystemFont5x7);
}

void loop() {
  if (Serial.available() > 0) {
    String data = Serial.readStringUntil('\n');
    dmd.clearScreen(true);
    if (data.indexOf("UN_TAC") >= 0) {
      dmd.drawString(2, 4, "KET XE!", 7, GRAPHICS_NORMAL);
    } else {
      dmd.drawString(2, 4, "L/TRINH OK", 10, GRAPHICS_NORMAL);
    }
  }
}

Thử nghiệm và đánh giá kết quả

Hệ thống được kiểm thử qua 50 lần chạy thực nghiệm trên mô hình sa bàn với các dải tốc độ xe mô hình từ $10\text{ cm/s}$ đến $80\text{ cm/s}$ (tương đương dải vận tốc thực tế $15 - 80\text{ km/h}$).

 Sai số vận tốc (%)
  8 |                               * (Điều kiện thiếu sáng)
  6 |               *
  4 |       *               *
  2 |   *       *       *
  0 +---------------------------------
       10  20  30  40  50  60  70  80  Vận tốc thực nghiệm (cm/s)
Kịch bản kiểm thử Vận tốc chuẩn ($V_{\text{ref}}$) Vận tốc đo ($V_{\text{meas}}$) Sai số tuyệt đối Tỷ lệ lỗi (%) Đánh giá chu kỳ đèn
Phao 1: Xe chạy chậm $15.0\text{ cm/s}$ $14.6\text{ cm/s}$ $0.4\text{ cm/s}$ $2.67%$ Đèn xanh tăng $15\text{ s}$
Phao 2: Tốc độ bình thường $35.0\text{ cm/s}$ $36.2\text{ cm/s}$ $1.2\text{ cm/s}$ $3.43%$ Duy trì chu kỳ chuẩn ($30\text{ s}$)
Phao 3: Tốc độ cao $60.0\text{ cm/s}$ $57.8\text{ cm/s}$ $2.2\text{ cm/s}$ $3.67%$ Đèn xanh giảm $10\text{ s}$
Phao 4: Nhiễu rung lắc nhẹ $40.0\text{ cm/s}$ $42.5\text{ cm/s}$ $2.5\text{ cm/s}$ $6.25%$ Hệ thống cảnh báo quá tốc
Phao 5: Ánh sáng yếu $30.0\text{ cm/s}$ $27.8\text{ cm/s}$ $2.2\text{ cm/s}$ $7.33%$ Nhận diện giảm nhẹ biên cạnh

Đánh giá hiệu năng hệ thống

  • Tốc độ xử lý khung hình (Frame Rate): Ổn định tại $24.8 - 25.2\text{ FPS}$ trên độ phân giải $640 \times 480$.
  • Độ trễ toàn trình (End-to-End Latency): Từ lúc camera chụp khung hình đến khi LED P10 cập nhật nội dung đạt trung bình $1.85\text{ s}$ (bao gồm $40\text{ ms}$ xử lý ảnh + $1.2\text{ s}$ HTTP Cloud latency + $0.6\text{ s}$ UART & quét buffer).
  • Độ chính xác trung bình: Đạt $94.53%$ trong điều kiện chiếu sáng tiêu chuẩn ban ngày.

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

  1. Kiến trúc Edge-to-Cloud phân lớp thông minh: Thay vì truyền toàn bộ luồng video độ nét cao (Full HD) về máy chủ tập trung đòi hỏi đường truyền 4G/5G băng thông cực lớn và tốn kém, mô hình thực hiện nén và tính toán đặc trưng chuyển động ngay tại thiết bị biên (Raspberry Pi 3). Chỉ có các gói dữ liệu số hóa dạng số thực ($V_{\text{avg}}$, Mật độ) được tải lên đám mây, giúp giảm hơn $98%$ dung lượng băng thông mạng.
  2. Cơ chế phân tách nhiệm vụ phần cứng độc lập (Decoupled Microcontroller Architecture): ESP8266 chịu trách nhiệm hoàn toàn về kết nối TCP/IP, giải mã HTTPS REST API và giao tiếp Wi-Fi; trong khi Arduino Uno R3 chuyên trách ngắt phần cứng (Timer Interrupts) để quét ma trận LED P10 và điều khiển IC ghi dịch chốt 74HC595. Thiết kế này triệt tiêu hoàn toàn hiện tượng nhấp nháy LED (flickering) khi vi điều khiển bận xử lý gói tin mạng.
  3. Giải pháp giao thông thích ứng chi phí cực thấp: So với hệ thống điều khiển giao thông tích hợp radar truyền thống có giá thành hàng chục ngàn USD, mô hình của đề tài chỉ tiêu tốn chưa đến $150 cho phần cứng một nút giao, mở ra khả năng nhân rộng quy mô lớn cho các đô thị vừa và nhỏ tại Việt Nam.

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

Kịch bản ứng dụng thực tế

  • Cảnh báo sớm từ xa tại các nút giao phân tầng: Lắp đặt hệ thống camera đo vận tốc cách giao lộ $300 - 500\text{ m}$. Khi phát hiện dòng phương tiện phía trước có vận tốc giảm đột ngột dưới $10\text{ km/h}$ (dấu hiệu tắc đường), bảng quang báo LED P10 lắp tại các ngã rẽ nhánh sẽ phát thông báo yêu cầu tài xế chuyển hướng, tránh dồn ứ cục bộ.
  • Tối ưu hóa thời gian đèn xanh tự động (Adaptive Green Wave): Khi mật độ phương tiện trên tuyến đường chính tăng cao, hệ thống tự động tăng thời gian đèn xanh thêm $10 - 25\text{ s}$ để giải tỏa lưu lượng, giảm phát thải động cơ do dừng chờ đèn đỏ quá lâu.
+-------------------------------------------------------------------------------+
|                      KẾ HOẠCH TRIỂN KHAI THỰC ĐỊA (ROADMAP)                  |
|                                                                               |
| Giai đoạn 1 (Tháng 1-2): Pilot tại 2 nút giao thông nội bộ trường Đại học     |
| Giai đoạn 2 (Tháng 3-5): Nâng cấp vỏ chống nước IP66 & Camera Hồng ngoại      |
| Giai đoạn 3 (Tháng 6-9): Tích hợp giao thức MQTT & Dashboard giám sát tập trung |
| Giai đoạn 4 (Tháng 10+): Chuyển giao công nghệ cho Trung tâm Quản lý Giao thông|
+-------------------------------------------------------------------------------+

Phân tích chi phí - lợi ích (Cost-Benefit & ROI)

  • Chi phí thiết bị cho 1 nút giao:
    • Raspberry Pi 3 Model B + Nguồn: $45
    • Camera Module + Cáp nối dài: $15
    • ESP8266 NodeMCU + Arduino Uno R3: $12
    • Module LED P10 Outdoor + Vỏ bảo vệ: $35
    • Phụ kiện, PCB, Nguồn 5V 5A Meanwell: $20
    • Tổng chi phí phần cứng: $\approx $127$ (tiết kiệm hơn $85%$ so với 01 bộ cảm biến radar Doppler công nghiệp).
  • Lợi ích kinh tế - xã hội: Giảm $15 - 25%$ thời gian chờ tại nút giao, tiết kiệm hàng triệu lít nhiên liệu tiêu hao vô ích và giảm thiểu tai nạn giao thông nhờ cảnh báo trực quan trước ngã tư.

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

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

  • Phụ thuộc điều kiện môi trường: Thuật toán Lucas-Kanade hoạt động dựa trên giả định cường độ sáng bất biến, do đó dễ phát sinh sai số khi ánh sáng thay đổi đột ngột (như đèn pha xe chiếu trực tiếp ban đêm hoặc thời tiết mưa bão gây lóa mặt đường).
  • Hiện tượng che khuất (Occlusion): Khi các xe cỡ lớn (xe buýt, xe tải) chạy song song xe máy, quỹ tâm xe nhỏ có thể bị gộp chung vào xe lớn, dẫn đến đếm sai mật độ phương tiện.
  • Giới hạn tốc độ của Google Sheets Webhook: Nền tảng Google Apps Script có giới hạn tần suất gọi API (quota limit), không phù hợp cho các hệ thống đòi hỏi phản hồi mili-giây ở quy mô toàn thành phố.

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

  1. Nâng cấp mô hình Trí tuệ Nhân tạo: Chuyển dịch từ phương pháp xử lý ảnh truyền thống sang các mạng nơ-ron tích chập nhẹ (Lightweight Deep Learning) như YOLOv8-Nano hoặc MobileNet-SSD kết hợp bộ theo dõi ByteTrack/DeepSORT, tận dụng bộ tăng tốc phần cứng USB Coral TPU.
  2. Chuẩn hóa hạ tầng IoT: Thay thế giao thức HTTP/Google Sheets bằng MQTT Broker (Eclipse Mosquitto) triển khai trên máy chủ đám mây AWS/DigitalOcean, đảm bảo độ trễ truyền thông dưới $100\text{ ms}$.
  3. Mở rộng phần cứng hiển thị: Sử dụng bảng LED đa màu RGB P10 kết hợp giao diện đồ họa bản đồ giao thông trực quan, bổ sung camera IP tầm quan sát xa $100\text{ m}$.

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

                              GIÁ TRỊ MANG LẠI
    +-----------------------+-----------------------+-----------------------+
    |      Sinh viên        |      Lập trình viên   |  Nhà quản lý & Đô thị |
    | Thực hành IoT & Vision| Mã nguồn mẫu rõ ràng  | Giải pháp ITS giá rẻ  |
    +-----------------------+-----------------------+-----------------------+
  • Sinh viên Kỹ thuật Máy tính / Điện tử: Nguồn tài liệu thực hành toàn diện từ việc lập trình xử lý ảnh trên Linux nhúng (Raspberry Pi), cấu hình ngắt timer vi điều khiển AVR đến thiết kế mạch in và lập trình giao tiếp IoT.
  • Kỹ sư và Lập trình viên Hệ thống Nhúng: Cung cấp mẫu thiết kế chuẩn (Design Pattern) về phân chia luồng xử lý giữa vi điều khiển thời gian thực và máy tính đơn bo (SBC), giải quyết triệt để xung đột tài nguyên giữa giao tiếp mạng và hiển thị phần cứng.
  • Cơ quan Quản lý Giao thông Đô thị: Cung cấp phương án khả thi để số hóa các nút giao thông cũ với ngân sách cực kỳ tiết kiệm, từng bước xây dựng thành phố thông minh (Smart City).
  • Nhà nghiên cứu Giao thông Thông minh (ITS): Cung cấp bộ số liệu thực nghiệm về mối tương quan giữa tốc độ trung bình, mật độ xe và hiệu quả điều tiết thời gian pha đèn tín hiệu.

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

1. Yêu cầu kỹ thuật phần cứng và môi trường để triển khai hệ thống là gì?

Hệ thống yêu cầu tối thiểu:

  • 01 bo mạch Raspberry Pi 3 Model B (hoặc Pi 4) chạy hệ điều hành Raspberry Pi OS.
  • 01 Module Pi Camera V1/V2 (độ phân giải từ 5MP trở lên).
  • 01 Kit ESP8266 NodeMCU v1.0 và 01 board Arduino Uno R3 / Nano.
  • Nguồn cấp điện 5V DC có dòng tối thiểu 3A để đảm bảo kit Pi và bảng LED P10 không bị sụt áp.
  • Mạng Wi-Fi băng tần 2.4GHz ổn định tại khu vực nút giao.

2. Giới hạn khả năng mở rộng (Scalability) của hệ thống là gì và cách khắc phục?

Trong cấu hình đồ án, hệ thống lưu trữ trên Google Spreadsheet chỉ chịu tải khoảng 10 - 20 nút giao do giới hạn quota của Google Apps Script. Để mở rộng quy mô lên hàng trăm nút giao đô thị, giải pháp là chuyển đổi toàn bộ backend sang cơ sở dữ liệu thời gian thực (như InfluxDB / PostgreSQL) và sử dụng MQTT Broker (Mosquitto/EMQX) kết hợp giao thức bảo mật TLS/SSL.

3. Hệ thống có thể tích hợp vào trung tâm điều hành giao thông sẵn có không?

Hoàn toàn có thể. Do dữ liệu vận tốc và mật độ được chuẩn hóa dưới định dạng JSON qua REST API / MQTT, bất kỳ hệ thống phần mềm SCADA hoặc Web Dashboard điều hành giao thông nào của thành phố cũng có thể tiêu thụ (consume) dữ liệu này một cách dễ dàng thông qua các cổng API tiêu chuẩn.

4. Chi phí bảo trì và độ bền thiết bị khi lắp đặt ngoài trời như thế nào?

Module LED P10 ngoài trời vốn được đúc keo silicon chống nước chuẩn IP65. Để bảo vệ các mạch xử lý trung tâm (Raspberry Pi, ESP8266, Arduino), toàn bộ linh kiện được đặt trong tủ điện kỹ thuật chống nước chuẩn IP66 có quạt tản nhiệt thông minh và chống sét lan truyền. Chi phí bảo dưỡng định kỳ hàng năm ước tính dưới $15 / trạm.

5. Thời gian thu hồi vốn đầu tư (ROI) ước tính trong bao lâu?

Đối với các đơn vị tư nhân (khu đô thị thông minh, bến bãi, cảng biển) hoặc ngân sách công, nhờ chi phí đầu tư ban đầu cực thấp (~$130/cụm) so với việc thuê nhân sự điều tiết thủ công hoặc lắp đặt hệ thống ngoại nhập hàng trăm triệu đồng, thời gian thu hồi vốn đầu tư gián tiếp thông qua việc giảm thiểu ùn tắc và giải phóng sức lao động ước tính chỉ từ 3 đến 6 tháng.

Kết luận

Đồ án tốt nghiệp "Xây Dựng Mô Hình Giám Sát Giao Thông" của sinh viên Phạm Hồng Đạt và Lê Khắc Anh Khoa đã nghiên cứu, thiết kế và chế tạo thành công một hệ thống giám sát và điều tiết giao thông hoàn chỉnh dựa trên sự giao thoa giữa Thị giác Máy tính (Computer Vision) và Internet Vạn Vật (IoT).

Bằng việc ứng dụng thuật toán luồng quang học Lucas-Kanade trên kit máy tính nhúng Raspberry Pi 3, kết hợp cầu nối truyền thông đám mây qua ESP8266 và Arduino Uno điều khiển LED ma trận P10 cùng hệ thống đèn tín hiệu giao thông, đồ án đã chứng minh tính khả thi vượt trội của phương pháp giám sát không tiếp xúc, chi phí thấp nhưng đạt độ tin cậy và độ chính xác cao ($>94%$).

Kết quả nghiên cứu này không chỉ là nền tảng học thuật vững chắc cho các nghiên cứu tiếp theo về Giao thông Thông minh (ITS) và Đô thị Thông minh (Smart City) tại Việt Nam, mà còn là một minh chứng thực tế cho việc ứng dụng công nghệ nhúng giải quyết các vấn đề cấp bách của xã hội. Các nhà phát triển và sinh viên có thể tiếp tục kế thừa, mở rộng mô hình với các thuật toán AI tiên tiến để nâng tầm giải pháp trong tương lai.