Giới thiệu dự án

Bối cảnh thị trường và vấn đề thực tế

Thị trường bán lẻ Việt Nam đang trải qua giai đoạn chuyển mình mạnh mẽ với tốc độ tăng trưởng kép hàng năm ấn tượng. Năm 2022, tổng mức bán lẻ hàng hóa và doanh thu dịch vụ tiêu dùng cả nước đạt xấp xỉ 5.680 nghìn tỷ đồng (~246 tỷ USD), tăng 19,8% so với năm 2021. Dự báo từ Bộ Công Thương cho thấy quy mô thị trường sẽ sớm cán mốc 350 tỷ USD vào năm 2025 với sự mở rộng quy mô lớn từ các tập đoàn bán lẻ quốc tế và nội địa như Central Retail (đầu tư 20.000 tỷ đồng) và Aeon Mall.

+-----------------------------------------------------------------------------------+
|                           THỰC TRẠNG THANH TOÁN BÁN LẺ                            |
+-----------------------------------------------------------------------------------+
|  Hàng hóa có bao bì   --> Quét mã vạch EAN/UPC  --> Tốc độ: 1-2 giây / món        |
|  Nông sản, thực phẩm  --> Tra mã PLU thủ công   --> Tốc độ: 8-15 giây / món       |
|                           (Dễ nhầm lẫn, phụ thuộc trí nhớ thu ngân)               |
+-----------------------------------------------------------------------------------+

Tuy nhiên, nút thắt lớn nhất trong quy trình vận hành POS (Point of Sale) tại các siêu thị hiện nay nằm ở nhóm hàng hóa tươi sống (rau, củ, quả, thịt, thủy hải sản). Đây là các mặt hàng không thể dán sẵn mã vạch (Barcode/QR Code) cố định do biến động về trọng lượng và đặc tính bề mặt. Thu ngân buộc phải ghi nhớ hàng trăm mã PLU (Price Look-Up) hoặc tra cứu thủ công trên phần mềm, sau đó đặt lên cân riêng biệt. Quy trình này chiếm tới 35–45% tổng thời gian chờ tại quầy thu ngân, dẫn đến tình trạng ùn tắc vào giờ cao điểm, gia tăng tỷ lệ sai sót tài chính và đẩy chi phí đào tạo nhân sự lên cao.

Mục tiêu dự án

  1. Thiết kế khối đo tải trọng chính xác cao: Tích hợp cảm biến Loadcell và module chuyển đổi ADC 24-bit HX711, điều khiển thông qua vi điều khiển Arduino Nano, đảm bảo sai số đo lường $< 0.1%$ trên dải đo từ 0 đến 40kg.
  2. Xây dựng mô hình Computer Vision nhúng: Triển khai mạng nơ-ron tích chập MobileNetV2 tối ưu hóa cho phần cứng biên, nhận diện chính xác các loại nông sản trong khoảng cách $0.2\text{m} - 0.4\text{m}$.
  3. Phát triển giao diện quản lý và thanh toán trực quan: Xây dựng ứng dụng GUI bằng Python và PyQt5 trên hệ điều hành Linux (Raspbian), hiển thị hình ảnh thời gian thực, kết quả Top-3 phân loại xác suất cao nhất, trọng lượng tức thời và tự động tính tiền.
  4. Đồng bộ hóa hệ thống nhúng phân tán: Thiết lập giao thức truyền thông Serial (UART) tốc độ cao giữa Arduino Nano và vi xử lý trung tâm Raspberry Pi 4 Model B (Broadcom BCM2711), tối ưu hóa độ trễ phản hồi toàn hệ thống dưới 500ms.

Phương pháp tiếp cận và kết quả kỳ vọng

