Giới thiệu dự án

Trong bối cảnh công nghiệp 4.0 và chuyển đổi số sản xuất, tự động hóa các công đoạn xử lý vật liệu đóng vai trò quyết định đến năng suất và chất lượng đầu ra. Theo Báo cáo xu hướng sản xuất kinh doanh ngành công nghiệp chế biến - chế tạo Việt Nam (Quý IV/2023), chỉ số cân bằng sử dụng lao động giảm -9,1% (với 20,3% doanh nghiệp cắt giảm nhân công trực tiếp), trong khi chỉ số khối lượng sản xuất lại tăng 2,2% (với 32,7% doanh nghiệp tăng sản lượng). Điều này chứng minh làn sóng chuyển dịch tất yếu từ phương thức gia công thâm dụng lao động sang các dây chuyền tự động hóa thông minh.

Khâu phân loại và cấp phôi chi tiết cơ khí đầu vào là một trong những điểm nghẽn lớn nhất:

  • Pain points thực tế: Phương pháp phân loại thủ công bộc lộ sai số cao do mệt mỏi thị giác khi làm việc liên tục, tốc độ phân loại chậm (dao động từ 15–30 sản phẩm/phút tùy kích thước), chi phí nhân công tăng lũy tiến và không đảm bảo tính đồng đều khi kiểm tra các chi tiết cơ khí kích thước nhỏ ($\le 60\times 60\text{ mm}$).
  • Bài toán đặt ra: Thiết kế một hệ thống tự động nhận diện, định vị và phân loại các chi tiết cơ khí kim loại có hình dạng đặc thù trong không gian 2D với độ chính xác cao, thời gian đáp ứng thời gian thực và chi phí chế tạo tối ưu.
graph TD
    A[Camera Công Nghiệp / Webcam] -->|Thu nhận ảnh phôi| B(PC Vision Processor - OpenCV)
    B -->|Hiệu chỉnh phối cảnh Aruco & Trích xuất Hu Moments| C{Phân loại mẫu & Định vị X, Y, Theta}
    C -->|Giao tiếp UART/Serial| D[Vi điều khiển ATmega2560]
    D -->|Điều khiển xung/hướng| E[Driver DRV8825 & Động cơ bước NEMA 17]
    D -->|Kích hoạt Relay/Solenoid| F[Bơm chân không & Giác hút DP15-2]
    E --> G[Hệ Cánh tay 3-DOF + Ray trượt tuyến tính]
    F --> G
    G --> H[Phân loại chính xác vào 4 khay chứa S1 - S4]

Mục tiêu dự án

  1. Nghiên cứu và hiện thực hóa các thuật toán xử lý ảnh công nghiệp: hiệu chỉnh biến dạng quang học qua mã Aruco Marker, lọc biên Canny, xấp xỉ đường viền đa giác và thuật toán so khớp hình học (Shape-based Matching / Hu Moments).
  2. Thiết kế và tích hợp cơ cấu phần cứng: Cánh tay robot 3 bậc tự do (3-DOF) kết hợp ray trượt tuyến tính (trục X) và cơ cấu chấp hành cuối (EOAT - End Of Arm Tool) dạng giác hút chân không.
  3. Xây dựng phần mềm điều khiển nhúng trên nền tảng vi điều khiển ATmega2560 giao tiếp đồng bộ với máy tính xử lý qua giao thức truyền thông nối tiếp UART.
  4. Đạt độ chính xác nhận dạng $\ge 95%$ và sai số định vị cơ khí $\le \pm 1.5\text{ mm}$ trên 4 nhóm sản phẩm cơ khí điển hình (S1, S2, S3, S4).

Giải pháp và phạm vi

  • Phương pháp tiếp cận: Ứng dụng thị giác máy 2D (Area Scan Camera) kết hợp cánh tay robot 3-DOF gắn trên ray trượt tuyến tính (Linear Rail Guide). Việc bổ sung ray trượt giúp giải quyết triệt để giới hạn không gian làm việc (Workspace) của cánh tay robot khớp nối truyền thống mà không làm tăng bậc tự do quay phức tạp.
  • Phạm vi & Giới hạn: Hệ thống tập trung nhận diện và gắp thả 4 loại chi tiết cơ khí kim loại dạng phẳng, kích thước tối đa $60\times 60\text{ mm}$, tải trọng gắp $\le 1.0\text{ kg}$, làm việc trong điều kiện nguồn sáng chiếu sáng liên tục và có kiểm soát.

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

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

