Giới thiệu dự án

Trong bối cảnh cuộc Cách mạng Công nghiệp 4.0, tự động hóa quy trình sản xuất và logistics đóng vai trò then chốt trong việc tối ưu hóa năng suất và giảm thiểu chi phí vận hành. Theo các báo cáo phân tích chuỗi cung ứng công nghiệp, khâu phân loại và kiểm tra chất lượng (QC) thủ công chiếm tới 30% – 40% chi phí nhân công trực tiếp, đồng thời tồn tại tỷ lệ sai sót dao động từ 3% đến 5% do yếu tố mệt mỏi thị giác của con người. Để giải quyết bài toán này, các hệ thống thị giác máy tính (Machine Vision) đã và đang được triển khai rộng rãi. Tuy nhiên, phần lớn các giải pháp thị giác 2D truyền thống gặp hạn chế nghiêm trọng khi phân biệt các vật thể có màu sắc, biên dạng tương đồng nhưng khác biệt về chiều cao hoặc cấu trúc không gian 3 chiều. Ngược lại, các hệ thống quét 3D Laser Profiler chuyên dụng trong công nghiệp lại có giá thành rất cao (thường từ $5,000 – $15,000), vượt quá khả năng tiếp cận của các doanh nghiệp vừa và nhỏ (SMEs) cũng như các mô hình thí nghiệm đào tạo.

Đồ án tốt nghiệp ngành Công nghệ Kỹ thuật Cơ điện tử (Khoa Cơ khí – Trường Đại học Công nghiệp Hà Nội) tập trung giải quyết bài toán trên thông qua đề tài: "Nghiên cứu, thiết kế hệ thống phân loại sản phẩm theo hình dạng, chiều cao sử dụng camera Kinect". Bằng cách khai thác công nghệ cảm biến quang học RGB-D giá thành thấp từ Microsoft Kinect Xbox 360 kết hợp cùng vi điều khiển Arduino Uno R3 và thư viện xử lý ảnh OpenCV, hệ thống cho phép phát hiện, đo lường và phân loại chính xác phôi sản phẩm theo cả hai tiêu chí hình học 2D (tròn, vuông, tam giác) và chiều cao thực tế (3D depth map) trên băng tải động.

+--------------------------------------------------------------------------------+
|                           PROJECT OBJECTIVES & TARGETS                         |
+--------------------------------------------------------------------------------+
| 1. Thiết kế cơ khí băng tải PVC module hóa, khung nhôm định hình 20x20 mm      |
| 2. Tích hợp cảm biến RGB-D Kinect Xbox 360 khai thác dữ liệu màu và độ sâu     |
| 3. Xây dựng thuật toán xử lý ảnh OpenCV: HSV Filter, Contours, Image Moments   |
| 4. Thiết lập mô hình toán học giải mã bản đồ độ sâu (Depth Map) tính chiều cao |
| 5. Thiết kế mạch điều khiển Arduino Uno R3 kết nối UART điều khiển 3 cơ cấu gạt|
| 6. Đạt độ chính xác phân loại toàn hệ thống >= 90% ở tốc độ băng tải 0.05 m/s  |
+--------------------------------------------------------------------------------+

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

  • Phạm vi phân loại: Nhận diện 4 nhóm phôi chuẩn: Phôi tròn cao, Phôi vuông cao, Phôi tam giác cao và Phôi thấp (phôi lỗi chiều cao).
  • Không gian hoạt động: Cảm biến Kinect bố trí nhìn vuông góc từ trên xuống (Top-down view), khoảng cách làm việc danh định từ camera đến mặt băng tải $Z_0 \approx 700\text{ mm} – 900\text{ mm}$ (nằm trong vùng làm việc tối ưu $0.5\text{ m} – 3.5\text{ m}$).
  • Môi trường hoạt động: Trong nhà (Indoor), ánh sáng ổn định, tránh bức xạ hồng ngoại trực tiếp từ ánh nắng mặt trời gây nhiễu cảm biến IR.

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

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

Phân tích các công nghệ phân loại sản phẩm hiện hành trên thị trường cho thấy sự đánh đổi rõ rệt giữa chi phí đầu tư, độ linh hoạt và năng lực trích xuất đặc trưng vật thể:

Tiêu chí so sánh Cụm cảm biến quang/tiệm cận đa tầng Camera 2D công nghiệp thông thường Camera 3D Laser Profiler công nghiệp Giải pháp đề xuất: Camera Kinect RGB-D
Dữ liệu trích xuất Nhị phân (Có/Không có tiếp xúc) Ảnh màu RGB / Grayscale 2D Điểm mây 3D (Point Cloud) độ chính xác cao Đồng thời ảnh màu RGB và Bản đồ độ sâu Depth Map
Đo chiều cao vật thể Kém (Chỉ phát hiện theo ngưỡng đặt trước) Không thể (Mất trục Z) Rất tốt (Sai số $< 0.05\text{ mm}$) Tốt (Sai số $\pm 1.0\text{ mm} – \pm 1.5\text{ mm}$ ở cự ly gần)
Nhận diện hình dạng Không hỗ trợ Rất tốt trên mặt phẳng 2D Rất tốt Tốt (Tròn, Vuông, Tam giác, Đa giác)
Chi phí phần cứng Thấp ($50 – $150) Trung bình ($300 – $1,000) Rất cao ($5,000 – $20,000) Rất thấp ($80 – $150)
Độ phức tạp tích hợp Thấp Trung bình Cao Trung bình (Sử dụng OpenNI / OpenCV)

Ma trận yêu cầu kỹ thuật (MoSCoW Prioritization)

  • Must Have (Bắt buộc): Băng tải chuyển động ổn định vận tốc $v = 0.05\text{ m/s}$; nhận diện đúng 3 hình học cơ bản (tròn, vuông, tam giác); đo chiều cao phôi phân biệt phôi cao/thấp; cơ cấu tay gạt servo SG90 gạt chính xác vào 3 máng phân loại.
  • Should Have (Nên có): Giao diện giám sát thời gian thực trên máy tính hiển thị FPS, luồng RGB và tọa độ tâm phôi; màn hình LCD 16x2 hiển thị số lượng sản phẩm phân loại theo từng nhóm.
  • Could Have (Có thể mở rộng): Tự động điều chỉnh góc nghiêng camera thông qua motor tích hợp trong Kinect; lưu trữ nhật ký phân loại vào cơ sở dữ liệu.
  • Won't Have (Chưa thực hiện): Phân loại các vật thể có hình học phức tạp bất định (Free-form 3D CAD matching) hoặc bề mặt gương phản xạ hoàn toàn.

Thiết kế hệ thống

Hệ thống được thiết kế theo cấu trúc module hóa phân tầng, bao gồm 3 phân hệ chính: Phân hệ Thị giác & Xử lý tính toán (Master PC), Phân hệ Điều khiển thời gian thực (Slave MCU), và Phân hệ Cơ khí chấp hành (Conveyor & Actuators).

+------------------------------------------------------------------------------------+
|                               SYSTEM ARCHITECTURE                                  |
+------------------------------------------------------------------------------------+
|  [ Microsoft Kinect Xbox 360 ] (RGB 640x480 @30fps + IR Depth CMOS 11-bit)         |
|         │ (USB 2.0 / PrimeSense PS1080 SoC Data Stream)                            |
|         ▼                                                                          |
|  [ Master Controller: PC Core i5 / Python 3.8+ / OpenCV 4.5 / OpenNI 2.2 ]         |
|    ├── Module 1: Color Filtering (HSV Masking) & Morphological Erosion             |
|    ├── Module 2: 2D Shape Classification (Contour Approximation & Image Moments)   |
|    └── Module 3: Height Estimation via Light Coding Triangulation z = f(d)         |
|         │                                                                          |
|         │ (Serial UART Protocol @ 9600 Baud: Packet ['S', ID, Checksum, 'E'])      |
|         ▼                                                                          |
|  [ Slave Controller: Arduino Uno R3 (ATmega328P @ 16MHz) ]                         |
|    ├── Inputs: 3x Cảm biến hồng ngoại LM393 (Phát hiện phôi tại các trạm gạt)      |
|    ├── Displays: Màn hình LCD 16x2 (I2C Driver PCF8574)                            |
|    └── Outputs:                                                                    |
|          ├── 1x DC Motor Driver L298N / Relay -> Động cơ DC Takanawa 555 (Băng tải)|
|          └── 3x Micro Servo SG90 (Cơ cấu tay gạt tại máng 1, máng 2, máng 3)       |
+------------------------------------------------------------------------------------+