Dự án áp dụng mô hình điện toán biên (Edge AI) kết hợp kiến trúc phần cứng lai (Dual-MCU Hybrid Architecture). Thay vì đẩy dữ liệu hình ảnh lên Cloud Server gây phụ thuộc vào băng thông mạng và tiềm ẩn độ trễ, toàn bộ tiến trình xử lý từ trích xuất đặc trưng hình ảnh đến tính toán trọng lượng đều được thực thi trực tiếp tại trạm POS cục bộ.

  • Chỉ số đo lường kỳ vọng:
    • Thời gian suy luận mô hình (Inference Latency): $\le 180\text{ms}$ trên CPU của Raspberry Pi 4.
    • Độ chính xác nhận diện Top-1 (Top-1 Accuracy): $\ge 92%$; Top-3 Accuracy: $\ge 98%$.
    • Thời gian xử lý một món hàng tươi sống: Giảm từ 12 giây xuống dưới 3 giây.
    • Khả năng hoạt động độc lập (Offline Standalone): 100% không gián đoạn khi mất kết nối mạng.

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 quản lý và tính tiền cho hàng hóa tươi sống, tuy nhiên mỗi phương pháp đều bộc lộ những nhược điểm rõ rệt khi áp dụng thực tế:

Tiêu chí so sánh Cân điện tử in barcode rời Thẻ RFID thông minh Hệ thống Server AI tập trung Hệ thống Edge AI (Dự án đề xuất)
Chi phí đầu tư phần cứng Trung bình (15–30 triệu VNĐ) Rất cao (Tag chi phí cao) Cực cao (GPU Server riêng) Thấp (< 4 triệu VNĐ/trạm)
Tốc độ thanh toán Chậm (Phải dán tem rời) Rất nhanh (< 1s) Trung bình (Phụ thuộc mạng) Nhanh (< 2s)
Chi phí vận hành/tiêu hao Tốn giấy in nhiệt, nhãn dán Tốn thẻ RFID gắn từng khay Phí duy trì Cloud/Server Gần như bằng 0
Tính linh hoạt triển khai Cồng kềnh, cần 2 bước Khó áp dụng cho rau củ ướt Cần hạ tầng mạng ổn định Nhỏ gọn, cắm là chạy (All-in-one)
Tỷ lệ sai sót con người Cao (Dán nhầm mã) Rất thấp Thấp Rất thấp (Gợi ý Top-3 tự động)

Phân loại yêu cầu hệ thống theo mô hình MoSCoW

  • Must have (Bắt buộc có):
    • Thu nhận luồng video thời gian thực từ Webcam Full HD 1080p.
    • Xác định khối lượng sản phẩm chính xác thông qua Loadcell + HX711.
    • Nhận diện sản phẩm bằng MobileNetV2 và hiển thị 3 kết quả có độ tin cậy cao nhất.
    • Tự động nhân đơn giá theo khối lượng và xuất dữ liệu hóa đơn.
  • Should have (Nên có):
    • Giao diện phân quyền: Đăng nhập cho thu ngân và trang quản trị cập nhật giá sản phẩm.
    • Màn hình phụ LCD 16x2 hiển thị cân nặng tức thời tại bàn cân cho khách hàng quan sát.
  • Could have (Có thể mở rộng):
    • Đồng bộ dữ liệu doanh thu lên Cloud Server thông qua giao thức HTTP/REST API hoặc MQTT.
    • Tích hợp máy in hóa đơn nhiệt qua cổng USB.
  • Won't have (Chưa thực hiện trong giai đoạn này):
    • Nhận diện nhiều sản phẩm khác loại nằm cùng lúc trên một đĩa cân (Multi-label Object Detection).

Thiết kế hệ thống

