Giới thiệu dự án

Sự bùng nổ của cuộc Cách mạng Công nghiệp 4.0 đã đưa robot tự hành (Autonomous Mobile Robot - AMR) và xe tự hành (AGV) trở thành trụ cột trong tự động hóa kho bãi, logistics và sản xuất công nghiệp. Theo các báo cáo thị trường quốc tế, ngành robot di động dự kiến đạt tốc độ tăng trưởng kép hàng năm (CAGR) trên 16% trong giai đoạn 2021–2028. Tuy nhiên, các giải pháp xe tự hành truyền thống phụ thuộc thuần túy vào cảm biến tiệm cận hoặc sóng siêu âm đơn kênh bộc lộ nhược điểm nghiêm trọng: không thể phân loại chướng ngại vật, dễ bị nhiễu bởi góc phản xạ âm và không có khả năng nhận biết ngữ cảnh không gian.

Đề tài đồ án tốt nghiệp kỹ sư ngành Kỹ thuật Máy tính và Thông tin: "Xe robot tránh chướng ngại vật sử dụng Raspberry Pi" (Graduation Project: Robot car avoids obstacles using Raspberry Pi) do sinh viên Bùi Xuân Hòa thực hiện dưới sự hướng dẫn của thầy Nguyễn Thanh Tùng tại Trường Quốc tế – Đại học Quốc gia Hà Nội (VNU-IS) đã giải quyết triệt để bài toán này bằng cách kết hợp thị giác máy tính (Computer Vision), mô hình học sâu Single Shot MultiBox Detector (SSD) và nền tảng Internet vạn vật (IoT).

                      HỆ THỐNG XE ROBOT TỰ HÀNH
  +----------------------------------------------------------------+
  |                                                                |
  |  [ CSI Camera / Webcam ]                                       |
  |             |                                                  |
  |             v                                                  |
  |   +-------------------+          WiFi / UART                   |
  |   |  Raspberry Pi 4   | ----------------------------+          |
  |   |  (SSD VGG-16 AI)  |                             |          |
  |   +-------------------+                             v          |
  |             |                            +-------------------+ |
  |             | MJPEG Stream               |   NodeMCU ESP32   | |
  |             v                            |  (Motor Control)  | |
  |   +-------------------+                  +-------------------+ |
  |   |  Blynk IoT Cloud  |                             |          |
  |   +-------------------+                             v          |
  |             ^                            [ L298N + DC Motors ] |
  |             | Telemetry & Control                              |
  |             v                                                  |
  |   [ Mobile App Interface ]                                     |
  |                                                                |
  +----------------------------------------------------------------+

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

  1. Thiết kế phần cứng nhúng phân tán: Xây dựng khung xe robot 4 bánh kết hợp tay gắp robot (Robotic Arm) 4 bậc tự do, phân chia xử lý giữa máy tính nhúng Raspberry Pi và vi điều khiển ESP32 / Arduino Uno WiFi (WeMos D1).
  2. Triển khai mô hình thị giác máy tính Deep Learning: Tích hợp mạng học sâu SSD (Single Shot Detector) trên nền tảng Raspberry Pi để nhận diện và định vị vật thể thời gian thực thông qua camera.
  3. Phát triển hệ thống điều khiển và giám sát IoT: Kết nối toàn bộ hệ thống qua nền tảng Blynk IoT, cho phép điều khiển hướng di chuyển, thao tác gắp vật thể và stream video thời gian thực từ camera về máy tính hoặc smartphone.
  4. Tối ưu hóa thuật toán tránh va chạm: Phối hợp dữ liệu tọa độ từ mô hình nhận diện vật thể để đưa ra quyết định chuyển hướng thông minh cho robot.

Phạm vi và giới hạn của đề tài

  • Phạm vi nghiên cứu: Nhận diện các đối tượng vật cản cơ bản (người, xe cộ, đồ vật thường gặp) dựa trên tập dữ liệu chuẩn 20 lớp (PASCAL VOC/COCO), xử lý hình ảnh độ phân giải 300x300 pixel, truyền nhận lệnh qua sóng Wi-Fi băng tần 2.4 GHz.
  • Giới hạn kỹ thuật: Tốc độ xử lý phụ thuộc vào xung nhịp vi xử lý Broadcom của Raspberry Pi khi chưa có bộ tăng tốc phần cứng chuyên dụng (Neural Compute Stick); khoảng cách điều khiển phụ thuộc vào vùng phủ sóng Wi-Fi của Access Point.

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

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

