Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số và phát triển đô thị thông minh (Smart City), các hệ thống giám sát an ninh bằng hình ảnh (CCTV/IP Camera) đóng vai trò sống còn trong việc bảo vệ an toàn tính mạng, trật tự xã hội và tài sản. Tuy nhiên, theo các báo cáo thống kê ngành thị giác máy tính và IoT, hơn 90% dữ liệu video được truyền tải từ các IP Camera truyền thống lên Cloud Server là dữ liệu tĩnh hoặc dữ liệu dư thừa không có sự kiện an ninh. Việc truyền tải liên tục toàn bộ luồng video độ nét cao (24/7) gây nên hiện tượng nghẽn băng thông mạng diện rộng, làm quá tải hạ tầng máy chủ lưu trữ và tiêu tốn chi phí vận hành đám mây khổng lồ.

+-----------------------------------------------------------------------------+
|                          MÔ HÌNH HỆ THỐNG TỔNG QUÁT                         |
+-----------------------------------------------------------------------------+
|  [Scan Camera] ---> (TCP Socket) ---> [Cloud Server] <---> (MQTT/HTTP/RTSP) |
|  (Raspberry Pi 3B)                     |    |             |   [Mobile App]  |
|                                        |    |             |   (Flutter/Dart)|
|  [Smart Camera] <--- (TCP Socket) <----+    +-------------+                 |
|  (NVIDIA Jetson Nano - Edge AI)                                             |
+-----------------------------------------------------------------------------+

Vấn đề cốt lõi đặt ra là sự thiếu hụt cơ chế tính toán linh hoạt tại biên (Edge Computing) kết hợp với thuật toán trao đổi dữ liệu tối ưu, dẫn đến hai hạn chế lớn:

  1. Lãng phí tài nguyên: Máy chủ phải xử lý giải mã và phân tích dữ liệu cho hàng trăm luồng video cùng lúc.
  2. Chi phí dịch vụ cao: Các giải pháp thương mại như Nest IQ Camera yêu cầu phí duy trì lưu trữ đám mây lên đến 300 USD/năm/camera đối với gói lưu trữ 30 ngày và tính năng nhận diện khuôn mặt.

Đề tài khóa luận "Tích hợp thuật toán trao đổi dữ liệu trên công nghệ tính toán biên cho Smart Camera" của tác giả Trần Tấn Tài (Ngành Kỹ thuật Máy tính, Trường Đại học Công nghệ Thông tin - ĐHQG TP.HCM, dưới sự hướng dẫn của TS. Nguyễn Minh Sơn) được nghiên cứu nhằm giải quyết triệt để bài toán trên.

Mục tiêu cụ thể của đề tài

  1. Thiết kế và cài đặt thuật toán truyền nhận dữ liệu qua giao thức TCP Socket giữa thiết bị tính toán biên Smart Camera (NVIDIA Jetson Nano), thiết bị thu thập Scan Camera (Raspberry Pi 3B) và Cloud Server.
  2. Ứng dụng framework FFmpeg để xây dựng luồng phát trực tiếp (Live Streaming) theo thời gian thực qua giao thức RTSP khi có yêu cầu từ người dùng.
  3. Xây dựng cơ chế cập nhật cơ sở dữ liệu (Database) và tái huấn luyện mô hình nhận diện khuôn mặt trực tiếp tại thiết bị biên từ thiết bị Scan Camera phụ trợ.
  4. Triển khai ứng dụng di động đa nền tảng bằng Flutter Framework hỗ trợ giao tiếp hai chiều thời gian thực qua giao thức MQTT và hiển thị luồng RTSP/HTTP.
  5. Thiết lập cơ chế chạy ngầm (Systemd Service) và đóng gói phần cứng hoàn chỉnh có tích hợp hệ thống tản nhiệt chủ động.

Phạm vi và giới hạn hệ thống

  • Độ phân giải hỗ trợ: Chuyển đổi linh hoạt giữa chuẩn SD (480p - $640 \times 480$) và chuẩn HD (720p - $1280 \times 720$).
  • Cơ chế xử lý đơn nhiệm: Tại một thời điểm, Smart Camera hoạt động tối ưu ở một trong hai chế độ: Chế độ tìm kiếm đối tượng theo yêu cầu hoặc Chế độ phát trực tiếp.
  • Yêu cầu mạng: Băng thông mạng tối thiểu đạt 18 Mbps để đảm bảo độ trễ streaming và truyền ảnh thấp nhất.

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

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