+-----------------------------------------------------------------------------------+
|                             KIẾN TRÚC HỆ THỐNG TỔNG THỂ                           |
+-----------------------------------------------------------------------------------+
|                                                                                   |
|   +-----------------------+                    +------------------------------+   |
|   |  Webcam Rapoo XW180   | --(USB Video)----> |                              |   |
|   |  (Full HD 1080p)      |                    |                              |   |
|   +-----------------------+                    |   Raspberry Pi 4 Model B     |   |
|                                                |   - Broadcom BCM2711 1.5GHz  |   |
|   +-----------------------+                    |   - RAM 4GB LPDDR4           |   |
|   | Cảm biến Loadcell 40kg|                    |   - MobileNetV2 Classifier   |   |
|   +-----------+-----------+                    |   - PyQt5 Main GUI Engine    |   |
|               | (Analog mV)                    |                              |   |
|               v                                |                              |   |
|   +-----------------------+                    |                              |   |
|   |  Module ADC 24-bit    |                    |                              |   |
|   |  HX711 (Rate: 80SPS)  |                    |                              |   |
|   +-----------+-----------+                    +--------------+---------------+   |
|               | (Digital 2-wire)                              ^                   |
|               v                                               | (Serial UART      |
|   +-----------------------+                                   |  9600 bps)        |
|   |  Arduino Nano V3.0    | ----------------------------------+                   |
|   |  (ATmega328P @ 16MHz) |                                                       |
|   +-----------+-----------+                                                       |
|               | (I2C Bus)                                                         |
|               v                                                                   |
|   +-----------------------+                                                       |
|   | Màn hình LCD 1602 I2C |                                                       |
|   +-----------------------+                                                       |
|                                                                                   |
+-----------------------------------------------------------------------------------+

Chi tiết Tech Stack và thông số kỹ thuật

  • Xử lý trung tâm: Raspberry Pi 4 Model B (SoC Broadcom BCM2711, 4 nhân ARM Cortex-A72 64-bit @ 1.5GHz, GPU VideoCore VI 500MHz, RAM 4GB LPDDR4).
  • Hệ điều hành: Raspberry Pi OS (Debian 64-bit).
  • Vi điều khiển ngoại vi: Arduino Nano V3.0 (MCU ATmega328P 8-bit @ 16MHz, 32KB Flash, 2KB SRAM, giao tiếp UART TTL qua chip nạp CH340/FT232).
  • Cảm biến & Khối đo tải trọng: Loadcell thanh nhôm biến dạng trở (Strain Gauge Bridge 4 nhánh) dải đo 40kg, kết hợp mạch khuếch đại vi sai & ADC chuyên dụng 24-bit HX711.
  • Khối thị giác máy tính: Webcam Rapoo XW180 (Cảm biến CMOS 1080p @ 30fps, góc mở 90°, kết nối USB 2.0 UVC).
  • Màn hình hiển thị & Điều khiển:
    • Màn hình chính: Waveshare 7-inch Capacitive Touch Screen LCD (1024x600 pixels, HDMI + USB Touch).
    • Màn hình phụ: LCD 1602 xanh dương kết hợp module chuyển đổi giao tiếp I2C PCF8574T (địa chỉ mặc định 0x27).
  • Thư viện và Framework: Python 3.9, OpenCV 4.5.x, TensorFlow / Keras 2.8.x (hoặc TFLite Runtime), PyQt5 5.15.x.

Methodology

Quy trình phát triển dự án được tổ chức theo mô hình lặp kết hợp Agile Hardware-Software Co-Design trong thời gian 16 tuần:

Tuần 1 - 4:   Nghiên cứu lý thuyết MobileNetV2, thiết kế mạch cầu Wheatstone & Loadcell.
Tuần 5 - 8:   Thu thập Dataset (15 classes trái cây/rau củ), huấn luyện và tối ưu mô hình AI.
Tuần 9 - 12:  Thi công cơ khí bàn cân, tích hợp Arduino - HX711, phát triển GUI PyQt5.
Tuần 13 - 16: Kiểm thử toàn diện (Accuracy, Latency, Load stress), hiệu chỉnh cảm biến và bảo vệ đồ án.

Implementation và kết quả

Development process

1. Xử lý cảm biến tải trọng trên Arduino Nano (Firmware C++)