Hiện nay trên thị trường tồn tại nhiều giải pháp chế tạo xe tự hành tránh vật cản với các ưu - nhược điểm khác nhau:

Tiêu chí Xe siêu âm Arduino (HC-SR04) Xe LiDAR SLAM công nghiệp Xe nhúng AI Raspberry Pi (Dự án)
Cảm biến chính Cảm biến siêu âm đơn điểm 2D/3D LiDAR Scanner CSI Camera + SSD Deep Learning
Khả năng nhận dạng Chỉ đo khoảng cách, không phân loại Xây dựng bản đồ đám mây điểm 2D/3D Nhận diện, phân loại chính xác 20+ loại vật thể
Chi phí chế tạo Rất thấp (< 50 USD) Rất cao (> 1000 USD) Trung bình (150 - 250 USD)
Khả năng mở rộng IoT Thấp, cấu hình vi điều khiển yếu Cao, đòi hỏi máy tính công nghiệp Rất cao (Blynk Cloud, Web Server, MQTT)
Xử lý đa nhiệm Không hỗ trợ đa luồng Hỗ trợ ROS / Linux Hỗ trợ Linux OS, Python đa luồng

Yêu cầu hệ thống theo mô hình MoSCoW

  • Must Have (Bắt buộc có):
    • Máy tính nhúng nhận dạng được vật thể phía trước qua Camera với độ trễ cho phép.
    • Khối vi điều khiển nhận lệnh điều khiển động cơ DC di chuyển: Tiến, Lùi, Rẽ trái, Rẽ phải, Dừng.
    • Giao diện điều khiển từ xa qua ứng dụng di động Blynk App.
  • Should Have (Nên có):
    • Cánh tay robot gắp nhả đồ vật bằng động cơ Servo MG90.
    • Cơ chế tự ngắt động cơ khi phát hiện vật cản nằm trong vùng khoảng cách nguy hiểm.
  • Could Have (Có thể mở rộng):
    • Tích hợp thêm cảm biến siêu âm bổ trợ cho camera khi điều kiện ánh sáng yếu.
    • Lưu trữ lịch sử di chuyển và hình ảnh phát hiện lên Cloud Server.
  • Won't Have (Chưa thực hiện ở pha này):
    • Tự động định vị toàn cầu ngoài trời bằng GPS RTK sai số centimet.

Thiết kế kiến trúc hệ thống

Hệ thống được thiết kế theo mô hình phân tầng Modular Architecture:

+-----------------------------------------------------------------------+
|                            APPLICATION LAYER                          |
|    Blynk Mobile App (iOS / Android)  <--->  Blynk Cloud Server API    |
+-----------------------------------------------------------------------+
                                   ^
                                   | (TCP/IP - Wi-Fi 802.11 b/g/n)
                                   v
+-----------------------------------------------------------------------+
|                            PROCESSING LAYER                           |
|  [Raspberry Pi 4 - Linux OS]             [NodeMCU ESP32 / Arduino]   |
|  - Camera Stream (OpenCV)                - Motor Drive Firmware       |
|  - SSD Object Detector (VGG16 Backbone)  - PWM Servo Control (MG90)   |
|  - Decision Engine (Decision Logic)      - Blynk Client Library       |
+-----------------------------------------------------------------------+
                                   |
                                   v (GPIO / PWM / I2C)
+-----------------------------------------------------------------------+
|                             ACTUATOR LAYER                            |
|  - Driver L298N + 4x DC Yellow Geared Motors (1:120)                  |
|  - 4x Micro Servos MG90S (Robotic Arm Gripper)                        |
|  - Dual Power Supply System (5V/3A Powerbank + 9V/12V Battery Pack)   |
+-----------------------------------------------------------------------+

