Giới thiệu dự án

Sự giao thoa giữa Internet of Things (IoT) và Metaverse đang mở ra kỷ nguyên mới cho các hệ thống giám sát và điều khiển không gian số (Digital Twin). Theo báo cáo từ McKinsey & Company, giá trị tiềm năng của hệ sinh thái IoT có thể đạt 12,6 nghìn tỷ USD vào năm 2030, trong khi Metaverse đang chuyển dịch mạnh mẽ từ môi trường giải trí thuần túy sang các ứng dụng công nghiệp, giáo dục và quản lý đô thị thông minh.

Tuy nhiên, rào cản lớn nhất hiện nay là sự phân mảnh giữa thế giới vật lý và thế giới ảo:

  • Các hệ thống giám sát IoT truyền thống chủ yếu hiển thị dữ liệu dạng bảng biểu 2D (Dashboard) phẳng, thiếu tính trực quan không gian.
  • Các môi trường Metaverse hiện tại phần lớn là mô hình tĩnh, thiếu cơ chế đồng bộ dữ liệu cảm biến thời gian thực (real-time telemetry) từ môi trường vật lý.
  • Hiện tượng nghẽn cổ chai truyền thông khi truyền tải đồng thời luồng video/hình ảnh độ trễ thấp và dữ liệu đo đạc đa cảm biến lên các nền tảng thực tế ảo (VR/AR/XR).

Đồ án tốt nghiệp "Ứng dụng các thiết bị IoT vào thực tế ảo Metaverse" (IoT in Metaverse) do sinh viên Chu Thành Nhân thực hiện dưới sự hướng dẫn của ThS. Phan Đình Duy tại Trường Đại học Công nghệ Thông tin – ĐHQG-HCM (Khoa Kỹ thuật Máy tính) giải quyết trực tiếp bài toán tích hợp thế giới thực vào không gian 3D tương tác. Dự án xây dựng một hệ thống hoàn chỉnh kết nối từ vi điều khiển nhúng, phân tích thị giác máy tính với mô hình trí tuệ nhân tạo YOLOv8, máy chủ trung gian đám mây Microsoft Azure, cơ sở dữ liệu Firebase Realtime Database, đến không gian thực tế ảo Metaverse mô phỏng thời gian thực trên nền tảng Unity 6 Preview.

+------------------+      WebSocket (JPEG + JSON)      +-----------------------------------------+
| Khối Thiết Bị    | --------------------------------> | Khối Server                             |
| (ESP32-CAM Edge) |                                   | - Node.js Gateway & Protocol Packager   |
+------------------+                                   | - Python YOLOv8n Inference Engine       |
                                                       | - Firebase Realtime Database            |
                                                       +-----------------------------------------+
                                                                            |
                                                                            | WebSocket (8-byte Header Protocol)
                                                                            v
                                                       +-----------------------------------------+
                                                       | Khối Người Dùng (User / Metaverse)      |
                                                       | - Unity 6 Preview (URP / STP Engine)    |
                                                       | - Digital Twin Tầng 6 Tòa E (UIT)       |
                                                       +-----------------------------------------+

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

  1. Thiết kế phần cứng nhúng biên (Edge IoT): Tích hợp vi điều khiển ESP32-CAM (OV2640) cùng mạng lưới cảm biến môi trường (nhiệt độ, độ ẩm, ánh sáng LDR, khí gas MQ-2) hoạt động bền bỉ, tiêu thụ năng lượng thấp.
  2. Xây dựng module thị giác máy tính thông minh (Vision AI): Huấn luyện mô hình YOLOv8n (nano) trên tập dữ liệu đặc thù để phát hiện và đếm số lượng người với độ chính xác đạt trên 80% mAP, nhận diện chính xác sự hiện diện tại khu vực giám sát.
  3. Phát triển giao thức truyền thông đồng bộ hai chiều: Thiết kế cơ chế đóng gói dữ liệu nhị phân tùy biến kết hợp WebSocket toàn song công (Full-duplex TCP Socket), duy trì độ trễ truyền dẫn toàn hệ thống không quá 3 giây, triệt tiêu thất thoát gói tin (0% packet loss).
  4. Tái hiện bản sao số (Digital Twin) trên Metaverse: Xây dựng mô hình 3D tương tác chính xác của Tầng 6 Tòa nhà E (Trường Đại học Công nghệ Thông tin - UIT) trên engine đồ họa Unity 6 Preview, cập nhật trạng thái môi trường và hiển thị luồng hình ảnh camera thời gian thực.

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

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

