Giới thiệu dự án

Sự gia tăng nhanh chóng của chất thải rắn sinh hoạt (MSW - Municipal Solid Waste) tại các đô thị đang tạo ra áp lực khổng lồ lên hệ thống xử lý môi trường. Theo các báo cáo môi trường đô thị, hơn 70% lượng rác thải sinh hoạt tại các nước đang phát triển hiện vẫn bị xử lý bằng phương pháp chôn lấp thủ công hoặc thiêu đốt tập trung mà không qua phân loại triệt để tại nguồn. Thực trạng này gây lãng phí nghiêm trọng nguồn tài nguyên có thể tái chế (nhựa, thủy tinh, kim loại), đồng thời làm tăng chi phí vận hành và phát sinh ô nhiễm thứ cấp (nước rỉ rác, khí thải độc hại).

                  +----------------------------------------------+
                  |  THỰC TRẠNG QUẢN LÝ RÁC THẢI ĐÔ THỊ          |
                  +----------------------------------------------+
                                         |
         +-------------------------------+-------------------------------+
         |                                                               |
+------------------+                                            +------------------+
|  Tại nguồn thải  |                                            | Thu gom & Vận chuyển |
+------------------+                                            +------------------+
  - Ý thức phân loại chưa đồng đều                                - Thu gom định kỳ cố định
  - Thùng rác truyền thống không có logic                         - Xe rác chạy qua thùng rỗng/tràn
  - Trộn lẫn rác tái chế & không tái chế                          - Tốn nhiên liệu & nhân công

Hệ thống quản lý rác thải hiện hữu đối mặt với hai nút thắt kỹ thuật và vận hành cốt lõi:

  • Phân loại thủ công thiếu chính xác tại nguồn: Đa phần thùng rác công cộng phụ thuộc hoàn toàn vào ý thức người dùng, dẫn đến tình trạng rác tái chế và rác vô cơ bị trộn lẫn, làm suy giảm giá trị kinh tế khi tái chế.
  • Quy trình thu gom tĩnh, thiếu dữ liệu thời gian thực: Đơn vị vệ sinh môi trường thực hiện thu gom theo lộ trình cố định mà không nắm bắt được trạng thái đầy của từng thùng rác, gây lãng phí nhiên liệu đối với các thùng còn trống và gây mất mỹ quan đô thị tại các điểm rác bị tràn.

Đề tài "Xây dựng mô hình thùng rác thông minh dựa trên công nghệ trí tuệ nhân tạo" (thuộc ngành Mạng máy tính và Truyền thông dữ liệu - Trường Đại học Công nghệ Thông tin, ĐHQG-HCM) được phát triển nhằm giải quyết triệt để các hạn chế trên thông qua 4 mục tiêu cụ thể:

  1. Thiết kế thiết bị phân loại tự động tại biên (Edge AI): Nhúng mô hình thị giác máy tính Convolutional Neural Network (CNN) tối ưu hóa trên vi điều khiển ESP32-CAM (4MB PSRAM) để nhận diện và cơ giới hóa việc phân chia rác tái chế và không tái chế.
  2. Xây dựng mạng lưới cảm biến giám sát mức rác qua LoRaWAN: Đo lường khoảng trống thùng rác bằng cảm biến siêu âm (Ultrasonic Sensor) và truyền tải dữ liệu dung tích thời gian thực qua giao thức LoRa 433MHz về The Things Network (TTN).
  3. Phát triển hệ thống Backend phân tán và Dự báo chuỗi thời gian: Triển khai Node.js Server đa luồng (Clustering) xử lý telemetry kết hợp Flask/Python Server chạy mạng Long Short-Term Memory (LSTM) để dự báo dung tích rác trong 4 giờ tiếp theo.
  4. Tối ưu hóa hành trình thu gom và trực quan hóa GIS: Tích hợp Mapbox Optimization API giải bài toán người du lịch (TSP - Traveling Salesperson Problem) kết hợp Thingsboard Dashboard để vạch tuyến đường thu gom ngắn nhất cho các thùng rác đầy hoặc dự báo sắp đầy.

