Giới thiệu dự án

Hỏa hoạn là một trong những hiểm họa khốc liệt nhất đe dọa đến tính mạng con người, tài nguyên thiên nhiên và cơ sở hạ tầng đô thị. Theo thống kê từ Cục Cảnh sát Phòng cháy chữa cháy và Cứu nạn cứu hộ, các vụ cháy nổ tại nhà xưởng, khu dân cư và rừng tự nhiên gây thiệt hại hàng nghìn tỷ đồng mỗi năm. Trong công tác phòng cháy, yếu tố then chốt quyết định mức độ thiệt hại chính là "thời gian vàng" phát hiện đám cháy trong những phút đầu tiên.

Vấn đề thực tiễn và điểm nghẽn kỹ thuật (Pain Points)

Các phương pháp giám sát truyền thống bộc lộ nhiều điểm nghẽn nghiêm trọng:

  • Quan sát thủ công: Dựa vào sức người tuần tra, không thể đảm bảo giám sát 24/7 trên diện tích rộng lớn và tiềm ẩn độ trễ phát hiện cao.
  • Hệ thống cảm biến vật lý (MQ-135, cảm biến nhiệt/khói): Phạm vi hoạt động hẹp, yêu cầu mật độ lắp đặt dày đặc gây tốn kém chi phí. Cảm biến khí/khói dễ bị báo động giả do bụi bẩn, sương mù hoặc luồng gió phân tán trước khi khói chạm tới đầu thu.
  • Hệ thống ảnh vệ tinh: Chu kỳ quét dài (tính bằng giờ hoặc ngày), phụ thuộc điều kiện mây che phủ, không cung cấp dữ liệu hình ảnh thời gian thực (Real-time).
  • Hạn chế phần cứng tại biên (Edge Device Bottlenecks): Các mô hình thị giác máy tính sâu (Deep Learning) thông thường đòi hỏi máy chủ trang bị GPU công suất lớn, tiêu thụ nhiều điện năng và băng thông truyền tải video khổng lồ nếu đẩy toàn bộ dữ liệu thô về máy chủ đám mây (Cloud Server).

Mục tiêu của dự án

  1. Nghiên cứu và đánh giá đa mô hình: Khảo sát, huấn luyện và đối sánh hiệu năng các kiến trúc nhận diện vật thể hiện đại gồm YOLOv3-tiny, YOLOv4-tiny và YOLOv5s trên tập dữ liệu đặc thù về phát hiện ngọn lửa.
  2. Tối ưu hóa mô hình học sâu cho thiết bị nhúng: Ứng dụng các kỹ thuật nén mô hình, chuyển đổi định dạng và tăng tốc suy luận thông qua NVIDIA TensorRT và TensorFlow Lite trên bo mạch nhúng NVIDIA Jetson Nano (phiên bản 2GB RAM).
  3. Xây dựng hệ thống IoT hoàn chỉnh: Tích hợp luồng giải mã video thời gian thực qua giao thức RTSP/WebRTC với Web Server Flask, đồng thời kết nối truyền thông điệp cảnh báo qua giao thức MQTT tới nền tảng ThingsBoard.
+-----------------------------------------------------------------------------------+
|                              PIPELINE TỔNG THỂ HỆ THỐNG                           |
|                                                                                   |
|  [ Camera Feed ] --> [ Jetson Nano (Edge Inference) ] --> [ Flask Web Server ]    |
|      (CSI/USB)       | - OpenCV Preprocessing       |     (Real-time Video Stream)|
|                      | - TensorRT Engine (YOLOv4)   |                             |
|                      | - NMS & Threshold Filtering  |                             |
|                      +--------------+---------------+                             |
|                                     |                                             |
|                                     v (MQTT Protocol - QoS 1)                     |
|                      [ ThingsBoard IoT Dashboard & Rule Engine ]                  |
|                      | - Real-time Telemetry (Fire Status, FPS)                   |
|                      | - Automated Alert / Push Notification                      |
+-----------------------------------------------------------------------------------+

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

