Giới thiệu dự án

Trong kỷ nguyên Công nghiệp 4.0 và Trí tuệ nhân tạo (AI), giao tiếp giữa người và máy (Human-Robot Interaction - HRI) đang chuyển dịch mạnh mẽ từ các phương thức truyền thống như bàn phím, nút bấm hay joystick sang các giao thức điều khiển tự nhiên, trực quan bằng cử chỉ và giọng nói. Theo các báo cáo nghiên cứu thị trường công nghệ robot di động, việc áp dụng thị giác máy tính (Computer Vision) trong điều khiển tự hành và bán tự hành giúp tăng tốc độ phản hồi điều phối lên hơn 35% so với thiết bị cầm tay có dây trong các môi trường công nghiệp và y tế đặc thù.

Đồ án khóa luận "Ứng dụng xử lý ảnh nhận dạng cử chỉ bàn tay điều khiển robot di động" (Thực hiện bởi sinh viên Nguyễn Văn Đạt, hướng dẫn bởi ThS. Trần Hoàn, Khoa Công nghệ Điện – Điện tử, Trường Đại học Công nghiệp Thực phẩm TP.HCM) tập trung giải quyết bài toán cốt lõi: Làm thế nào để điều khiển một robot di động (Mobile Robot) di chuyển đa hướng theo thời gian thực (Real-time) chỉ thông qua nhận dạng cử chỉ bàn tay từ Camera quang học mà không cần mang găng tay cảm biến phức tạp hay phụ thuộc vào đường truyền có dây.

+------------------+         +------------------+         +------------------+
|   Khối Thu Nhận  |  CSI    |  Xử Lý Trung Tâm |   UDP   |   Khối Chấp Hành |
|  OV5647 Camera   | ======> | Raspberry Pi 3B  | ======> |  ESP8266 + L298N |
|   (5MP, 60fps)   |         | (OpenCV, Python) |  Wi-Fi  |  (2x DC GA25)    |
+------------------+         +------------------+         +------------------+

Mục tiêu của dự án (Project Objectives)

  1. Thiết kế giải thuật xử lý ảnh: Xây dựng pipeline xử lý hình ảnh dựa trên trích xuất đặc trưng hình thái học (Morphological Features), bao gồm tính toán bao lồi (Convex Hull) và khuyết tật lồi (Convexity Defects) để nhận diện số ngón tay với độ chính xác cao.
  2. Xây dựng hệ thống nhúng trung tâm: Cấu hình hệ điều hành Linux (Raspbian) trên bo mạch Raspberry Pi 3 Model B, tối ưu hóa môi trường Python và OpenCV để xử lý luồng video thời gian thực đạt tốc độ khung hình $\ge 25\text{ FPS}$.
  3. Phát triển hệ thống truyền thông không dây: Ứng dụng giao thức mạng không kết nối UDP/IP qua mạng cục bộ Wi-Fi giữa Raspberry Pi và vi điều khiển WeMos D1 (ESP8266) nhằm đạt độ trễ truyền gói tin dưới 10ms.
  4. Thiết kế phần cứng và cơ khí robot: Chế tạo khung gầm robot 2 bánh chủ động kết hợp bánh dẫn hướng, tích hợp mạch cầu H L298 và động cơ giảm tốc DC GA25 12V 280 RPM.
  5. Đồng bộ hóa 5 tập lệnh điều khiển:
    • No Hand (0 ngón): Dừng hệ thống (STOP).
    • 1 ngón (Up): Robot tiến thẳng về phía trước (FORWARD).
    • 2 ngón (Down): Robot lùi về phía sau (BACKWARD).
    • 3 ngón (Left): Robot quay sang trái (TURN LEFT).
    • 4–5 ngón (Right): Robot quay sang phải (TURN RIGHT).

Phạm vi và giới hạn (Scope & Limitations)

  • Phạm vi: Ứng dụng nhận diện trong không gian phòng thí nghiệm/nhà xưởng với khoảng cách nhận diện từ $0.3\text{m}$ đến $1.2\text{m}$ trước camera; xử lý trong vùng quan tâm (Region of Interest - ROI) được định nghĩa trước trên khung hình.
  • Giới hạn kỹ thuật: Chưa tích hợp mạng nơ-ron tích chập (CNN) học sâu do giới hạn phần cứng nhúng thế hệ cũ; giải thuật phân đoạn nhị phân phụ thuộc vào độ tương phản giữa bàn tay và nền hậu cảnh.

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

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