Technology Stack chi tiết

  • Hệ điều hành máy tính nhúng: Raspberry Pi OS (Debian-based 32-bit/64-bit kernel 5.x).
  • Ngôn ngữ lập trình:
    • Python 3.7+ (xử lý hình ảnh, suy luận mô hình học sâu, pipeline stream).
    • C++ (Arduino Wiring) biên dịch trên Arduino IDE 1.8.x cho NodeMCU ESP32 và WeMos D1.
  • Thư viện thị giác máy tính & AI:
    • OpenCV 4.5.x (truy xuất VideoCapture, tiền xử lý ma trận ảnh RGB/Grayscale, vẽ Bounding Box).
    • Framework Deep Learning (Caffe / TensorFlow Lite / PyTorch Runtime) chạy kiến trúc SSD-300.
  • Nền tảng IoT: Blynk Library v0.6.x for ESP32/ESP8266, Blynk Cloud Server REST API / WebSocket.

Implementation và kết quả

Thuật toán nhận dạng vật thể SSD (Single Shot MultiBox Detector)

Mô hình SSD loại bỏ hoàn toàn mạng đề xuất vùng (Region Proposal Network - RPN) cồng kềnh của Faster R-CNN (vốn chỉ đạt 7 FPS trên CPU), gom toàn bộ tác vụ định vị (localization) và phân loại (classification) vào một mạng nơ-ron tích chập duy nhất.

Input Image (300x300x3)
        |
        v
+-----------------------------+
| VGG-16 Base Network         | ---> Feature Map Conv4_3 (38x38x512) -> [Predictor: 38x38x4 Boxes]
| (Conv1_1 đến Conv5_3)       |
+-----------------------------+
        |
        v
+-----------------------------+
| Extra Feature Layers        |
| - Conv7 (FC7 mapped)        | ---> Feature Map (19x19x1024) --------> [Predictor: 19x19x6 Boxes]
| - Conv8_2                   | ---> Feature Map (10x10x512) ---------> [Predictor: 10x10x6 Boxes]
| - Conv9_2                   | ---> Feature Map (5x5x256) -----------> [Predictor: 5x5x6 Boxes]
| - Conv10_2                  | ---> Feature Map (3x3x256) -----------> [Predictor: 3x3x4 Boxes]
| - Conv11_2                  | ---> Feature Map (1x1x256) -----------> [Predictor: 1x1x4 Boxes]
+-----------------------------+
        |
        +-------------------------------------------------------------> [Total: 8,732 Default Boxes]
                                                                                   |
                                                                                   v
                                                                      [Non-Maximum Suppression (NMS)]
                                                                                   |
                                                                                   v
                                                                       [Final Detected Objects]

1. Cơ chế Multi-scale Feature Maps và Anchor Box Calculation

Mô hình tính toán tỉ lệ kích thước các khung mặc định (Default Bounding Boxes) theo từng tầng tích chập $k \in [1, m]$ (với $m=6$ tầng phát hiện):

$$s_k = s_{min} + \frac{s_{max} - s_{min}}{m - 1}(k - 1)$$

Trong đó $s_{min} = 0.1$ và $s_{max} = 0.9$. Đối với mỗi feature map, tập tỉ lệ khung hình (aspect ratio) được cấu hình $a_r \in {1, 2, 3, \frac{1}{2}, \frac{1}{3}}$. Chiều rộng $w_k^a = s_k \sqrt{a_r}$ và chiều cao $h_k^a = s_k / \sqrt{a_r}$. Khi $a_r = 1$, một khung bổ sung có kích thước $s'k = \sqrt{s_k s{k+1}}$ được thêm vào.

Tổng số khung dự đoán trên 6 tầng đặc trưng:

$$\text{Total Boxes} = (38^2 \times 4) + (19^2 \times 6) + (10^2 \times 6) + (5^2 \times 6) + (3^2 \times 4) + (1^2 \times 4) = 5776 + 2166 + 600 + 150 + 36 + 4 = 8732\text{ boxes}$$

2. Hàm mất mát đa tác vụ (Multi-task Loss Function)

Hàm mất mát tổng thể là sự kết hợp có trọng số giữa mất mát phân loại (Confidence Loss) và mất mát định vị (Localization Loss):