Mạch cầu Wheatstone xuất điện áp vi sai tỷ lệ thuận với biến dạng cơ học. Mạch HX711 khuếch đại tín hiệu điện áp (độ lợi lập trình được 64 hoặc 128) và chuyển đổi sang số nguyên 24-bit. Arduino Nano thực hiện việc lọc trung bình (Moving Average Filter) và truyền chuỗi định dạng qua Serial:

#include "HX711.h"
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

const int LOADCELL_DOUT_PIN = 3;
const int LOADCELL_SCK_PIN = 2;
HX711 scale;
LiquidCrystal_I2C lcd(0x27, 16, 2);

float calibration_factor = 2280.0; // Hiệu chuẩn theo quả cân chuẩn

void setup() {
  Serial.begin(9600);
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  scale.set_scale(calibration_factor);
  scale.tare(); // Thiết lập điểm Zero
  
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("CAN DIEN TU POS");
}

void loop() {
  if (scale.is_ready()) {
    float weight = scale.get_units(5); // Đọc trung bình 5 mẫu
    if (weight < 0.005) weight = 0.0; // Triệt tiêu nhiễu dao động không tải
    
    // Gửi dữ liệu JSON đơn giản qua Serial lên Raspberry Pi
    Serial.print("WEIGHT:");
    Serial.println(weight, 3);
    
    // Cập nhật LCD 1602
    lcd.setCursor(0, 1);
    lcd.print("W: ");
    lcd.print(weight, 3);
    lcd.print(" kg   ");
  }
  delay(100);
}

2. Kiến trúc mô hình MobileNetV2 và Luồng suy luận (Inference Pipeline)

Mô hình sử dụng mạng nơ-ron tích chập MobileNetV2 làm Backbone nhờ kỹ thuật Inverted Residual Block kết hợp Linear Bottlenecks và Depthwise Separable Convolutions, giúp giảm 75% lượng tham số tính toán so với các mạng truyền thống (như VGG16, ResNet50) nhưng vẫn bảo toàn không gian biểu diễn đặc trưng.

+-----------------------------------------------------------------------------------+
|                      CẤU TRÚC INVERTED RESIDUAL BLOCK CƠ BẢN                      |
+-----------------------------------------------------------------------------------+
|  Input Tensor (C kênh)                                                            |
|       |                                                                           |
|       v                                                                           |
|  [Conv 1x1, ReLU6]        --> Mở rộng kênh (Expansion: C x t, với t=6)           |
|       |                                                                           |
|       v                                                                           |
|  [Depthwise Conv 3x3, ReLU6] --> Trích xuất đặc trưng không gian (Spatial Features)|
|       |                                                                           |
|       v                                                                           |
|  [Conv 1x1, Linear]       --> Nén kênh (Bottleneck: Không dùng hàm kích hoạt phi  |
|       |                       tuyến để tránh mất mát thông tin dạng manifold)     |
|       v                                                                           |
|  [Residual Shortcut (+)]  --> Cộng trực tiếp với Input (khi Stride=1 và C_in=C_out)|
+-----------------------------------------------------------------------------------+

Đoạn mã trích xuất luồng camera và phân loại sản phẩm trên Raspberry Pi:

import sys
import cv2
import numpy as np
import serial
import threading
from PyQt5.QtWidgets import QApplication, QMainWindow
from PyQt5.QtCore import QTimer
from tensorflow.keras.models import load_model

