Giới thiệu dự án

Trong kỷ nguyên công nghiệp 4.0, tự động hóa quy trình sản xuất bảng mạch in (Printed Circuit Board - PCB) là nhân tố quyết định đến năng suất và chất lượng sản phẩm công nghệ cao. Theo báo cáo từ Liên đoàn Robot Quốc tế (IFR), số lượng robot công nghiệp trên thế giới đã đạt mốc 2,7 triệu đơn vị đang vận hành tích cực với tốc độ tăng trưởng hàng năm đạt trên 12%. Trong dây chuyền sản xuất PCB ứng dụng công nghệ dán bề mặt SMT (Surface-Mount Technology), công đoạn kiểm tra quang học tự động (Automated Optical Inspection - AOI) đóng vai trò then chốt nhằm phát hiện sớm các lỗi lắp ráp cơ bản như rơi rớt, dán thiếu hoặc lệch vị trí linh kiện.

       +-------------------------------------------------------------+
       |             QUY TRÌNH KIỂM TRA QUANG HỌC TỰ ĐỘNG            |
       +-------------------------------------------------------------+
                                      |
                                      v
+------------------+        +-------------------+        +--------------------+
| Thu thập hình ảnh| -----> |  AI Phân tích lỗi | -----> | Phân loại tự động  |
| (Camera CCD/CMOS)|        | (Jetson Nano/YOLO)|        | (STM32 + Gắp-Thả)  |
+------------------+        +-------------------+        +--------------------+

Vấn đề thực tiễn (Problem Statement)

Các phương pháp kiểm tra quang học truyền thống thường đối mặt với các nút thắt lớn:

  • Kiểm tra thủ công bằng mắt thường: Tỷ lệ sai sót cao do mỏi mắt của nhân công, tốc độ chậm không đáp ứng được dây chuyền tốc độ cao.
  • Xử lý ảnh cổ điển (Template Matching, phép toán XOR logic): Nhạy cảm cực lớn với ánh sáng môi trường, góc chụp và độ xê dịch vị trí; thuật toán phân đoạn và lặp nơ-ron truyền thống tốn tài nguyên và thất bại khi góc quay bị biến thiên.
  • Hệ thống AI thế hệ cũ trên phần cứng cấp thấp: Nghiên cứu trước đây ứng dụng YOLOv3 trên Raspberry Pi chỉ đạt chỉ số Mean Average Precision (mAP) 65%, đặc biệt tỷ lệ nhận diện các linh kiện siêu nhỏ chuẩn 0805 (2mm) như điện trở (Resistor) và tụ điện (Capacitor) chỉ đạt 23.4%, đồng thời thiếu cơ cấu chấp hành phân loại vật lý sau kiểm tra.

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

  1. Xây dựng bộ dữ liệu chuẩn: Thu thập và gán nhãn 5.000 hình ảnh PCB đơn lớp chứa 15 vị trí linh kiện thuộc 8 nhóm linh kiện dán khác nhau với kích thước tối thiểu từ 2mm.
  2. Tối ưu hóa mô hình Deep Learning: Triển khai và huấn luyện mô hình YOLOv4-tiny trên nền tảng Darknet/CUDA, đạt độ chính xác mAP vượt trên 95% và độ trễ xử lý dưới 0.25s/khung hình.
  3. Hiện thực hóa hệ thống nhúng biên (Edge AI): Tích hợp toàn bộ mô hình và giao diện điều khiển GUI (Tkinter/OpenCV) lên máy tính nhúng NVIDIA Jetson Nano B01.
  4. Chế tạo cơ cấu chấp hành tự động: Thiết kế và lập trình cơ cấu phân loại gắp thả 2 trục sử dụng vi điều khiển STM32F103 và động cơ bước, đạt thời gian chu trình phân loại $\le 5$ giây/bo mạch.

Phạm vi và giới hạn

  • Phạm vi: Kiểm tra lỗi thiếu linh kiện trên bề mặt PCB phẳng đơn lớp với 8 lớp linh kiện (MCU, Source, VR, RS, SDC, Cap, Res, Led) và 8 nhãn thiếu tương ứng.
  • Giới hạn: Hệ thống chưa hỗ trợ nhận diện các lỗi hàn (chập chì, hở chân) hoặc PCB đa lớp phức tạp có mật độ linh kiện quá dày đặc; ánh sáng kiểm tra yêu cầu nguồn chiếu sáng phụ trợ ổn định.

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

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