Giải pháp tiếp cận dựa trên mô hình Điện toán biên (Edge Computing). Mọi tác vụ phân tích khung hình, nhận diện vị trí ngọn lửa (Bounding Box) và tính toán xác suất đều được thực thi cục bộ trên Jetson Nano. Chỉ có dữ liệu siêu dữ liệu (Metadata: tọa độ box, độ tin cậy, trạng thái cảnh báo) và video nén được truyền qua mạng khi phát hiện sự cố.

  • Mục tiêu hiệu năng: Tốc độ xử lý đạt $\ge 20 \text{ FPS}$ trên Jetson Nano 2GB; độ trễ suy luận $< 50\text{ ms}$; độ chính xác phát hiện (mAP@0.5) đạt trên $80%$.
  • Phạm vi & Giới hạn: Hệ thống tập trung nhận diện ngọn lửa quang phổ khả kiến (RGB) trong điều kiện ánh sáng đa dạng; giới hạn xử lý cục bộ trên camera đơn độ phân giải 720p/1080p để bảo toàn tài nguyên bộ nhớ 2GB LPDDR4.

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

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

Giải pháp Cơ chế hoạt động Ưu điểm Nhược điểm Độ trễ Chi phí triển khai
Cảm biến khí/khói MQ-135 Điện hóa / Quang điện Chi phí cảm biến rẻ, kích thước nhỏ Dễ báo động giả, không định vị được đám cháy, phạm vi cực hẹp Trung bình (vài giây tới phút) Thấp cục bộ, cao nếu phủ rộng
Ảnh vệ tinh (MODIS/VIIRS) Đo bức xạ nhiệt hồng ngoại Phủ sóng diện tích toàn cầu Chu kỳ cập nhật dài (3–12 giờ), không hỗ trợ giám sát cục bộ Rất cao ($> 1\text{ giờ}$) Phụ thuộc bên thứ ba
Fire Detection CNN (Toby Breckon) Phân loại ảnh (Classification) dựa trên TensorFlow 1.5 Cấu trúc đơn giản, dễ cài đặt Chỉ phân loại có/không có lửa, không xác định tọa độ box, không tối ưu cho Edge Cao ($< 5\text{ FPS}$ trên CPU) Trung bình
FireNET (Olafenwa Moses) YOLOv3 trên Keras/ImageAI Dễ triển khai với 6 dòng lệnh Python Tài nguyên chiếm dụng nặng, độ trễ khung hình lớn, tụt FPS nghiêm trọng trên ARM Cao ($3\text{--}5\text{ FPS}$ trên Jetson) Trung bình
Giải pháp đề xuất (Edge TensorRT) YOLOv4-tiny + TensorRT Engine trên Jetson Nano Nhận diện thời gian thực, bounding box chính xác, siêu nhẹ, tích hợp IoT Yêu cầu bước chuyển đổi và tối ưu hóa mô hình phức tạp Rất thấp ($> 22\text{ FPS}$, $< 45\text{ms}$) Tối ưu (~$60\text{--}100$$/node)

Phân loại yêu cầu người dùng (MoSCoW Matrix)

  • Must-have: Mô hình Deep Learning phát hiện chính xác ngọn lửa với bounding box; tối ưu hóa chạy ổn định trên bộ nhớ Jetson Nano 2GB không tràn RAM (OOM); cảnh báo thời gian thực qua MQTT.
  • Should-have: Web Server streaming hình ảnh trực tiếp có vẽ bounding box; Dashboard ThingsBoard trực quan hóa trạng thái và lịch sử báo động; cấu hình ngưỡng tin cậy (Confidence Threshold) linh hoạt.
  • Could-have: Lưu trữ snapshot đám cháy khi kích hoạt cảnh báo; gửi tin nhắn SMS/Email tự động qua Rule Chain.
  • Won't-have (Hiện tại): Phân tích hướng gió/hướng lan truyền của lửa; tích hợp camera hồng ngoại chuyên dụng (Thermal Camera).