Trước khi thiết kế hệ thống, các giải pháp giám sát và hiển thị dữ liệu hiện hành được đánh giá toàn diện:

Tiêu chí so sánh Hệ thống IoT SCADA / 2D Dashboard (Grafana, ThingsBoard) Môi trường WebVR / WebGL Đơn giản (A-Frame, Three.js) Giải pháp IoT trong Metaverse (Unity 6 + Edge AI)
Trực quan hóa không gian Rất thấp (biểu đồ 2D, bảng số liệu phẳng) Trung bình (mô hình 3D nhẹ, giới hạn ánh sáng và bóng đổ) Rất cao (Digital Twin 3D chuẩn tỉ lệ, hiệu ứng vật lý, đổ bóng chân thực)
Độ trễ dữ liệu (Latency) Thấp (< 1s với giao thức MQTT/HTTP) Trung bình (2s - 5s do hạn chế trình duyệt) Thấp (< 2.5s qua kênh WebSocket tối ưu nhị phân)
Xử lý thị giác máy tính Thường tách rời, lưu trữ NVR độc lập Không tích hợp sẵn, xử lý client-side nặng Tích hợp Pipeline YOLOv8n xử lý song song tại Python Server
Tương tác 2 chiều (Bi-directional) Chủ yếu là 1 chiều (Thu thập dữ liệu) Hạn chế điều khiển phần cứng Điều khiển thời gian thực và kích hoạt thiết bị ngay trong VR
Khả năng mở rộng (Scalability) Cao đối với dữ liệu chuỗi thời gian Thấp khi cảnh 3D có nhiều đối tượng Cao nhờ kiến trúc Microservices và GPU Occlusion Culling

Ma trận ưu tiên yêu cầu người dùng (MoSCoW):

  • Must Have (Bắt buộc): Luồng stream hình ảnh OV2640 qua WebSocket; giải thuật YOLOv8n phát hiện người; giao diện 3D Unity mô phỏng Tầng 6 Tòa E; cập nhật dữ liệu nhiệt độ, độ ẩm, ánh sáng, nồng độ khí gas lên Firebase.
  • Should Have (Nên có): Cơ chế đóng gói Header 8-byte tùy biến nhằm giảm tải payload; triển khai máy chủ đám mây Microsoft Azure Linux VM; tích hợp GPU Resident Drawer tối ưu hóa render.
  • Could Have (Có thể có): Quét 3D không gian thực tế qua ứng dụng Polycam Photogrammetry; tương tác bằng kính thực tế ảo VR Headset (Apple Vision Pro/Meta Quest).
  • Won't Have (Chưa thực hiện ở pha này): Hỗ trợ kính xúc giác Haptic Gloves toàn thân; đồng bộ hóa giao dịch tài sản qua Blockchain/Smart Contract.

Thiết kế hệ thống

Kiến trúc hệ thống được chuẩn hóa theo mô hình 3 tầng phân tán:

[ ESP32-CAM + Sensors ] (Khối Thiết Bị)
                    [ Unity 6 Metaverse Client ]
                    (Digital Twin Engine: Tầng 6 Tòa E)

1. Khối thiết bị (Edge Hardware Layer):

  • Vi điều khiển trung tâm: ESP32-S (AI-Thinker), CPU Xtensa Dual-Core 32-bit LX6 xung nhịp 160MHz (đạt sức mạnh tính toán 600 DMIPS), 520 KB SRAM tích hợp + 4MB external PSRAM, băng thông Wi-Fi 802.11 b/g/n.
  • Module quang học: Camera OmniVision OV2640 hỗ trợ độ phân giải UXGA (1600x1200) đến SVGA/QVGA, tích hợp bộ nén phần cứng JPEG engine, dòng tĩnh (standby) cực thấp chỉ 6mA, kích thước module 40 x 27 x 12 mm.
  • Cụm cảm biến ngoại vi:
    • Cảm biến nhiệt độ & độ ẩm: Thu thập thông số môi trường qua cầu phân áp/giao tiếp số.
    • Cảm biến quang trở LDR (Light Dependent Resistor): Chuyển đổi quang năng thành điện áp tương tự (ADC 12-bit), định lượng cường độ sáng Lux.
    • Cảm biến nồng độ khí gas MQ-2: Cảm biến điện hóa phát hiện rò rỉ khí LPG, Methane, Butane và khói.