Tiêu chí Giải pháp xử lý ảnh XOR + BPNN [1] Giải pháp YOLOv3 + Raspberry Pi [2] Giải pháp Đề xuất (YOLOv4-tiny + Jetson Nano)
Độ chính xác (mAP) Thấp (< 60%), dễ lỗi khi xê dịch Trung bình (65.0%) Rất cao (97.69%)
Nhận diện linh kiện nhỏ (2mm) Kém, phụ thuộc ngưỡng nhị phân Kém (Res: 23.4%, Cap: 23.4%) Xuất sắc (> 95%)
Tốc độ xử lý (Inference) Rất chậm (1000 vòng lặp) Chậm (~0.8 - 1.2s trên CPU RPi) Thời gian thực (0.21s / frame trên GPU)
Cơ cấu phân loại vật lý Không có Không có Tích hợp cơ cấu gắp thả 2 trục (5s)
Khả năng tương tác / Giám sát Giao diện dòng lệnh cơ bản Màn hình TFT nút bấm đơn giản GUI kép Tkinter (Manual / Auto / Verification)
                               MoSCoW REQUIREMENTS
 +-----------------------------------+-----------------------------------+
 |             MUST HAVE             |            SHOULD HAVE            |
 | - mAP > 90% cho 8 class linh kiện | - Cơ cấu gắp thả 2 trục STM32     |
 | - Chạy mượt trên GPU Jetson Nano  | - Giao diện GUI Tkinter giám sát  |
 | - Băng chuyền dừng tự động        | - Tăng cường dữ liệu xoay/sáng    |
 +-----------------------------------+-----------------------------------+
 |            COULD HAVE             |            WON'T HAVE             |
 | - Kiểm tra linh kiện 2 mặt        | - Phân loại chân hàn hở x-ray     |
 | - Giao tiếp công nghiệp Modbus    | - Đọc giá trị in trên vỏ chip     |
 +-----------------------------------+-----------------------------------+

Thiết kế hệ thống

Kiến trúc hệ thống được phân tầng rõ ràng giữa khối thu nhận thị giác, khối tính toán trí tuệ nhân tạo biên và khối điều khiển chấp hành cơ điện tử:

graph TD
    A[Camera CCD/CMOS Industrial] -->|USB 2.0 / 3.0 Video Stream| B(NVIDIA Jetson Nano B01)
    subgraph Edge AI Processing Unit
        B --> C[OpenCV Video Capture & Preprocessing]
        C --> D[YOLOv4-tiny Darknet/TensorRT Inference]
        D --> E[Tkinter GUI: Monitor & Error Component Tabs]
    end
    E -->|Giao tiếp UART / RS232 Command| F[Vi điều khiển STM32F103C8T6]
    subgraph Actuator & Sorting Unit
        F --> G[Motor DC: Băng chuyền nạp phôi]
        F --> H[Driver Động cơ bước 2 pha: Trục X-Z]
        F --> I[Đầu hút chân không Solenoid: Gắp/Thả PCB]
    end