Hệ thống được thiết kế vận hành độc lập bằng nguồn pin năng lượng mặt trời, phân loại rác nhị phân (Tái chế vs Không tái chế), truyền thông diện rộng tầm xa trong bán kính 1-5 km qua môi trường mạng không dây công suất thấp.

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

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

Nghiên cứu so sánh hệ thống đề xuất với hai hướng tiếp cận phổ biến trong các công bố khoa học trước đây:

Tiêu chí so sánh Giải pháp SVM + SIFT (Mindy Yang & Gary Thung) Giải pháp YOLOv3 trên Cloud (Đô thị thông minh) Giải pháp Đề tài (Edge CNN + LoRaWAN + LSTM)
Phần cứng triển khai Máy tính trạm / GPU rời Camera IP + Server xử lý tập trung ESP32-CAM + ESP32 LoRa SX1278
Vị trí tính toán Offline trên Server Cloud Server (Streaming Video) On-device Inference (Biên mạng)
Giao thức truyền thông Wi-Fi / Ethernet Băng thông cao (4G / 5G / Fiber) LoRaWAN 433MHz (Băng thông thấp, tầm xa)
Năng lượng tiêu thụ Rất cao (>50W) Cao (>100W cho toàn hệ thống) Rất thấp (<2W, tích hợp Solar Panel)
Tính năng mở rộng Chỉ phân loại ảnh tĩnh Phát hiện rác qua luồng video Phân loại biên + Dự báo LSTM + Tuyến đường TSP
Chi phí phần cứng/nút > 3.000.000 VNĐ > 5.000.000 VNĐ ~ 450.000 - 650.000 VNĐ

Yêu cầu kỹ thuật của hệ thống được phân cấp theo mô hình MoSCoW:

  • Must-have: Phân loại tự động rác trên ESP32-CAM; gửi dữ liệu khoảng cách qua LoRaWAN; hiển thị trạng thái lên Thingsboard Dashboard; vẽ đường đi thu gom khi mức rác vượt 90%.
  • Should-have: Dự báo xu hướng đầy bằng mô hình LSTM; cơ chế Clustering trên Node.js để cân bằng tải khi tiếp nhận dữ liệu từ hàng ngàn node; bộ giả lập thiết bị ảo (Virtual Device Simulator).
  • Could-have: Tích hợp bộ sạc năng lượng mặt trời tự động; nén ảnh đầu vào tối đa để giảm chu kỳ suy luận.
  • Won't-have (giai đoạn này): Nhận diện chi tiết hơn 10 nhóm chất thải công nghiệp; nén ép rác cơ học tự động bên trong thùng.

Thiết kế hệ thống

Kiến trúc hệ thống gồm 3 phân tầng tích hợp chặt chẽ từ phần cứng đến đám mây:

[ THIẾT BỊ SMART BIN ]
  ├── Cảm biến Siêu âm 1 (Kích hoạt Camera khi có rác)
  ├── ESP32-CAM AI Thinker (Chạy CNN TFLite -> Phân loại -> Điều khiển Servo 0/180 độ)
  └── ESP32 LoRa Heltec SX1278 + 2 Cảm biến Khoảng cách (Đo 2 ngăn)
              │
              ▼ (LoRa RF 433MHz)
[ DRAGINO LG02 DUAL-CHANNEL GATEWAY ]
              │
              ▼ (HTTP / Packet Forwarder)
[ THE THINGS NETWORK (TTN) ] 
              │
              ▼ (HTTP Webhook Telemetry)
[ NODE.JS CORE SERVER ] (Cluster Engine, CSV Logger, Virtual Device Manager)
        │                                 │
        ▼ (REST API)                      ▼ (HTTP Data Exchange)