Technology Stack và phiên bản phần mềm

  • Master Computation Engine: Python 3.8.10, OpenCV-Python 4.5.5.64, NumPy 1.21.6, PySerial 3.5.
  • Kinect Drivers & Middleware: Microsoft Kinect SDK v1.8 / OpenNI v2.2.0.33, PrimeSense Sensor Driver v5.1.6.6.
  • Embedded Control Platform: Arduino IDE 1.8.19, C/C++ (AVR-GCC), Servo Library standard.
  • Mechanical CAD/CAE: Dassault Systèmes SolidWorks 2020 SP5.0.

Giao thức truyền thông nối tiếp (UART Communication Protocol)

Dữ liệu phân loại được truyền từ Master PC xuống Arduino thông qua cổng COM (Virtual Serial Port) với cấu hình: Baudrate 9600 bps, Data bits 8, Parity None, Stop bit 1. Khung truyền dữ liệu (Data Frame) được chuẩn hóa để chống mất gói:

$$\text{Frame} = [\text{0x53 (ASCII 'S')}] + [\text{Type_ID}] + [\text{Checksum}] + [\text{0x45 (ASCII 'E'})]$$

Trong đó Type_ID nhận các giá trị:

  • '1': Phôi tròn cao $\rightarrow$ Kích hoạt trạm gạt 1 khi cảm biến hồng ngoại 1 tác động.
  • '2': Phôi vuông cao $\rightarrow$ Kích hoạt trạm gạt 2 khi cảm biến hồng ngoại 2 tác động.
  • '3': Phôi tam giác cao $\rightarrow$ Kích hoạt trạm gạt 3 khi cảm biến hồng ngoại 3 tác động.
  • '0': Phôi thấp (lỗi) $\rightarrow$ Không kích hoạt gạt, phôi đi thẳng về khay phôi lỗi cuối băng tải.

Tính toán thiết kế cơ khí và động lực học

1. Tính toán công suất động cơ dẫn động băng tải

  • Vận tốc đồng bộ băng tải: $v = 0.05\text{ m/s}$.
  • Đường kính rulô chủ động: $D = 30\text{ mm} = 0.03\text{ m} \rightarrow$ Bán kính $R = 0.015\text{ m}$.
  • Tốc độ quay trục rulô: $n = \frac{60 \cdot v}{\pi \cdot D} = \frac{60 \cdot 0.05}{\pi \cdot 0.03} \approx 31.83\text{ vòng/phút}$.
  • Tổng khối lượng băng tải và rulô: $m_{\text{rulo}} = 2.5\text{ kg}$. Khối lượng tải phôi cực đại: $m_{\text{phoi}} = 0.3\text{ kg}$.
  • Tổng lực kéo cản ma sát:

$$F_{\text{ms}} = (m_{\text{rulo}} + m_{\text{phoi}}) \cdot g \cdot (\mu_{\text{trượt}} + k_{\text{lăn}}) = (2.5 + 0.3) \cdot 9.81 \cdot (0.5 + 0.5) = 27.468\text{ N}$$

  • Công suất có ích trên trục công tác:

$$P_{\text{ct}} = \frac{F_{\text{ms}} \cdot v}{1000} = \frac{27.468 \cdot 0.05}{1000} = 1.3734 \times 10^{-3}\text{ kW} \approx 1.3734\text{ W}$$

  • Hiệu suất tổng thể hệ truyền động: $\eta = \eta_{\text{ổ lăn}} \cdot \eta_{\text{bánh răng}} \cdot \eta_{\text{đai}} = 0.99 \cdot 0.96 \cdot 0.95 \approx 0.8495$.
  • Công suất động cơ cần thiết có tính hệ số dự trữ $K = 1.6$:

$$P_{\text{đc}} \ge K \cdot \frac{P_{\text{ct}}}{\eta} = 1.6 \cdot \frac{1.3734}{0.8495} \approx 2.587\text{ W}$$

  • Lựa chọn thiết bị: Động cơ DC giảm tốc Takanawa 555 Metal Gear Motor (Điện áp danh định $12\text{VDC} – 24\text{VDC}$, công suất cực đại $60\text{W}$, mô-men xoắn $15\text{ kg}\cdot\text{cm}$, tốc độ không tải $60\text{ RPM}$ tại $12\text{V}$) đáp ứng dư tải an toàn, loại trừ hoàn toàn nguy cơ kẹt tải.