Giải pháp Nền tảng xử lý Chế độ Streaming Nhận diện đối tượng Cập nhật Dataset từ xa Chi phí duy trì
Hệ thống IP Camera truyền thống Cloud Server tập trung Liên tục 24/7 (Băng thông cao) Xử lý tại Cloud (Nặng tải) Thủ công tại Server Rất cao
Nest IQ Camera Hybrid Edge/Cloud Liên tục khi có chuyển động Nhận diện khuôn mặt quen/lạ Đăng ký qua App $300/năm/thiết bị
Mô hình Gören (2020) Edge + Cloud Computing Không hỗ trợ Stream Chỉ lọc ảnh gửi Cloud Không hỗ trợ Trung bình
Ultra96-V2 (Vinh Khang & Hoài, 2023) SoC FPGA Ultra96-V2 Streaming riêng biệt Nhận dạng vật thể riêng biệt (2 USB Cam) Hạn chế Cao
Giải pháp đề tài NVIDIA Jetson Nano + Pi 3B RTSP on-demand (FFmpeg) Nhận diện tại Edge (Jetson) Hỗ trợ qua Scan Cam + Socket Tối ưu / Tự chủ

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

  • Must have (Bắt buộc):
    • Nhận diện khuôn mặt theo tên yêu cầu tại Edge (Jetson Nano).
    • Truyền ảnh chứa đối tượng tìm kiếm lên Cloud Server qua TCP Socket.
    • Streaming chuẩn H.264/RTSP khi người dùng kích hoạt qua giao thức MQTT.
    • Đóng gói dịch vụ tự khởi động (Systemd Service) trên Linux.
  • Should have (Nên có):
    • Thiết bị Scan Camera độc lập (Raspberry Pi 3B) để bổ sung mẫu khuôn mặt mới vào database của Smart Camera.
    • Bộ nhớ chia sẻ (POSIX Shared Memory) để đồng bộ trạng thái camera giữa các tiến trình trên Cloud.
    • Chuyển đổi độ phân giải SD/HD theo thời gian thực.
  • Could have (Có thể có):
    • Giao diện ứng dụng di động Flutter hiển thị đồng thời danh sách đối tượng, trạng thái camera và khung video.
  • Won't have (Chưa thực hiện):
    • Nhận diện đồng thời đa luồng camera song song trên cùng một chip xử lý biên Jetson Nano 2GB/4GB.

Thiết kế hệ thống

Kiến trúc giải pháp được thiết kế theo mô hình 4 tầng phân tán: Edge Layer (Smart Camera & Scan Camera) - Communication Layer (MQTT & TCP Socket) - Cloud Server Layer - Presentation Layer (Flutter Mobile App).

+-----------------------------------------------------------------------------------+
|                            KIẾN TRÚC TẦNG HỆ THỐNG                                |
+-----------------------------------------------------------------------------------+
| [PRESENTATION] Mobile App (Flutter / Dart UI)                                    |
|       ^                        ^                         |                        |
|  (RTSP Stream)           (HTTP Image)              (MQTT Pub/Sub)                 |
|       |                        |                         v                        |
| [CLOUD SERVER] RTSP Server (Port 8556) <---+     Mosquitto Broker (Port 1883)     |
|                HTTP Server (Port 80/443)  |     POSIX Shared Memory (cam_status) |
|                TCP Socket Server Manager  |     Process Multi-forking & Threads  |
|                               ^           |              ^                        |
|                         (TCP Socket) (FFmpeg Pipe)  (MQTT Sub)                    |
|                               |           |              |                        |
| [EDGE LAYER]   Smart Camera (NVIDIA Jetson Nano) + USB Camera (HD/SD)             |
|                Scan Camera (Raspberry Pi 3B) + USB Camera (SD)                    |
+-----------------------------------------------------------------------------------+