[ THINGSBOARD PLATFORM ]          [ PYTHON / FLASK SERVER ]
  - Device/Asset Management         - Deep Learning LSTM Multi-step
  - Rule Chains / Map Display       - 4-Hour Trend Forecasting
        ▲
        │ (GeoJSON Polyline)
[ MAPBOX ROUTE-MATRIX API ] (Giải bài toán TSP tìm đường ngắn nhất)

Bảng công nghệ sử dụng trong hệ thống:

Thành phần Công nghệ / Phần cứng Phiên bản / Thông số kỹ thuật Vai trò chức năng
Vi điều khiển Edge AI ESP32-CAM AI Thinker 4MB PSRAM, Dual-core 240MHz Thu nhận hình ảnh, chạy inference TFLite
Mạch truyền thông LoRa Heltec ESP32 LoRa V2 SX1278 Transceiver, Freq 433MHz Đọc cảm biến siêu âm, đóng gói LoRaWAN
LoRa Gateway Dragino LG02 Dual Channel 433MHz, Linux OS Cầu nối LoRa Wireless sang IP Network
Deep Learning Framework TensorFlow / TFLite v2.4.x / TensorFlow Lite Micro Huấn luyện mạng CNN & LSTM chuỗi thời gian
Inference Engine TFLite Converter + C++ FlatBuffers Binary format Nhúng mạng nơ-ron trực tiếp lên bộ nhớ Flash
Core API Gateway Node.js v14.x LTS (Cluster, Express) Điều phối luồng dữ liệu, xử lý HTTP Webhook
AI Prediction Server Python / Flask Python 3.8, Keras, Pandas, NumPy Xử lý dữ liệu CSV, chạy suy luận chuỗi LSTM
IoT Management & UI Thingsboard Community v3.2.x (Rule Chains, PostgreSQL) Quản lý vòng đời thiết bị, hiển thị Dashboard
GIS & Routing Service Mapbox Directions API v5 / Route Optimization API Ma trận khoảng cách, tính toán tọa độ đường đi

Hệ thống API RESTful nội bộ được chuẩn hóa:

  • POST /api/devices: Khởi tạo thuộc tính thùng rác vật lý/ảo và tự động gán quan hệ với 2 cảm biến siêu âm.
  • POST /api/TTN/telemetry: Webhook tiếp nhận Payload từ The Things Network, giải mã byte thành giá trị khoảng cách (cm), ghi log vào file .csv của thiết bị.
  • POST /api/devices/{name}/random: Endpoint sinh dữ liệu mô phỏng tải cho các thùng rác ảo.
  • GET /api/devices/prediction: Chuyển dữ liệu chuỗi thời gian sang Flask Server để nhận mảng dự báo lượng rác trong 4 bước tiếp theo (mỗi bước = 1 giờ).
  • GET /api/devices/staticMap: Thu thập danh sách tọa độ các thùng rác có mức đầy $\ge 90%$ (thực tế hoặc dự báo), gọi Mapbox API để nhận danh sách waypoint tối ưu và trả về GeoJSON Polygon cho Thingsboard.

Methodology

Dự án áp dụng mô hình phát triển phần mềm linh hoạt (Agile Scrum) kết hợp quy trình kỹ thuật hệ thống nhúng (Embedded Systems Engineering) qua 4 mốc tiến độ chính:

  1. Milestone 1 (Tuần 1 - 4): Thiết kế phần cứng, cấu hình Gateway Dragino LG02 kết nối TTN, chuẩn hóa định dạng đóng gói dữ liệu Cayenne LPP và Custom Payload.
  2. Milestone 2 (Tuần 5 - 8): Thu thập dữ liệu TrashNet, xây dựng và tinh chỉnh kiến trúc Separable CNN, chuyển đổi sang định dạng TFLite C-Array bằng lệnh xxd, kiểm thử trên ESP32-CAM.
  3. Milestone 3 (Tuần 9 - 12): Xây dựng Node.js Server đa tiến trình, phát triển mô hình LSTM đa bước thời gian trên Python Server, liên kết API Thingsboard và Mapbox.
  4. Milestone 4 (Tuần 13 - 16): Tích hợp toàn diện toàn hệ thống, thử nghiệm thực tế với vật thể rác, đánh giá độ trễ và khả năng chịu tải của backend.