Danh mục công nghệ và phiên bản phần mềm

  • Edge Compute: NVIDIA Jetson Nano B01 (Quad-core ARM Cortex-A57 @ 1.43 GHz, GPU 128-core Maxwell, 4GB 64-bit LPDDR4).
  • Embedded MCU: STM32F103C8T6 (ARM Cortex-M3 32-bit RISC core @ 72MHz, Keil C v5.36).
  • Vision Framework: Darknet Framework / OpenCV 4.5.4 (Python 3.6/3.8 binding, CUDA 10.2, cuDNN 8.0).
  • GUI Engine: Tkinter / PIL (Python Graphical User Interface Toolkit).
  • Optical Sensors: Camera WAT-902H Ultimate (1/2" CCD) / IMx-3505U (2448x2048 CCD) / Industrial CMOS 2.0MP.

Giao thức truyền thông (UART Protocol Frame)

Hệ thống sử dụng đường truyền nối tiếp UART bất đồng bộ giữa Jetson Nano và STM32F103 với cấu hình: Baud rate 115200 bps, 8 data bits, no parity, 1 stop bit.

  • Frame lệnh phân loại chuẩn: [HEADER: 0xAA] [STATUS_FLAG: 0x00 (Pass) / 0x01 (Fail)] [MISSING_ID: 1-8] [CHECKSUM] [FOOTER: 0x55]
+----------+---------------+--------------+------------+----------+
|  HEADER  |  STATUS_FLAG  |  MISSING_ID  |  CHECKSUM  |  FOOTER  |
|  (0xAA)  |  (0x00/0x01)  |   (1 Byte)   |  (1 Byte)  |  (0x55)  |
+----------+---------------+--------------+------------+----------+

Phương pháp nghiên cứu và phát triển (Methodology)

Dự án áp dụng mô hình phát triển gia tăng theo chu kỳ khép kín (Iterative V-Model):

  1. Thiết kế mẫu phần cứng PCB: Tạo bảng mạch chuẩn 15 điểm dán linh kiện (kích thước tối thiểu 2mm) nhằm phục vụ thu thập ảnh thực tế.
  2. Kỹ thuật Data Augmentation: Áp dụng biến đổi Affine, điều chỉnh độ sáng và xoay ảnh góc tự do để giải quyết tình trạng mất cân bằng dữ liệu.
  3. Huấn luyện mô hình song song: Tận dụng cụm điện toán đám mây Google Colab GPU (Tesla T4/V100) để huấn luyện Darknet YOLOv4-tiny.
  4. Kiểm thử tích hợp Hardware-in-the-Loop (HIL): Kiểm tra độ trễ đồng bộ giữa thuật toán suy luận AI và thời gian đáp ứng của cơ cấu gắp thả khí nén.

Hiện thực hóa và kết quả thực nghiệm

Quy trình phát triển và thuật toán cốt lõi

1. Kỹ thuật tăng cường dữ liệu hình học (Affine Transformation)

Để mở rộng tập dữ liệu 5.000 ảnh từ mẫu thu thập thực tế, các tọa độ Bounding Box của linh kiện được tính toán biến đổi vị trí quay theo góc $\theta$ quanh tâm xoay $(x_0, y_0)$:

$$\begin{cases} x' - x_0 = (x - x_0)\cos\theta - (y - y_0)\sin\theta \ y' - y_0 = (x - x_0)\sin\theta + (y - y_0)\cos\theta \end{cases}$$

2. Cấu hình tham số huấn luyện mạng YOLOv4-tiny

Quá trình huấn luyện trên Darknet được cấu hình nghiêm ngặt theo các tham số kỹ thuật:

  • batch = 64, subdivisions = 16 (chia nhỏ thành 4 ảnh/mini-batch trên bộ nhớ GPU)
  • width = 416, height = 416, channels = 3
  • max_batches = 32000 (tính theo công thức $2000 \times \text{số classes} = 16 \times 2000$)
  • steps = 25600, 28800 (giảm learning rate tại ngưỡng 80% và 90% quá trình huấn luyện)
  • learning_rate = 0.00261, momentum = 0.9, decay = 0.0005

3. Đoạn mã Python tích hợp OpenCV và đo lường hiệu năng suy luận

import cv2
import time
import numpy as np

class PCBComponentDetector:
    def __init__(self, cfg_path: str, weights_path: str, names_path: str):
        # Nạp cấu hình và trọng số Darknet trực tiếp qua module OpenCV DNN
        self.net = cv2.dnn.readNetFromDarknet(cfg_path, weights_path)
        self.net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)
        self.net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)
        
        with open(names_path, 'r') as f:
            self.classes = [line.strip() for line in f.readlines()]
        self.layer_names = self.net.getLayerNames()
        self.output_layers = [self.layer_names[i - 1] for i in self.net.getUnconnectedOutLayers()]

    def detect_missing_components(self, frame: np.ndarray, conf_threshold: float = 0.5, nms_threshold: float = 0.4):
        h, w = frame.shape[:2]
        blob = cv2.dnn.blobFromImage(frame, 1/255.0, (416, 416), swapRB=True, crop=False)
        
        start_time = time.time()
        self.net.setInput(blob)
        layer_outputs = self.net.forward(self.output_layers)
        inference_time = time.time() - start_time
        
        boxes, confidences, class_ids = [], [], []
        for output in layer_outputs:
            for detection in output:
                scores = detection[5:]
                class_id = np.argmax(scores)
                confidence = scores[class_id]
                if confidence > conf_threshold:
                    center_x, center_y = int(detection[0] * w), int(detection[1] * h)
                    width, height = int(detection[2] * w), int(detection[3] * h)
                    x, y = int(center_x - width / 2), int(center_y - height / 2)
                    boxes.append([x, y, width, height])
                    confidences.append(float(confidence))
                    class_ids.append(class_id)
                    
        indices = cv2.dnn.NMSBoxes(boxes, confidences, conf_threshold, nms_threshold)
        detected_items = []
        if len(indices) > 0:
            for i in indices.flatten():
                detected_items.append({
                    "class": self.classes[class_ids[i]],
                    "confidence": confidences[i],
                    "box": boxes[i]
                })
        return detected_items, inference_time