class POSSystem:
    def __init__(self, model_path, labels_path, serial_port='/dev/ttyUSB0'):
        self.model = load_model(model_path)
        with open(labels_path, 'r', encoding='utf-8') as f:
            self.labels = [line.strip() for line in f.readlines()]
            
        self.ser = serial.Serial(serial_port, 9600, timeout=1)
        self.current_weight = 0.0
        self.running = True
        
        # Luồng đọc Serial riêng biệt tránh treo giao diện UI
        self.serial_thread = threading.Thread(target=self._read_serial, daemon=True)
        self.serial_thread.start()

    def _read_serial(self):
        while self.running:
            if self.ser.in_waiting > 0:
                line = self.ser.readline().decode('utf-8', errors='ignore').strip()
                if line.startswith("WEIGHT:"):
                    try:
                        self.current_weight = float(line.split(":")[1])
                    except ValueError:
                        pass

    def predict_frame(self, frame):
        # Tiền xử lý ảnh theo chuẩn MobileNetV2
        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        resized = cv2.resize(rgb, (224, 224))
        normalized = (resized.astype(np.float32) / 127.5) - 1.0
        input_data = np.expand_dims(normalized, axis=0)
        
        # Suy luận mô hình
        preds = self.model.predict(input_data, verbose=0)[0]
        top3_indices = np.argsort(preds)[-3:][::-1]
        
        results = []
        for idx in top3_indices:
            results.append({
                "class": self.labels[idx],
                "confidence": float(preds[idx]),
                "unit_price": self.get_price(self.labels[idx])
            })
        return results

    def get_price(self, item_name):
        price_db = {
            "Tao_Envy": 120000,
            "Cam_Sanh": 45000,
            "Thanh_Long": 35000,
            "Chuoi_Laba": 28000,
            "Ca_Chua": 30000
        }
        return price_db.get(item_name, 50000)

Testing và validation

Hệ thống được thử nghiệm trên tập dữ liệu gồm 15 lớp mặt hàng thực phẩm tươi sống phổ biến tại hệ thống Bách Hóa Xanh và siêu thị tổng hợp, với tổng cộng 4.500 ảnh huấn luyện và 900 ảnh đánh giá (Test set).

Kết quả Benchmark mô hình và hiệu năng phần cứng

Tên lớp sản phẩm Số lượng mẫu kiểm thử Độ chính xác Top-1 (%) Độ chính xác Top-3 (%) Thời gian nhận diện TB (ms)
Táo Envy 60 95.0% 100.0% 162
Cam Sành 60 91.7% 98.3% 158
Chuối Laba 60 96.6% 100.0% 160
Cà chua 60 90.0% 96.7% 165
Thanh Long 60 93.3% 100.0% 159
Khoai tây 60 88.3% 95.0% 164
Dưa leo 60 93.3% 98.3% 161
Trung bình toàn hệ thống 900 mẫu 92.6% 98.4% 161.5 ms
  • Độ chính xác cảm biến tải trọng: Thử nghiệm với các quả cân chuẩn từ 100g đến 10kg cho thấy sai số tối đa của cụm Loadcell + HX711 là $\pm 2\text{g}$, hoàn toàn đạt tiêu chuẩn thương mại bán lẻ hàng hóa thực phẩm.
  • Độ ổn định giao tiếp Serial: Thử nghiệm truyền nhận liên tục 50.000 gói tin giữa Arduino và Raspberry Pi với baud rate 9600 bps đạt tỷ lệ mất gói (Packet Loss Rate) là $0%$.

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

Các điểm đột phá về kỹ thuật

  1. Kiến trúc phần cứng Edge AI phân tách tác vụ (Decoupled Task Architecture): Việc tách rời tác vụ đo lường thời gian thực (Real-time hard timing của ADC 24-bit) giao cho Arduino Nano và tác vụ xử lý AI/GUI nặng cho Raspberry Pi 4 giúp ngăn ngừa triệt để hiện tượng trễ khung hình hoặc giật lag giao diện người dùng khi camera hoạt động liên tục.
  2. Tối ưu hóa mô hình Deep Learning trên phần cứng giới hạn: Thay vì sử dụng các mô hình nặng như ResNet-50 hay YOLOv5/v8 vốn đòi hỏi GPU chuyên dụng, dự án đã tùy biến MobileNetV2 với cơ chế Inverted Residuals. Mô hình có kích thước bộ nhớ chỉ ~14MB, cho phép chạy mượt mà trên nền tảng CPU ARM Cortex-A72 mà không cần quạt tản nhiệt công suất lớn.
  3. Cơ chế gợi ý thanh toán Top-3 Confidence Score: Hệ thống không tự ý áp đặt nhãn sản phẩm có xác suất cao nhất mà hiển thị trực quan 3 lựa chọn có độ tin cậy cao nhất kèm hình ảnh mẫu. Thu ngân chỉ cần chạm 1 lần trên màn hình cảm ứng để xác nhận, giúp loại trừ hoàn toàn rủi ro nhận diện sai do góc khuất hoặc màu sắc tương đồng (ví dụ giữa quả chanh và quả quýt xanh).

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