Implementation và kết quả

Development process & Core Algorithms

+------------------------------------------------------------------------------------+
|                         VISION PIPELINE IMPLEMENTATION                             |
+------------------------------------------------------------------------------------+
|  [ Frame RGB (640x480) ]                     [ Raw Depth Stream (11-bit Disparity) ]
|         │                                                       │
|         ▼                                                       ▼
|  [ cvtColor: BGR -> HSV ]                     [ Linearization z = 1 / (c1*d + c0) ]
|         │                                                       │
|         ▼                                                       ▼
|  [ inRange Masking ]                          [ ROI Depth Extraction at Centroid ]
|         │                                                       │
|         ▼                                                       │
|  [ cv2.erode (Kernel 3x3) ]                                     │
|         │                                                       │
|         ▼                                                       │
|  [ cv2.findContours ]                                           │
|         │                                                       │
|         ▼                                                       │
|  [ approxPolyDP & Moments ]                                     │
|         │                                                       │
|         ├── Poly Vertices = 3 ───────> Triangle                 │
|         ├── Poly Vertices = 4 ───────> Rectangle/Square         │
|         └── Circularity Ratio >= 0.85 > Circle                  │
|         │                                                       │
|         └───────────────────────┬───────────────────────────────┘
|                                 ▼
|                  [ Combined Classification Logic ]
|             ├── Shape Type & (z_base - z_object) >= Threshold_Height
|             └── Decision: 1 (Tròn), 2 (Vuông), 3 (Tam giác), 0 (Phôi thấp)
+------------------------------------------------------------------------------------+

1. Mô hình toán học tính toán khoảng cách và độ sâu (Depth Mapping)

Nguyên lý đo sâu của Kinect dựa trên kỹ thuật Light Coding: Bộ chiếu laser hồng ngoại (IR Projector) phát ra lưới điểm ngẫu xạ cố định vào không gian, camera IR thu nhận ảnh biến dạng của lưới điểm. Bộ xử lý phần cứng PrimeSense PS1080 tính toán giá trị độ chênh lệch (disparity $d$, biểu diễn 11-bit trong đoạn $[0, 2047]$). Khoảng cách vật lý thực $z$ (tính bằng mét) từ camera đến bề mặt phôi tuân theo mô hình hình học tam giác lượng giác (Nicolas Burrus Model):

$$z = \frac{1}{c_1 \cdot d + c_0} = \frac{1}{-0.0030711 \cdot d + 3.3309495}$$

Chiều cao thực tế của phôi ($H_{\text{phôi}}$) được xác định bằng hiệu khoảng cách giữa mặt đáy băng tải ($Z_{\text{base}}$) và đỉnh bề mặt phôi ($Z_{\text{surface}}$):

$$H_{\text{phôi}} = Z_{\text{base}} - Z_{\text{surface}}$$

Nếu $H_{\text{phôi}} < H_{\text{ngưỡng}}$ ($H_{\text{ngưỡng}} = 30\text{ mm}$), phôi được phân loại là "Phôi thấp".

2. Trích xuất tâm và nhận diện biên dạng 2D (Contour & Moments)

  • Moment hình học 2D bậc $(p+q)$ trên ảnh nhị phân $I(x, y)$:

$$M_{pq} = \sum_{x} \sum_{y} x^p \cdot y^q \cdot I(x, y)$$

  • Tọa độ tâm (Centroid):

$$\bar{x} = \frac{M_{10}}{M_{00}}, \quad \bar{y} = \frac{M_{01}}{M_{00}}$$

  • Độ tròn (Circularity Metric): Với diện tích $A = M_{00}$ và chu vi $P = \text{arcLength}(\text{contour})$, độ tròn được định nghĩa:

$$C = \frac{4 \pi \cdot A}{P^2}$$

Nếu $C \ge 0.82 \rightarrow$ Phôi tròn. Nếu $C < 0.82$, sử dụng cv2.approxPolyDP với sai số $\epsilon = 0.04 \cdot P$:

  • Số đỉnh $= 3 \rightarrow$ Phôi tam giác.
  • Số đỉnh $= 4 \rightarrow$ Phôi vuông / chữ nhật.

3. Source Code Module Xử lý ảnh và Điều khiển (Python Core)