$$L(x, c, l, g) = \frac{1}{N} \left( L_{conf}(x, c) + \alpha L_{loc}(x, l, g) \right)$$

  • Trong đó $N$ là số lượng khung dự đoán khớp với ground-truth ($IoU > 0.5$). Nếu $N=0$, gán loss bằng 0.
  • $L_{loc}$ sử dụng hàm Smooth L1 Loss tính toán trên 4 tham số độ lệch tâm và kích thước $(\hat{g}_j^{cx}, \hat{g}_j^{cy}, \hat{g}_j^w, \hat{g}_j^h)$:

$$L_{loc}(x, l, g) = \sum_{i \in Pos}^N \sum_{m \in {cx, cy, w, h}} x_{ij}^k , \text{smooth}_{L1}(l_i^m - \hat{g}_j^m)$$

$$\text{smooth}_{L1}(x) = \begin{cases} 0.5x^2 & \text{nếu } |x| < 1 \ |x| - 0.5 & \text{ngược lại} \end{cases}$$

  • $L_{conf}$ là hàm Softmax Loss đa lớp áp dụng kỹ thuật Hard Negative Mining:

$$L_{conf}(x, c) = -\sum_{i \in Pos}^N x_{ij}^p \log(\hat{c}i^p) - \sum{i \in Neg} \log(\hat{c}_i^0) \quad \text{với } \hat{c}_i^p = \frac{\exp(c_i^p)}{\sum_p \exp(c_i^p)}$$

Hiện thực hóa mã nguồn (Source Code Implementation)

Xử lý nhận diện vật thể trên Raspberry Pi (Python 3 & OpenCV)

import cv2
import numpy as np
import time

# Cấu hình đường dẫn model Caffe/SSD
PROTOTXT_PATH = "models/MobileNetSSD_deploy.prototxt"
MODEL_PATH = "models/MobileNetSSD_deploy.caffemodel"
CONFIDENCE_THRESHOLD = 0.5

# 20 lớp đối tượng PASCAL VOC + Background
CLASSES = ["background", "aeroplane", "bicycle", "bird", "boat",
           "bottle", "bus", "car", "cat", "chair", "cow", "diningtable",
           "dog", "horse", "motorbike", "person", "pottedplant", "sheep",
           "sofa", "train", "tvmonitor"]

# Khởi tạo mạng SSD
net = cv2.dnn.readNetFromCaffe(PROTOTXT_PATH, MODEL_PATH)

# Khởi tạo Camera CSI / USB Webcam
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 320)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 240)

def detect_and_avoid():
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break

        (h, w) = frame.shape[:2]
        # Tiền xử lý ma trận ảnh thành Blob (chuẩn hóa 300x300, scale 0.007843, mean 127.5)
        blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 
                                     0.007843, (300, 300), 127.5)
        net.setInput(blob)
        detections = net.forward()

        obstacle_detected = False

        for i in range(detections.shape[2]):
            confidence = detections[0, 0, i, 2]
            if confidence > CONFIDENCE_THRESHOLD:
                idx = int(detections[0, 0, i, 1])
                box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
                (startX, startY, endX, endY) = box.astype("int")

                # Tính diện tích Bounding Box để ước lượng khoảng cách vật cản
                box_area = (endX - startX) * (endY - startY)
                label = f"{CLASSES[idx]}: {confidence * 100:.1f}%"
                
                # Vẽ khung nhận diện
                cv2.rectangle(frame, (startX, startY), (endX, endY), (0, 255, 0), 2)
                cv2.putText(frame, label, (startX, startY - 5),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

                # Ngưỡng kích thước box cảnh báo va chạm (> 25% khung hình)
                if box_area > (w * h * 0.25):
                    obstacle_detected = True

        cv2.imshow("Robot AI Vision Stream", frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

if __name__ == "__main__":
    detect_and_avoid()

Điều khiển động cơ xe và cánh tay qua Blynk trên ESP32/Arduino (C++)

#define BLYNK_PRINT Serial
#include <WiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleEsp32.h>
#include <ESP32Servo.h>

// Thông tin mạng WiFi và Token Blynk
char auth[] = "Your_Blynk_Auth_Token";
char ssid[] = "Robot_AP_SSID";
char pass[] = "Robot_Password";

// Định nghĩa chân điều khiển động cơ L298N
const int IN1 = 18;
const int IN2 = 19;
const int IN3 = 22;
const int IN4 = 23;

// Định nghĩa 4 Servos điều khiển cánh tay gắp (Robotic Arm)
Servo baseServo, shoulderServo, elbowServo, gripperServo;

void setup() {
  Serial.begin(115200);
  Blynk.begin(auth, ssid, pass);

  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);

  // Gán chân PWM cho Servo MG90
  baseServo.attach(13);
  shoulderServo.attach(12);
  elbowServo.attach(14);
  gripperServo.attach(27);
}

// Điều khiển chuyển động xe thông qua Virtual Pin V1 (Joystick Widget)
BLYNK_WRITE(V1) {
  int x = param[0].asInt();
  int y = param[1].asInt();

  if (y > 350) {          // Tiến
    digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);
    digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW);
  } else if (y < 150) {   // Lùi
    digitalWrite(IN1, LOW);  digitalWrite(IN2, HIGH);
    digitalWrite(IN3, LOW);  digitalWrite(IN4, HIGH);
  } else if (x < 150) {   // Rẽ trái
    digitalWrite(IN1, LOW);  digitalWrite(IN2, HIGH);
    digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW);
  } else if (x > 350) {   // Rẽ phải
    digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);
    digitalWrite(IN3, LOW);  digitalWrite(IN4, HIGH);
  } else {                // Dừng
    digitalWrite(IN1, LOW);  digitalWrite(IN2, LOW);
    digitalWrite(IN3, LOW);  digitalWrite(IN4, LOW);
  }
}