Implementation và kết quả

Development process

Thách thức kỹ thuật lớn nhất của dự án là đưa một mạng nơ-ron học sâu vào bộ nhớ RAM giới hạn chỉ 4MB của ESP32-CAM mà vẫn duy trì tốc độ suy luận dưới 2 giây. Nhóm tác giả đã áp dụng kỹ thuật Separable Convolution (Tách lớp tích chập) nhằm giảm mạnh số lượng phép tính nhân-cộng (MACs) so với Convolution truyền thống.

Kiến trúc mạng CNN tùy biến được thiết kế với tổng số 532,161 tham số:

  • Input: Ảnh kích thước $96 \times 96 \times 3$ (RGB chuẩn hóa).
  • Trích xuất đặc trưng: 3 khối tích chập liên tiếp, mỗi khối gồm 2 tầng SeparableConv2D ($3 \times 3$, số filter lần lượt là 32, 16, 9) kết hợp BatchNormalization, hàm kích hoạt ReLU, bộ điều chuẩn trọng số L2 Regularization và tầng lấy mẫu cực đại MaxPooling2D (pool size $2 \times 2$).
  • Phân loại: Tầng Flatten $\rightarrow$ Tầng Dropout (tỷ lệ 0.3) $\rightarrow$ Tầng Dense (1024 units) $\rightarrow$ Tầng Dense (512 units) $\rightarrow$ Tầng Dense (6 units) với hàm kích hoạt Softmax.
[Input: 96x96x3]
       │
       ▼
[SeparableConv2D (32, 3x3) + BatchNorm + ReLU + L2] ──► [SeparableConv2D (32, 3x3) + BatchNorm + MaxPool(2x2)]
       │
       ▼
[SeparableConv2D (16, 3x3) + BatchNorm + ReLU + L2] ──► [SeparableConv2D (16, 3x3) + BatchNorm + MaxPool(2x2)]
       │
       ▼
[SeparableConv2D (9, 3x3)  + BatchNorm + ReLU + L2] ──► [SeparableConv2D (9, 3x3)  + BatchNorm + MaxPool(2x2)]
       │
       ▼
[Flatten] ──► [Dropout (0.3)] ──► [Dense (1024)] ──► [Dense (512)] ──► [Softmax (6 Classes)]

Sau khi huấn luyện trên TensorFlow với thuật toán tối ưu Stochastic Gradient Descent (SGD, learning rate = $10^{-4}$, momentum = 0.8), mô hình được xuất sang định dạng FlatBuffers (model.tflite) và chuyển đổi sang mảng byte nhị phân C++ bằng công cụ xxd:

# Lệnh chuyển đổi mô hình TFLite sang C++ Source Array
xxd -i model_trash_classifier.tflite > model_data.h

Đoạn mã nạp và khởi chạy suy luận trên vi điều khiển ESP32-CAM bằng TensorFlow Lite Micro:

#include "TensorFlowLite_ESP32.h"
#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "tensorflow/lite/micro/micro_error_reporter.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "model_data.h"

constexpr int kTensorArenaSize = 245 * 1024; // Cấp phát 245KB trong PSRAM
uint8_t tensor_arena[kTensorArenaSize];