Thiết kế hệ thống

Kiến trúc hệ thống bao gồm 3 phân tầng chính:

+-------------------------------------------------------------------------------+
|                             KIẾN TRÚC PHÂN TẦNG HỆ THỐNG                      |
+-------------------------------------------------------------------------------+
| [1. TẦNG THU THẬP & BIÊN (EDGE INFERENCE LAYER)]                              |
|   - Hardware: NVIDIA Jetson Nano 2GB (128-core Maxwell GPU, Quad ARM A57)     |
|   - Sensors: Camera Module (USB / CSI MIPI)                                   |
|   - Software Stack: JetPack 4.5, Linux Ubuntu 18.04 LTS                       |
|   - Core Engine: TensorRT Runtime Engine (.trt) compiled from ONNX            |
|   - Image Processing: OpenCV 4.4.0 (CUDA-accelerated)                         |
+---------------------------------------+---------------------------------------+
                                        |
                   (Local Stream / MQTT Publish Payload)
                                        |
+---------------------------------------v---------------------------------------+
| [2. TẦNG TRUYỀN THÔNG & MÁY CHỦ (COMMUNICATION & BACKEND LAYER)]              |
|   - Web Streaming: Flask Microframework (HTTP MJPEG Streamer)                 |
|   - Message Broker: MQTT Protocol (QoS level 1, Topic: v1/devices/me/telemetry)|
|   - Security: Token-based Device Authentication & TLS Encryption              |
+---------------------------------------+---------------------------------------+
                                        |
                   (Telemetry / Alarm Events via TCP/IP)
                                        |
+---------------------------------------v---------------------------------------+
| [3. TẦNG QUẢN TRỊ & CẢNH BÁO (APPLICATION & MANAGEMENT LAYER)]                |
|   - Platform: ThingsBoard IoT Community Edition                               |
|   - Processing: Rule Chain Engine (Threshold Verification -> Alarm Trigger)   |
|   - User Interface: Web Dashboard (Gauges, State Indicators, Live Action Log) |
+-------------------------------------------------------------------------------+

Technology Stack và số hiệu phiên bản

  • Hệ điều hành thiết bị nhúng: NVIDIA JetPack SDK v4.5 (Ubuntu 18.04.5 LTS aarch64).
  • Thư viện tăng tốc phần cứng: CUDA v10.2, cuDNN v8.0.0, TensorRT v7.1.3.
  • Frameworks huấn luyện: Darknet (YOLOv3-tiny, YOLOv4-tiny), PyTorch v1.8.0 (YOLOv5s), ONNX v1.8.1.
  • Ngôn ngữ & Thư viện phụ trợ: Python v3.6.9, OpenCV v4.4.0 (build with GStreamer & CUDA), NumPy v1.19.4.
  • Backend & IoT Middleware: Flask v1.1.2, Eclipse Paho-MQTT v1.5.1, ThingsBoard v3.2.2.

Methodology

Dự án triển khai theo mô hình Agile kết hợp phân kỳ kỹ thuật (4 giai đoạn) trong thời gian từ tháng 03/2021 đến tháng 07/2021:

+-------------------------------------------------------------------------------+
|                            TIẾN ĐỘ THỰC HIỆN DỰ ÁN                            |
+-------------------------------------------------------------------------------+
| Tháng 03 - 04/2021 | Giai đoạn 1: Chuẩn bị Dataset & Huấn luyện Model ban đầu|
|                    | - Thu thập 3,000+ ảnh lửa & non-fire (bóng đèn, hoàng hôn)|
|                    | - Gán nhãn LabelImg -> Train Darknet YOLOv3/v4 & PyTorch |
+--------------------+----------------------------------------------------------+
| Tháng 04 - 05/2021 | Giai đoạn 2: Tối ưu hóa mô hình & Porting sang Jetson    |
|                    | - Export ONNX -> Compile Engine TensorRT FP16            |
|                    | - Benchmark độ trễ, tối ưu hóa CUDA stream trên Nano 2GB |
+--------------------+----------------------------------------------------------+
| Tháng 05 - 06/2021 | Giai đoạn 3: Xây dựng Flask Streaming & Tích hợp MQTT    |
|                    | - Lập trình Web Server phát luồng video MJPEG            |
|                    | - Cấu hình ThingsBoard Rule Chain & Telemetry Gateway    |
+--------------------+----------------------------------------------------------+
| Tháng 06 - 07/2021 | Giai đoạn 4: Đánh giá thực nghiệm, Kiểm thử & Đóng gói   |
|                    | - Stress test thời gian thực, đo đạc FPS, tinh chỉnh NMS |
|                    | - Hoàn thiện tài liệu kỹ thuật & nghiệm thu khóa luận     |
+-------------------------------------------------------------------------------+

Ma trận rủi ro và giải pháp khắc phục

  • Rủi ro tràn bộ nhớ RAM (OOM Crash): Jetson Nano chỉ có 2GB RAM dùng chung giữa CPU và GPU.
    • Giải pháp: Tắt giao diện đồ họa GNOME desktop (sudo init 3), tạo phân vùng Swap Memory 4GB trên thẻ MicroSD chuẩn Class 10 U3, sử dụng định dạng dữ liệu nửa chính xác FP16 trong TensorRT để cắt giảm $50%$ dung lượng lưu trữ trọng số.
  • Rủi ro nhận diện nhầm ánh đèn và ánh nắng:
    • Giải pháp: Tăng cường dữ liệu (Data Augmentation) với các mẫu âm tính có chứa bóng đèn sợi đốt, phản chiếu kính và ánh mặt trời; tinh chỉnh hàm mất mát tập trung vào vật thể kích thước nhỏ.

Implementation và kết quả

Development Process

1. Chuẩn bị và tiền xử lý dữ liệu

Tập dữ liệu được tổng hợp từ các nguồn chuẩn mở và thực nghiệm thực tế với hơn 3,000 ảnh gán nhãn đơn lớp (fire).

  • Công cụ gán nhãn: LabelImg xuất định dạng chuẩn Darknet TXT: <object-class> <x_center> <y_center> <width> <height> (chuẩn hóa về $[0, 1]$).
  • Phân chia tập dữ liệu: $80%$ Training Set, $10%$ Validation Set, $10%$ Testing Set.

2. Toán tử và cấu trúc hàm mất mát (Loss Function)

Kiến trúc YOLO chia khung hình thành lưới $S \times S$. Dự đoán bounding box được tối ưu hóa qua hàm tổng độ lỗi:

$$\mathcal{L}{\text{total}} = \mathcal{L}{\text{loc}} + \mathcal{L}{\text{conf}} + \mathcal{L}{\text{cls}}$$

Trong đó, độ lỗi định vị (Localization Loss) sử dụng tọa độ chuẩn hóa tâm $(x, y)$ và kích thước $(w, h)$:

$$\mathcal{L}{\text{loc}} = \lambda{\text{coord}} \sum_{i=0}^{S^2} \sum_{j=0}^{B} \mathbb{I}_{ij}^{\text{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]$$

Chỉ số giao thoa trên diện tích hợp (Intersection over Union - IoU) dùng để đánh giá chất lượng box:

$$\text{IoU} = \frac{\text{Area}(\text{Box}{\text{pred}} \cap \text{Box}{\text{truth}})}{\text{Area}(\text{Box}{\text{pred}} \cup \text{Box}{\text{truth}})}$$

Sau khi dự đoán, thuật toán triệt tiêu phi cực đại (Non-Maximum Suppression - NMS) loại bỏ các box trùng lặp có $\text{IoU} > 0.45$.

3. Quy trình nén và chuyển đổi sang TensorRT Engine

+-------------------------------------------------------------------------------+
|                       PIPELINE CHUYỂN ĐỔI TENSORRT ENGINE                     |
+-------------------------------------------------------------------------------+
| [ Darknet .weights / PyTorch .pt ]                                            |
|        |                                                                      |
|        v (Export Layer Mapping)                                               |
| [ ONNX Intermediate Representation (.onnx) ]                                  |
|        |                                                                      |
|        v (TensorRT Builder with FP16 Precision & Layer Fusion Optimization)   |
| [ TensorRT Serialized Engine (.trt / .engine) ]                               |
|        |                                                                      |
|        v (cudaEngine -> ExecutionContext -> GPU Inference Memory)            |
| [ Real-Time Inference on Jetson Nano ]                                        |
+-------------------------------------------------------------------------------+

Đoạn mã chuyển đổi từ mô hình ONNX sang Engine TensorRT tối ưu FP16 trên Jetson Nano:

import tensorrt as trt

TRT_LOGGER = trt.Logger(trt.Logger.WARNING)

def build_engine_onnx(onnx_file_path, engine_file_path, fp16_mode=True):
    builder = trt.Builder(TRT_LOGGER)
    network_flags = 1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)
    network = builder.create_network(network_flags)
    parser = trt.OnnxParser(network, TRT_LOGGER)

    with open(onnx_file_path, 'rb') as model:
        if not parser.parse(model.read()):
            for error in range(parser.num_errors):
                print(f"ONNX Parsing Error: {parser.get_error(error)}")
            return None

    config = builder.create_builder_config()
    config.max_workspace_size = 1 << 28  # 256MB allocated scratchpad memory

    if fp16_mode and builder.platform_has_tf32:
        config.set_flag(trt.BuilderFlag.FP16)

    print("Dang khoi tao va bien dich TensorRT Engine...")
    engine = builder.build_engine(network, config)
    
    with open(engine_file_path, "wb") as f:
        f.write(engine.serialize())
    print(f"Xuat Engine thanh cong tai: {engine_file_path}")
    return engine

4. Module truyền thông cảnh báo qua MQTT

import json
import time
import paho.mqtt.client as mqtt

THINGSBOARD_HOST = '192.168.1.100'  # Dia chi ThingsBoard Server
ACCESS_TOKEN = 'JETSON_FIRE_NODE_01'
TOPIC_TELEMETRY = 'v1/devices/me/telemetry'

client = mqtt.Client()
client.username_pw_set(ACCESS_TOKEN)
client.connect(THINGSBOARD_HOST, 1883, 60)
client.loop_start()

def send_fire_alert(confidence, bbox_coords, fps):
    payload = {
        "fire_detected": True if confidence > 0.5 else False,
        "confidence": round(float(confidence), 3),
        "bbox": bbox_coords,  # [xmin, ymin, xmax, ymax]
        "inference_fps": round(float(fps), 1),
        "timestamp": int(time.time() * 1000)
    }
    client.publish(TOPIC_TELEMETRY, json.dumps(payload), qos=1)

Testing và validation

Quá trình kiểm thử thực hiện trên tập Test Set độc lập (300 ảnh đa dạng quang cảnh) và luồng video thực nghiệm với các thông số đo đạc cụ thể:

Mô hình kiểm nghiệm Định dạng mô hình Tốc độ trên Laptop (GTX 1050) Tốc độ trên Jetson Nano 2GB (FPS) Thời gian suy luận (Latency) Độ chính xác mAP@0.5 Mức chiếm dụng RAM (Jetson Nano)
YOLOv3-tiny Darknet Native $45.2\text{ FPS}$ $8.4\text{ FPS}$ $119.0\text{ ms}$ $78.2%$ $1.4\text{ GB}$
YOLOv4-tiny Darknet Native $58.6\text{ FPS}$ $11.2\text{ FPS}$ $89.2\text{ ms}$ $84.6%$ $1.3\text{ GB}$
YOLOv5s PyTorch (.pt) $52.0\text{ FPS}$ $5.1\text{ FPS}$ $196.0\text{ ms}$ $86.1%$ $1.8\text{ GB}$ (Nguy cơ OOM)
YOLOv4-tiny (TFLite) .tflite (FP16) $38.0\text{ FPS}$ $14.5\text{ FPS}$ $68.9\text{ ms}$ $83.9%$ $950\text{ MB}$
YOLOv4-tiny (TensorRT) .trt (FP16 Engine) $82.4\text{ FPS}$ $23.8\text{ FPS}$ $42.0\text{ ms}$ $84.1%$ $680\text{ MB}$ 
Tốc độ suy luận (FPS) trên NVIDIA Jetson Nano 2GB:
======================================================================
YOLOv5s (PyTorch)        [█████] 5.1 FPS
YOLOv3-tiny (Darknet)    [████████] 8.4 FPS
YOLOv4-tiny (Darknet)    [███████████] 11.2 FPS
YOLOv4-tiny (TFLite FP16)[██████████████] 14.5 FPS
YOLOv4-tiny (TensorRT)   [████████████████████████] 23.8 FPS  <-- (TỐI ƯU NHẤT)
======================================================================

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

  • Tăng tốc độ khung hình vượt bậc: Mô hình YOLOv4-tiny sau khi tối ưu hóa với TensorRT FP16 đạt tốc độ $23.8\text{ FPS}$, tăng gấp $2.12$ lần ($+112.5%$) so với Darknet nguyên bản ($11.2\text{ FPS}$) và gấp $4.66$ lần so với YOLOv5s trên PyTorch ($5.1\text{ FPS}$).
  • Tiết kiệm tài nguyên bộ nhớ: Mức chiếm dụng RAM giảm từ $1.3\text{ GB}$ xuống chỉ còn $680\text{ MB}$ (giảm $47.6%$), loại bỏ hoàn toàn hiện tượng tràn bộ nhớ (Out-of-Memory) khi vận hành liên tục 24/7.
  • Bảo toàn độ chính xác: mAP@0.5 sau khi lượng tử hóa sang FP16 vẫn duy trì ở mức $84.1%$ (chỉ suy hao không đáng kể $0.5%$ so với bản float32 gốc).
  • Hệ thống điều hành phân tán hoàn chỉnh: Kết nối thành công luồng suy luận biên với ThingsBoard Dashboard qua MQTT với độ trễ truyền tin cảnh báo $< 150\text{ ms}$.

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

  1. Làm chủ quy trình tối ưu hóa Deep Learning trên Edge Device: Cung cấp đường ống hoàn chỉnh (End-to-End Pipeline) chuyển đổi mô hình từ mạng nơ-ron tích chập (CNN) sang ONNX và biên dịch sang Engine TensorRT tối ưu lớp (Layer Fusion) trực tiếp trên kiến trúc ARM64 của Jetson Nano.
  2. Khắc phục triệt để rào cản phần cứng thấp (Low-cost Edge AI): Chứng minh tính khả thi của việc triển khai các tác vụ thị giác máy tính nặng trên dòng bo mạch $2\text{GB RAM}$ giá rẻ, mở ra cơ hội thương mại hóa quy mô lớn mà không cần trang bị các dòng máy chủ đắt tiền.
  3. Kiến trúc liên kết IoT tiêu chuẩn công nghiệp: Kết hợp thành công giữa Computer Vision và giao thức nhẹ MQTT, cho phép biến một camera giám sát thông thường thành một thiết bị IoT thông minh (AIoT Edge Node) có khả năng tương thích với mọi nền tảng SCADA/IoT Cloud hiện đại.

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

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

  • Kho bãi và nhà xưởng công nghiệp: Lắp đặt tại các điểm mù, khu vực lưu trữ hóa chất hoặc vật liệu dễ cháy để phát hiện tia lửa/ngọn lửa sơ khai trước khi hệ thống báo khói cơ học phản ứng.
  • Trạm quan sát kiểm lâm: Tích hợp trên các tháp quan sát rừng sử dụng năng lượng mặt trời, truyền dữ liệu viễn thông băng thông thấp (4G/LoRa) về trung tâm điều hành.
  • Tòa nhà thông minh & Khu dân cư: Kết hợp với hệ thống camera giám sát nội bộ (CCTV) sẵn có để bổ sung tính năng cảnh báo cháy tự động.