Technology Stack & Versions

  • Edge Computing Hardware: NVIDIA Jetson Nano Developer Kit (Quad-core ARM A57 @ 1.43 GHz, 128-core NVIDIA Maxwell GPU), Raspberry Pi 3 Model B (Quad-core ARM Cortex-A53).
  • Embedded OS: Ubuntu 18.04 LTS / Linux Tegra (Jetson), Raspberry Pi OS (Linux Kernel 5.x).
  • Core Languages & Compilers: C/C++ (GCC/G++ 9.4.0, C++11 Standard), Dart SDK 3.x.
  • Computer Vision & Multimedia: OpenCV (Open Source Computer Vision Library) C++ Interface, FFmpeg Multimedia Framework (libavcodec, libavformat, libswscale).
  • IoT & Network Protocols: Eclipse Mosquitto MQTT Broker v5, POSIX TCP Socket API, RTSP (Real-Time Streaming Protocol).
  • Client Application: Flutter SDK (Google) đa nền tảng.

Cơ sở dữ liệu và IPC (Inter-Process Communication)

  • Dataset Storage: Quản lý ảnh khuôn mặt theo cấu trúc thư mục phân cấp dataset/<name>.jpg đi kèm tệp chỉ mục cấu trúc .csv ánh xạ nhãn nhận diện (label_id;image_path).
  • POSIX Shared Memory: Khởi tạo khối nhớ dùng chung /cam_status trên RAM của Cloud Server thông qua các hàm hệ thống shm_open(), ftruncate(), và mmap(). Cơ chế này cho phép luồng quản lý kết nối Socket của tiến trình con (Child Process) cập nhật trạng thái hoạt động của Smart Camera trực tiếp cho luồng MQTT Publisher của tiến trình cha (Parent Process) mà không phát sinh độ trễ I/O đĩa cứng.
// Khởi tạo vùng nhớ chia sẻ POSIX Shared Memory trên Cloud Server
int shm_fd = shm_open("cam_status", O_CREAT | O_RDWR, 0666);
ftruncate(shm_fd, 10);
void *ptr = mmap(0, 10, PROT_WRITE | PROT_READ, MAP_SHARED, shm_fd, 0);
strcpy((char*)ptr, "Khong/"); // Trạng thái mặc định ban đầu

Phương pháp nghiên cứu và phát triển (Methodology)

Dự án được thực hiện theo phương pháp phát triển linh hoạt (Agile - Iterative Engineering), chia làm 4 giai đoạn rõ ràng:

  1. Giai đoạn 1: Nghiên cứu giao thức & Tối ưu luồng dữ liệu: Xây dựng thuật toán socket truyền mảng byte ảnh (send_image/receive_image) và cấu hình đường ống FFmpeg Pipeline.
  2. Giai đoạn 2: Phát triển mô-đun tại Edge: Tích hợp thuật toán nhận diện khuôn mặt Haar Cascade/OpenCV, xây dựng tiến trình đa luồng (Multi-threading) tách biệt giữa tác vụ xử lý video và tác vụ lắng nghe cấu hình MQTT.
  3. Giai đoạn 3: Phát triển Cloud Server & App: Lập trình máy chủ Socket đa tiến trình (Fork-based Process Manager), tích hợp MQTT Mosquitto, hoàn thiện ứng dụng di động Flutter.
  4. Giai đoạn 4: Đóng gói phần cứng & Đánh giá thực nghiệm: Thiết kế vỏ hộp chứa Smart Camera, bố trí quạt tản nhiệt khí 5V, đo đạc độ trễ truyền gói tin, đo FPS và kiểm thử độ bền hệ thống trong 24 giờ liên tục.

Triển khai và kết quả thực nghiệm

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

1. Đường ống phát luồng trực tiếp FFmpeg qua IPC Pipe

Để truyền dữ liệu video trực tiếp từ bộ nhớ OpenCV lên máy chủ RTSP mà không phải ghi file tạm ra bộ nhớ Flash (giảm hao mòn thẻ nhớ và giảm độ trễ), hệ thống sử dụng cơ chế ghi trực tiếp vào đường ống chuẩn (popen) của FFmpeg:

// Thiết lập đường ống dẫn dữ liệu từ C++ sang tiến trình FFmpeg CLI
FILE *pipeout;
std::string ffmpeg_cmd = std::string("ffmpeg -y -f rawvideo -r 20 -video_size ") 
    + std::to_string(width) + "x" + std::to_string(height) 
    + " -pixel_format bgr24 -i pipe: -crf 24 -pix_fmt yuv420p -f rtsp -rtsp_transport tcp "
    + "rtsp://119.45.xx.xx:8556/mystream720";
