Giới thiệu dự án

Sự bùng nổ của cuộc Cách mạng Công nghiệp 4.0 đã thúc đẩy sự gia tăng vượt bậc của các thiết bị Internet of Things (IoT) trên toàn cầu. Theo báo cáo thống kê từ Statista, số lượng thiết bị IoT kết nối đã tăng từ 9,76 tỷ thiết bị (năm 2020) lên 15,9 tỷ thiết bị (năm 2023) và được dự báo sẽ vượt mốc 31,2 tỷ thiết bị vào năm 2030. Tại các đô thị thông minh hiện đại, các thiết bị IoT phủ rộng từ cảm biến quan trắc chất lượng không khí, hệ thống chiếu sáng thông minh cho đến các trạm giám sát thủy văn và khí tượng.

Tuy nhiên, sự phát triển nóng này kéo theo hai bài toán hóc búa:

  1. Sự không đồng nhất về phần cứng và giao thức: Hàng ngàn cảm biến sử dụng các chuẩn truyền thông phân mảnh (HTTP, MQTT, LoRa, ZigBee) với cấu trúc dữ liệu dị nguyên, gây tắc nghẽn trong việc giám sát và điều khiển tập trung.
  2. Thiếu khả năng khai phóng giá trị từ dữ liệu chuỗi thời gian (Time-series Data): Dữ liệu vi khí hậu thu thập định kỳ thường chỉ dừng lại ở mức hiển thị biểu đồ tức thời (Descriptive Analytics) mà chưa được kết hợp với các mô hình Trí tuệ Nhân tạo (AI) để đưa ra dự báo sớm (Predictive Analytics) hỗ trợ quản lý vận hành đô thị.

Đứng trước thách thức đó, đồ án tốt nghiệp "Hệ thống quản lý IoT với khả năng dự đoán mưa dựa trên AI" được nghiên cứu và hiện thực hóa bởi nhóm sinh viên Khoa Mạng máy tính và Truyền thông – Trường Đại học Công nghệ Thông tin, ĐHQG-HCM, dưới sự hướng dẫn của TS. Lê Kim Hùng và ThS. Thái Huy Tân.

+-----------------------------------------------------------------------------------+
|                                MỤC TIÊU DỰ ÁN                                     |
+-----------------------------------------------------------------------------------+
| [1] Nghiên cứu, tùy chỉnh và mở rộng nền tảng mã nguồn mở OpenRemote              |
| [2] Xây dựng kiến trúc Microservices đa nền tảng (Web UI TypeScript + Android SDK)|
| [3] Đề xuất mô hình học sâu BiLSTM kết hợp ECA và Attention dự đoán mưa           |
| [4] Tích hợp Rule Engine tự động hóa kích hoạt cảnh báo theo thời gian thực       |
+-----------------------------------------------------------------------------------+

Phương pháp tiếp cận của đề tài là xây dựng một nền tảng quản lý tập trung dựa trên OpenRemote, đóng gói toàn bộ hệ thống dưới dạng Docker Container, tích hợp bảo mật định danh Keycloak (OAuth2/OpenID Connect) và thiết lập một Microservice AI độc lập để dự báo thời tiết. Mô hình học sâu đạt độ chính xác trung bình 80% trên tập dữ liệu khí tượng thực tế tại Việt Nam (Vietnam Weather Data), đồng thời chứng minh hiệu quả vượt trội khi benchmark trên tập dữ liệu chuẩn quốc tế Rain in Australia.

Phạm vi nghiên cứu tập trung vào các thiết bị giám sát môi trường đô thị kết nối qua HTTP/REST API và MQTT, xử lý dữ liệu vi khí hậu với chu kỳ cập nhật và dự báo định kỳ mỗi 1 giờ.

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

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

Nhiều giải pháp IoT chuyên dụng trong công nghiệp và nông nghiệp đã được triển khai nhưng bộc lộ nhiều hạn chế về mặt linh hoạt và năng lực phân tích dữ liệu nâng cao:

Giải pháp / Nghiên cứu Công nghệ cốt lõi Ưu điểm Nhược điểm & Khoảng trống kỹ thuật
Giám sát nông nghiệp qua LoRa [5] STM32L151, RFM95W, LoRa Gateway Truyền tải tầm xa (lên đến 10km), năng lượng tiêu thụ cực thấp. Không có mô hình AI phân tích dữ liệu; chỉ dừng lại ở mức truyền telemetry thô về máy chủ.
Giám sát trạm dệt may qua ZigBee [6] ZigBee Mesh Network, Central Node Giám sát phụ tải điện năng cục bộ, giảm lãng phí so với cấp điện cố định. Phụ thuộc mạng diện hẹp, giao diện quản trị đóng kín, không hỗ trợ dự báo xu hướng tiêu thụ.
Hệ thống đề xuất (OpenRemote + AI) Docker, Microservices, BiLSTM-ECA-Attention Quản lý đa giao thức (HTTP/MQTT), quản trị quyền OAuth2, dự đoán mưa thông minh đạt độ chính xác 80%. Đòi hỏi tài nguyên tính toán cho container và huấn luyện mô hình học sâu.

Để xác định chính xác các yêu cầu kỹ thuật, hệ thống áp dụng ma trận phân loại MoSCoW:

  • Must have: Quản lý thiết bị theo cấu trúc cây (Asset Hierarchy), hiển thị bản đồ định vị thời gian thực, xác thực tập trung SSO với Keycloak, API dự đoán mưa mỗi 1 giờ.
  • Should have: Giao diện ứng dụng di động Android chuyên biệt, hệ thống quy tắc (Rule Engine) kích hoạt thông báo tự động, trực quan hóa biểu đồ lịch sử cảm biến.
  • Could have: Xuất dữ liệu cảm biến đa định dạng (JSON/CSV), bộ lọc thuộc tính thiết bị nâng cao.
  • Won't have (trong phạm vi hiện tại): Điều khiển tự động phần cứng chấp hành qua mạng di động GSM/NB-IoT.

Thiết kế hệ thống

Kiến trúc hệ thống được xây dựng theo mô hình Microservices phân tán, gồm 6 thành phần chính chạy độc lập trong các Docker Container:

[ IoT Devices ] ---> (HTTP / MQTT) ---> [ HAProxy (Port 80/443) ]
                                                |
        +---------------------------------------+---------------------------------------+
        |                                       |                                       |
[ Keycloak IAM (OAuth2) ]             [ OpenRemote Manager Core ]             [ AI Prediction Service ]
        |                                       |                                       |
        +---------------------------------------+---------------------------------------+
                                                |
                                    [ PostgreSQL 15 Database ]
  1. Dịch vụ Proxy (HAProxy): Cân bằng tải, chuyển hướng yêu cầu HTTPS/WSS, đảm bảo hệ thống chịu tải cao và tính sẵn sàng liên tục.
  2. Xác thực & Phân quyền (Keycloak): Triển khai chuẩn OpenID Connect / OAuth2, hỗ trợ Single Sign-On (SSO), xác thực đa yếu tố (2FA), mã hóa thông tin xác thực an toàn.
  3. Bảng điều khiển trung tâm (OpenRemote Manager): Thành phần lõi quản lý Asset, thuộc tính (Attributes), Gateway Connection, Broker MQTT và Websocket API.
  4. Cơ sở dữ liệu (PostgreSQL): Lưu trữ quan hệ và đối tượng với 14 bảng logic, tích hợp ràng buộc toàn vẹn, bảo vệ bằng cơ chế xác thực SCRAM-SHA-256.
  5. Dịch vụ dự đoán AI: Container xử lý dữ liệu và chạy suy luận mô hình học sâu BiLSTM-ECA-Attention theo chu kỳ thời gian thực.
  6. Clients (Web UI & Mobile App): Web UI phát triển bằng TypeScript; Mobile App phát triển native trên nền tảng Android SDK (Java), kết nối thông qua hệ thống RESTful API chuẩn hóa.
-- Thiết kế lược đồ bảng lưu trữ dữ liệu thiết bị và quy tắc tự động hóa
CREATE TABLE asset (
    id VARCHAR(64) PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    asset_type VARCHAR(100) NOT NULL,
    parent_id VARCHAR(64),
    location POINT,
    created_on TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    CONSTRAINT fk_parent FOREIGN KEY (parent_id) REFERENCES asset(id) ON DELETE CASCADE
);