Hướng dẫn triển khai nhanh trên Jetson Nano

# 1. Clone source code va cai dat moi truong
git clone https://github.com/vuhanhanh/jetson-fire-detection.git
cd jetson-fire-detection
pip3 install -r requirements.txt

# 2. Chuyen doi mo hinh ONNX sang TensorRT Engine (thuc hien tren Jetson)
python3 build_engine.py --onnx weights/yolov4-tiny-fire.onnx \
                       --output weights/yolov4-tiny-fire.trt \
                       --fp16

# 3. Khoi chay Web Streaming Server va he thong canh bao MQTT
python3 main_app.py --engine weights/yolov4-tiny-fire.trt \
                    --camera 0 \
                    --mqtt-server 192.168.1.100 \
                    --token JETSON_FIRE_NODE_01

+-------------------------------------------------------------------------------+
|                       PHÂN TÍCH TÀI CHÍNH & HIỆU QUẢ ĐẦU TƯ (ROI)             |
+-------------------------------------------------------------------------------+
| Hạng mục                    | Giải pháp Server Cloud       | Giải pháp Jetson Edge AI  |
+-----------------------------+------------------------------+--------------------------+
| Chi phí phần cứng ban đầu   | Camera ($50) + Server ($2,000)| Jetson Nano + Cam ($120) |
| Chi phí duy trì băng thông  | ~$50 - $100 / tháng / node   | < $5 / tháng (Metadata)  |
| Chi phí bản quyền phần mềm  | Cloud API license theo giờ   | Mã nguồn mở ThingsBoard  |
| Thời gian hoàn vốn (ROI)    | 24 - 36 tháng                | 3 - 6 tháng              |
+-------------------------------------------------------------------------------+

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

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

  • Nhiễu thị giác phức tạp: Ngọn lửa có kích thước quá nhỏ ở khoảng cách xa ($> 30\text{ m}$) với độ phân giải camera thấp dễ bị bỏ sót.
  • Chưa tích hợp nhận diện khói đồng thời: Hệ thống hiện chỉ tập trung phân lớp ngọn lửa, chưa kết hợp mô hình phân đoạn khói (Smoke Segmentation) để cảnh báo sớm ở giai đoạn cháy âm ỉ.
  • Giới hạn quang phổ: Camera RGB thông thường hoạt động kém trong môi trường hoàn toàn không có ánh sáng (đêm tối không có đèn chiếu sáng phụ trợ).

Hướng phát triển tiếp theo

  • Tích hợp thêm cảm biến ảnh nhiệt (Thermal Camera) hoặc camera hồng ngoại bước sóng ngắn để phát hiện nguồn nhiệt ẩn.
  • Nâng cấp kiến trúc lên các dòng mô hình mới hơn như YOLOv8-nano / YOLOv10-nano và triển khai trên nền tảng Jetson Orin Nano để xử lý đa luồng camera (Multi-stream RTSP).
  • Đóng gói ứng dụng thành Docker Container và quản lý phân tán qua K3s (Lightweight Kubernetes) để hỗ trợ cập nhật mô hình từ xa (OTA Updates).

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

  • Sinh viên & Học viên chuyên ngành: Nguồn tài liệu tham khảo chi tiết về quy trình chuyển đổi, tối ưu hóa mô hình từ lý thuyết sang thiết bị phần cứng thực tế.
  • Kỹ sư AIoT & Lập trình viên nhúng: Nắm bắt kiến trúc tích hợp giữa Engine TensorRT, luồng video OpenCV và giao thức MQTT trên Linux ARM.
  • Doanh nghiệp & Đơn vị tích hợp giải pháp: Sở hữu thiết kế tham chiếu chi phí thấp ($< 150$$) để thương mại hóa các hệ thống an ninh - phòng cháy chữa cháy thông minh.
  • Nhà nghiên cứu thị giác máy tính: Cung cấp dữ liệu đo lường thực nghiệm đối sánh giữa các biến thể YOLO trên nền tảng điện toán biê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 NVIDIA Jetson Nano (bản 2GB hoặc 4GB RAM), nguồn điện $5\text{V}-2\text{A}$ qua cổng Micro-USB (hoặc $5\text{V}-4\text{A}$ qua cổng DC Jack để đảm bảo ổn định), thẻ nhớ MicroSD tối thiểu $32\text{GB}$ (tốc độ đọc/ghi Class 10 U3), và 01 Camera chuẩn USB hoặc CSI tương thích GStreamer.