pipeout = popen(ffmpeg_cmd.c_str(), "w");

// Vòng lặp đẩy từng frame ảnh liên tục vào Pipeline
while (strcmp(fnd_name, "Stream") == 0 && socket_desc > 0) {
    cap >> frame;
    cv::flip(frame, frame, 1);
    fwrite(frame.data, 1, width * height * 3, pipeout);
}

2. Xử lý đa luồng và bắt sự kiện điều khiển qua MQTT

Thiết bị Smart Camera chạy đồng thời hai luồng độc lập thông qua POSIX Threads (pthread):

  • Luồng 1 (Video Processing Thread): Thu thập khung hình từ camera, thực hiện nhận diện khuôn mặt đối sánh với nhãn mục tiêu find_name. Khi phát hiện trùng khớp (detect_and_predict() == 1), hệ thống lưu tạm ảnh imwrite("name.jpg"), gửi chuỗi tên đối tượng qua hàm write() của Socket, sau đó gọi hàm send_image() để truyền dữ liệu byte sang máy chủ.
  • Luồng 2 (MQTT Listener Thread): Sử dụng thư viện libmosquitto để nhận chỉ thị chuyển đổi chế độ hoặc đổi độ phân giải từ người dùng.
// Callback tiếp nhận thông điệp điều khiển từ ứng dụng Flutter
void on_message(struct mosquitto *mosq, void *obj, const struct mosquitto_message *msg) {
    printf("New message with topic %s: %s\n", msg->topic, (char *)msg->payload);
    std::string mes((char *)msg->payload);
    if (mes == "HD" || mes == "SD") {
        strcpy(flag, mes.c_str()); // Đổi cờ độ phân giải
    } else {
        strcpy(find_name, mes.c_str()); // Cập nhật tên đối tượng cần tìm kiếm
    }
}

+-----------------------------------------------------------------------------+
|               LUỒNG ĐIỀU KHIỂN & TRAO ĐỔI DỮ LIỆU TẠI SMART CAMERA          |
+-----------------------------------------------------------------------------+
|                                                                             |
|   +--------------------------+         +--------------------------------+   |
|   |  MQTT Listener (Thread 2)|         | Video Processing (Thread 1)    |   |
|   +--------------------------+         +--------------------------------+   |
|                 |                                      |                    |
|   Nhận lệnh "Stream" / "Name"                          v                    |
|                 |                         +---------------------------+     |
|                 +-----------------------> | Chế độ = Stream?          |     |
|                                           +---------------------------+     |
|                                             /                       \       |
|                                      (Đúng)/                         \(Sai) |
|                                           v                           v     |
|                             +--------------------+     +------------------+ |
|                             | Mở FFmpeg Pipe     |     | Nhận diện khuôn  | |
|                             | Stream RTSP H.264  |     | mặt OpenCV       | |
|                             +--------------------+     +------------------+ |
|                                                                       |     |
|                                                            Tìm thấy đối tượng?
|                                                                       |     |
|                                                                     (Đúng)  |
|                                                                       v     |
|                                                        +------------------+ |
|                                                        | Gửi tên & ảnh qua| |
|                                                        | TCP Socket       | |
|                                                        +------------------+ |
+-----------------------------------------------------------------------------+

Kiểm thử và đánh giá hệ thống

1. Đánh giá thuật toán gửi ảnh qua TCP Socket

Thực nghiệm đo lường tốc độ truyền mảng dữ liệu ảnh nén JPEG giữa các nút phần cứng trong mạng qua TCP Socket:

Thiết bị gửi Băng thông trung bình Thời gian gửi gói tin (ms) Tính toàn vẹn dữ liệu
Smart Camera (Jetson Nano) 2.1 MB/s $42 \pm 3\text{ ms}$ 100% (TCP ACK đảm bảo)
Scan Camera (Raspberry Pi 3B) 1.8 MB/s $51 \pm 4\text{ ms}$ 100% (TCP ACK đảm bảo)
Cloud Server (Host) 12.5 MB/s $8 \pm 1\text{ ms}$ 100% (Không suy hao)

2. Đánh giá luồng phát trực tiếp và gửi ảnh qua WiFi so với 4G LTE