import cv2
import numpy as np
import serial
import time

# Khởi tạo kết nối Serial với Arduino Uno
try:
    ser = serial.Serial('COM3', 9600, timeout=0.1)
    time.sleep(2)
    print("[INFO] Da ket noi thanh cong voi Arduino tren COM3")
except Exception as e:
    print(f"[ERROR] Khong the mo cong Serial: {e}")
    ser = None

def calculate_depth(disparity_val):
    """Chuyen doi gia tri Disparity 11-bit sang khoang cach thuc (cm)"""
    if disparity_val >= 1030 or disparity_val <= 434:
        return 0.0
    z_meter = 1.0 / (-0.0030711016 * disparity_val + 3.3309495161)
    return z_meter * 100.0  # Tra ve don vi cm

def process_vision_pipeline(rgb_frame, depth_frame, z_base_cm=80.0, h_threshold_cm=3.0):
    """
    Pipeline xu ly: Loc mau HSV, tim Contour, xap xi da giac, do do sau va phan loai
    """
    # 1. Chuyen doi sang khong gian mau HSV va loc nguong
    hsv = cv2.cvtColor(rgb_frame, cv2.COLOR_BGR2HSV)
    lower_hsv = np.array([0, 50, 50])
    upper_hsv = np.array([180, 255, 255])
    mask = cv2.inRange(hsv, lower_hsv, upper_hsv)

    # 2. Phep co Erosion loai bo nhieu bien hat
    kernel = np.ones((3, 3), np.uint8)
    mask_eroded = cv2.erode(mask, kernel, iterations=1)

    # 3. Tim duong bao Contour
    contours, _ = cv2.findContours(mask_eroded, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    
    product_type = 0  # 0: Phoi thap/loi, 1: Tron, 2: Vuong, 3: Tam giac
    
    for cnt in contours:
        area = cv2.contourArea(cnt)
        if area < 500:  # Loai bo cac vung bien dien tich qua nho
            continue
            
        # Tinh toan tam Moment
        M = cv2.moments(cnt)
        if M["m00"] == 0:
            continue
        cx = int(M["m10"] / M["m00"])
        cy = int(M["m01"] / M["m00"])
        
        # Lay do sau tai diem tam
        raw_disp = depth_frame[cy, cx]
        z_surface_cm = calculate_depth(raw_disp)
        height_cm = z_base_cm - z_surface_cm
        
        # Kiem tra chieu cao
        if height_cm < h_threshold_cm:
            product_type = 0  # Phoi thap
            shape_label = "Low Defect"
        else:
            # Phan loai hinh dang
            peri = cv2.arcLength(cnt, True)
            approx = cv2.approxPolyDP(cnt, 0.04 * peri, True)
            vertices = len(approx)
            circularity = 4 * np.pi * (area / (peri * peri))
            
            if circularity > 0.82:
                product_type = 1
                shape_label = "Circle High"
            elif vertices == 4:
                product_type = 2
                shape_label = "Square High"
            elif vertices == 3:
                product_type = 3
                shape_label = "Triangle High"
            else:
                product_type = 0
                shape_label = "Unknown"

        # Gui ma phan loai xuong Arduino
        if ser and ser.is_open:
            packet = bytearray([0x53, ord(str(product_type)), 0x45])
            ser.write(packet)
            
        # Ve visualization
        cv2.drawContours(rgb_frame, [cnt], -1, (0, 255, 0), 2)
        cv2.circle(rgb_frame, (cx, cy), 4, (0, 0, 255), -1)
        cv2.putText(rgb_frame, f"{shape_label} | H:{height_cm:.1f}cm", (cx - 40, cy - 10),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 0), 2)
                    
    return rgb_frame

4. Source Code Nhúng trên Vi điều khiển (Arduino Firmware)

#include <Servo.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);

Servo servo1; // Máng 1: Tròn cao
Servo servo2; // Máng 2: Vuông cao
Servo servo3; // Máng 3: Tam giác cao

const int IR_PIN_1 = 2;
const int IR_PIN_2 = 3;
const int IR_PIN_3 = 4;

volatile char current_target_type = '0';
int count_circle = 0, count_square = 0, count_triangle = 0, count_defect = 0;