2. Giới hạn mở rộng (Scalability) của hệ thống và giải pháp nâng cấp?

Một thiết bị Jetson Nano 2GB xử lý tối ưu 01 luồng camera độ phân giải 720p ở tốc độ $\sim 24\text{ FPS}$. Khi cần giám sát nhiều vị trí, ta triển khai theo mô hình phân tán (Mesh Edge Nodes), mỗi node xử lý một camera và cùng gửi bản tin MQTT về một máy chủ ThingsBoard Cluster trung tâm.

3. Làm thế nào để tích hợp hệ thống với hạ tầng báo cháy sẵn có của tòa nhà?

Thông qua ngõ xuất tín hiệu GPIO trên Jetson Nano, có thể điều khiển trực tiếp module Relay để kích hoạt chuông báo động vật lý hoặc tủ trung tâm PCCC. Về mặt phần mềm, ThingsBoard cung cấp Webhook/REST API để kết nối trực tiếp vào hệ thống SCADA/BMS của tòa nhà.

4. Hệ thống cần bảo trì định kỳ những hạng mục nào?

Cần vệ sinh ống kính camera định kỳ tránh bụi bẩn làm giảm chất lượng nhận diện, kiểm tra nhiệt độ hoạt động của chip Tegra trên Jetson Nano (đảm bảo gắn quạt tản nhiệt hoặc tản nhiệt nhôm khi vận hành ngoài trời), và kiểm tra dung lượng lưu trữ log/swap trên thẻ nhớ.

5. Chi phí đầu tư ước tính và thời gian thu hồi vốn (ROI)?

Chi phí phần cứng cho một trạm biên dao động từ $2.5 - 3.5$ triệu VNĐ (thấp hơn $70%$ so với việc trang bị máy tính công nghiệp x86). Thời gian hoàn vốn ước tính từ 3 đến 6 tháng nhờ cắt giảm hoàn toàn chi phí đường truyền Internet tốc độ cao và chi phí thuê bao điện toán đám mây.

Kết luận

Đồ án khóa luận tốt nghiệp của sinh viên Vũ Hà Anh (Khoa Mạng máy tính và Truyền thông - Trường ĐH Công nghệ Thông tin, ĐHQG-HCM) đã giải quyết thành công bài toán phát hiện ngọn lửa thời gian thực trên thiết bị nhúng giới hạn tài nguyên NVIDIA Jetson Nano. Bằng việc kết hợp kiến trúc YOLOv4-tiny với bộ công cụ tối ưu hóa NVIDIA TensorRT FP16, hệ thống đạt tốc độ xử lý vượt trội $23.8\text{ FPS}$ với mức tiêu thụ RAM cực thấp ($680\text{ MB}$) và độ chính xác mAP đạt $84.1%$.

Việc tích hợp hoàn chỉnh hệ thống truyền thông điệp MQTT và Dashboard quản trị ThingsBoard đã tạo nên một giải pháp AIoT toàn diện, mang tính ứng dụng thực tiễn cao, chi phí thấp và sẵn sàng triển khai trong các kịch bản an toàn phòng cháy chữa cháy dân dụng lẫn công nghiệp.