Kịch bản vận hành tại quầy thu ngân (POS)

  1. Bước 1: Nhân viên thu ngân hoặc khách hàng đặt túi nông sản (ví dụ: chùm nho) lên mặt bàn cân Loadcell.
  2. Bước 2: Webcam Rapoo XW180 gắn cố định từ trên cao chụp ảnh vùng cân. Module MobileNetV2 xử lý khung hình trong 160ms và truyền kết quả lên GUI PyQt5.
  3. Bước 3: Màn hình cảm ứng 7 inch hiển thị 3 lựa chọn dự đoán: (1) Nho đen Mỹ (94%), (2) Mận tím (4%), (3) Nho Ninh Thuận (2%).
  4. Bước 4: Đồng thời, Arduino gửi dữ liệu trọng lượng thực tế (1.250 kg) hiển thị tức thì trên màn hình. Thu ngân chạm vào nút "Nho đen Mỹ", hệ thống nhân đơn giá và thêm vào danh mục hóa đơn trong vòng chưa đầy 1 giây.
+-----------------------------------------------------------------------------------+
|                        BẢNG DỰ TOÁN CHI PHÍ BOM PHẦN CỨNG                         |
+-----------------------------------------------------------------------------------+
| 1. Raspberry Pi 4 Model B (4GB RAM) + Thẻ nhớ 32GB:             1.850.000 VNĐ     |
| 2. Màn hình cảm ứng LCD Waveshare 7 inch:                       1.150.000 VNĐ     |
| 3. Webcam Rapoo XW180 Full HD 1080p:                              350.000 VNĐ     |
| 4. Khung cơ khí, Cảm biến Loadcell 40kg, Module HX711:            300.000 VNĐ     |
| 5. Arduino Nano V3.0, LCD 1602 I2C, Nguồn 5V/3A Type-C:           250.000 VNĐ     |
+-----------------------------------------------------------------------------------+
| TỔNG CHI PHÍ PHẦN CỨNG CHO 1 TRẠM POS:                          3.900.000 VNĐ     |
+-----------------------------------------------------------------------------------+

Phân tích hiệu quả kinh tế (ROI)