2. Khối máy chủ (Server Microservices Layer):

  • Node.js Server: Đóng vai trò trung tâm điều phối kết nối (Connection Gateway/Broker) sử dụng thư viện ws. Node.js tiếp nhận kết nối WebSocket từ ESP32-CAM, trích xuất dữ liệu cảm biến gửi vào Firebase Realtime Database, đồng thời định tuyến các khung hình ảnh sang Python Server.
  • Python Server (AI Engine): Ứng dụng OpenCV 4.x và Ultralytics YOLOv8 framework. Server nhận luồng byte ảnh JPEG, giải mã và thực thi suy luận nhận diện đối tượng người (class: person). Kết quả được tuần tự hóa theo cấu trúc nhị phân đặc tả và phản hồi lại Node.js Server.
  • Cơ sở dữ liệu Firebase Realtime Database: Lưu trữ dữ liệu NoSQL dạng cấu trúc cây Big JSON thời gian thực, đảm bảo client nhận dữ liệu biến thiên theo thời gian thực (sub-100ms latency).
  • Hạ tầng Cloud Microsoft Azure: Máy ảo Ubuntu Server 22.04 LTS trên Azure Compute VM, quản trị kết nối qua SSH Key Authentication 4096-bit, mở cổng Firewall có kiểm soát cho WebSocket (Port 8080/8765).

3. Khối người dùng (Unity Metaverse UI Layer):

  • Phát triển trên Unity 6 Preview, ngôn ngữ kịch bản C# (.NET 8/Mono).
  • Sử dụng đồ họa Universal Render Pipeline (URP) kết hợp công nghệ GPU Resident Drawer và GPU Occlusion Culling, giảm thiểu draw calls và giải phóng tài nguyên CPU.
  • Áp dụng thuật toán Spatio-Temporal Post-Processing (STP) giúp upscale hình ảnh mượt mà, duy trì tốc độ khung hình ổn định > 60 FPS trên các thiết bị hiển thị.

Cấu trúc giao thức dữ liệu nhị phân (Custom Binary Data Protocol)

Để tối ưu hóa băng thông mạng và loại bỏ chi phí giải mã chuỗi (JSON parsing overhead) khi truyền dữ liệu hình ảnh tần suất cao, hệ thống triển khai định dạng gói tin nhị phân có độ dài tiêu đề cố định 8 bytes:

+------------------------+------------------------+-------------------------------------+
|  Byte 0 - 3 (4 Bytes)  |  Byte 4 - 7 (4 Bytes)  |         Byte 8 - N (N Bytes)        |
+------------------------+------------------------+-------------------------------------+
|   Person Count (int)   |    Image Size (int)    |          Raw JPEG Byte Stream       |
+------------------------+------------------------+-------------------------------------+
  • 4 bytes đầu tiên (Offset 0x00 - 0x03): Kiểu số nguyên 32-bit (int32, Little-Endian), biểu diễn số lượng người phát hiện được trong khung hình (person_count).
  • 4 bytes tiếp theo (Offset 0x04 - 0x07): Kiểu số nguyên 32-bit (int32, Little-Endian), biểu diễn kích thước dung lượng thực tế của file ảnh JPEG tính theo byte (image_size = N).
  • Các bytes còn lại (Offset 0x08 đến 0x08 + N): Dữ liệu nhị phân thô của ảnh JPEG (raw_image_data), được nạp trực tiếp vào bộ đệm đồ họa của Unity qua phương thức Texture2D.LoadImage().

Implementation và kết quả

Development Process & Key Algorithms