Hệ thống được thử nghiệm truyền tải ở hai độ phân giải SD ($640 \times 480$) và HD ($720 \times 1280$) trên hạ tầng mạng WiFi văn phòng và mạng di động viễn thông 4G:

TỐC ĐỘ TRUYỀN ẢNH VÀ ĐỘ TRỄ PHÁT TRỰC TIẾP THEO MẠNG
----------------------------------------------------------------------
Độ phân giải SD (480p) - WiFi   : [===] 38 ms | Stream: 20 FPS (Độ trễ ~0.8s)
Độ phân giải SD (480p) - 4G LTE : [=====] 62 ms | Stream: 19 FPS (Độ trễ ~1.2s)
Độ phân giải HD (720p) - WiFi   : [======] 74 ms | Stream: 20 FPS (Độ trễ ~1.1s)
Độ phân giải HD (720p) - 4G LTE : [==========] 118 ms | Stream: 18 FPS (Độ trễ ~1.6s)
----------------------------------------------------------------------

3. Kiểm thử độ ổn định và tản nhiệt trong thời gian dài (Stress Test)

Hệ thống Smart Camera (đã tích hợp hộp bảo vệ và quạt tản nhiệt) được vận hành liên tục trong 24 giờ để kiểm tra hiện tượng rò rỉ bộ nhớ (Memory Leak) và suy giảm hiệu năng do quá nhiệt (Thermal Throttling):

Mốc thời gian kiểm tra Tốc độ gửi ảnh qua Socket FPS luồng Live Stream Nhiệt độ GPU/SoC Jetson Trạng thái hệ thống
Sau 6 giờ $43.2\text{ ms}$ 20 FPS $48.5^\circ\text{C}$ Ổn định tuyệt đối
Sau 12 giờ $44.1\text{ ms}$ 20 FPS $51.2^\circ\text{C}$ Không tràn RAM
Sau 19 giờ $43.8\text{ ms}$ 20 FPS $52.0^\circ\text{C}$ Luồng RTSP mượt mà
Sau 24 giờ $44.5\text{ ms}$ 20 FPS $52.3^\circ\text{C}$ Hoạt động bình thường

4. Đánh giá độ chính xác nhận diện khuôn mặt theo góc quay

Thử nghiệm nhận dạng đối tượng mục tiêu được thực hiện ở các góc độ tương quan giữa khuôn mặt và ống kính camera:

Góc chụp so với trục camera Số lần kiểm thử Nhận diện chính xác Tỷ lệ chính xác (%)
Góc thẳng (Chính diện $0^\circ$) 50 48 96.0%
Góc nghiêng trái ($15^\circ - 30^\circ$) 50 43 86.0%
Góc nghiêng phải ($15^\circ - 30^\circ$) 50 44 88.0%
Trung bình toàn hệ thống 150 135 90.0%

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

  1. Kiến trúc truyền thông hỗn hợp tối ưu băng thông: Bằng cách kết hợp giao thức TCP Socket cho dữ liệu nhị phân nặng (hình ảnh JPEG đối tượng), MQTT Mosquitto cho các bản tin điều khiển nhẹ (JSON/Text command) và RTSP trên nền FFmpeg cho luồng video thời gian thực, hệ thống giảm hơn 85% lưu lượng băng thông truyền tải so với các camera IP truyền thống liên tục đẩy luồng video thô lên Cloud.
  2. Cơ chế tái huấn luyện động tại biên (Dynamic Model Updating): Khắc phục điểm yếu cố hữu của các hệ thống Edge AI tĩnh. Khi thiết bị Scan Camera (Raspberry Pi 3B) thu thập đối tượng mới, dữ liệu khuôn mặt được chuyển tiếp trực tiếp vào Smart Camera qua Socket, kích hoạt hàm read_csv() và create_model() để tái tạo mô hình nhận diện mới tại chỗ mà không cần biên dịch lại mã nguồn hay khởi động lại thiết bị.
  3. Cơ chế chuyển đổi luồng On-the-fly qua Linux Pipe: Tích hợp lệnh popen() điều khiển FFmpeg CLI giúp giải phóng và tái tạo luồng stream theo các độ phân giải khác nhau (SD 480p @ 30 FPS / HD 720p @ 20 FPS) chỉ trong $300\text{ ms}$, tối ưu tài nguyên phần cứng vốn hạn chế của Jetson Nano.
  4. Đồng bộ hóa dữ liệu phân tán bằng Shared Memory: Ứng dụng kỹ thuật bộ nhớ chia sẻ POSIX cấp nhân hệ điều hành Linux giúp giải quyết bài toán đồng bộ dữ liệu giữa tiến trình Socket quản lý kết nối Camera và tiến trình MQTT phân phối thông tin tới hàng trăm ứng dụng di động Flutter.

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

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

  • Hệ thống điểm danh thông minh tại giảng đường và doanh nghiệp: Thiết bị Scan Camera đặt tại cổng vào để đăng ký nhân viên/sinh viên mới; các thiết bị Smart Camera tại phòng học tự động quét và nhận diện đối tượng theo danh sách chỉ định, gửi log điểm danh kèm ảnh bằng chứng về Server.
  • Giám sát an ninh và phát hiện đối tượng trong danh sách đen (Blacklist): Người quản trị gửi yêu cầu tìm kiếm nghi phạm từ Mobile App; Smart Camera tại các nút giao thông hoặc sảnh tòa nhà sẽ tự động giám sát ngầm, chỉ đẩy cảnh báo và ảnh chụp khi phát hiện đối tượng, loại bỏ hoàn toàn gánh nặng lưu trữ video rác.
  • Hệ thống giám sát nhà thông minh (Smart Home Security): Cho phép gia chủ chủ động chuyển đổi giữa việc xem trực tiếp con nhỏ/thú cưng (RTSP Live Stream) và chế độ tìm kiếm người thân trong gia đình khi có chuông cửa.