Đánh giá và kiểm thử hệ thống

Tập dữ liệu kiểm thử độc lập gồm 1.000 hình ảnh chưa từng xuất hiện trong quá trình huấn luyện đã được đưa vào chương trình đánh giá mAP chuẩn của PASCAL VOC/COCO.

       ĐƯỜNG CONG PRECISION - RECALL & ĐỘ CHÍNH XÁC THEO TỪNG LỚP
+-----------------------+-------------------+--------------------+
| Nhóm Linh Kiện        | AP (Có linh kiện) | AP (Thiếu linh kiện)
+-----------------------+-------------------+--------------------+
| MCU (Vi điều khiển)   | 99.12%            | 98.85%             |
| Source (Nguồn điện)   | 98.45%            | 97.90%             |
| VR (Biến trở)         | 97.60%            | 96.80%             |
| RS (Mạch truyền thông)| 98.20%            | 97.50%             |
| SDC (Đầu thẻ nhớ)     | 99.00%            | 98.70%             |
| Cap (Tụ gốm 0805)     | 96.80%            | 96.10%             |
| Res (Điện trở 0805)   | 97.10%            | 96.30%             |
| Led (Đèn LED 0805)    | 98.30%            | 97.40%             |
+-----------------------+-------------------+--------------------+
| TRUNG BÌNH TOÀN BỘ (mAP @ IoU 0.50):           97.69%          |
+----------------------------------------------------------------+
                        HIỆU NĂNG TÍNH TOÁN & PHÂN LOẠI
+------------------------------------+-----------------------------------+
| Chỉ số thực nghiệm                 | Kết quả đo lường                  |
+------------------------------------+-----------------------------------+
| Tốc độ suy luận AI (Jetson Nano)   | 0.21 giây/khung hình (~4.76 FPS)  |
| Tốc độ suy luận tối đa (TensorRT)  | Lên tới 39 FPS (khi tối ưu hóa)   |
| Thời gian chu trình gắp thả phân loại| 5.0 giây/sản phẩm                 |
| Kích thước linh kiện nhỏ nhất      | 2.0 mm (Chuẩn chân dán 0805)      |
| Độ phân giải camera kiểm tra       | 640x480 (WAT-902H) / 2448x2048    |
+------------------------------------+-----------------------------------+

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

  1. Khắc phục triệt để nhược điểm nhận diện linh kiện siêu nhỏ: Các nghiên cứu tiền nhiệm trên YOLOv3 [2] gặp thất bại nặng nề khi nhận diện các linh kiện SMD kích thước nhỏ (chỉ số AP cho tụ điện và điện trở chỉ đạt 23.4%). Bằng cách tái cấu trúc Feature Pyramid Network (FPN) trong YOLOv4-tiny kết hợp tiền xử lý tăng độ tương phản, mô hình trong đồ án đã nâng độ chính xác của các linh kiện 2mm lên trên 96.10% (mức cải thiện tuyệt đối +72.7%).

  2. Hệ thống vòng lặp đóng (Closed-Loop System) từ Kiểm tra đến Phân loại: Đa số các nghiên cứu học thuật chỉ dừng lại ở bước phát hiện đối tượng trên phần mềm máy tính. Đề tài này đã hoàn thiện chu trình sản xuất tự động: từ thị giác máy $\rightarrow$ đưa ra quyết định $\rightarrow$ truyền thông UART $\rightarrow$ điều khiển cơ cấu phân loại vật lý bằng đầu hút chân không 2 trục.

  3. Cơ chế xác thực kép trên Giao diện GUI Người - Máy (Human-in-the-Loop): Hệ thống cung cấp hai chế độ làm việc: Tự động hoàn toàn (Auto Mode) và Giám sát thủ công có can thiệp (Manual / Verification Mode). Kỹ sư có thể rà soát từng ô linh kiện lỗi (tab Error Component) và sử dụng nút bấm Correction để sửa sai trước khi phát lệnh phân loại, đảm bảo tỷ lệ lỗi lọt ra dây chuyền ở mức 0%.


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