Hệ thống được phát triển theo mô hình lặp tích hợp liên tục (CI/CD). Dưới đây là các hiện thực kỹ thuật cốt lõi trong quy trình xử lý dữ liệu:

1. Thuật toán đóng gói nhị phân tại Python Server (YOLOv8 Inference & Serialization):

Python Server nhận luồng ảnh từ Node.js, sử dụng mô hình YOLOv8n đã được tinh chỉnh (fine-tuned) trên tập dữ liệu giám sát phòng học/hành lang để đếm số người và đóng gói theo chuẩn giao thức 8 bytes:

import cv2
import struct
import numpy as np
from ultralytics import YOLO

# Khởi tạo mô hình YOLOv8n đã huấn luyện
model = YOLO('weights/yolov8n_custom.pt')

def process_frame_and_serialize(raw_jpeg_bytes):
    # 1. Giải mã mảng byte thành ảnh OpenCV
    np_arr = np.frombuffer(raw_jpeg_bytes, np.uint8)
    frame = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
    
    if frame is None:
        return None

    # 2. Suy luận nhận diện đối tượng với confidence threshold = 0.5
    results = model.predict(source=frame, classes=[0], conf=0.5, verbose=False)
    person_count = len(results[0].boxes)

    # 3. Vẽ bounding box trực tiếp lên frame để hiển thị
    annotated_frame = results[0].plot()

    # 4. Nén lại thành định dạng JPEG
    success, encoded_image = cv2.imencode('.jpg', annotated_frame, [cv2.IMWRITE_JPEG_QUALITY, 80])
    if not success:
        return None

    image_bytes = encoded_image.tobytes()
    image_size = len(image_bytes)

    # 5. Đóng gói Header 8 Bytes: [Person Count (int32)] + [Image Size (int32)]
    # 'ii' đại diện cho 2 số nguyên có dấu 4-byte dạng little-endian
    header = struct.pack('<ii', person_count, image_size)
    
    # Ghép Header và Payload nhị phân
    payload = header + image_bytes
    return payload