void setup() {
  Serial.begin(9600);
  servo1.attach(9);
  servo2.attach(10);
  servo3.attach(11);
  
  // Trạng thái đóng ban đầu (0 độ)
  servo1.write(0);
  servo2.write(0);
  servo3.write(0);

  pinMode(IR_PIN_1, INPUT);
  pinMode(IR_PIN_2, INPUT);
  pinMode(IR_PIN_3, INPUT);

  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("SYSTEM READY...");
}

void loop() {
  // Đọc dữ liệu từ Python qua UART
  if (Serial.available() >= 3) {
    if (Serial.read() == 'S') {
      current_target_type = Serial.read();
      char end_byte = Serial.read();
      if (end_byte == 'E') {
        update_lcd();
      }
    }
  }

  // Quản lý cơ cấu gạt theo cảm biến vị trí
  if (digitalRead(IR_PIN_1) == LOW && current_target_type == '1') {
    trigger_servo(servo1);
    count_circle++;
    current_target_type = '0';
    update_lcd();
  }
  else if (digitalRead(IR_PIN_2) == LOW && current_target_type == '2') {
    trigger_servo(servo2);
    count_square++;
    current_target_type = '0';
    update_lcd();
  }
  else if (digitalRead(IR_PIN_3) == LOW && current_target_type == '3') {
    trigger_servo(servo3);
    count_triangle++;
    current_target_type = '0';
    update_lcd();
  }
}

void trigger_servo(Servo &s) {
  s.write(90); // Mở góc gạt 90 độ
  delay(800);  // Giữ để phôi trượt vào máng
  s.write(0);  // Đóng về vị trí ban đầu
}

void update_lcd() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("C:"); lcd.print(count_circle);
  lcd.print(" S:"); lcd.print(count_square);
  lcd.setCursor(0, 1);
  lcd.print("T:"); lcd.print(count_triangle);
  lcd.print(" D:"); lcd.print(count_defect);
}

Testing và validation

Quá trình kiểm nghiệm thực nghiệm được tiến hành liên tục trên mô hình phần cứng tại xưởng thực hành Cơ điện tử. Mỗi loại phôi được cấp liên tục 40 lần (tổng cộng 160 lượt chạy) với thứ tự ngẫu nhiên nhằm đánh giá độ tin cậy và phân tích các dạng sai hỏng:

Nhóm sản phẩm thử nghiệm Số lượng mẫu chạy Số mẫu phân loại đúng Số mẫu lỗi / nhận diện sai Độ chính xác phân loại (%) Nguyên nhân sai số chính
Phôi tròn cao 40 38 2 95.0% Trễ đáp ứng cơ cấu servo khi phôi lăn sát mép
Phôi vuông cao 40 37 3 92.5% Góc xoay phôi làm biến dạng xấp xỉ đa giác
Phôi tam giác cao 40 36 4 90.0% Đỉnh nhọn bị bo tròn quang học $\rightarrow$ nhầm sang tròn
Phôi thấp (Defect) 40 39 1 97.5% Nhiễu biên chiều sâu tại mép chuyển tiếp
Tổng thể toàn hệ thống 160 150 10 93.75% Đạt và vượt chỉ tiêu thiết kế ban đầu ($>90%$) 
+------------------------------------------------------------------------------------+
|                         ACCURACY & PERFORMANCE BENCHMARKS                          |
+------------------------------------------------------------------------------------+
|  Phôi tròn cao:       [███████████████████████████████████████░░] 95.0%            |
|  Phôi vuông cao:      [█████████████████████████████████████░░░░] 92.5%            |
|  Phôi tam giác cao:   [████████████████████████████████████░░░░░] 90.0%            |
|  Phôi thấp (Lỗi):     [████████████████████████████████████████░] 97.5%            |
|                                                                                    |
|  * Processing Frame Rate: 30 FPS (Độ trễ xử lý thuật toán: 18.2 ms/frame)          |
|  * Năng suất phân loại danh định: 24 - 30 sản phẩm/phút                            |
|  * Công suất tiêu thụ toàn tải: 21.5W (Kinect: 4.7W + Hệ cơ điện: 16.8W)           |
+------------------------------------------------------------------------------------+

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

  1. Tối ưu hóa chi phí phần cứng (Cost-to-Performance Innovation): Đề tài chứng minh tính khả thi của việc sử dụng cảm biến RGB-D tiêu dùng thương mại (Microsoft Kinect Xbox 360) thay thế cho các cảm biến 3D công nghiệp chuyên dụng, giảm giá thành đầu tư từ hàng nghìn USD xuống dưới $200 USD mà vẫn đảm bảo độ chính xác trên 93%.
  2. Thuật toán tích hợp 2D-3D Hybrid Vision: Khắc phục triệt để nhược điểm mất chiều sâu của hệ thống thị giác 2D truyền thống bằng cách kết hợp trích xuất đặc trưng hình học 2D (Contours & Image Moments) và trích xuất độ sâu 3D tại ma trận tâm (Disparity-to-Depth Linearization) trong một luồng xử lý duy nhất với thời gian thực thi $< 20\text{ ms}$.
  3. Cơ chế đồng bộ phần cứng phi tiếp xúc: Phối hợp chính xác giữa việc phân loại từ xa bằng Camera và cơ chế kích hoạt tay gạt cục bộ thông qua cảm biến hồng ngoại LM393, loại bỏ hoàn toàn hiện tượng lệch bước thời gian (Timing Jitter) do trượt ma sát trên băng tải.

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