CREATE TABLE asset_datapoint (
    id BIGSERIAL PRIMARY KEY,
    asset_id VARCHAR(64) NOT NULL,
    attribute_name VARCHAR(100) NOT NULL,
    value NUMERIC(10, 4) NOT NULL,
    timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
    CONSTRAINT fk_asset FOREIGN KEY (asset_id) REFERENCES asset(id) ON DELETE CASCADE
);

CREATE TABLE asset_ruleset (
    id VARCHAR(64) PRIMARY KEY,
    rule_name VARCHAR(255) NOT NULL,
    condition_json JSONB NOT NULL,
    action_json JSONB NOT NULL,
    is_active BOOLEAN DEFAULT TRUE
);

Methodology

Dự án áp dụng quy trình phát triển phần mềm linh hoạt (Agile Scrum) với 4 giai đoạn chính (Sprint 2 tuần/chu kỳ):

  • Milestone 1 (Tuần 1 - 3): Khảo sát mã nguồn mở OpenRemote, triển khai hạ tầng Docker, cấu hình Keycloak IAM và PostgreSQL.
  • Milestone 2 (Tuần 4 - 7): Nghiên cứu, thiết kế và huấn luyện mô hình mạng nơ-ron học sâu BiLSTM-ECA-Attention trên các bộ dữ liệu khí tượng.
  • Milestone 3 (Tuần 8 - 11): Phát triển giao diện Web UI (TypeScript) và Android SDK Client; tích hợp hệ thống REST API và WebSocket cho luồng dữ liệu thời gian thực.
  • Milestone 4 (Tuần 12 - 14): Kiểm thử hiệu năng, tối ưu hóa suy luận mô hình AI và đóng gói tài liệu kỹ thuật.

Implementation và kết quả

Development process

Trọng tâm cải tiến của đề tài là kiến trúc mạng nơ-ron tích hợp dự báo chuỗi thời gian khí tượng: BiLSTM + Efficient Channel Attention (ECA) + Attention Mechanism.

Input Vector x in R^(d) (10 features)
       │
       ▼
┌─────────────────────────────────────────┐
│ Layer 1: BiLSTM (256 units)             │ ──> [Batch Normalization + Dropout (0.2)]
└─────────────────────────────────────────┘
       │
       ▼
┌─────────────────────────────────────────┐
│ Layer 2: BiLSTM (128 units)             │ ──> Output O_bilstm in R^(d x 128)
└─────────────────────────────────────────┘
       │
       ▼
┌─────────────────────────────────────────┐
│ Layer 3: Efficient Channel Attention    │ ──> GAP + 1D Conv (Kernel k) ──> O_eca
└─────────────────────────────────────────┘
       │
       ▼
┌─────────────────────────────────────────┐
│ Layer 4: Sequence Attention Mechanism   │ ──> Trọng số ngữ cảnh token ──> O_att
└─────────────────────────────────────────┘
       │
       ▼
┌─────────────────────────────────────────┐
│ Dense Layer + Sigmoid                   │ ──> Xác suất mưa ngày mai [0, 1]
└─────────────────────────────────────────┘

Công thức toán học cốt lõi

Thành phần BiLSTM giải quyết triệt để hiện tượng suy giảm gradient (Vanishing Gradient) trong mạng RNN truyền thống nhờ cấu trúc bộ nhớ dài hạn $c_t$ và ngắn hạn $h_t$:

$$\begin{aligned} f_t &= \sigma(W_f \cdot [h_{t-1}, x_t] + b_f) \quad \text{(Cổng quên - Forget Gate)} \ i_t &= \sigma(W_i \cdot [h_{t-1}, x_t] + b_i) \quad \text{(Cổng vào - Input Gate)} \ \tilde{c}t &= \tanh(W_c \cdot [h{t-1}, x_t] + b_c) \quad \text{(Ứng viên trạng thái cell)} \ c_t &= f_t \odot c_{t-1} + i_t \odot \tilde{c}t \quad \text{(Cập nhật trạng thái cell)} \ o_t &= \sigma(W_o \cdot [h{t-1}, x_t] + b_o) \quad \text{(Cổng ra - Output Gate)} \ h_t &= o_t \odot \tanh(c_t) \quad \text{(Trạng thái ẩn đầu ra)} \end{aligned}$$