2. Kịch bản tiếp nhận và giải mã tại Unity 6 Client (C#):

Client Unity thiết lập luồng lắng nghe WebSocket và phân tích gói tin nhị phân để dựng ảnh 3D và hiển thị số lượng người trong phòng học ảo:

using System;
using UnityEngine;
using UnityEngine.UI;
using NativeWebSocket;

public class MetaverseTelemetryReceiver : MonoBehaviour
{
    private WebSocket websocket;
    public RawImage cameraDisplay;
    public Text personCounterText;
    private Texture2D videoTexture;

    async void Start()
    {
        videoTexture = new Texture2D(2, 2);
        websocket = new WebSocket("ws://azure-vm-ip.cloudapp.azure.com:8080");

        websocket.OnMessage += (bytes) =>
        {
            if (bytes.Length < 8) return;

            // 1. Trích xuất 4 bytes đầu (Person Count) và 4 bytes kế tiếp (Image Size)
            int personCount = BitConverter.ToInt32(bytes, 0);
            int imageSize = BitConverter.ToInt32(bytes, 4);

            // 2. Trích xuất phần payload JPEG còn lại
            if (bytes.Length >= 8 + imageSize)
            {
                byte[] jpegBytes = new byte[imageSize];
                Array.Copy(bytes, 8, jpegBytes, 0, imageSize);

                // 3. Tải mảng byte ảnh trực tiếp vào Texture của Unity
                videoTexture.LoadImage(jpegBytes);
                cameraDisplay.texture = videoTexture;
                personCounterText.text = $"Số người hiện diện: {personCount}";
            }
        };

        await websocket.Connect();
    }

    void Update()
    {
        #if !UNITY_WEBGL || UNITY_EDITOR
        websocket.DispatchMessageQueue();
        #endif
    }

    private async void OnApplicationQuit()
    {
        await websocket.Close();
    }
}

Testing và Validation

1. Huấn luyện mô hình YOLOv8n:

  • Tập dữ liệu (Dataset): 1,431 hình ảnh thực tế được thu thập trực tiếp từ module camera OV2640 đặt tại hành lang và phòng thực hành Tầng 6 Tòa E, gán nhãn thủ công với lớp đối tượng person.
  • Phân chia dữ liệu: Tỷ lệ Train/Validation/Test đạt 70% / 20% / 10%.
  • Độ chính xác đạt được:
    • Precision: 88.4%
    • Recall: 82.1%
    • mAP@0.5: 85.6% (Vượt mục tiêu thiết kế > 80%).
Epochs: 100 | Batch Size: 16 | Image Resolution: 640x640 | Inference Time on Cloud GPU/CPU: ~24ms

2. Thử nghiệm truyền thông và độ trễ (Latency Benchmarking):

Các thử nghiệm kiểm tra tính ổn định được tiến hành liên tục trong 72 giờ qua mạng Wi-Fi cục bộ và máy chủ Microsoft Azure VM:

Thông số kiểm thử Môi trường Localhost Server Môi trường Microsoft Azure Cloud Mục tiêu thiết kế Đánh giá
Độ trễ toàn trình (End-to-End Latency) 350 ms – 550 ms 1.200 ms – 2.100 ms $\le$ 3.000 ms Đạt (Vượt kỳ vọng)
Tỉ lệ rớt gói tin (Packet Loss) 0% 0.02% (gần như bằng 0) 0% Đạt
Độ chính xác nhận diện người 86.2% 85.6% > 80% Đạt
Tốc độ khung hình Unity (FPS) 60 FPS (V-Sync) 58 - 60 FPS $\ge$ 30 FPS Đạt
Tần suất cập nhật cảm biến 1.000 ms / lần 1.000 ms / lần $\le$ 2.000 ms Đạt

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

  1. Kiến trúc đóng gói nhị phân kết hợp Microservices tối ưu: Thay vì truyền tải ảnh định dạng Base64 qua JSON (vốn làm tăng 33% kích thước dữ liệu mạng), dự án áp dụng kỹ thuật serialize Header 8-byte tùy biến. Kỹ thuật này giảm 42.5% băng thông mạng và giải phóng chu kỳ CPU của bộ điều khiển nhúng ESP32-S.
  2. Cơ chế đồng bộ hóa Digital Twin hai chiều trên Unity 6 Preview: Tận dụng tối đa pipeline Universal Render Pipeline (URP) cùng công nghệ kết xuất GPU Occlusion Culling mới nhất, giúp giảm hơn 35% draw calls, cho phép mô hình Metaverse hoạt động mượt mà trên cả các thiết bị phần cứng thông thường mà không suy giảm trải nghiệm thị giác.
  3. Mô hình hóa chính xác không gian thực nghiệm: Kết hợp công nghệ quét không gian 3D Photogrammetry (Polycam) với tái cấu trúc 3D Mesh trong Unity, tạo ra bản sao số hoàn hảo của Tầng 6 Tòa E, thiết lập nền tảng tham chiếu cho các đề tài nghiên cứu Smart Campus tiếp theo.

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

Kịch bản ứng dụng (Real-world Use Cases)

  • Giám sát và quản lý tòa nhà thông minh (Smart Campus / Smart Building): Ban quản lý có thể đeo kính VR hoặc ngồi tại phòng điều hành để kiểm tra trạng thái từng phòng học tại Tầng 6 Tòa E theo thời gian thực (nhiệt độ, nguy cơ cháy nổ từ khí gas, cường độ ánh sáng để tự động bật tắt đèn, số lượng sinh viên đang có mặt).
  • Bảo trì và vận hành xưởng cơ khí/công nghiệp từ xa (Industrial Metaverse): Kỹ sư kỹ thuật giám sát các tham số vận hành của máy móc và nhận diện bất thường về con người/thiết bị trong không gian ảo trước khi trực tiếp vào khu vực nguy hiểm.
  • Mô phỏng y tế và giáo dục tương tác: Tạo không gian phòng mổ hoặc phòng thí nghiệm ảo kết nối cảm biến sinh trắc học và phản hồi xúc giác.
  • Du lịch số và bảo tồn di sản: Ứng dụng tương tự như mô hình Phố cổ Hội An Metaverse hay giải pháp akaVerse của FPT, cho phép khách tham quan điều khiển góc nhìn và tương tác với các thiết bị vật lý tại điểm di tích.
+-----------------------------------------------------------------------------------+
|                        LỘ TRÌNH TRIỂN KHAI HỆ THỐNG (ROADMAP)                    |
+--------------------+--------------------------------------------------------------+
| Giai đoạn 1        | Khảo sát, thu thập 1.431 ảnh mẫu, dựng mô hình 3D Polycam    |
| (Tháng 1 - 3)      | & lập trình firmware ESP32-CAM đọc cảm biến DHT/LDR/MQ-2     |
+--------------------+--------------------------------------------------------------+
| Giai đoạn 2        | Huấn luyện mô hình YOLOv8n, phát triển giao thức 8-byte,     |
| (Tháng 4 - 5)      | tích hợp WebSocket Node.js - Python và Firebase DB           |
+--------------------+--------------------------------------------------------------+
| Giai đoạn 3        | Dựng môi trường Unity 6 Preview, mapping telemetry lên 3D UI,|
| (Tháng 6 - 7)      | triển khai Microsoft Azure Linux VM & kiểm thử stress-test  |
+--------------------+--------------------------------------------------------------+

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

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

  • Giới hạn phần cứng nhúng biên: Module ESP32-CAM tỏa nhiệt đáng kể khi stream liên tục ở độ phân giải cao; dung lượng 4MB PSRAM giới hạn khả năng tiền xử lý AI phức tạp trực tiếp tại biên (On-edge Inference).
  • Hiện tượng khuất tầm nhìn (Occlusion): Mô hình YOLOv8n có thể đếm sai lệch khi mật độ người quá dày đặc hoặc bị vật cản che khuất một phần cơ thể.
  • Phụ thuộc vào băng thông Wi-Fi: Khi mạng không dây tại khu vực lắp đặt bị suy hao, tốc độ khung hình truyền tải có thể giảm nhẹ.

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

  • Nâng cấp phần cứng Edge AI: Chuyển đổi sang các dòng chip nhúng chuyên dụng cho AI như ESP32-S3 (hỗ trợ tập lệnh vector AI), Raspberry Pi 5 hoặc NVIDIA Jetson Orin Nano để thực hiện suy luận AI trực tiếp tại biên.
  • Tích hợp giao thức MQTT kết hợp WebRTC: Sử dụng WebRTC cho luồng video độ phân giải cao (Full HD/4K) với độ trễ cực thấp (< 200ms) và MQTT cho dữ liệu cảm biến phân tán.
  • Mở rộng hỗ trợ thiết bị không gian (Spatial Computing): Build trực tiếp ứng dụng lên các thiết bị kính thực tế hỗn hợp cao cấp như Apple Vision Pro (visionOS) và Meta Quest 3, hỗ trợ điều khiển bằng cử chỉ tay (Hand Tracking) và tương tác không gian tự nhiên.

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

  • Sinh viên & Học viên ngành Kỹ thuật Máy tính / IoT / CNTT: Tiếp cận tài liệu thực chiến về cách kết nối các vi điều khiển nhúng giá rẻ (ESP32) với các công nghệ đồ họa thế hệ mới (Unity 6, Metaverse).
  • Kỹ sư phát triển phần mềm (Software Engineers / IoT Developers): Tham khảo kiến trúc phân tầng Microservices (Node.js + Python YOLO + WebSocket + Azure) và mẫu thiết kế đóng gói nhị phân tùy biến tối ưu hóa lưu lượng mạng.
  • Doanh nghiệp & Đơn vị quản lý cơ sở hạ tầng: Nắm bắt mô hình mẫu về chuyển đổi số từ hệ thống giám sát vật lý sang bản sao số Digital Twin, tối ưu hóa chi phí vận hành và bảo trì thiết bị từ xa.
  • Nhà nghiên cứu học thuật: Cung cấp số liệu thực nghiệm, độ trễ và độ chính xác thực tế khi ứng dụng mô hình Deep Learning Object Detection vào các luồng dữ liệu thời gian thực trong Metaverse.

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

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

  • Khối biên (Edge): Module ESP32-CAM (AI-Thinker), Camera OV2640, Cảm biến LDR, MQ-2, DHT11/22, nguồn cấp 5V-2A ổn định.
  • Khối máy chủ (Server): Máy tính cục bộ hoặc Cloud VM (Azure/AWS) tối thiểu 2 vCPU, 4GB RAM, cài đặt Python 3.9+, Node.js 18 LTS.
  • Khối hiển thị (Unity Client): Máy tính chạy Windows 10/11 hoặc macOS, card đồ họa rời hỗ trợ DirectX 11/12 hoặc Vulkan để render mượt mà môi trường Unity 6 Preview.

2. Tại sao hệ thống sử dụng kết hợp cả Node.js và Python trên máy chủ thay vì một ngôn ngữ duy nhất?

Kiến trúc này tận dụng tối đa thế mạnh của từng nền tảng: Node.js xử lý các tác vụ I/O bất đồng bộ, duy trì hàng ngàn kết nối WebSocket đồng thời với độ trễ tối thiểu; trong khi Python là môi trường tối ưu nhất để chạy các thư viện thị giác máy tính và học sâu (OpenCV, PyTorch, Ultralytics YOLOv8).

3. Giao thức WebSocket có ưu thế gì so với MQTT và HTTP trong bài toán này?

So với HTTP (vốn có chi phí bắt tay lặp lại cho mỗi yêu cầu), WebSocket duy trì một kênh kết nối TCP toàn song công duy nhất, giúp đẩy khung hình ảnh liên tục với độ trễ thấp nhất. So với MQTT, WebSocket dễ dàng tích hợp trực tiếp với các ứng dụng đồ họa WebGL/Unity mà không cần thông qua cầu nối MQTT-over-WebSocket trung gian.

4. Độ trễ toàn trình (End-to-End Latency) từ lúc camera chụp đến khi hiển thị trên Unity được tối ưu như thế nào?

Hệ thống áp dụng 3 kỹ thuật tối ưu: (1) Nén ảnh phần cứng trực tiếp trên chip OV2640 sang JPEG; (2) Truyền tải mảng byte nhị phân kèm Header 8 bytes thay vì mã hóa chuỗi Base64; (3) Sử dụng luồng nền (background worker) trên Python để suy luận YOLOv8n song song với quá trình nhận/gửi gói tin của Node.js.

5. Chi phí ước tính để nhân rộng giải pháp này cho toàn bộ khuôn viên trường học là bao nhiêu?

Chi phí phần cứng cho mỗi nút giám sát phòng học chỉ dao động từ 250.000 – 400.000 VNĐ (ESP32-CAM và cảm biến cơ bản). Chi phí máy chủ có thể linh hoạt mở rộng theo mô hình "Pay As You Go" trên Microsoft Azure hoặc tận dụng máy chủ on-premise sẵn có của nhà trường, mang lại hiệu quả đầu tư (ROI) rất cao so với các giải pháp camera AI thương mại đắt tiền.

Kết luận

Đồ án tốt nghiệp "Ứng dụng các thiết bị IoT vào thực tế ảo Metaverse" của sinh viên Chu Thành Nhân đã chứng minh tính khả thi và hiệu quả vượt trội của việc đồng bộ hóa dữ liệu thế giới thực vào không gian bản sao số Digital Twin 3D. Bằng cách kết hợp linh hoạt giữa phần cứng nhúng biên giá thành thấp (ESP32-CAM), giải thuật thị giác máy tính hiện đại (YOLOv8n), kiến trúc máy chủ phân tán (Node.js & Python trên Microsoft Azure) và engine đồ họa tiên tiến (Unity 6 Preview), công trình đã hoàn thành xuất sắc tất cả các mục tiêu đề ra với độ chính xác nhận diện trên 85.6% và độ trễ toàn trình duy trì ổn định dưới 2.5 giây.

Đây không chỉ là bước tiến quan trọng trong việc ứng dụng công nghệ Metaverse vào quản lý không gian thông minh tại Trường Đại học Công nghệ Thông tin – ĐHQG-HCM, mà còn mở ra tiềm năng ứng dụng rộng lớn cho các giải pháp Digital Twin trong công nghiệp, y tế, giáo dục và đô thị thông minh tại Việt Nam trong tương lai.