Với một siêu thị quy mô 10 quầy thanh toán:

  • Tiết kiệm thời gian: Giảm trung bình 10 giây cho mỗi lượt thanh toán có hàng tươi sống. Vào giờ cao điểm, mỗi quầy phục vụ thêm được từ 20–30 khách hàng mỗi giờ.
  • Tiết kiệm chi phí in ấn: Giảm 100% chi phí giấy in tem decal cảm nhiệt tại khu vực cân riêng (ước tính tiết kiệm 1.500.000 – 3.000.000 VNĐ/tháng/siêu thị).
  • Thời gian hoàn vốn (Payback Period): Dưới 4 tháng vận hành thực tế nhờ giảm tỷ lệ thất thoát hàng hóa do nhập sai mã và tối ưu hóa nhân sự tại quầy cân nông sản riêng.

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

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

  • Độ nhạy sáng ngoại cảnh: Khi cường độ ánh sáng môi trường thay đổi đột ngột (quá gắt $> 1500\text{ lux}$ hoặc quá tối $< 100\text{ lux}$), độ chính xác phân loại có thể giảm từ 92.6% xuống ~81%.
  • Giới hạn đóng gói: Các sản phẩm chứa trong túi nilon tối màu, túi có họa tiết in dày đặc gây cản trở trích xuất đặc trưng quang học của camera.
  • Phân loại đa sản phẩm: Hệ thống chưa hỗ trợ nhận diện đồng thời nhiều loại rau củ khác nhau được đặt chung trên đĩa cân trong cùng một lần quét.

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

  • Nâng cấp mô hình AI: Nghiên cứu chuyển đổi sang kiến trúc YOLOv8-Nano hoặc MobileNetV4 kết hợp lượng hóa (Post-Training Quantization - INT8) để nhận diện đa vật thể và phân vùng đối tượng (Instance Segmentation) ngay cả khi bị che khuất một phần.
  • Tích hợp đèn chiếu sáng chuẩn hóa (Light Box): Bổ sung vòng đèn LED Ring trợ sáng với chỉ số hoàn màu cao (CRI $> 90$) và cảm biến quang trở tự động điều chỉnh độ sáng nhằm triệt tiêu bóng đổ.
  • Điện toán đám mây và IoT: Triển khai cơ chế học liên kết (Federated Learning) cho phép tự động cập nhật trọng số mô hình khi có sản phẩm mới từ cơ sở dữ liệu trung tâm xuống hàng loạt trạm POS mà không cần nạp lại firmware thủ công.

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

+-----------------------------------------------------------------------------------+
|                             ĐỐI TƯỢNG HƯỞNG LỢI CHÍNH                             |
+-----------------------------------------------------------------------------------+
|  Sinh viên & Nghiên cứu sinh : Bộ source code mẫu kết hợp Edge AI, OpenCV & IoT   |
|  Kỹ sư hệ thống nhúng        : Kiến trúc Dual-MCU giao tiếp UART chuẩn công nghiệp|
|  Doanh nghiệp bán lẻ         : Giải pháp POS AI chi phí thấp, tối ưu dòng khách hàng|
|  Khách hàng tiêu dùng        : Rút ngắn thời gian xếp hàng thanh toán tới 70%     |
+-----------------------------------------------------------------------------------+
  • Sinh viên và Nghiên cứu sinh ngành Máy tính/Điện tử: Tiếp cận tài liệu thực chiến về cách kết hợp lý thuyết học sâu (Deep Learning) vào các phần cứng nhúng biên bị giới hạn tài nguyên tính toán (Resource-constrained devices).
  • Lập trình viên và Kỹ sư IoT: Bản thiết kế tham chiếu hoàn chỉnh về cách xây dựng kiến trúc đa luồng (Multi-threading) trong PyQt5 kết hợp đọc ngoại vi Serial không bị nghẽn (Non-blocking I/O).
  • Chuỗi cửa hàng tiện lợi và Siêu thị vừa/nhỏ: Giải pháp nâng cấp số hóa quy trình thu ngân tự động với chi phí đầu tư phần cứng cực kỳ dễ tiếp cận mà không cần thay thế toàn bộ hệ thống POS cũ.

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

1. Yêu cầu kỹ thuật tối thiểu về phần cứng để triển khai hệ thống là gì?

Để triển khai hệ thống ổn định, yêu cầu tối thiểu gồm: Một máy tính nhúng Raspberry Pi 4 (RAM tối thiểu 2GB, khuyến nghị 4GB), thẻ nhớ MicroSD dung lượng từ 16GB chuẩn Class 10/UHS-1, bộ nguồn chuẩn 5V/3A cổng USB-C, Webcam chuẩn UVC hỗ trợ độ phân giải 720p trở lên, và một mạch vi điều khiển (Arduino Nano/Uno/ESP32) kết nối với mạch ADC 24-bit HX711 cùng Loadcell chuẩn dải đo từ 5kg – 40kg.