Hiện nay, các giải pháp điều khiển robot di động tương tác người - máy được chia thành nhiều nhánh công nghệ khác nhau:

Phương pháp Ưu điểm Nhược điểm Chi phí linh kiện
Găng tay cảm biến (Data Glove - Flex/IMU) Độ chính xác cao (>98%), không bị ảnh hưởng bởi ánh sáng Cồng kềnh, vướng víu cho người dùng, dễ đứt gãy dây cáp Cao ($100 - $300)
Mạng nơ-ron học sâu (Deep Learning CNN / MediaPipe) Nhận diện cử chỉ phức tạp, độ bền vững cao Yêu cầu GPU mạnh (Jetson Nano/PC), ngốn điện, trễ cao trên Pi 3 Trung bình - Cao ($150 - $400)
Thị giác máy tính hình thái học (Convex Hull - Đồ án) Nhẹ, chạy mượt mà trên CPU nhúng ARM Cortex-A53, chi phí tối ưu Nhạy cảm với nền phức tạp và ánh sáng gắt Thấp (< $80)

Phân loại yêu cầu người dùng theo mô hình MoSCoW:

  • Must have: Nhận dạng chính xác 5 trạng thái cử chỉ cơ bản; truyền tín hiệu điều khiển không dây thời gian thực; cơ cấu chấp hành đảo chiều quay động cơ chuẩn xác.
  • Should have: Giao diện hiển thị trực tiếp luồng video kèm bounding box, đường viền contour và điểm defect; thông số FPS đạt mức $\ge 25\text{ FPS}$.
  • Could have: Khả năng tự động điều chỉnh ngưỡng sáng thích nghi (Adaptive Thresholding).
  • Won't have (lần này): Điều khiển bám theo quỹ đạo bàn tay liên tục trong không gian 3D (Optical Flow 3D Tracking).

Thiết kế hệ thống

Kiến trúc phân tầng phần cứng và phần mềm

Kiến trúc hệ thống được phân chia thành 3 tầng rõ rệt:

Chi tiết thông số Technology Stack

  • Máy tính nhúng trung tâm: Raspberry Pi 3 Model B (SoC Broadcom BCM2837, Quad-core 64-bit ARM Cortex-A53 @ 1.2 GHz, 1GB LPDDR2 RAM).
  • Cảm biến hình ảnh: Raspberry Pi Camera Module V1 (OmniVision OV5647 5MP, Native CSI-2 bus, tiêu cự cố định, độ phân giải quay $640 \times 480$ @ 60fps).
  • Khối thu phát Wi-Fi & điều khiển phụ trợ: Bo mạch WeMos D1 R2 (ESP8266MOD Tensilica Xtensa LX106 32-bit @ 80 MHz, 4MB Flash, chuẩn Wi-Fi 802.11 b/g/n).
  • Mạch công suất điều khiển động cơ: Module L298N Dual Full-Bridge (IC L298, điện áp tải $5\text{V} - 35\text{V}$, dòng định mức 2A/kênh, tích hợp diode bảo vệ dòng ngược).
  • Động cơ chấp hành: 02 Động cơ DC giảm tốc GA25-370 (Điện áp định mức 12VDC, tỷ số truyền kim loại, tốc độ trục ra 280 RPM, dòng không tải 50mA).
  • Nguồn cấp: Nguồn độc lập 5V/2.5A cho Raspberry Pi và Pin Li-ion 12V/3000mAh cho khối công suất động cơ.
  • Nền tảng phần mềm: Raspbian OS (Debian-based Linux), Python 2.7/3.x, OpenCV Library (bản 2.4.13/3.x), Arduino IDE C++.

Thiết kế giao thức truyền thông UDP Datagram