// Điều khiển góc mở kẹp cánh tay robot qua Slider V2
BLYNK_WRITE(V2) {
  int angle = param.asInt();
  gripperServo.write(angle);
}

void loop() {
  Blynk.run();
}

Kết quả thử nghiệm và đánh giá thực nghiệm

Hệ thống được đưa vào thử nghiệm thực tế trong môi trường phòng lab và hành lang với các bài kiểm tra đo đạc thông số:

  1. Hiệu năng xử lý mô hình AI trên Raspberry Pi 4:

    • Tốc độ suy luận (Inference Latency): Đạt mức trung bình 115 ms/frame (~8.7 FPS) khi sử dụng kiến trúc SSD kết hợp MobileNet rút gọn, vượt trội so với mức 140 ms của VGG-16 nguyên bản.
    • Độ chính xác trung bình (mAP@0.5): Đạt 72.4% đối với các đối tượng kích thước trung bình và lớn trong phạm vi từ 0.5 mét đến 3.5 mét.
    • Độ phân giải luồng video stream: 320x240 pixel ở tốc độ 15 FPS qua chuẩn nén MJPEG, tiêu tốn băng thông trung bình ~450 KB/s.

  2. Khả năng điều khiển và độ trễ phản hồi:

    • Độ trễ truyền nhận lệnh từ Blynk App qua ESP32: < 45 ms trong cùng mạng Wi-Fi cục bộ.
    • Tỉ lệ né tránh vật cản tĩnh thành công: 93.3% (28/30 lần thử nghiệm).
    • Tải trọng cánh tay gắp MG90: Gắp và di chuyển ổn định các vật thể có khối lượng đến 120 gram.
    SO SÁNH TỐC ĐỘ XỬ LÝ FRAME GIỮA CÁC MÔ HÌNH NHẬN DIỆN (FPS)
 12 +-------------------------------------------------------------+
    |                                                             |
 10 +                                           +---------------+ |
    |                                           | SSD MobileNet | |
  8 +                          +--------------+ |   (8.7 FPS)   | |
    |                          |  SSD VGG-16  | |               | |
  6 +                          |  (6.8 FPS)   | |               | |
    |                          |              | |               | |
  4 +                          |              | |               | |
    |         +--------------+ |              | |               | |
  2 +         | Faster R-CNN | |              | |               | |
    |         |  (1.4 FPS)   | |              | |               | |
  0 +---------+--------------+-+--------------+-+---------------+--+
               Mô hình 1        Mô hình 2        Mô hình 3

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