+-----------------------------------------------------------------------------+
|                     KỊCH BẢN TRIỂN KHAI THỰC TẾ                             |
+-----------------------------------------------------------------------------+
|                                                                             |
|   [Cổng Check-in]                [Khu vực Giám sát]        [Người Quản trị] |
|   +-------------------+          +-------------------+     +--------------+ |
|   | Scan Camera       |          | Smart Camera      |     | Flutter App  | |
|   | (Raspberry Pi 3B) |          | (Jetson Nano)     |     | (iOS/Android)| |
|   +-------------------+          +-------------------+     +--------------+ |
|             |                              |                       |        |
|      (Đăng ký khuôn mặt)          (Nhận diện mục tiêu)     (Nhận cảnh báo & |
|             |                              |                Xem Live RTSP)  |
|             v                              v                       v        |
|   +-----------------------------------------------------------------------+ |
|   |                CLOUD SERVER (Socket / Mosquitto / RTSP)               | |
|   +-----------------------------------------------------------------------+ |
+-----------------------------------------------------------------------------+

Hướng dẫn triển khai (Deployment Guide)

  1. Thiết lập phần cứng: Lắp ráp Jetson Nano vào khung vỏ bảo vệ, đấu nối quạt tản nhiệt 5V vào chân GPIO Header (Pin 4 - 5V, Pin 6 - GND) để đảm bảo giải nhiệt khi GPU hoạt động tải cao.
  2. Cấu hình dịch vụ chạy ngầm trên Linux (Systemd Service): Tạo file cấu hình /etc/systemd/system/smartcamera.service để tự khởi động chương trình cùng hệ điều hành:
[Unit]
Description=Smart Camera Edge Service
After=network.target

[Service]
Type=simple
User=ds01
WorkingDirectory=/home/ds01/smart_camera_project
ExecStart=/home/ds01/smart_camera_project/run_camera.sh
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Kích hoạt service bằng lệnh: sudo systemctl enable --now smartcamera.service.

  1. Phân tích hiệu quả kinh tế (ROI): Thay vì đầu tư hệ thống máy chủ Cloud GPU đắt đỏ để giải mã hàng loạt kênh video (ước tính 150 - 200 USD/kênh/năm) hoặc thuê bao Nest IQ (300 USD/cam/năm), giải pháp tích hợp phần cứng Jetson Nano ($99) kết hợp Server cấu hình cơ bản giúp tiết kiệm 70% chi phí đầu tư ban đầu và 85% chi phí duy trì hàng năm.

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

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

  • Đơn nhiệm tại một thời điểm: Smart Camera chưa thể chạy đồng thời vừa nhận dạng khuôn mặt vừa phát luồng trực tiếp với FPS cao do giới hạn tài nguyên GPU/VRAM của Jetson Nano 2GB/4GB khi xử lý phân giải HD.
  • Độ phân giải bị giới hạn: Chưa hỗ trợ chuẩn Full HD (1080p) hoặc 4K do băng thông mã hóa thời gian thực bằng CPU/FFmpeg CLI pipeline bị thắt nút cổ chai.
  • Thuật toán xử lý ánh sáng: Khả năng nhận diện khuôn mặt suy giảm khi môi trường có độ tương phản cao, ngược sáng mạnh hoặc thiếu sáng vào ban đêm.