Để loại bỏ overhead thiết lập bắt tay (handshake) của giao thức TCP, hệ thống sử dụng giao thức truyền thông mạng socket UDP (User Datagram Protocol).

  • IP Address ESP8266 (Server/Access Point): 192.168.4.1 (hoặc IP cấp phát qua Router: 192.168.1.50).
  • UDP Port: 8888.
  • Định dạng tải trọng (Payload): Chuỗi ASCII mã hóa 1 ký tự ('0': Dừng, '1': Tiến, '2': Lùi, '3': Rẽ trái, '4': Rẽ phải). Kích thước gói tin cực nhỏ (1 byte payload + 28 bytes header UDP/IP), giảm thiểu tối đa hiện tượng trễ hàng đợi mạng.

Phương pháp luận phát triển (Methodology)

Dự án áp dụng mô hình phát triển V-Model cải tiến, kết hợp kiểm thử đơn vị từng module phần cứng trước khi tích hợp:

  1. Giai đoạn 1 (Tuần 1–4): Nghiên cứu giải thuật thị giác máy tính trên PC giả lập, tinh chỉnh các tham số lọc nhiễu Gaussian và ngưỡng nhị phân.
  2. Giai đoạn 2 (Tuần 5–8): Cấu hình môi trường nhúng Linux trên Raspberry Pi 3, kết nối Camera CSI và đo lường FPS.
  3. Giai đoạn 3 (Tuần 9–12): Lập trình firmware ESP8266 UDP Server, kết nối mạch công suất L298N và hiệu chỉnh bảng chân logic điều khiển động cơ DC.
  4. Giai đoạn 4 (Tuần 13–16): Tích hợp hệ thống tổng thể, chạy thử nghiệm thực địa và thu thập số liệu độ chính xác.

Implementation và kết quả

Quy trình hiện thực hóa và Giải thuật cốt lõi

1. Biến đổi ảnh và Tiền xử lý (Preprocessing)

Từ luồng video camera, khung hình gốc kích thước $640 \times 480$ pixel được cắt trích vùng quan tâm ROI (Region of Interest) nhằm tập trung tính toán: $$\text{ROI} = \text{Frame}[y_1:y_2, x_1:x_2]$$

Ảnh màu BGR trong ROI được chuyển đổi sang ảnh mức xám (Grayscale 8-bit, 256 mức xám từ 0 đến 255) theo công thức chuẩn: $$Y = 0.2125 \cdot R + 0.7145 \cdot G + 0.0721 \cdot B$$

Để loại bỏ nhiễu tần số cao (nhiễu muối tiêu, nhiễu hạt cảm biến), một bộ lọc Gauss (Gaussian Blur) 2D với ma trận hạt nhân kernel kích thước $7 \times 7$ được áp dụng: $$G(x, y) = \frac{1}{2\pi\sigma^2} e^{-\frac{x^2 + y^2}{2\sigma^2}}$$

Sau đó, ảnh được phân đoạn nhị phân (Binary Thresholding) để tách phần bàn tay (tiền cảnh - pixel giá trị 255) ra khỏi hậu cảnh (pixel giá trị 0).

2. Trích xuất Bao lồi (Convex Hull) và Khuyết tật lồi (Convexity Defects)

Sau khi trích xuất đường viền ngoài lớn nhất bằng hàm cv2.findContours, thuật toán Graham Scan / Sklansky được sử dụng để xây dựng bao lồi đa giác khép kín $\mathcal{H}$ bao quanh bàn tay: $$\mathcal{H} = \text{ConvexHull}(\text{Contour})$$

Các điểm trũng sâu giữa các ngón tay tạo thành các điểm khuyết tật lồi $\mathcal{D}_i = {S_i, E_i, F_i, d_i}$, trong đó:

  • $S_i$: Điểm bắt đầu (Start Point).
  • $E_i$: Điểm kết thúc (End Point).
  • $F_i$: Điểm xa nhất nằm trên đường viền lõm vào trong (Far Point).
  • $d_i$: Khoảng cách từ $F_i$ đến đoạn thẳng nối $S_i E_i$ (Defect Depth).