Các điểm cải tiến kỹ thuật nổi bật

  1. Kiến trúc phần cứng nhúng phân tán (Heterogeneous Edge Architecture):
    • Tách biệt rõ ràng tầng tính toán AI nặng (giao cho vi xử lý lõi tứ Broadcom BCM2711 của Raspberry Pi 4) và tầng điều khiển thời gian thực chính xác cứng (Real-time Hard Control) cho các chân PWM của ESP32/ATmega328P. Thiết kế này giúp hệ thống không bao giờ bị treo lệnh điều khiển động cơ khi CPU máy tính nhúng đang xử lý tác vụ suy luận nặng.
  2. Cơ chế nguồn điện độc lập chống sụt áp (Isolated Dual-Power Circuit):
    • Sử dụng 2 nguồn cấp riêng biệt: Nguồn sạc dự phòng chuẩn 5V/3A cấp riêng cho Raspberry Pi và mạch vi điều khiển logic; Bộ pin 9V–12V cấp riêng cho khối động cơ công suất DC qua mạch cầu H L298N. Giải pháp này triệt tiêu 100% hiện tượng sụt áp và nhiễu sóng xung ngược từ cuộn dây động cơ gây khởi động lại đột ngột (Brownout Reset) trên máy tính nhúng.
  3. Tối ưu hóa Multi-Scale Anchor Boxes cho góc nhìn của Robot:
    • Tinh chỉnh tập tỷ lệ Aspect Ratios cho các tầng dự đoán của SSD phù hợp với góc đặt camera thấp trên thân xe, tăng độ nhạy nhận diện các vật thể nằm sát mặt sàn.

Bảng so sánh giải pháp với các công trình tương tự

Thông số so sánh Giải pháp truyền thống (Arduino + HC-SR04) Giải pháp Raspberry Pi + YOLO Tiny Giải pháp đồ án (Pi 4 + SSD Multi-scale + ESP32)
Phân loại vật thể Không thể phân loại Phân loại được Phân loại chi tiết 20 nhóm vật thể
Độ ổn định hệ thống Cao (chỉ chạy logic đơn giản) Trung bình (dễ sụt áp nếu chung nguồn) Rất cao (nguồn cách ly, phân tầng xử lý)
Giao diện điều khiển Remote hồng ngoại / Bluetooth HC-05 Web Browser thuần Giao diện Blynk Cloud chuyên nghiệp (iOS/Android)
Tích hợp cơ cấu gắp Không có Hiếm khi tích hợp Cánh tay 4-DOF điều khiển đồng bộ qua WiFi
Tốc độ đáp ứng ~20 ms (phản xạ cơ học) ~180 ms (nghẽn luồng) ~115 ms (tối ưu hóa luồng suy luận)

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

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

  1. Robot hỗ trợ hậu cần và vận chuyển nội bộ (Smart Logistics AGV): Ứng dụng trong các nhà kho thông minh, tự động nhận diện thùng hàng, pallet, tránh va chạm với công nhân và tự động gắp các gói hàng nhẹ.
  2. Robot tuần tra và giám sát an ninh (Security Patrol Robot): Tuần tra định kỳ tại các khu vực hạn chế người, truyền hình ảnh camera sắc nét về phòng điều khiển trung tâm và phát hiện kẻ đột nhập hoặc chướng ngại vật rơi trên đường.
  3. Mô hình giáo dục STEM & Nghiên cứu Khoa học: Nền tảng mở phục vụ giảng dạy cho sinh viên ngành Điện tử - Viễn thông, Công nghệ Thông tin, Cơ điện tử tiếp cận nhanh chóng với AIoT và Edge Computing.
       QUY TRÌNH TRIỂN KHAI VẬN HÀNH (DEPLOYMENT PIPELINE)
  +----------------------------------------------------------------+
  |                                                                |
  |  [BƯỚC 1: Cấu hình Mạng & Phần cứng]                            |
  |  Flash OS -> Cấu hình Static IP -> Test GPIO, PWM Servos       |
  |             |                                                  |
  |             v                                                  |
  |  [BƯỚC 2: Cài đặt Môi trường AI & Thị giác máy tính]           |
  |  Compile OpenCV -> Deploy SSD Models -> Cấu hình Video Stream  |
  |             |                                                  |
  |             v                                                  |
  |  [BƯỚC 3: Đồng bộ Giao thức IoT & Điều khiển]                  |
  |  Nạp Firmware ESP32 -> Map Virtual Pins Blynk -> Test Latency  |
  |             |                                                  |
  |             v                                                  |
  |  [BƯỚC 4: Hiệu chuẩn Thực địa & Hoàn thiện Vận hành]           |
  |  Cân chỉnh NMS Threshold -> Thử nghiệm Né tránh -> Bàn giao    |
  |                                                                |
  +----------------------------------------------------------------+