Tiêu chí Phân loại thủ công (Manual) Cảm biến truyền thống (Photoelectric/Proximity) Hệ thống Thị giác máy & Robot (Đề tài)
Độ chính xác $80 - 88%$ (phụ thuộc tâm lý/thể lực) $85 - 90%$ (chỉ đo được 1 thuộc tính) $\ge 96.5%$ (nhận dạng hình học đa chiều)
Tốc độ xử lý $2.5 - 4.0\text{ s/vật}$ $0.8 - 1.2\text{ s/vật}$ $1.5 - 2.2\text{ s/vật}$ (bao gồm nhận diện + gắp/thả)
Tính linh hoạt Rất cao nhưng không ổn định Rất thấp (phải đổi layout cảm biến khi đổi mẫu) Rất cao (thay đổi thuật toán / template trên phần mềm)
Chi phí vận hành Lũy tiến theo thời gian (lương nhân công) Thấp Tối ưu, khấu hao nhanh
Khả năng lưu trữ Không có nhật ký số Tín hiệu nhị phân đơn giản Toàn diện (tọa độ, phân loại, tỉ lệ lỗi)

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

  • Must have: Tự động nhận diện 4 loại biên dạng (S1, S2, S3, S4); tự động hiệu chỉnh góc nghiêng phối cảnh bằng 4 mã Aruco Marker; điều khiển chính xác tọa độ gắp bằng động cơ bước; cơ cấu giác hút chân không tin cậy.
  • Should have: Giao diện người dùng (GUI) hiển thị hình ảnh thời gian thực, bounding box, thông số tọa độ $(X, Y, \theta)$ và tỉ lệ khớp (Match Score).
  • Could have: Tự động cảnh báo dị vật hoặc phôi nằm ngoài vùng làm việc.
  • Won't have (lần này): Nhận dạng đối tượng xếp chồng 3D (Random Bin-picking), phân tích chiều sâu bằng cảm biến RGB-D.

Thiết kế hệ thống

Hệ thống được thiết kế theo kiến trúc điều khiển phân tầng: Tầng xử lý thị giác cấp cao (High-level Vision Engine) chạy trên PC kết nối với Tầng điều khiển thực thi cấp thấp (Low-level Motion Controller) qua cổng COM/UART.

+-----------------------------------------------------------------------+
|                       TẦNG XỬ LÝ THỊ GIÁC (PC)                        |
|  - Camera Feed (1080p @ 30 FPS)                                       |
|  - Aruco Marker Corner Extraction -> cv2.getPerspectiveTransform      |
|  - Preprocessing: Grayscale -> GaussianBlur -> Canny -> Dilate        |
|  - Contour Analysis: cv2.findContours -> cv2.approxPolyDP -> HuMoments|
|  - Coordinate Transformation: Pixel (u, v) -> World (X_w, Y_w)        |
+-----------------------------------+-----------------------------------+
                                    | Chuỗi định dạng: "G0 X... Y... Z... S...\n" (UART 115200 bps)
+-----------------------------------v-----------------------------------+
|                   TẦNG ĐIỀU KHIỂN CHUYỂN ĐỘNG (MCU)                   |
|  - Arduino Mega 2560 (ATmega2560 @ 16 MHz)                            |
|  - Motion Planner: Thuật toán nội suy bước & Động học nghịch (IK)    |
|  - Actuators: 4x NEMA 17 Stepper Motors (1.8 deg/step) via DRV8825    |
|  - Pneumatics: Bơm mini 12V + Van điện từ CNV6-3 + Giác hút DP15-2    |
|  - Feedback: Công tắc hành trình cơ khí xác định điểm gốc (Homing)    |
+-----------------------------------------------------------------------+