Thành phần ECA (Efficient Channel Attention) nâng cao tính biểu diễn đặc trưng bằng cách kết hợp Global Average Pooling (GAP) và tích chập 1D (1D Convolution) với kích thước kernel thích ứng $k$:

$$k = \psi(C) = \left| \frac{\log_2(C)}{\gamma} + \frac{b}{\gamma} \right|_{\text{odd}}$$

$$\omega = \sigma(\text{C1D}k(\text{GAP}(O{\text{bilstm}})))$$

Thành phần Attention tiếp tục tính toán mức độ đóng góp của từng bước thời gian vào quyết định phân loại, giúp vector đặc trưng hội tụ tối ưu trước khi đưa qua lớp phân loại nhị phân Sigmoid.

# Trích đoạn định nghĩa mô hình BiLSTM-ECA-Attention sử dụng TensorFlow/Keras
import tensorflow as tf
from tensorflow.keras import layers, models

def build_bilstm_eca_attention_model(input_shape):
    inputs = layers.Input(shape=input_shape)
    
    # Khối BiLSTM 2 tầng
    x = layers.Bidirectional(layers.LSTM(256, return_sequences=True))(inputs)
    x = layers.BatchNormalization()(x)
    x = layers.Dropout(0.2)(x)
    
    x = layers.Bidirectional(layers.LSTM(128, return_sequences=True))(x)
    x = layers.BatchNormalization()(x)
    x = layers.Dropout(0.2)(x)
    
    # Khối Efficient Channel Attention (ECA)
    gap = layers.GlobalAveragePooling1D()(x)
    gap_reshaped = layers.Reshape((-1, 1))(gap)
    conv1d = layers.Conv1D(filters=1, kernel_size=3, padding='same', use_bias=False)(gap_reshaped)
    channel_weights = layers.Activation('sigmoid')(conv1d)
    channel_weights = layers.Reshape((1, -1))(channel_weights)
    x_eca = layers.Multiply()([x, channel_weights])
    
    # Khối Attention Mechanism
    att_weights = layers.Dense(1, activation='tanh')(x_eca)
    att_weights = layers.Softmax(axis=1)(att_weights)
    context_vector = layers.Multiply()([x_eca, att_weights])
    context_vector = layers.GlobalAveragePooling1D()(context_vector)
    
    # Tầng phân loại đầu ra
    outputs = layers.Dense(1, activation='sigmoid')(context_vector)
    
    model = models.Model(inputs=inputs, outputs=outputs, name="BiLSTM_ECA_Attention")
    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
    return model

Testing và validation

Mô hình được tiền xử lý qua kỹ thuật chuẩn hóa dữ liệu số (MinMaxScaler), mã hóa dữ liệu hạng mục (One-Hot Encoding) và cân bằng nhãn thiếu hụt bằng SMOTE. Quá trình kiểm nghiệm thực hiện qua 10 lần thử nghiệm độc lập trên tập dữ liệu khí tượng Việt Nam:

Mô hình thử nghiệm Accuracy (%) Precision (%) Recall (%) F1-Score (%)
K-Nearest Neighbors (KNN) 73.45 71.20 69.80 70.49
Support Vector Machine (SVC) 75.12 74.30 72.10 73.18
Standard BiLSTM 76.80 75.90 74.50 75.19
BiLSTM + Attention 78.40 77.10 76.80 76.95
BiLSTM + ECA + Attention (Đề xuất) 80.00 79.20 78.60 78.90 
Benchmark kiểm nghiệm độ chính xác (Accuracy):
KNN:                     [██████████████░░░░░] 73.45%
SVC:                     [███████████████░░░░] 75.12%
BiLSTM Standard:         [███████████████▎░░░] 76.80%
BiLSTM + Attention:      [███████████████▋░░░] 78.40%
BiLSTM + ECA + Attention:[████████████████░░░] 80.00% (Tối ưu nhất)

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