Bảng dự toán chi phí phần cứng (BOM - Bill of Materials)

Linh kiện Thông số kỹ thuật Số lượng Chi phí ước tính (VND)
Raspberry Pi 4 Model B Broadcom BCM2711, 4GB RAM 01 1,450,000
NodeMCU ESP-32 / WeMos D1 WiFi + Bluetooth, Dual-core 02 180,000
Camera Module / Webcam 1080p HD, góc nhìn rộng 01 250,000
Khung xe 4 bánh + Động cơ Động cơ vàng tỷ số 1:120 + Bánh xe 01 bộ 160,000
Mạch điều khiển L298N Dual H-Bridge Motor Driver 01 45,000
Cánh tay robot + 4 Servo MG90 Khung Acrylic/Kim loại + Servo MG90S 01 bộ 280,000
Nguồn sạc dự phòng + Pin 18650 Nguồn 5V/3A + Cell pin 8.4V-12V 01 bộ 300,000
Tổng chi phí phần cứng ~ 2,665,000 VND

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

Các hạn chế kỹ thuật hiện tại

  • Công suất tỏa nhiệt và giới hạn xung nhịp: Khi chạy suy luận Deep Learning liên tục trong hơn 30 phút, vi xử lý Raspberry Pi 4 có thể đạt nhiệt độ trên 70°C nếu không trang bị quạt tản nhiệt tích cực, dẫn đến hiện tượng Thermal Throttling làm tụt giảm FPS.
  • Độ nhạy sáng của Camera: Thuật toán xử lý hình ảnh dựa trên mạng SSD phụ thuộc nhiều vào điều kiện chiếu sáng của môi trường. Trong bóng tối hoặc ánh sáng ngược mạnh, độ chính xác nhận diện giảm xuống dưới 50%.
  • Bán kính hoạt động: Hiện tại hệ thống kết nối thông qua WiFi cục bộ (Local Access Point), bán kính vận hành bị giới hạn trong khoảng 30–50 mét.

Hướng phát triển và nâng cấp đề xuất

  1. Tăng tốc phần cứng bằng NPU/Edge TPU: Bổ sung thanh tăng tốc Google Coral USB Accelerator hoặc chuyển đổi sang board mạch chuyên dụng như NVIDIA Jetson Nano để nâng tốc độ xử lý lên 25–30 FPS.
  2. Tích hợp công nghệ định vị SLAM & cảm biến LiDAR: Kết hợp cảm biến laser 2D LiDAR và thuật toán Gmapping/Cartographer trong hệ điều hành Robot (ROS 2) để xây dựng bản đồ số hóa không gian 2D/3D chính xác.
  3. Chuyển giao điều khiển qua 4G/5G Teleoperation: Nâng cấp module truyền thông sang 4G LTE/5G SIM Hat để điều khiển robot từ bất kỳ đâu qua Internet băng thông rộng độ trễ thấp.

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

  • Sinh viên và Học viên Kỹ thuật: Tiếp cận tài liệu thực hành hoàn chỉnh kết hợp giữa lý thuyết Deep Learning phức tạp (Mô hình SSD, Smooth L1 Loss, Anchor Box) và kỹ thuật nhúng phần cứng thực tế (Raspberry Pi, ESP32, L298N).
  • Lập trình viên IoT & Robotics: Tham khảo mẫu kiến trúc phân tầng xử lý tách biệt giữa Machine Vision và Real-time Actuator, tránh các lỗi phổ biến về nghẽn luồng và sụt áp.
  • Doanh nghiệp & Startup Tự động hóa: Mô hình chứng minh tính khả thi (Proof-of-Concept) giá rẻ để phát triển các nguyên mẫu robot phục vụ kho vận, nhà xưởng quy mô vừa và nhỏ với chi phí chỉ bằng 1/10 các giải pháp nhập khẩu.
  • Nhà nghiên cứu học thuật: Nguồn dữ liệu thực nghiệm về hiệu năng thực thi của các mô hình Object Detection trên thiết bị nhúng biên cấu hình giới hạ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 thành công hệ thống là gì?