Góc hợp bởi kẽ ngón tay $\angle S_i F_i E_i$ ($\theta$) được xác định qua định lý hàm cosin: $$a = |E_i - F_i|, \quad b = |S_i - F_i|, \quad c = |S_i - E_i|$$ $$\cos \theta = \frac{a^2 + b^2 - c^2}{2ab} \implies \theta = \arccos\left(\frac{a^2 + b^2 - c^2}{2ab}\right)$$

Điều kiện xác định một kẽ ngón tay hợp lệ: $\theta \le 80^\circ$ và $d_i > 1000$ (giá trị chuẩn hóa). Số lượng ngón tay xòe ra được suy luận từ số lượng kẽ ngón tay hợp lệ ($N_{\text{ngón}} = N_{\text{defects}} + 1$).

# Trích đoạn giải thuật xử lý ảnh nhận diện cử chỉ bàn tay (Python + OpenCV)
import cv2
import numpy as np
import socket

# Cấu hình socket UDP
UDP_IP = "192.168.4.1"
UDP_PORT = 8888
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

cap = cv2.VideoCapture(0)

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    # 1. Trích xuất ROI (Region of Interest)
    roi = frame[100:400, 100:400]
    gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
    blur = cv2.GaussianBlur(gray, (7, 7), 0)
    
    # 2. Phân đoạn nhị phân ngưỡng cố định/Otsu
    _, thresh = cv2.threshold(blur, 70, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    
    # 3. Tìm đường viền lớn nhất
    contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    if contours:
        cnt = max(contours, key=lambda x: cv2.contourArea(x))
        if cv2.contourArea(cnt) > 2000:
            # 4. Tìm bao lồi và khuyết tật lồi
            hull = cv2.convexHull(cnt, returnPoints=False)
            defects = cv2.convexityDefects(cnt, hull)
            
            finger_count = 0
            if defects is not None:
                for i in range(defects.shape[0]):
                    s, e, f, d = defects[i, 0]
                    start = tuple(cnt[s][0])
                    end = tuple(cnt[e][0])
                    far = tuple(cnt[f][0])
                    
                    # Tính độ dài các cạnh tam giác
                    a = np.linalg.norm(np.array(end) - np.array(far))
                    b = np.linalg.norm(np.array(start) - np.array(far))
                    c = np.linalg.norm(np.array(start) - np.array(end))
                    
                    # Áp dụng định lý cosin tính góc kẽ ngón tay
                    angle = np.arccos((a**2 + b**2 - c**2) / (2 * a * b)) * (180 / np.pi)
                    if angle <= 80 and d > 1000:
                        finger_count += 1
            
            total_fingers = finger_count + 1 if finger_count > 0 else 1
            
            # 5. Phân loại lệnh điều khiển gửi UDP
            cmd_map = {1: '1', 2: '2', 3: '3', 4: '4', 5: '4'}
            cmd = cmd_map.get(total_fingers, '0')
            sock.sendto(cmd.encode(), (UDP_IP, UDP_PORT))
    else:
        sock.sendto(b'0', (UDP_IP, UDP_PORT))

3. Điều khiển logic mạch cầu H L298N trên WeMos D1

Bảng trạng thái kích đóng ngắt các Transistor công suất bên trong mạch cầu H L298:

// Logic điều khiển chiều quay động cơ trên Arduino IDE (WeMos D1)
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

const int IN1 = D1, IN2 = D2; // Động cơ Trái
const int IN3 = D3, IN4 = D4; // Động cơ Phải

WiFiUDP Udp;
char packetBuffer[255];

void setup() {
    pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT);
    pinMode(IN3, OUTPUT); pinMode(IN4, OUTPUT);
    WiFi.softAP("ROBOT_GESTURE_AP", "12345678");
    Udp.begin(8888);
}

void loop() {
    int packetSize = Udp.parsePacket();
    if (packetSize) {
        int len = Udp.read(packetBuffer, 255);
        if (len > 0) packetBuffer[len] = 0;
        char cmd = packetBuffer[0];
        
        switch (cmd) {
            case '1': // Tiến thẳng (FORWARD)
                digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);
                digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW); break;
            case '2': // Lùi lại (BACKWARD)
                digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH);
                digitalWrite(IN3, LOW); digitalWrite(IN4, HIGH); break;
            case '3': // Rẽ trái (TURN LEFT)
                digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH);
                digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW); break;
            case '4': // Rẽ phải (TURN RIGHT)
                digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);
                digitalWrite(IN3, LOW); digitalWrite(IN4, HIGH); break;
            default:  // Dừng (STOP)
                digitalWrite(IN1, LOW); digitalWrite(IN2, LOW);
                digitalWrite(IN3, LOW); digitalWrite(IN4, LOW); break;
        }
    }
}