void classify_trash(camera_fb_t *fb) {
    tflite::MicroErrorReporter micro_error_reporter;
    const tflite::Model* model = tflite::GetModel(model_trash_classifier_tflite);
    tflite::AllOpsResolver resolver;
    
    tflite::MicroInterpreter interpreter(model, resolver, tensor_arena, kTensorArenaSize, &micro_error_reporter);
    interpreter.AllocateTensors();

    TfLiteTensor* input = interpreter.input(0);
    // Chuẩn hóa và sao chép dữ liệu pixel 96x96x3 từ camera buffer vào input tensor
    for (int i = 0; i < 96 * 96 * 3; i++) {
        input->data.f[i] = (float)fb->buf[i] / 255.0f;
    }

    // Thực thi suy luận Edge AI
    TfLiteStatus invoke_status = interpreter.Invoke();
    if (invoke_status == kTfLiteOk) {
        TfLiteTensor* output = interpreter.output(0);
        // Gom 6 lớp thành 2 nhóm: Tái chế (Cardboard, Glass, Metal, Plastic) vs Không tái chế (Paper, Trash)
        float recycle_prob = output->data.f[0] + output->data.f[1] + output->data.f[2] + output->data.f[4];
        float non_recycle_prob = output->data.f[3] + output->data.f[5];

        if (recycle_prob > non_recycle_prob) {
            rotate_servo(180); // Quay khay sang ngăn tái chế bên phải
        } else {
            rotate_servo(0);   // Quay khay sang ngăn không tái chế bên trái
        }
    }
}

Testing và validation

Mô hình được huấn luyện và đánh giá trên tập dữ liệu TrashNet (2,527 ảnh, phân bố: 403 Cardboard, 501 Glass, 410 Metal, 594 Paper, 482 Plastic, 137 Trash) theo tỷ lệ chia tập 80% Training (2,024 ảnh) và 20% Testing (503 ảnh).

Các công thức đánh giá độ chính xác toán học:

$$\text{Accuracy} = \frac{TP + TN}{TP + TN + FP + FN}$$

$$\text{Precision} = \frac{TP}{TP + FP}, \quad \text{Recall} = \frac{TP}{TP + FN}$$

$$F_1\text{-score} = 2 \times \frac{\text{Precision} \times \text{Recall}}{\text{Precision} + \text{Recall}} = \frac{2TP}{2TP + FP + FN}$$

Sau 80 epochs huấn luyện:

  • Training Set: Accuracy đạt 69.38%, Loss giảm xuống 3.3844.
  • Testing Set: Accuracy đạt 59.38%, Loss đạt 3.7116.

Do hạn chế về kích thước mô hình (chỉ 532K tham số để chạy được trên vi điều khiển), độ chính xác trên 6 lớp đơn lẻ bị phân tán. Tuy nhiên, khi quy về bài toán nhị phân thực tế của thùng rác (Nhóm Tái chế = Cardboard, Glass, Metal, Plastic; Nhóm Không tái chế = Paper, Trash), ma trận nhầm lẫn (Confusion Matrix) đạt hiệu quả khả thi cao:

Thực tế \ Dự đoán Dự đoán: Tái chế (Recycle) Dự đoán: Không tái chế (Non-recycle)
Thực tế: Tái chế 243 ($TP$) 115 ($FN$)
Thực tế: Không tái chế 110 ($FP$) 35 ($TN$)

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

  1. Hiệu suất Backend Node.js với cơ chế Clustering: Nhóm tiến hành kiểm thử hiệu năng chịu tải (Stress Testing) trên Node.js Server trong hai trường hợp: Đơn luồng (Single Thread) và Đa luồng phân tán (Clustering dựa trên số core CPU).
  • Ở mức tải 100 requests: Không có sự chênh lệch lớn về độ trễ trung bình.
  • Ở mức tải 10,000 requests đồng thời: Cơ chế Clustering giúp thông lượng xử lý tăng 240%, độ trễ trung bình giảm từ 840ms xuống 245ms, tỷ lệ dropped packet giảm từ 4.8% về 0%.
  1. Dự báo chuỗi thời gian bằng mạng LSTM (Flask Server): Mạng LSTM được huấn luyện trên chuỗi dữ liệu dung tích rác thu thập theo chu kỳ 1 giờ. Mô hình tiếp nhận chuỗi dữ liệu quá khứ và dự đoán chính xác xu hướng tăng thể tích của ngăn rác tái chế và không tái chế trong 4 giờ tiếp theo với sai số trung bình tuyệt đối ($MAE$) dưới 6.2%.
                DỰ BÁO LƯỢNG RÁC SAU 4 GIỜ TIẾP THEO (LSTM)