Hệ thống đã hoàn thiện 100% các tính năng đề ra theo hợp đồng giao diện:

  • Quản trị thiết bị tập trung: Cấu hình theo cây thư mục phân cấp, hỗ trợ ánh xạ vị trí trên giao diện bản đồ số (OpenLayers / Leaflet).
  • Rule Engine & Cảnh báo thông minh: Tự động gửi thông báo hệ thống khi thông số cảm biến (nhiệt độ, độ ẩm) vượt ngưỡng thiết lập hoặc khi mô hình AI phát hiện xác suất mưa > 75%.
  • Hiệu năng hệ thống: Khả năng phản hồi REST API dưới 120ms, độ trễ luồng dữ liệu thời gian thực qua WebSocket/MQTT dưới 50ms.

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

  • Đổi mới kỹ thuật mạng học sâu cho IoT: Thay vì sử dụng các mạng Transformer cồng kềnh đòi hỏi GPU dung lượng lớn, kiến trúc BiLSTM kết hợp ECA module giúp tối ưu hóa trọng số giữa các kênh đặc trưng khí tượng với chi phí tính toán cực thấp ($O(C)$ thay vì $O(C^2)$).
  • Cải thiện hiệu năng định lượng: Tăng độ chính xác phân loại thêm 3.2% so với BiLSTM nguyên bản và tăng 4.88% so với các thuật toán học máy cổ điển (SVC).
  • Đóng gói giải pháp hoàn chỉnh: Cung cấp một bộ khung tích hợp đầy đủ từ tầng thiết bị phần cứng, tầng quản trị danh tính IAM bảo mật cấp doanh nghiệp đến tầng ứng dụng Web/Mobile thân thiện cho người dùng cuối.

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

Kịch bản ứng dụng đô thị thông minh

[ Trạm quan trắc IoT đô thị ]
 (Đo: Nhiệt độ, Độ ẩm, Áp suất, Mây)
             │ (MQTT Stream)
             ▼
[ Hệ thống quản trị OpenRemote ]
             │ (Cronjob 1 Giờ)
             ▼
[ Dịch vụ dự báo AI (BiLSTM-ECA) ] ──> Dự báo: Xác suất mưa 85% vào ngày mai
             │
             ▼
[ Trigger Rule Engine ] ──> Kích hoạt:
                            ├─ Thông báo khẩn cấp đến đội ngũ thoát nước đô thị
                            ├─ Tự động hạ cửa xả điều tiết hồ chứa nước thông minh
                            └─ Gửi Notification cảnh báo đến App Android người dân

Hướng dẫn triển khai hệ thống (Deployment Guide)

Hệ thống được đóng gói thông qua Docker Compose, sẵn sàng vận hành trên máy chủ Linux (Ubuntu Server 22.04 LTS):

# 1. Clone mã nguồn và cấu hình biến môi trường
git clone https://github.com/uit-project/iot-weather-management.git
cd iot-weather-management
cp .env.example .env

# 2. Khởi chạy toàn bộ hạ tầng Microservices
docker-compose up -d --build

# 3. Kiểm tra trạng thái hoạt động của các container
docker-compose ps

Yêu cầu tài nguyên máy chủ tối thiểu:

  • CPU: 4 Cores (x86_64 hoặc ARM64).
  • RAM: 8 GB (Khuyến nghị 16 GB để xử lý tác vụ huấn luyện lại mô hình).
  • Lưu trữ: 50 GB SSD.

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

  • Hạn chế hiện tại: Tập dữ liệu khí tượng cục bộ giới hạn trong 10 đặc trưng cơ bản; ứng dụng di động hiện chỉ hỗ trợ nền tảng Android SDK native, chưa hỗ trợ hệ điều hành iOS; chu kỳ cập nhật suy luận mô hình AI cố định theo từng 1 giờ thay vì suy luận phân tán tại biên (Edge Computing).
  • Hướng phát triển tương lai:
    1. Tích hợp công nghệ lượng hóa mô hình (Model Quantization với TensorRT / ONNX Runtime) để nhúng trực tiếp mô hình AI lên phần cứng Gateway (Raspberry Pi 4 / Jetson Nano).
    2. Nâng cấp ứng dụng di động đa nền tảng bằng Flutter hoặc React Native.
    3. Kết hợp dữ liệu ảnh mây vệ tinh và Radar thời tiết vào mô hình thị giác máy tính đa phương thức (Multimodal AI).

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

  • Sinh viên & Học viên: Cung cấp tài liệu tham khảo chi tiết về kiến trúc Microservices thực chiến và phương pháp xây dựng mô hình Deep Learning ứng dụng trong IoT.
  • Kỹ sư phát triển phần mềm (Developers): Cung cấp mã nguồn mẫu chuẩn mực về việc tùy biến nền tảng OpenRemote, tích hợp Keycloak OAuth2 và kết nối thiết bị qua REST/MQTT.
  • Doanh nghiệp & Cơ quan quản lý đô thị: Sở hữu giải pháp quản lý tài sản IoT tập trung với chi phí bản quyền $0, nâng cao năng lực ứng phó ngập úng đô thị nhờ AI dự báo sớm.
  • Nhà nghiên cứu khoa học: Kế thừa cấu trúc mô hình BiLSTM-ECA-Attention để áp dụng cho các bài toán phân tích chuỗi thời gian cảm biến khác.

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