Khả năng ứng dụng công nghiệp

  • Dây chuyền chế biến nông sản: Phân loại củ quả (cà chua, cam, táo) theo kích cỡ đường kính và thể tích không gian 3D.
  • Ngành đóng gói thực phẩm & dược phẩm: Kiểm tra phát hiện các hộp, chai lọ bị móp méo, thiếu nắp hoặc không đạt chuẩn chiều cao trước khi đóng thùng.
  • Công nghiệp phụ trợ cơ khí: Phân loại tự động các chi tiết phôi tiện, phôi dập sau gia công thô theo chủng loại biên dạng hình học.
+------------------------------------------------------------------------------------+
|                         DEPLOYMENT & RETROFIT ROADMAP                              |
+------------------------------------------------------------------------------------+
|  Phase 1: Chuẩn bị cơ sở hạ tầng (Nguồn DC 12V-5A, Khung gá chống rung Camera)     |
|  Phase 2: Lắp đặt cơ khí & Cân chỉnh độ phẳng mặt băng tải PVC                     |
|  Phase 3: Hiệu chuẩn độ sâu Kinect (Calibration Z-base plane) qua Trackbars GUI    |
|  Phase 4: Tích hợp Master PC, kết nối UART và kiểm thử đồng bộ tay gạt             |
|  Phase 5: Bàn giao vận hành, thiết lập ngưỡng dung sai phân loại phôi              |
+------------------------------------------------------------------------------------+

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

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

  • Vùng mù độ sâu (Blind Zone): Cảm biến Kinect Xbox 360 không thể đo khoảng cách ở cự ly $< 0.5\text{ m}$. Do đó, chiều cao khung gá camera bắt buộc phải cao tối thiểu $0.7\text{ m} – 0.8\text{ m}$ so với băng chuyền.
  • Nhiễu ánh sáng mạnh: Khi hoạt động ngoài trời hoặc dưới nguồn đèn halogen công suất lớn, tia hồng ngoại môi trường sẽ làm bão hòa cảm biến IR CMOS, gây ra các điểm khuyết (Depth holes) trên bản đồ độ sâu.
  • Giới hạn cơ cấu gạt: Động cơ servo SG90 vỏ nhựa có tuổi thọ giới hạn khi hoạt động liên tục trong môi trường công nghiệp nặng.

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

  • Nâng cấp cảm biến: Thay thế Kinect Xbox 360 bằng camera Intel RealSense D435i hoặc Kinect Azure (sử dụng công nghệ Time-of-Flight tiên tiến, độ phân giải chiều sâu cao hơn, giảm vùng mù xuống $0.1\text{ m}$).
  • Ứng dụng AI/Deep Learning: Tích hợp mô hình mạng nơ-ron tích chập nhẹ (YOLOv8-Nano hoặc MobileNet-SSD) chạy trên các kit nhúng như NVIDIA Jetson Nano để nhận diện phôi đa dạng, phôi bị che khuất một phần.
  • Công nghiệp hóa cơ cấu chấp hành: Chuyển đổi cơ cấu gạt servo sang Xilanh khí nén tác động kép điều khiển qua Solenoid Valve 24V để tăng tốc độ phản hồi và độ bền cơ học.

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

  • Sinh viên ngành Cơ điện tử / Tự động hóa / Robot: Cung cấp tài liệu tham khảo hoàn chỉnh từ thiết kế cơ khí 3D (SolidWorks), tính toán công suất động lực học, đến kỹ thuật lập trình xử lý ảnh nhị phân và giao tiếp phần cứng thời gian thực.
  • Kỹ sư và Lập trình viên Embedded Vision: Nắm vững phương pháp tích hợp camera chiều sâu giá rẻ vào hệ thống điều khiển công nghiệp thông qua các giao thức truyền thông tiêu chuẩn.
  • Các cơ sở sản xuất vừa và nhỏ (SMEs): Tiếp cận giải pháp tự động hóa chi phí thấp, thời gian hoàn vốn (ROI) nhanh (dưới 3 tháng so với thuê nhân công), dễ dàng bảo trì và mở rộng tính năng.

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

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