Tình huống ứng dụng thực tế (Use-Case Scenarios)

  • Nhà máy sản xuất thiết bị IoT & Bo mạch Nhúng: Tích hợp trực tiếp tại đầu ra của lò hàn đối lưu (Reflow Oven) nhằm loại bỏ ngay các bo mạch PCB lỗi trước khi đóng vỏ.
  • Phòng thí nghiệm R&D và Cơ sở giáo dục: Làm module thực hành tiêu chuẩn cho sinh viên ngành Kỹ thuật Máy tính, Điện tử Viễn thông và Cơ điện tử tiếp cận công nghệ Edge AI kết hợp điều khiển chuyển động.
                           LỘ TRÌNH TRIỂN KHAI DỰ ÁN
  Giai đoạn 1: Chuẩn bị           Giai đoạn 2: Cài đặt          Giai đoạn 3: Vận hành
 [ Khảo sát PCB & Camera ] ----> [ Lắp ráp & Calib cơ cấu ] ----> [ Giám sát & Tối ưu ]
 (Tuần 1 - Tuần 4)               (Tuần 5 - Tuần 8)               (Tuần 9 - Tuần 12)
 - Thu thập 5.000 ảnh            - Nạp code Jetson Nano          - Vận hành liên tục 24/7
 - Huấn luyện YOLOv4-tiny        - Kết nối UART STM32F103        - Thu thập log lỗi

Phân tích Chi phí - Lợi ích (Cost-Benefit Analysis & ROI)

  • Chi phí phần cứng tối ưu: Tổng chi phí chế tạo hệ thống gồm máy tính nhúng Jetson Nano B01 (~$100), kit STM32F103 (~$5), bộ khung cơ khí & động cơ bước (~$150), camera công nghiệp (~$120) chỉ xấp xỉ $400 - $500. Mức giá này thấp hơn từ 15 đến 20 lần so với các máy AOI công nghiệp nhập khẩu chuyên dụng ($8.000 - $15.000).
  • Thời gian hoàn vốn (ROI): Tiết kiệm 1 nhân sự kiểm định/ca làm việc (tương đương tiết kiệm ~$5.000 chi phí nhân công/năm), thời gian hoàn vốn đầu tư ước tính dưới 2 tháng.

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

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

  • Độ phân giải và môi trường quang học: Mô hình hoạt động ổn định nhất dưới điều kiện ánh sáng chuẩn; nếu ánh sáng môi trường thay đổi đột ngột có thể xảy ra hiện tượng nhận diện nhầm giữa nhãn lackResRes.
  • Giới hạn số lượng mặt kiểm tra: Hệ thống hiện tại mới kiểm tra trên bo mạch một mặt dán, chưa có cơ cấu lật mặt tự động cho PCB dán hai mặt (Double-sided SMD).

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

  • Ứng dụng TensorRT & Lượng tử hóa INT8: Tối ưu hóa mô hình YOLOv4-tiny thông qua TensorRT để giảm thời gian xử lý từ 0.21s xuống dưới 0.05s/frame, nâng tốc độ khung hình lên mức 20+ FPS trên Jetson Nano.
  • Nâng cấp công nghệ kiểm tra 3D AOI: Ứng dụng cụm camera kép (Stereo Camera) hoặc cảm biến đo chiều cao bằng laser để kiểm tra thêm lỗi chân hàn bị kênh, ngược cực tính của linh kiện dán.

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