Đo lường và Đánh giá thực nghiệm

1. Kiểm thử kịch bản nhận diện (Scenario Benchmarks)

Hệ thống đã trải qua 500 lần thử nghiệm phân loại cử chỉ ở các điều kiện ánh sáng khác nhau:

Cử chỉ (Lệnh) Số lần test Nhận diện đúng Độ chính xác (%) Thời gian phản hồi TB (ms)
Không bàn tay (STOP) 100 99 99.0% 18.2 ms
1 ngón tay (UP - Tiến) 100 94 94.0% 24.5 ms
2 ngón tay (DOWN - Lùi) 100 93 93.0% 25.1 ms
3 ngón tay (LEFT - Trái) 100 91 91.0% 26.8 ms
4-5 ngón tay (RIGHT - Phải) 100 92 92.0% 27.4 ms
Tổng thể trung bình 500 469 93.8% 24.4 ms 
Biểu đồ phân phối độ trễ toàn trình (Total End-to-End Latency: ~38.4ms)
+-------------------------------------------------------------------------+
| Thu nhận ảnh CSI (15.0ms) | Xử lý ảnh OpenCV (19.4ms) | UDP & L298 (4.0ms) |
+-------------------------------------------------------------------------+
0ms                        15ms                        34.4ms             38.4ms

2. Thống kê khắc phục lỗi phát sinh (Bug Tracking & Solutions)

  • Nhiễu vùng cổ tay: Ban đầu thuật toán nhận diện nhầm diện tích cẳng tay là một phần ngón tay. Giải pháp: Giới hạn khung ROI cố định và áp dụng kỹ thuật xấp xỉ đa giác lồi cắt bỏ phần diện tích tiếp giáp dưới đáy ROI.
  • Hiện tượng rung giật động cơ khi mất gói tin: Giải pháp: Tích hợp cơ chế Watchdog Timer trên WeMos D1. Nếu sau $300\text{ ms}$ không nhận được gói tin UDP mới, ESP8266 sẽ tự động kích hoạt trạng thái STOP để đảm bảo an toàn va chạm.

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

  1. Tối ưu hóa Pipeline xử lý hình thái học không cần Deep Learning: Thay vì chạy các mô hình CNN cồng kềnh đòi hỏi card đồ họa chuyên dụng, giải thuật sử dụng tổ hợp Grayscale $\rightarrow$ Gaussian Blur $\rightarrow$ Otsu Threshold $\rightarrow$ Convexity Defects giúp giảm tải CPU của Raspberry Pi 3 xuống dưới 42%, duy trì tốc độ ổn định $28 - 30\text{ FPS}$.
  2. Kiến trúc phân tán Master-Slave qua UDP: Tách biệt hoàn toàn tác vụ tính toán thị giác nặng (Master - Raspberry Pi) và tác vụ điều khiển I/O động cơ thời gian thực (Slave - WeMos D1). Kiến trúc này giúp giảm thiểu hiện tượng nghẽn ngắt (interrupt blocking) của hệ điều hành Linux khi điều khiển chân GPIO trực tiếp, tăng độ an toàn cơ điện tử.
  3. Hiệu quả kinh tế vượt trội: Toàn bộ hệ sinh thái phần cứng có chi phí lắp ráp dưới 1.800.000 VNĐ, chỉ bằng $15 - 20%$ giá thành của các bộ kit nghiên cứu HRI nhập ngoại.

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