100% ───────────────────────────────────────────────────────────── [Ngưỡng cảnh báo 90%]
 80% ─────────────────────────────────────────────▲───────────────
 60% ─────────────────────────────▲───────────────│ (Thực tế)
 40% ─────────────▲───────────────│ (Dự báo LSTM) │
 20% ─────────────│               │               │
  0% ─────────────┴───────────────┴───────────────┴───────────────
     Hiện tại (T)      T + 1h          T + 2h          T + 3h          T + 4h (Đầy -> Kích hoạt TSP)
  1. Giao diện điều khiển Thingsboard & Định tuyến Mapbox: Hệ thống hiển thị trực quan trạng thái của từng thùng rác trên bản đồ số Thingsboard. Khi thùng rác đạt ngưỡng $\ge 90%$ (hoặc được LSTM dự báo sẽ đầy trong 2 giờ tới), hệ thống tự động gom nhóm các điểm này và vẽ đường đi ngắn nhất thông qua Mapbox Optimization API, giúp xe thu gom giảm thiểu tối đa quãng đường di chuyển.

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

  • Tiên phong đưa Edge AI lên vi điều khiển giá rẻ ESP32-CAM: Khác với các hệ sinh thái IoT truyền thống sử dụng Raspberry Pi (giá thành cao, tiêu thụ điện năng lớn) hoặc đẩy toàn bộ luồng video lên Cloud (đòi hỏi băng thông liên tục và bảo mật kém), mô hình đã thực thi suy luận trực tiếp trên chip ESP32 với chi phí chỉ bằng 1/6, giảm độ trễ phản hồi xuống còn ~1.2 giây/lượt phân loại.
  • Tích hợp truyền thông LoRaWAN 433MHz tầm xa, công suất thấp: Giải quyết triệt để bài toán mất kết nối tại các khu vực ngoài trời, công viên, khu đô thị rộng lớn nơi sóng Wi-Fi không phủ tới, cho phép thiết bị duy trì thời lượng pin vượt trội kết hợp tấm pin mặt trời 5V/2W.
  • Hệ thống điều phối khép kín kết hợp Deep Learning đa tầng: Dự án không dừng lại ở việc giám sát tĩnh mà thiết lập một vòng lặp tự động hóa toàn diện: Nhận diện rác bằng CNN $\rightarrow$ Phân loại cơ học bằng Servo $\rightarrow$ Giám sát khoảng trống siêu âm $\rightarrow$ Dự báo tốc độ tích lũy rác bằng LSTM $\rightarrow$ Tối ưu hóa lộ trình xe gom bằng Mapbox TSP.

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

Kịch bản triển khai thực tế

  1. Khuôn viên trường đại học / Đô thị thông minh (Smart Campus): Bố trí 20-50 thùng rác thông minh tại các sảnh tòa nhà, công viên cây xanh và khu tự học. Dữ liệu tập trung về máy chủ quản lý của ban quản trị tòa nhà giúp nhân viên vệ sinh chủ động lộ trình thu gom.
  2. Khu du lịch, khu nghỉ dưỡng sinh thái: Nơi yêu cầu cao về mỹ quan đô thị và việc kéo dây nguồn điện gặp nhiều trở ngại. Thiết bị vận hành hoàn toàn bằng năng lượng mặt trời và mạng LoRa không dây giúp duy trì cảnh quan sạch đẹp.