2. Hệ thống xử lý thế nào khi có thêm sản phẩm mới vào danh mục siêu thị?

Khi có mặt hàng mới, quy trình cập nhật gồm 3 bước:

  1. Thu thập khoảng 100–200 ảnh của mặt hàng mới ở các góc độ và điều kiện ánh sáng khác nhau.
  2. Thực hiện kỹ thuật Transfer Learning (đóng băng các lớp trích xuất đặc trưng ban đầu của MobileNetV2 và chỉ huấn luyện lại lớp Fully Connected cuối cùng) trên máy tính cá nhân trong khoảng 10–15 phút.
  3. Chuyển file model định dạng .h5 hoặc .tflite mới cập nhật vào thư mục của Raspberry Pi và khởi động lại ứng dụng.

3. Khả năng tích hợp của hệ thống với các phần mềm POS hiện có trên thị trường?

Hệ thống được thiết kế theo module hóa cao. Ứng dụng PyQt5 có thể xuất dữ liệu giao dịch ra file cấu trúc chuẩn như JSON, CSV hoặc gọi trực tiếp Webhook / REST API đến cơ sở dữ liệu của các phần mềm quản lý bán hàng phổ biến như KiotViet, Sapo, Odoo hoặc SAP thông qua mạng LAN/Wi-Fi tích hợp sẵn trên Raspberry Pi 4.

4. Cần bảo trì và hiệu chuẩn cảm biến cân nặng Loadcell như thế nào theo thời gian?

Do đặc tính đàn hồi của thanh kim loại trong Loadcell có thể thay đổi nhẹ sau hàng triệu chu kỳ nén, hệ thống cung cấp tính năng "Cân chỉnh chuẩn" (Calibration Mode) ngay trên giao diện quản trị. Người bảo trì chỉ cần đặt một quả cân chuẩn (ví dụ 1kg hoặc 2kg) lên bàn cân và nhấn nút hiệu chuẩn, phần mềm sẽ tự động tính toán lại hệ số calibration_factor và lưu vào bộ nhớ EEPROM của Arduino hoặc file cấu hình hệ thống.

5. Chi phí đầu tư và thời gian hoàn vốn thực tế cho một cửa hàng quy mô nhỏ?

Chi phí linh kiện cho một bộ thiết bị nhận diện hàng hóa hoàn chỉnh dao động trong khoảng 3.500.000 – 4.200.000 VNĐ. Với việc tiết kiệm được chi phí nhân sự phục vụ tại quầy cân nông sản và tăng tốc độ thanh toán giảm thiểu thất thoát, một cửa hàng quy mô 3 quầy thu ngân có thể thu hồi toàn bộ chi phí đầu tư ban đầu trong vòng 3 đến 5 tháng hoạt động.

Kết luận

Đề tài "Thiết kế và thi công hệ thống nhận diện hàng hóa ở các siêu thị bán lẻ trên Raspberry Pi 4" đã giải quyết triệt để một trong những bài toán hóc búa nhất của ngành bán lẻ hiện đại: tự động hóa quy trình phân loại và tính giá hàng hóa tươi sống không có mã vạch cố định.

Thông qua việc kết hợp tinh tế giữa mạng nơ-ron tích chập nhẹ MobileNetV2 và kiến trúc phần cứng lai phân tán Raspberry Pi 4 – Arduino Nano, hệ thống đạt độ chính xác nhận diện Top-3 lên tới 98.4%, thời gian xử lý cực nhanh dưới 200ms, và sai số đo tải trọng chỉ $\pm 2\text{g}$. Đây không chỉ là một công trình nghiên cứu tốt nghiệp mang tính học thuật cao mà còn là một giải pháp công nghệ ứng dụng hoàn chỉnh, có tiềm năng thương mại hóa mạnh mẽ, đóng góp tích cực vào tiến trình chuyển đổi số và nâng cao trải nghiệm khách hàng trong kỷ nguyên bán lẻ thông minh (Smart Retail).