Tình huống ứng dụng thực địa (Use Cases)

  • Vận chuyển hàng hóa trong phòng sạch / Y tế cách ly: Robot di chuyển đưa trang thiết bị hoặc mẫu phẩm theo hiệu lệnh tay của nhân viên y tế mà không cần tiếp xúc vật lý lên nút bấm, ngăn ngừa lây nhiễm chéo vi khuẩn.
  • Hỗ trợ người khuyết tật vận động: Tích hợp module camera gắn cố định lên xe lăn điện để người dùng điều hướng chuyển động chỉ bằng các cử chỉ tay nhẹ nhàng.
  • Giảng dạy và Nghiên cứu STEAM: Mô hình chuẩn trực quan cho sinh viên chuyên ngành Cơ điện tử, Kỹ thuật Điều khiển & Tự động hóa tiếp cận thực hành xử lý ảnh nhúng.
       Triển Khai Mạng Lưới Sản Xuất / Kho Bãi
       
 [Người Vận Hành] 
 [Trạm Camera Cố Định / Raspberry Pi 3]
[AGV Robot 01 (WeMos D1)]       [AGV Robot 02 (WeMos D1)]
  [Khu Vực A]                         [Khu Vực B]

Yêu cầu triển khai và Ước tính ROI

  • Cấu hình phần cứng tối thiểu: Raspberry Pi 3B / 4B (nguồn 5V 2.5A), Camera CSI V1/V2, Module WeMos D1 ESP8266, Cầu H L298N, Khung xe 2 bánh GA25 12V.
  • Môi trường vận hành: Chiếu sáng phòng ổn định ($300 - 600\text{ Lux}$), nền hậu cảnh phía sau bàn tay đơn sắc hoặc ít hoa văn chuyển động.
  • Khả năng nhân rộng (Scalability): Một trạm phát hình ảnh trung tâm có thể mở rộng phát broadcast tín hiệu UDP điều khiển đồng thời cụm từ 3 đến 5 robot AGV trong cùng một dải mạng con LAN.

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

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

  • Giải thuật phân đoạn nhị phân vẫn nhạy cảm với điều kiện môi trường nếu cường độ ánh sáng thay đổi đột ngột (gây hiện tượng đứt nét bao lồi).
  • Vùng nhận dạng giới hạn trong khung ROI tĩnh, đòi hỏi người dùng phải đặt bàn tay đúng vị trí ô vuông định sẵn trên màn hình.

Đề xuất hướng nâng cấp (Future Enhancements)

  1. Nâng cấp thuật toán sang MediaPipe Hands / YOLOv8-Nano: Chuyển đổi nền tảng sang Raspberry Pi 4 (4GB RAM) hoặc Jetson Nano để chạy mô hình Deep Learning nhận diện 21 điểm khớp xương bàn tay 3D (3D Hand Landmarks) ở mọi góc nghiêng và hậu cảnh phức tạp.
  2. Tích hợp giải thuật điều khiển kín PID: Gắn thêm đĩa Encoder quang học vào trục động cơ GA25 để phản hồi vận tốc thực tế, giúp robot di chuyển thẳng tuyệt đối và bám quỹ đạo chính xác.
  3. Ứng dụng công nghệ xử lý ảnh màu HSV động kết hợp trừ nền thích nghi (Adaptive Background Subtraction) để loại bỏ hoàn toàn giới hạn của khung ROI.

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

  • Sinh viên Kỹ thuật (Điện tử, Tự động hóa, CNTT): Nắm vững quy trình kết hợp giữa thị giác máy tính OpenCV và vi điều khiển nhúng thời gian thực; có tài liệu tham khảo chi tiết từ sơ đồ nguyên lý đến mã nguồn.
  • Kỹ sư Lập trình Nhúng (Embedded Developers): Nắm bắt giải pháp phân tách kiến trúc xử lý Master (SoC Linux) - Slave (MCU) qua giao thức UDP socket không dây gọn nhẹ.
  • Doanh nghiệp vừa và nhỏ (SMEs): Mô hình tham chiếu chi phí thấp để tự động hóa các xe tự hành AGV đơn giản trong nhà xưởng mà không cần đầu tư hạ tầng cảm biến dẫn đường từ trường đắt đỏ.
  • Nhà nghiên cứu Giao tiếp Người - Máy (HRI Researchers): Dữ liệu thực nghiệm về độ trễ và độ chính xác của phương pháp hình thái học thuần túy trên vi kiến trúc ARM Cortex-A.

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