1. Yêu cầu kỹ thuật tối thiểu để triển khai hệ thống là gì?

Hệ thống yêu cầu máy chủ chạy hệ điều hành Linux (Ubuntu/Debian), cài đặt Docker Engine 24+ và Docker Compose v2+. Về phần cứng, cần tối thiểu 4 vCPU, 8GB RAM và 50GB ổ cứng SSD để vận hành ổn định cụm container PostgreSQL, Keycloak, OpenRemote Core và AI Service.

2. Hệ thống có khả năng mở rộng (Scalability) như thế nào khi lượng thiết bị tăng vọt?

Nhờ kiến trúc Microservices, hệ thống có thể mở rộng theo chiều ngang (Horizontal Scaling). Dịch vụ cân bằng tải HAProxy có thể định tuyến lưu lượng đến nhiều container OpenRemote Manager và Prediction Service song song. Cơ sở dữ liệu PostgreSQL có thể cấu hình mô hình Master-Slave Replication để giảm tải truy vấn đọc dữ liệu cảm biến.

3. Làm thế nào để tích hợp các loại cảm biến mới vào hệ thống?

Hệ thống cung cấp sẵn chuẩn giao tiếp RESTful API và MQTT Broker. Người quản trị chỉ cần tạo Asset mới trên bảng điều khiển, lấy mã Asset ID và cấu hình thiết bị phần cứng đẩy dữ liệu JSON định dạng {"attributeName": value} đến Endpoint hoặc Topic MQTT tương ứng.

4. Hệ thống đảm bảo an toàn thông tin và bảo mật dữ liệu như thế nào?

Dữ liệu truyền nhận qua mạng công cộng được mã hóa toàn diện qua giao thức TLS/HTTPS. Hệ thống xác thực danh tính Keycloak quản lý phiên làm việc qua JWT Token có thời hạn, phân quyền theo vai trò (Role-Based Access Control), đồng thời bảo vệ cơ sở dữ liệu bằng cơ chế băm mật khẩu SCRAM-SHA-256.

5. Chi phí đầu tư và thời gian hoàn vốn (ROI) của dự án?

Do toàn bộ hệ thống sử dụng các nền tảng mã nguồn mở (OpenRemote, Keycloak, PostgreSQL, Docker, TensorFlow), chi phí bản quyền phần mềm là 0 đồng. Doanh nghiệp chỉ chi trả chi phí hạ tầng máy chủ và thiết bị cảm biến. Thời gian hoàn vốn ước tính từ 6 – 12 tháng thông qua việc giảm thiểu thiệt hại do ngập lụt cục bộ và tự động hóa quy trình quản lý đô thị.

Kết luận

Đồ án "Hệ thống quản lý IoT với khả năng dự đoán mưa dựa trên AI" của nhóm sinh viên Trường Đại học Công nghệ Thông tin, ĐHQG-HCM đã giải quyết trọn vẹn bài toán quản lý thiết bị phân tán và khai phóng tiềm năng dữ liệu thời tiết. Bằng việc kết hợp sáng tạo giữa nền tảng mở OpenRemote, kiến trúc bảo mật Microservices và mô hình học sâu BiLSTM-ECA-Attention đạt độ chính xác 80%, đồ án khẳng định tính ứng dụng cao trong việc xây dựng các đô thị thông minh hiện đại, hướng tới giải pháp quản trị môi trường chủ động và bền vững.