Cấu hình tối thiểu bao gồm board Raspberry Pi 3 Model B+ (khuyên dùng Raspberry Pi 4 Model B với 2GB/4GB RAM), thẻ nhớ MicroSD dung lượng tối thiểu 16GB Class 10 (tốc độ đọc/ghi > 80 MB/s), nguồn cấp dòng ổn định 5V/3A Type-C, và vi điều khiển ESP32 hoặc ESP8266 để điều khiển động cơ.

2. Vì sao mô hình SSD lại được ưu tiên lựa chọn hơn Faster R-CNN trong đồ án này?

Faster R-CNN sử dụng mạng RPN hai giai đoạn (Two-Stage Detector) cho độ chính xác cao nhưng đòi hỏi tài nguyên tính toán cực lớn, tốc độ trên vi xử lý nhúng chỉ đạt ~1–2 FPS. Trong khi đó, SSD là mạng một giai đoạn (Single-Stage Detector) trực tiếp dự đoán tọa độ khung và nhãn lớp qua các tầng tích chập phụ trợ đa tỉ lệ, giúp đạt tốc độ 7–10 FPS trên Raspberry Pi, đáp ứng yêu cầu tránh vật cản thời gian thực.

3. Làm cách nào để khắc phục hiện tượng trễ hình ảnh (Video Latency) khi truyền về ứng dụng?

Để giảm thiểu độ trễ luồng video: hạ độ phân giải capture của camera xuống mức 320x240 hoặc 640x480 pixel, sử dụng chuẩn nén MJPEG qua giao thức HTTP Stream cục bộ thay vì đẩy trực tiếp qua các dịch vụ Cloud trung gian, và thiết lập luồng đọc camera chạy trên một tiến trình đa luồng (Multi-threading) độc lập trong Python.

4. Hệ thống xử lý ra sao khi xe bị mất kết nối Wi-Fi đột ngột?

Trong firmware nạp cho ESP32, hệ thống đã được lập trình cơ chế an toàn (Failsafe Timer): Nếu không nhận được tín hiệu Ping định kỳ từ Blynk Server hoặc Raspberry Pi trong vòng 500 ms, vi điều khiển sẽ tự động ngắt toàn bộ xung PWM cấp cho mạch L298N, đưa xe về trạng thái dừng khẩn cấp (Emergency Stop) để ngăn chặn va chạm mất kiểm soát.

5. Chi phí và thời gian triển khai một hệ thống tương tự mất bao lâu?

Tổng chi phí linh kiện phần cứng dao động từ 2.500.000 đến 3.000.000 VND. Thời gian triển khai cho một nhóm 1–2 kỹ sư nắm vững nền tảng lập trình Python và C/C++ ước tính khoảng 4 đến 6 tuần, bao gồm các giai đoạn: thiết kế cơ khí khung xe, cấu hình hệ điều hành nhúng, huấn luyện/triển khai mô hình AI, và tích hợp kiểm thử thực tế.

Kết luận

Đồ án tốt nghiệp "Xe robot tránh chướng ngại vật sử dụng Raspberry Pi" của tác giả Bùi Xuân Hòa là một công trình nghiên cứu ứng dụng tiêu biểu, kết hợp nhuần nhuyễn giữa trí tuệ nhân tạo hiện đại và kỹ thuật điều khiển nhúng. Bằng việc ứng dụng thành công mô hình học sâu SSD trên nền tảng Raspberry Pi 4 cùng cấu trúc phân tầng điều khiển qua ESP32 và Blynk IoT, đề tài đã giải quyết xuất sắc bài toán định vị, nhận dạng và né tránh vật cản tự động với chi phí chế tạo tối ưu.

Công trình không chỉ mang giá trị học thuật cao đối với sinh viên chuyên ngành Kỹ thuật Máy tính và Công nghệ Thông tin mà còn mở ra tiềm năng ứng dụng thực tiễn to lớn trong việc nội địa hóa các giải pháp robot tự hành AGV/AMR phục vụ cuộc cách mạng chuyển đổi số và tự động hóa công nghiệp.