1. Yêu cầu hệ thống và phần mềm tối thiểu để tự triển khai dự án này là gì?

Cần chuẩn bị bo mạch Raspberry Pi 3 Model B cài Raspbian Buster/Bullseye, Python 2.7 hoặc 3.x kèm thư viện opencv-python và numpy. Khối chấp hành cần bo mạch WeMos D1 (ESP8266), mạch cầu H L298N, 2 động cơ DC 12V và nguồn cấp độc lập cho 2 tầng điều khiển/công suất để tránh sụt áp gây reset vi điều khiển.

2. Tại sao lại chọn giao thức UDP thay vì TCP hay HTTP REST API để truyền tín hiệu điều khiển?

Trong điều khiển robot thời gian thực, độ trễ và tính liên tục quan trọng hơn việc đảm bảo 100% không mất gói tin. TCP có độ trễ lớn do cơ chế bắt tay 3 bước (3-way handshake) và truyền lại khi lỗi. UDP gửi trực tiếp gói tin datagram nhỏ mà không duy trì trạng thái kết nối, giúp độ trễ giảm xuống dưới $5\text{ ms}$, ngăn chặn hiện tượng trễ lệnh điều khiển gây va chạm.

3. Làm thế nào để hệ thống không nhận diện nhầm khuôn mặt hoặc cẳng tay thành ngón tay?

Hệ thống sử dụng kỹ thuật khoanh vùng quan tâm ROI (Region of Interest) cố định ở góc khung hình kết hợp lọc diện tích contour ($Area_{\min} > 2000\text{ px}$) và lọc góc khuyết tật lồi $\theta \le 80^\circ$. Các vùng có diện tích quá lớn như khuôn mặt hoặc đường cong thoải của cẳng tay sẽ bị loại bỏ khỏi danh sách kẽ ngón tay hợp lệ.

4. Chi phí chế tạo một mô hình hoàn chỉnh là bao nhiêu và mất bao lâu để hoàn thành?

Tổng chi phí linh kiện phần cứng dao động khoảng 1.500.000 – 1.800.000 VNĐ (tính theo thời giá linh kiện phổ thông). Thời gian hiện thực hóa từ khâu thiết kế cơ khí, lắp ráp mạch đến nạp mã nguồn và cân chỉnh giải thuật mất khoảng 4 đến 6 tuần làm việc.

5. Dự án có thể mở rộng điều khiển cánh tay robot (Robot Arm) được không?

Hoàn toàn khả thi. Bằng cách định nghĩa thêm các cử chỉ mở rộng (kết hợp số ngón tay xòe và hướng nghiêng của bàn tay), ta có thể map các mã ký tự qua UDP sang bộ điều khiển Servo PWM trên ESP8266 để điều khiển các bậc tự do (Gắp, Nhả, Nâng, Hạ) của cánh tay robot.

Kết luận

Đồ án "Ứng dụng xử lý ảnh nhận dạng cử chỉ bàn tay điều khiển robot di động" đã chứng minh tính khả thi và hiệu quả cao của việc ứng dụng các giải thuật thị giác máy tính kinh điển (Bao lồi Convex Hull và Khuyết tật lồi Convexity Defects) trên nền tảng máy tính nhúng giá rẻ Raspberry Pi 3 kết hợp vi điều khiển WeMos D1 ESP8266. Hệ thống đạt độ chính xác nhận diện tổng thể 93.8%, thời gian phản hồi toàn trình dưới 40ms, đáp ứng hoàn hảo yêu cầu điều khiển thời gian thực cho robot di động 5 trạng thái chuyển động cơ bản.

Nghiên cứu không chỉ giải quyết trọn vẹn bài toán tích hợp liên ngành giữa Xử lý ảnh số - Kỹ thuật Vi điều khiển - Truyền thông mạng không dây - Cơ điện tử, mà còn mở ra nền tảng vững chắc cho các đề tài nghiên cứu chuyên sâu tiếp theo về xe tự hành thông minh và giao tiếp người - máy không chạm trong công nghiệp hiện đại.