Hướng phát triển mở rộng

  • Tối ưu hóa mô hình Deep Learning: Chuyển đổi mô hình nhận diện khuôn mặt sang kiến trúc mạng nơ-ron tích chập sâu (FaceNet/MobileFaceNet) và tăng tốc suy luận bằng NVIDIA TensorRT để đạt tốc độ >30 FPS.
  • Nâng cấp giao thức truyền thông WebRTC: Thay thế RTSP bằng WebRTC để giảm độ trễ phát trực tiếp từ $\sim 1\text{s}$ xuống dưới $200\text{ ms}$, hỗ trợ xem trực tiếp mượt mà trên trình duyệt web mà không cần cài đặt ứng dụng.
  • Hỗ trợ cụm đa Camera (Camera Cluster Orchestration): Phát triển tính năng nhận diện liên camera (Re-Identification), cho phép theo dấu vết di chuyển của một đối tượng xuyên suốt qua nhiều vị trí lắp đặt Smart Camera khác nhau.

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

+-----------------------------------------------------------------------------+
|                          ĐỐI TƯỢNG HƯỞNG LỢI                                |
+-----------------------------------------------------------------------------+
|  [Sinh viên Kỹ thuật]  --->  Mã nguồn C++ Socket, FFmpeg Pipe, Kiến trúc    |
|                              hệ thống nhúng thực tế.                        |
|                                                                             |
|  [Kỹ sư / Lập trình]   --->  Mẫu thiết kế giao tiếp Edge-Cloud-Mobile,     |
|                              cơ chế đồng bộ POSIX Shared Memory.            |
|                                                                             |
|  [Doanh nghiệp / IoT]  --->  Giải pháp Smart Camera độc lập, cắt giảm 85%    |
|                              chi phí băng thông và thuê bao Cloud.          |
|                                                                             |
|  [Nhà nghiên cứu]      --->  Bộ dữ liệu thực nghiệm độ trễ mạng WiFi vs 4G, |
|                              đánh giá hiệu năng Jetson Nano liên tục 24h.   |
+-----------------------------------------------------------------------------+
  • Sinh viên ngành Kỹ thuật Máy tính, Điện tử & CNTT: Tài liệu tham khảo toàn diện về cách kết hợp giữa lập trình hệ thống cấp thấp (Linux Socket, Multi-threading, Shared Memory), xử lý đa phương tiện (FFmpeg, OpenCV) và phát triển ứng dụng di động (Flutter).
  • Kỹ sư phát triển hệ thống nhúng & IoT: Bản thiết kế kiến trúc chuẩn mực để giải quyết bài toán thắt nút cổ chai băng thông khi triển khai các dòng camera AI biên ra môi trường thực tế.
  • Doanh nghiệp tích hợp giải pháp an ninh: Một kiến trúc hoàn chỉnh, có khả năng thương mại hóa ngay với chi phí phần cứng thấp, giảm thiểu phụ thuộc vào các dịch vụ đám mây nước ngoài.
  • Nhóm nghiên cứu học thuật: Số liệu thực nghiệm đáng tin cậy về hiệu năng phần cứng, mức tiêu thụ tài nguyên và độ chính xác của các thuật toán thị giác máy tính trên nền tảng tính toán biên.

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

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

  • Thiết bị biên Smart Camera: NVIDIA Jetson Nano (khuyến nghị bản 4GB RAM), thẻ nhớ MicroSD tối thiểu 32GB Class 10/UHS-1, 01 USB Camera chuẩn UVC hỗ trợ độ phân giải tối thiểu 720p.
  • Thiết bị Scan Camera: Raspberry Pi 3 Model B trở lên, nguồn 5V/2.5A, 01 USB Camera 480p.
  • Cloud Server: Máy chủ ảo (VPS) chạy Linux (Ubuntu 20.04/22.04 LTS), tối thiểu 1 Core CPU, 2GB RAM, có mở các cổng mạng: Port 1883 (MQTT Mosquitto), Port 8556 (RTSP Server), Port kết nối TCP Socket tùy chọn.