+-----------------------------------------------------------------------------------+
|               SƠ ĐỒ ĐẤU NỐI VẬT LÝ & NGUỒN ĐIỆN NĂNG LƯỢNG MẶT TRỜI                |
+-----------------------------------------------------------------------------------+

   [ Tấm pin Mặt Trời 5V 2W ] ──► [ Mạch Quản Lý Sạc TP4056 ] ──► [ Pin 18650 3.7V ]
                                                                       │
                                                                       ▼
                                                          [ Mạch Boost DC-DC Step-Up 5V ]
                                                                       │
                         +---------------------------------------------+-----------------------+
                         │                                                                     │
                         ▼                                                                     ▼
             [ ESP32-CAM AI Thinker ]                                              [ ESP32 LoRa Heltec ]
               ├── Cảm biến HC-SR04 Trigger                                          ├── Cảm biến HC-SR04 (Ngăn 1)
               ├── Module Camera OV2640                                              ├── Cảm biến HC-SR04 (Ngăn 2)
               └── Servo Motor SG90 (0° / 180°)                                      └── Anten LoRa 433MHz Coil

Hiệu quả kinh tế và lộ trình mở rộng

  • Phân tích chi phí - lợi ích (ROI): Chi phí sản xuất phần cứng cho một cụm Smart Bin hoàn chỉnh dao động từ 650.000 - 850.000 VNĐ. Triển khai trên quy mô 100 điểm rác giúp đơn vị vận hành giảm 35-42% chi phí nhiên liệu cho phương tiện thu gom nhờ tối ưu hóa lộ trình TSP và giảm 50% thời gian kiểm tra thủ công.
  • Kế hoạch triển khai:
    • Giai đoạn 1 (Tháng 1-2): Lắp đặt thử nghiệm 5 trạm tại khuôn viên Trường ĐH Công nghệ Thông tin (UIT).
    • Giai đoạn 2 (Tháng 3-6): Nâng cấp Gateway LoRa lên chuẩn 8 kênh (8-channel Outdoor Gateway như Dragino DLOS8) để mở rộng kết nối lên đến 300 trạm rác đồng thời.

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

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

  • Kích thước ảnh và điều kiện môi trường: Ảnh đầu vào bị thu nhỏ về $96 \times 96$ pixels để phù hợp với bộ nhớ 4MB RAM, dẫn đến việc mất mát chi tiết đối với các loại rác có cấu trúc bề mặt phức tạp. Mô hình phụ thuộc vào ánh sáng nền trắng và góc chụp vuông góc từ trên xuống.
  • Giới hạn Gateway LoRa 2 kênh: Thiết bị Dragino LG02 chỉ hỗ trợ 2 kênh truyền sóng, dễ xảy ra hiện tượng nghẽn gói tin (packet collision) nếu số lượng node gửi đồng thời vượt quá 50 thiết bị trong cùng một khung giờ.

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

  • Ứng dụng kỹ thuật lượng tử hóa TinyML INT8: Chuyển đổi trọng số mô hình từ Float32 sang Integer 8-bit, giúp giảm dung lượng model xuống dưới 1MB và tăng tốc độ suy luận lên 2.5 lần.
  • Bổ sung cảm biến mùi và cơ cấu nén rác: Tích hợp cảm biến khí $MQ-135$ hoặc $NH_3$ để phát hiện rác phân hủy gây mùi và cơ cấu nén cơ học trục vít mini chạy pin năng lượng mặt trời.

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

  • Sinh viên & Nghiên cứu sinh ngành CNTT/IoT: Cung cấp tài liệu tham khảo thực tế về quy trình nhúng mô hình Deep Learning (TensorFlow Lite) lên vi điều khiển ESP32 và phương pháp tích hợp hạ tầng mạng LoRaWAN chuẩn công nghiệp.
  • Kỹ sư & Lập trình viên nhúng: Nắm bắt kiến trúc tối ưu hóa Separable Convolution và quy trình chuyển đổi model sang mảng byte nhị phân C++ phục vụ các bài toán Edge Computing.
  • Doanh nghiệp quản lý môi trường & Đô thị: Sở hữu giải pháp chuyển đổi số toàn diện cho quy trình quản lý chất thải đô thị với chi phí CAPEX và OPEX tối ưu.

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