Thông số kỹ thuật chi tiết các thành phần cốt lõi:

  1. Cánh tay robot & Ray trượt:
    • Cấu trúc: 3 bậc tự do khớp phẳng + 1 trục trượt tịnh tiến tuyến tính (Ray nhôm định hình + Trục thép trượt $\Phi 8\text{ mm}$, truyền động đai răng GT2).
    • Chiều dài tay đòn: $L_1 = 140\text{ mm}$, $L_2 = 140\text{ mm}$; Vùng với tối đa: $R_{\max} = 300\text{ mm}$; Góc quay khớp: $0^\circ - 270^\circ$.
    • Tải trọng nâng định mức: $1.0\text{ kg}$.
  2. Khâu chấp hành khí nén:
    • Bơm hút chân không mini 12V DC, áp suất âm đạt $-65\text{ kPa}$.
    • Van điện từ 3 cửa 2 vị trí CNV6-3 (điều khiển xả/ngắt chân không nhanh).
    • Giác hút silicon chuyên dụng DP15-2/DL60-1211B chịu mài mòn cao.
  3. Mạch điều khiển & Công suất:
    • Vi điều khiển ATmega2560 (54 chân I/O số, 4 bộ UART phần cứng).
    • Module điều khiển động cơ bước DRV8825 hỗ trợ vi bước lên đến 1/32 step.
    • Nguồn cấp tổ ong công nghiệp: Meanwell 12V - 20A (công suất danh định 240W).

Methodology & Quy trình kỹ thuật

Dự án áp dụng mô hình phát triển mẫu thử công nghiệp chữ V (V-Model Prototyping) với vòng đời kéo dài từ tháng 03/2024 đến tháng 07/2024:

[Phân tích yêu cầu] ----------------------------------> [Kiểm thử nghiệm thu toàn hệ thống]
       \                                                               /
   [Thiết kế Cơ-Điện-Thuật toán] -------------> [Kiểm thử tích hợp Vision + Arm]
             \                                         /
          [Chế tạo CAD/3D & Lập trình] -> [Kiểm thử đơn vị Module]

Bảng đánh giá và kiểm soát rủi ro kỹ thuật:

Rủi ro kỹ thuật Mức độ Biện pháp giảm thiểu
Trượt bước (Step loss) ở tải cao Cao Căn chỉnh $V_{\text{ref}}$ chuẩn trên DRV8825 theo công thức $I_{\text{max}} = V_{\text{ref}} \times 2$; thiết lập đường cong gia tốc S-curve.
Biến dạng quang học và sai số góc đặt camera Nghiêm trọng Sử dụng 4 mã Aruco Marker dán tại 4 góc vùng làm việc để tính toán ma trận biến đổi phối cảnh đồng phẳng (Perspective Transformation Matrix).
Độ trễ giao tiếp Serial giữa PC và MCU Trung bình Tối ưu hóa chuỗi ký tự truyền ngắn gọn, tốc độ truyền baudrate 115200 bps, sử dụng bộ đệm nhận ngắt vòng tròn (Ring Buffer).
Bề mặt chi tiết kim loại bị phản xạ ánh sáng Trung bình Sử dụng kỹ thuật chiếu sáng khuếch tán gián tiếp và cân bằng ngưỡng nhị phân thích nghi (Adaptive Thresholding).

Implementation và kết quả

Development Process & Core Algorithms

Quá trình phát triển phần mềm xử lý ảnh sử dụng Python 3.10 và OpenCV 4.8+. Dưới đây là các thuật toán nền tảng được trích xuất trực tiếp từ mã nguồn triển khai của dự án:

1. Thuật toán tự động hiệu chỉnh biến dạng phối cảnh bằng Aruco Markers

Để loại bỏ hiện tượng méo do ống kính và góc nghiêng camera, 4 Aruco markers thuộc từ điển DICT_6X6_250 được gắn cố định tại 4 góc bàn làm việc:

import cv2
import numpy as np