2. Hệ thống có khả năng mở rộng (Scalability) kết nối nhiều Smart Camera cùng lúc không?

Có. Trên Cloud Server, kiến trúc mạng được thiết kế theo mô hình đa tiến trình (Forking Server). Khi mỗi thiết bị Smart Camera mới kết nối tới qua TCP Socket, tiến trình cha (Parent Process) sẽ tự động tạo một tiến trình con (Child Process) độc lập qua hàm fork() để quản lý riêng thiết bị đó. Khi một camera bị ngắt kết nối đột ngột, chỉ tiến trình con tương ứng bị hủy bỏ mà không gây gián đoạn cho toàn bộ hệ thống.

3. Tại sao hệ thống lại kết hợp cả ba giao thức: TCP Socket, MQTT và RTSP?

Mỗi giao thức được tối ưu hóa cho một dạng dữ liệu chuyên biệt:

  • TCP Socket: Đảm bảo tính toàn vẹn 100% khi truyền mảng byte ảnh JPEG của đối tượng (dữ liệu nhị phân nặng, không được phép mất gói).
  • MQTT: Giao thức truyền tin siêu nhẹ (Lightweight Pub/Sub), hoàn hảo cho các lệnh điều khiển thời gian thực và đồng bộ trạng thái giữa Mobile App và Camera.
  • RTSP: Giao thức chuẩn công nghiệp chuyên dụng để truyền tải luồng video liên tục với độ trễ thấp và khả năng giải mã phần cứng tốt trên thiết bị di động.

4. Thiết bị Smart Camera có bị quá nhiệt khi chạy liên tục ngoài trời không?

Trong các bài kiểm tra thực nghiệm tải nặng liên tục suốt 24 giờ trong phòng thí nghiệm, khi gắn kèm quạt tản nhiệt chủ động 5V, nhiệt độ SoC Jetson Nano luôn duy trì ở mức an toàn ($48.5^\circ\text{C} - 52.3^\circ\text{C}$). Để triển khai ngoài trời, cần đặt thiết bị trong hộp bảo vệ chuẩn chống nước IP66 có thiết kế khe thoát nhiệt đối lưu cưỡng bức.

5. Chi phí ước tính để sản xuất một bộ Smart Camera hoàn chỉnh là bao nhiêu?

Chi phí linh kiện phần cứng cho một cụm thiết bị Smart Camera hoàn chỉnh ước tính khoảng 2.500.000 - 3.200.000 VNĐ (bao gồm Jetson Nano, USB Camera, nguồn chuẩn 5V/4A, thẻ nhớ tốc độ cao, vỏ bảo vệ và quạt tản nhiệt). Mức chi phí này thấp hơn đáng kể so với các dòng Smart Camera chuyên dụng nhập khẩu có cùng tính năng AI trên thị trường.

Kết luận

Đề tài khóa luận "Tích hợp thuật toán trao đổi dữ liệu trên công nghệ tính toán biên cho Smart Camera" của tác giả Trần Tấn Tài đã chứng minh tính khả thi, độ tin cậy và hiệu quả vượt trội của mô hình tính toán biên kết hợp đám mây trong bài toán giám sát an ninh thông minh. Bằng việc làm chủ công nghệ từ tầng phần cứng nhúng (NVIDIA Jetson Nano, Raspberry Pi 3B), tầng giao thức mạng cấp thấp (C++ TCP Socket, POSIX Shared Memory, MQTT Mosquitto), tầng xử lý đa phương tiện (OpenCV, FFmpeg RTSP Pipeline) cho đến tầng ứng dụng người dùng (Flutter Framework), nghiên cứu đã tạo ra một sản phẩm hoàn chỉnh có giá trị thực tiễn cao.

Giải pháp không chỉ giải quyết triệt để bài toán nghẽn băng thông và tối ưu hóa chi phí vận hành máy chủ đám mây, mà còn mở ra hướng phát triển bền vững cho các hệ thống an ninh giám sát tự chủ, bảo mật và thông minh tại Việt Nam.