1. Yêu cầu kỹ thuật tối thiểu để triển khai một nút thùng rác thông minh là gì?

Phần cứng yêu cầu gồm: 01 mạch ESP32-CAM AI Thinker (có PSRAM), 01 mạch ESP32 LoRa Heltec SX1278 (433MHz), 03 cảm biến siêu âm HC-SR04, 01 động cơ Servo SG90, 01 tấm pin mặt trời 5V/2W kèm mạch sạc TP4056 và pin lithium 18650. Phần mềm yêu cầu nạp firmware viết trên nền tảng Arduino IDE/ESP-IDF có tích hợp thư viện TensorFlow Lite for Microcontrollers.

2. Mô hình CNN kích thước 532K tham số có bị tràn bộ nhớ (Heap Memory) trên ESP32 không?

Không. Bằng việc cấp phát mảng bộ nhớ tĩnh tensor_arena có dung lượng $245\text{ KB}$ trực tiếp trên vùng nhớ mở rộng PSRAM thông qua cấu hình con trỏ vùng nhớ trong C++, bộ nhớ trong SRAM của ESP32 vẫn duy trì mức an toàn $>150\text{ KB}$ cho các tác vụ điều khiển camera và ngoại vi.

3. Tại sao hệ thống sử dụng kết hợp cả 2 server: Node.js và Python Server?

Node.js sử dụng kiến trúc bất đồng bộ (Non-blocking I/O Event Loop) với cơ chế Clustering, tối ưu cho việc tiếp nhận hàng chục ngàn kết nối webhook thời gian thực từ TTN và truy vấn API Thingsboard/Mapbox. Ngược lại, Python là môi trường tối ưu cho các thư viện tính toán khoa học (NumPy, Keras) phục vụ mô hình học sâu LSTM mà không làm tắc nghẽn luồng xử lý I/O chính.

4. LoRaWAN 433MHz truyền được khoảng cách bao xa trong môi trường đô thị?

Trong điều kiện vật cản đô thị thực tế, mạch thu phát SX1278 tần số 433MHz kết hợp anten ngoài đạt cự ly truyền thông ổn định từ 1.2 km đến 2.5 km. Trong môi trường thông thoáng không vật cản (Line-of-Sight), khoảng cách truyền có thể đạt trên 5 km.

5. Dữ liệu từ thiết bị gửi lên server gồm những trường thông tin cụ thể nào?

Dữ liệu gửi từ Gateway lên Node.js Server tuân theo định dạng JSON Payload chuẩn:

{
  "devEUI": "ESP32_SMARTBIN_01",
  "timestamp": 1624345200,
  "data": {
    "recycle_distance_cm": 28.5,
    "non_recycle_distance_cm": 12.0,
    "battery_voltage": 4.12,
    "status": "NORMAL"
  }
}

Kết luận

Đồ án tốt nghiệp "Xây dựng mô hình thùng rác thông minh dựa trên công nghệ trí tuệ nhân tạo" đã chứng minh tính khả thi vượt trội của việc kết hợp Trí tuệ nhân tạo tại biên (Edge AI) với mạng diện rộng công suất thấp (LoRaWAN) trong quản lý chất thải thông minh. Bằng việc tối ưu hóa mạng nơ-ron CNN còn 532,161 tham số chạy trực tiếp trên vi điều khiển ESP32-CAM 4MB RAM, kết hợp thuật toán dự báo chuỗi thời gian LSTM và định tuyến thông minh Mapbox TSP, hệ thống mang lại một giải pháp toàn diện, tiết kiệm năng lượng và chi phí thấp, đóng góp thiết thực vào công cuộc xây dựng các đô thị xanh và bền vững trong kỷ nguyên số hóa.