def calibrate_workspace_aruco(frame, target_width=600, target_height=600):
    """
    Tự động phát hiện 4 mã Aruco tại 4 góc và biến đổi ma trận Perspective
    """
    aruco_dict = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_6X6_250)
    parameters = cv2.aruco.DetectorParameters()
    detector = cv2.aruco.ArucoDetector(aruco_dict, parameters)
    
    corners, ids, _ = detector.detectMarkers(frame)
    if ids is not None and len(ids) >= 4:
        # Sắp xếp tọa độ tâm 4 Aruco theo thứ tự: Top-Left, Top-Right, Bottom-Right, Bottom-Left
        centers = {}
        for i, marker_id in enumerate(ids.flatten()):
            c = corners[i][0]
            center_x = int(np.mean(c[:, 0]))
            center_y = int(np.mean(c[:, 1]))
            centers[marker_id] = (center_x, center_y)
            
        # Giả định ID: 0 (TL), 1 (TR), 2 (BR), 3 (BL)
        pts_src = np.float32([centers[0], centers[1], centers[2], centers[3]])
        pts_dst = np.float32([[0, 0], [target_width, 0], [target_width, target_height], [0, target_height]])
        
        # Ma trận biến đổi đồng phẳng Homography
        matrix = cv2.getPerspectiveTransform(pts_src, pts_dst)
        warped = cv2.warpPerspective(frame, matrix, (target_width, target_height))
        return warped, matrix
    return frame, None

2. Trích xuất biên dạng, tính toán trọng tâm và so khớp đặc trưng hình học

Sử dụng toán tử lọc Canny, tìm đường bao đa giác và tính toán 7 bất biến moment Hu (Hu Moments) độc lập với tỉ lệ, phép tịnh tiến và phép quay:

def extract_object_features(warped_img):
    gray = cv2.cvtColor(warped_img, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    edges = cv2.Canny(blurred, threshold1=50, threshold2=150)
    
    # Giãn ảnh để liền mạch viền
    kernel = np.ones((3, 3), np.uint8)
    dilated = cv2.dilate(edges, kernel, iterations=1)
    
    contours, _ = cv2.findContours(dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    detected_objects = []
    
    for cnt in contours:
        area = cv2.contourArea(cnt)
        if 500 < area < 50000: # Lọc nhiễu theo diện tích
            # Xấp xỉ đa giác để giảm điểm lưu trữ
            epsilon = 0.02 * cv2.arcLength(cnt, True)
            approx = cv2.approxPolyDP(cnt, epsilon, True)
            
            # Trọng tâm đối tượng
            M = cv2.moments(cnt)
            if M["m00"] != 0:
                cx = int(M["m10"] / M["m00"])
                cy = int(M["m01"] / M["m00"])
            else:
                continue
                
            # Hộp giới hạn xoay (Min Area Bounding Box)
            rect = cv2.minAreaRect(cnt)
            angle = rect[-1]
            
            # Tính toán Hu Moments phục vụ Shape Matching
            hu_moments = cv2.HuMoments(M)
            # Log biến đổi để chuẩn hóa giá trị
            for i in range(7):
                hu_moments[i] = -1 * np.copysign(1.0, hu_moments[i]) * np.log10(np.abs(hu_moments[i]) + 1e-30)
                
            detected_objects.append({
                "center": (cx, cy),
                "angle": angle,
                "hu_moments": hu_moments,
                "contour": approx
            })
    return detected_objects

3. Điều khiển động cơ và Động học nghịch (Inverse Kinematics) trên Arduino

Vi điều khiển giải bài toán động học nghịch 2D cho hệ tay 2 khớp phẳng ($L_1, L_2$) và trục trượt $X$: $$X_w = X_{\text{rail}} + L_1 \cos(\theta_1) + L_2 \cos(\theta_1 + \theta_2)$$ $$Y_w = L_1 \sin(\theta_1) + L_2 \sin(\theta_1 + \theta_2)$$

// Trích xuất từ mã nguồn firmware điều khiển Arduino Mega 2560
#include <AccelStepper.h>

#define L1 140.0 // mm
#define L2 140.0 // mm

AccelStepper stepperRail(AccelStepper::DRIVER, 2, 3); // Trục X trượt
AccelStepper stepperJoint1(AccelStepper::DRIVER, 4, 5); // Khớp vai Theta 1
AccelStepper stepperJoint2(AccelStepper::DRIVER, 6, 7); // Khớp khuỷu Theta 2

void calculateIK_and_Move(float target_X, float target_Y, float target_Angle) {
    // Tối ưu hóa: Phân bổ tọa độ X cho Ray trượt để đưa vùng đích vào tầm với lý tưởng của Arm
    float rail_pos = target_X - 100.0; // Định vị cánh tay cách vật 100mm theo phương X
    if (rail_pos < 0) rail_pos = 0;
    
    float local_X = target_X - rail_pos;
    float local_Y = target_Y;
    
    float r = sqrt(local_X * local_X + local_Y * local_Y);
    if (r > (L1 + L2)) return; // Ngoài tầm với
    
    // Tính toán góc khớp qua định lý Cosine
    float cos_theta2 = (local_X * local_X + local_Y * local_Y - L1 * L1 - L2 * L2) / (2 * L1 * L2);
    float theta2 = acos(constrain(cos_theta2, -1.0, 1.0)); // Radian
    
    float k1 = L1 + L2 * cos(theta2);
    float k2 = L2 * sin(theta2);
    float theta1 = atan2(local_Y, local_X) - atan2(k2, k1);
    
    // Quy đổi góc sang Step (1.8 deg, 1/16 microstepping)
    long stepsRail = rail_pos * 80; // 80 steps/mm
    long stepsJ1 = (theta1 * 180.0 / PI) * (3200.0 / 360.0);
    long stepsJ2 = (theta2 * 180.0 / PI) * (3200.0 / 360.0);
    
    stepperRail.moveTo(stepsRail);
    stepperJoint1.moveTo(stepsJ1);
    stepperJoint2.moveTo(stepsJ2);
}

Testing và Validation

Hệ thống được thử nghiệm thực tế với 4 mẫu chi tiết cơ khí kim loại (S1: Hình chữ H, S2: Hình tròn có rãnh then, S3: Hình tam giác có lỗ định tâm, S4: Hình chữ nhật khuyết góc). Mỗi mẫu tiến hành 100 chu kỳ thử nghiệm ở các góc xoay và vị trí ngẫu nhiên trong vùng làm việc $400\times 300\text{ mm}$.

Bảng kết quả thử nghiệm định vị và nhận dạng chi tiết cơ khí:

Loại sản phẩm Số lần test Nhận diện đúng Tỉ lệ chính xác (%) Sai số tọa độ TB $\Delta X$ (mm) Sai số tọa độ TB $\Delta Y$ (mm) Thời gian chu kỳ TB (s)
Mẫu S1 100 98 98.0% $\pm 0.65$ $\pm 0.72$ $1.85$
Mẫu S2 100 97 97.0% $\pm 0.58$ $\pm 0.61$ $1.78$
Mẫu S3 100 95 95.0% $\pm 0.82$ $\pm 0.88$ $1.92$
Mẫu S4 100 96 96.0% $\pm 0.74$ $\pm 0.79$ $1.84$
Tổng thể / TB 400 386 96.5% $\pm 0.70$ $\pm 0.75$ 1.85 s/vật

Phân tích lỗi (Failure Analysis):

  • 14 lần nhận diện sai hoặc phân loại trượt (chiếm 3.5%) tập trung vào trường hợp phôi bị dính dầu mỡ gây lóa sáng cục bộ khiến đường bao contour bị đứt đoạn, dẫn đến sai lệch giá trị Hu Moments.

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

  1. Hiệu chỉnh tọa độ thời gian thực với 4-Aruco Marker: Thay vì cố định camera và phụ thuộc vào ma trận bàn cờ tĩnh (Checkerboard Camera Calibration) dễ bị lệch khi rung lắc cơ khí, đề tài áp dụng cơ chế tự thích nghi phối cảnh qua 4 điểm mốc Aruco. Khi camera bị lệch nhẹ, hệ thống tự động bù sai lệch hình học mà không cần hiệu chỉnh lại toàn bộ hệ thống.
  2. Cấu trúc lai (Hybrid Kinematics) 3-DOF Robot + Linear Slider: Tối ưu hóa chi phí khi mở rộng không gian làm việc theo phương ngang lên gấp 3 lần (hành trình ray trượt 600mm) mà chỉ sử dụng cơ cấu 3 bậc tự do đơn giản, giảm tải tính toán động học nghịch so với cánh tay 6-DOF công nghiệp đắt đỏ.
  3. So khớp hình học cải tiến bằng Hu Moments kết hợp xấp xỉ biên: Giảm thời gian xử lý ảnh từ $120\text{ ms}$ (đối với phương pháp so mẫu truyền thống Template Matching) xuống chỉ còn $18\text{ ms/frame}$, cho phép camera chạy mượt mà ở tốc độ 30 FPS.
So sánh hiệu suất trích xuất đặc trưng:
- Template Matching:        ████████████████████ 120 ms (Kém linh hoạt với góc xoay)
- Deep Learning (YOLOv5s):  ██████ 35 ms (Cần GPU đắt tiền)
- Hu Moments + PolyDP (Đề tài): ███ 18 ms (Chạy mượt trên CPU i3)

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

Kịch bản ứng dụng trong sản xuất công nghiệp

  • Cấp phôi tự động cho máy CNC/Dập: Tự động nhận diện hướng đặt của phôi kim loại trên bàn cấp liệu không định hướng, điều khiển giác hút gắp và xoay đúng chiều nạp vào khuôn máy gia công.
  • Phân loại linh kiện trên băng chuyền đóng gói: Ứng dụng trong các nhà máy sản xuất phụ tùng xe máy, ô tô, linh kiện điện tử gia dụng để loại bỏ lỗi dị vật và phân luồng sản phẩm tự động.

Yêu cầu triển khai hạ tầng & Đánh giá hiệu quả kinh tế (ROI)

  • Hạ tầng lắp đặt: Khung nhôm định hình $30\times 30\text{ mm}$, nguồn điện 1 pha 220V/50Hz, camera lắp vuông góc với mặt phẳng làm việc ở độ cao $450 - 550\text{ mm}$, hệ thống đèn LED Ring ánh sáng trắng 6500K khử bóng sườn.
  • Chi phí dự toán phần cứng: ~6.500.000 VNĐ (Bao gồm động cơ, driver, ATmega2560, vật liệu in 3D/khung nhôm, camera, hệ khí nén).
  • Phân tích ROI: So với việc thuê 1 nhân công phân loại chi phí 7.500.000 VNĐ/tháng, hệ thống giúp doanh nghiệp thu hồi vốn chỉ trong vòng dưới 2 tháng hoạt động.

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

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

  • Hệ thống chỉ xử lý hình ảnh 2 chiều trong mặt phẳng, chưa phân loại được các vật thể có chiều cao biến thiên phức tạp hoặc các chi tiết xếp chồng lên nhau (Overlapping objects).
  • Cơ cấu giác hút chân không chỉ phát huy tối đa lực bám trên các bề mặt phẳng, nhẵn; hạn chế đối với vật thể có bề mặt gồ ghề, dạng lưới hoặc có nhiều lỗ thủng lớn.

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

  1. Tích hợp mô hình thị giác học sâu (Deep Learning) như YOLOv8-Oriented Bounding Box (OBB) để phát hiện và phân loại các chi tiết bị che khuất hoặc thay đổi điều kiện ánh sáng mạnh.
  2. Nâng cấp cánh tay robot lên chuẩn công nghiệp 4-DOF SCARA hoặc Delta Robot tốc độ cao kết hợp thuật toán bám băng tải động (Conveyor Tracking with Rotary Encoder).
  3. Bổ sung cảm biến đo áp suất chân không kỹ thuật số để giám sát thời gian thực trạng thái phôi đã được hút dính chắc chắn hay chưa, tăng cường độ an toàn công nghiệp.

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

  • Sinh viên & Học viên chuyên ngành: Nắm bắt trọn vẹn quy trình xây dựng đồ án tích hợp liên ngành Cơ điện tử - Xử lý ảnh - Tự động hóa từ phần cứng đến thuật toán phần mềm thực tế.
  • Kỹ sư R&D & Lập trình viên nhúng: Tham khảo mô hình truyền thông đồng bộ UART giữa Python Vision và Firmware C++ vi điều khiển, kỹ thuật giải động học nghịch kết hợp ray trượt tuyến tính.
  • Doanh nghiệp vừa và nhỏ (SMEs): Có giải pháp tự động hóa khâu phân loại phôi với chi phí cực thấp, dễ dàng bảo trì và linh hoạt tùy biến khi đổi mẫu sản phẩm cơ khí.

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

1. Hệ thống có yêu cầu máy tính cấu hình cao hoặc GPU chuyên dụng không?
Không. Toàn bộ thuật toán xử lý ảnh sử dụng các hàm toán tử cơ bản của OpenCV (Canny, Dilate, Hu Moments) được tối ưu hóa bằng ngôn ngữ C++ dưới lõi, do đó máy tính văn phòng sử dụng CPU thông thường (Intel Core i3 thế hệ 8 hoặc tương đương, 4GB RAM) đã có thể xử lý trơn tru ở tốc độ 30 FPS.

2. Làm thế nào để hệ thống thích ứng khi thay đổi loại sản phẩm cơ khí mới?
Người vận hành chỉ cần đưa mẫu sản phẩm mới vào vùng quan sát của camera, chụp ảnh trích xuất 7 tham số Hu Moments và lưu vào tệp cấu hình config.json. Không cần phải thiết kế lại phần cứng hay lập trình lại firmware vi điều khiển.

3. Cơ chế chống trượt bước của động cơ bước NEMA 17 được thực hiện như thế nào?
Hệ thống sử dụng driver DRV8825 được cân chỉnh điện áp $V_{\text{ref}} = 0.85\text{ V}$ (tương ứng dòng đỉnh $1.7\text{ A}$ phù hợp cuộn dây), kết hợp cài đặt gia tốc khởi động (Acceleration Profile) trên thư viện AccelStepper nhằm triệt tiêu hiện tượng giật cục do quán tính cơ khí.

4. Tại sao lại chọn giác hút chân không thay vì kẹp gắp cơ khí (Gripper)?
Giác hút chân không cho phép tiếp cận chi tiết kim loại dạng tấm phẳng từ phía trên mà không cần khoảng không gian hở hai bên như kẹp cơ khí, giúp gắp được các chi tiết đặt sát nhau trong khay nạp và không gây xước bề mặt gia công chính xác.

5. Sai số định vị $\pm 0.7\text{ mm}$ đến từ những yếu tố nào và cách cải thiện?
Sai số bao gồm: Độ phân giải pixel của camera (~$0.3\text{ mm/pixel}$ ở độ cao 500mm), độ rơ của dây đai răng GT2 và sai số biến dạng in 3D của các khớp nối cánh tay. Có thể cải thiện bằng cách sử dụng ray trượt vitme bi công nghiệp và nâng cấp camera độ phân giải 4K.

Kết luận

Đề tài "Thiết kế mô hình hệ thống phân loại sản phẩm ứng dụng thị giác máy và cánh tay robot" đã giải quyết trọn vẹn bài toán tự động hóa phân loại chi tiết cơ khí đầu vào với độ chính xác nhận dạng đạt $96.5%$, tốc độ phân loại $1.85\text{ s/sản phẩm}$ và sai số cơ khí trong phạm vi cho phép ($\le \pm 0.75\text{ mm}$).

Sự kết hợp đồng bộ giữa thị giác máy linh hoạt (OpenCV, Aruco Marker, Hu Moments) và cơ cấu cơ điện tử vững chắc (3-DOF Robot Arm, Ray trượt tuyến tính, ATmega2560, Khí nén chân không) khẳng định tính khả thi cao trong việc chuyển giao và ứng dụng thực tế tại các xưởng sản xuất cơ khí chính xác quy mô vừa và nhỏ. Đây là nền tảng kỹ thuật vững chắc để tiếp tục nâng cấp lên các hệ thống phân loại thông minh tích hợp trí tuệ nhân tạo (AI) và robot cộng tác (Cobot) trong tương lai.