Máy tính Master chỉ cần CPU Intel Core i3 thế hệ 4 trở lên (hoặc tương đương), RAM 4GB, 01 cổng USB 2.0 cấp riêng cho Kinect và 01 cổng USB kết nối Arduino. Kinect Xbox 360 bắt buộc phải sử dụng nguồn Adapter ngoài $12\text{VDC} – 1.5\text{A}$ do cổng USB máy tính không cấp đủ dòng cho động cơ và đèn chiếu IR.

2. Làm thế nào để loại bỏ hiện tượng sai lệch độ sâu do rung động của băng tải?

Hệ thống sử dụng bộ lọc không gian kết hợp phép co hình thái học (cv2.erode) và lấy giá trị trung vị độ sâu (Median Depth Filtering) trong vùng lân cận $5 \times 5$ pixel xung quanh điểm tâm $(\bar{x}, \bar{y})$ thay vì lấy 1 pixel đơn lẻ, giúp triệt tiêu rung nhiễu cơ học của mặt băng.

3. Có thể phân loại các sản phẩm có màu sắc trùng với màu băng tải không?

Có. Nhờ kênh dữ liệu chiều sâu độc lập từ camera hồng ngoại, hệ thống hoàn toàn có thể trích xuất biên dạng vật thể dựa trên sự chênh lệch độ cao giữa bề mặt sản phẩm và mặt băng tải thông qua thuật toán Depth Thresholding, ngay cả khi màu sắc sản phẩm trùng hoàn toàn với nền.

4. Băng tải có thể chạy ở tốc độ cao hơn $0.05\text{ m/s}$ không?

Có thể tăng tốc độ lên đến $0.15\text{ m/s}$. Tuy nhiên, cần thay thế cơ cấu gạt servo SG90 bằng van điện từ khí nén (Pneumatic Actuator) để đáp ứng thời gian mở/đóng $< 100\text{ ms}$, tránh hiện tượng kẹt hoặc va đập làm vỡ sản phẩm.

5. Chi phí chế tạo toàn bộ hệ thống mô hình là bao nhiêu?

Tổng chi phí chế tạo mô hình dao động từ 3.500.000 đến 4.500.000 VNĐ (bao gồm: Camera Kinect cũ ~800k, Khung nhôm & Băng tải ~1.5tr, Động cơ Takanawa 555 & Driver ~500k, Arduino & Linh kiện cảm biến/servo ~700k, Nguồn & phụ kiện ~500k).

Kết luận

Đề tài "Nghiên cứu, thiết kế hệ thống phân loại sản phẩm theo hình dạng, chiều cao sử dụng camera Kinect" đã giải quyết trọn vẹn và đồng bộ các yêu cầu đặt ra từ bài toán lý thuyết đến chế tạo thực nghiệm. Bằng sự kết hợp chặt chẽ giữa kỹ thuật cơ khí chính xác, thiết kế mạch điện tử điều khiển và thuật toán thị giác máy tính OpenCV, hệ thống đạt độ chính xác phân loại ấn tượng 93.75% trên 160 mẫu thử nghiệm thực tế. Đây là minh chứng rõ nét cho xu hướng ứng dụng các công nghệ cảm biến thông minh giá thành thấp vào hiện đại hóa dây chuyền sản xuất, mở ra tiềm năng ứng dụng rộng lớn cho các doanh nghiệp và là tiền đề vững chắc cho các nghiên cứu chuyên sâu về thị giác 3D trong tương lai.