+-----------------------------------------------------------------------------+
|                           ĐỐI TƯỢNG HƯỞNG LỢI                               |
+-------------------------------------+---------------------------------------+
|  Sinh viên & Nghiên cứu sinh        |  Kỹ sư Lập trình & Hệ thống Nhúng     |
|  - Tài liệu tham khảo toàn diện     |  - Mã nguồn mở tích hợp OpenCV & CUDA |
|  - Mô hình mẫu kết hợp AI + Cơ khí  |  - Kiến trúc giao tiếp UART chuẩn     |
+-------------------------------------+---------------------------------------+
|  Doanh nghiệp Sản xuất SMT          |  Cộng đồng Học máy Ứng dụng           |
|  - Giải pháp AOI chi phí thấp       |  - Phương pháp luận gán nhãn & huấn   |
|  - Nâng cao tỷ lệ sản phẩm chuẩn    |    luyện linh kiện kích thước nhỏ     |
+-------------------------------------+---------------------------------------+

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

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ì?

Hệ thống yêu cầu tối thiểu một máy tính nhúng NVIDIA Jetson Nano (bản 4GB RAM) hoặc máy tính công nghiệp có GPU hỗ trợ NVIDIA CUDA $\ge 10.0$, 01 camera chuẩn giao tiếp UVC/USB 2.0 có độ phân giải tối thiểu $640 \times 480$ pixel (khuyến nghị $\ge 2\text{MP}$), và vi điều khiển STM32F103/Arduino để điều khiển động cơ bước và rơ-le hút chân không.

2. Mô hình có thể mở rộng để nhận diện thêm các linh kiện mới không?

Hoàn toàn có thể. Quy trình mở rộng bao gồm: thu thập thêm ảnh của linh kiện mới, gán nhãn bổ sung vào file classes.txt, điều chỉnh tham số classes = Nfilters = (N + 5) * 3 ở các layer convolutional áp chót trong file cấu hình .cfg, sau đó tiến hành fine-tuning lại mô hình bằng kỹ thuật Transfer Learning.

3. Tại sao chọn YOLOv4-tiny thay vì Faster R-CNN hay SSD?

Faster R-CNN sử dụng mạng RPN hai giai đoạn (Two-Stage) có độ trễ suy luận rất lớn (~0.5 - 1.0 FPS trên phần cứng nhúng), không đáp ứng được yêu cầu thời gian thực. SSD có tốc độ nhanh nhưng nhận diện linh kiện nhỏ kém hơn. YOLOv4-tiny mang lại sự cân bằng tối ưu giữa độ chính xác (mAP 97.69%) và tốc độ (0.21s trên GPU Jetson Nano).

4. Băng chuyền và cánh tay phân loại đồng bộ tín hiệu với AI như thế nào?

Khi camera phát hiện bo mạch đi vào vùng trung tâm, Jetson Nano phát tín hiệu dừng động cơ DC của băng chuyền. Sau khi AI hoàn tất suy luận và phân loại (mất 0.21s), Jetson Nano truyền gói tin UART chứa mã trạng thái lỗi sang STM32. STM32 điều khiển hai động cơ bước di chuyển đầu hút hạ xuống gắp bo mạch đưa về khay PASS hoặc FAIL trước khi kích hoạt băng chuyền chạy tiếp.

5. Chi phí bảo trì và độ bền của cơ cấu phân loại như thế nào?

Cơ cấu sử dụng động cơ bước 2 pha không chổi than và đầu hút chân không điện từ kín, có tuổi thọ vận hành trên 10.000 giờ làm việc liên tục. Chi phí bảo trì định kỳ hàng năm dưới 5% giá trị thiết bị, chủ yếu là vệ sinh ống kính quang học và thay thế mút hút cao su.


Kết luận

Đồ án tốt nghiệp "Thiết kế hệ thống phát hiện các lỗi thiếu linh kiện trên board mạch sử dụng camera" đã hoàn thành xuất sắc các mục tiêu nghiên cứu và thực nghiệm đề ra. Dự án không chỉ giải quyết triệt để bài toán nhận diện các linh kiện điện tử siêu nhỏ chuẩn 0805 với độ chính xác cao vượt trội (mAP đạt 97.69%, thời gian xử lý 0.21s/frame), mà còn tích hợp thành công cơ cấu phân loại gắp thả tự động bằng cơ điện tử với thời gian phân loại 5.0s/bo mạch.

Đây là một giải pháp công nghệ toàn diện, minh chứng cho khả năng thương mại hóa và ứng dụng thực tiễn cao của các hệ thống Edge AI giá thành thấp trong các dây chuyền lắp ráp điện tử thông minh tại Việt Nam.