Hệ thống Machine Vision gồm những gì: camera, quang học, chiếu sáng, I/O

Ở Giai đoạn 1 bạn đã viết được chương trình OpenCV đọc ảnh, phân ngưỡng, tìm contour và trả về OK/NG. Nhưng một chương trình xử lý ảnh mới chỉ là một khối trong trạm kiểm tra thật. Trước nó là đèn, ống kính, camera và tín hiệu kích hoạt; sau nó là PLC, van thổi loại hàng và cơ sở dữ liệu. Phần lớn dự án Machine Vision thất bại không phải vì thuật toán kém, mà vì một khối khác bị chọn sai, thường là chiếu sáng. Bài này mở đầu chặng 4 "Machine Vision": bạn sẽ nhìn toàn bộ hệ thống, đi dọc một trạm kiểm tra nắp chai từ cảm biến đến lúc loại hàng, và tự chứng minh bằng code vì sao người trong nghề hay nói "chiếu sáng quyết định 80% thành công".

1. Machine Vision và Computer Vision khác nhau thế nào?

Computer Vision (thị giác máy tính) là lĩnh vực khoa học nghiên cứu cách máy tính hiểu ảnh: nhận dạng khuôn mặt, xe tự lái, phân đoạn ảnh y tế, tìm kiếm ảnh. Machine Vision (thị giác máy) là ngành kỹ thuật ứng dụng: dùng camera, chiếu sáng và xử lý ảnh để tự động kiểm tra, đo, nhận dạng và dẫn hướng trong sản xuất. Machine Vision dùng thuật toán của Computer Vision, nhưng sản phẩm cuối cùng là một trạm máy chạy 24/7 nối với dây chuyền, không phải một mô hình hay một bài báo.

Ranh giới không tuyệt đối: deep learning ngày nay xuất hiện ở cả hai bên, và một trạm Machine Vision có thể dùng mạng nơ-ron để phân loại lỗi bề mặt. Điểm khác cốt lõi là tư duy hệ thống: kỹ sư Machine Vision được phép (và phải) thay đổi điều kiện chụp để bài toán dễ đi, thay vì cố viết thuật toán chịu được mọi điều kiện xấu.

2. Sơ đồ khối của một trạm Machine Vision

          ┌──────────────┐
 Sản phẩm │  Chiếu sáng  │  tạo tương phản giữa đặc điểm cần xem và nền
 trên  ──▶│  Quang học   │  ống kính + filter: tạo ảnh sắc nét đúng FOV
 băng tải │  Camera      │  cảm biến biến ánh sáng thành ảnh số
          └──────┬───────┘
   Cảm biến /    │ ảnh (GigE Vision, USB3 Vision, CoaXPress…)
   encoder ──trigger──┐
                 ▼    │
          ┌──────────────┐
          │   Xử lý      │  PC công nghiệp / smart camera / máy nhúng
          │ (phần mềm)   │  thuật toán → OK/NG, số đo, tọa độ
          └──────┬───────┘
                 │ I/O số 24 V, PROFINET, EtherNet/IP, Modbus TCP…
                 ▼
          ┌──────────────┐        ┌───────────────────┐
          │ PLC / Robot  │──────▶ │ Van thổi, cần gạt │  loại sản phẩm NG
          └──────┬───────┘        └───────────────────┘
                 ▼
          HMI, lưu ảnh NG, MES (thống kê, truy xuất)

Khối "kích hoạt" và chuỗi thời gian sẽ học kỹ ở chặng 5 "Industrial Vision". Camera, ống kính và đèn có cả chặng 6 "Camera / Lens / Lighting". Giao tiếp PLC, robot, MES nằm ở chặng 9. Bài này chỉ cần bạn nắm vai trò và mối liên hệ giữa các khối.

3. Đi dọc một trạm thật: kiểm tra có nắp chai

Bài toán: dây chuyền nước giải khát chạy 300 chai/phút, khoảng cách tâm hai chai liên tiếp (pitch) 100 mm. Trạm phải phát hiện chai thiếu nắp và thổi chai đó ra khỏi băng tải. Đây là bài toán "có/không" kinh điển, đủ đơn giản để thấy rõ mọi khối.

Bố trí

• Chiếu sáng: đèn nền (backlight) đặt sau băng tải, camera đặt phía trước, cùng độ cao với cổ chai. Chai che đèn nên hiện thành bóng đen trên nền trắng. Có nắp hay không chỉ là câu hỏi "vùng phía trên cổ chai có tối không".
• Camera: đơn sắc, màn trập global (chụp cả khung cùng lúc, không méo khi vật chạy), độ phân giải vừa phải (khoảng 0,3–1,3 MP là thừa đủ cho bài có/không).
• Kích hoạt: cảm biến quang (photoelectric sensor) dạng thu phát, chùm tia ngang cổ chai, đặt sao cho khi tia bị cắt thì chai nằm giữa khung hình.
• Loại hàng: van khí nén thổi ngang, đặt cách camera 600 mm về phía hạ nguồn.

Chuỗi sự kiện cho một chai

Hai con số chi phối thiết kế: chu kỳ (một chai mới tới mỗi bao lâu) và số chai nằm giữa camera và van. Tính nhanh:

chai_phut = 300          # năng suất dây chuyền
pitch_mm = 100           # khoảng cách tâm hai chai
khoang_cach_van_mm = 600 # camera → van thổi

chu_ky_ms = 60_000 / chai_phut
toc_do_mm_s = chai_phut / 60 * pitch_mm
thoi_gian_toi_van_s = khoang_cach_van_mm / toc_do_mm_s
so_chai_giua = khoang_cach_van_mm / pitch_mm

print(f"Chu kỳ mỗi chai     : {chu_ky_ms:.0f} ms")
print(f"Tốc độ băng tải     : {toc_do_mm_s:.0f} mm/s = {toc_do_mm_s * 60 / 1000:.0f} m/phút")
print(f"Thời gian tới van   : {thoi_gian_toi_van_s:.2f} s")
print(f"Số chai nằm giữa camera và van: {so_chai_giua:.0f}")

Chu kỳ mỗi chai     : 200 ms
Tốc độ băng tải     : 500 mm/s = 30 m/phút
Thời gian tới van   : 1.20 s
Số chai nằm giữa camera và van: 6

Hệ quả thực tế:

• Ảnh, xử lý và gửi kết quả cộng lại khoảng 15–25 ms, còn rất xa chu kỳ 200 ms. Bài này không bị giới hạn bởi tốc độ xử lý.
• Khi chai NG tới van thì camera đã chụp thêm khoảng 6 chai khác. PC không thể tự bật van "ngay khi thấy lỗi"; PLC phải lưu kết quả vào một hàng đợi (FIFO, hay thanh ghi dịch) và mở van đúng chai. Nếu băng tải đổi tốc độ, cần encoder để theo dõi theo quãng đường thay vì theo thời gian (chặng 5).
• Mọi chai phải có đúng một kết quả. Nếu trigger bị dội (một chai gây hai xung) hoặc PC treo một nhịp, hàng đợi lệch và trạm bắt đầu thổi nhầm chai. Vì vậy trạm thật luôn có giám sát: đếm số trigger so với số kết quả, và báo lỗi khi PC không trả lời đúng hạn.

4. Vì sao chiếu sáng quyết định "80% thành công"?

"80%" là cách nói kinh nghiệm của ngành, không phải con số đo được. Ý nghĩa của nó: phần mềm không tạo ra thông tin không có trong ảnh. Nếu nắp đỏ và nền xám có cùng độ sáng trên ảnh đơn sắc, không ngưỡng nào tách được chúng. Ngược lại, khi chiếu sáng làm đặc điểm cần xem nổi hẳn lên, thuật toán đơn giản nhất cũng chạy ổn định nhiều tháng.

Ta thử bằng code. Cùng một thuật toán ("độ chênh xám giữa vùng nắp và vùng nền bên cạnh, so với ngưỡng"), chạy trên hai kiểu chiếu sáng:

• Đèn phía trước: nắp có ba màu (trắng, đỏ, xanh), ánh sáng xưởng thay đổi theo giờ, thỉnh thoảng có vệt chói trên cổ chai.
• Đèn nền: chai che đèn nên nắp màu gì cũng thành bóng đen.

Kỹ sư cài ngưỡng bằng một chai nắp trắng và một chai không nắp (điều rất hay gặp khi chạy thử), rồi thử trên 1000 chai mỗi loại:

import cv2
import numpy as np

H, W = 160, 160
ROI_NAP = (slice(28, 48), slice(62, 98))      # vùng nắp: (hàng, cột)
ROI_NEN = (slice(28, 48), slice(8, 40))       # vùng nền tham chiếu cùng độ cao


def tao_anh(co_nap, kieu_den, rng, mau_nap=None):
    """Ảnh cổ chai nhìn ngang. kieu_den: 'truoc' (đèn phía trước) hoặc 'nen' (backlight)."""
    dy = int(rng.integers(-3, 4))                         # chai lệch vị trí ±3 px
    if kieu_den == "nen":
        nen, co_chai, nap, nhieu = 225 + rng.normal(0, 3), 25, 25, 4
    else:
        moi_truong = rng.uniform(-35, 35)                 # ánh sáng xưởng thay đổi
        nen = 120 + moi_truong
        co_chai = nen + 12                                # cổ chai: tương phản thấp với nền
        mau = rng.choice([205, 140, 100]) if mau_nap is None else mau_nap  # trắng / đỏ / xanh
        nap = mau + 0.5 * moi_truong
        nhieu = 10
    anh = np.full((H, W), nen, np.float32)
    cv2.rectangle(anh, (66, 50 + dy), (94, H), float(co_chai), -1)            # cổ chai
    if co_nap:
        cv2.rectangle(anh, (60, 26 + dy), (100, 52 + dy), float(nap), -1)     # nắp
    if kieu_den == "truoc" and rng.random() < 0.5:                            # vệt chói
        cv2.ellipse(anh, (80, 70 + dy), (6, 18), 0, 0, 360, 250.0, -1)
    anh += rng.normal(0, nhieu, anh.shape)
    return np.clip(anh, 0, 255).astype(np.uint8)


def diem(anh):
    """Cùng một thuật toán cho mọi kiểu đèn: độ chênh xám giữa vùng nắp và vùng nền."""
    return abs(float(anh[ROI_NAP].mean()) - float(anh[ROI_NEN].mean()))


rng = np.random.default_rng(1)
for kieu in ("truoc", "nen"):
    # Kỹ sư cài ngưỡng từ 1 chai có nắp TRẮNG và 1 chai không nắp
    anh_ok = tao_anh(True, kieu, np.random.default_rng(100), mau_nap=205)
    anh_ng = tao_anh(False, kieu, np.random.default_rng(101))
    nguong = (diem(anh_ok) + diem(anh_ng)) / 2
    s_ok = np.array([diem(tao_anh(True, kieu, rng)) for _ in range(1000)])
    s_ng = np.array([diem(tao_anh(False, kieu, rng)) for _ in range(1000)])
    sai_ok = int((s_ok <= nguong).sum())      # có nắp nhưng báo thiếu → loại nhầm
    sai_ng = int((s_ng > nguong).sum())       # thiếu nắp nhưng báo có → lọt lỗi
    print(f"Đèn {kieu}: ngưỡng {nguong:.1f}")
    print(f"  điểm chai có nắp  : {s_ok.min():6.1f} .. {s_ok.max():6.1f}")
    print(f"  điểm chai thiếu nắp: {s_ng.min():6.1f} .. {s_ng.max():6.1f}")
    print(f"  khoảng hở (min có nắp - max thiếu nắp): {s_ok.min() - s_ng.max():.1f}")
    print(f"  báo thiếu nắp nhầm: {sai_ok}/1000 | thiếu nắp bị cho qua: {sai_ng}/1000")
    cv2.imwrite(f"nap_{kieu}.png", np.hstack([anh_ok, anh_ng]))

Đèn truoc: ngưỡng 41.5
  điểm chai có nắp  :    2.0 ..  103.3
  điểm chai thiếu nắp:    0.0 ..    1.6
  khoảng hở (min có nắp - max thiếu nắp): 0.3
  báo thiếu nắp nhầm: 656/1000 | thiếu nắp bị cho qua: 0/1000
Đèn nen: ngưỡng 100.4
  điểm chai có nắp  :  183.5 ..  209.9
  điểm chai thiếu nắp:    0.0 ..    8.7
  khoảng hở (min có nắp - max thiếu nắp): 174.8
  báo thiếu nắp nhầm: 0/1000 | thiếu nắp bị cho qua: 0/1000

Đọc kết quả như một kỹ sư:

• Đèn phía trước: điểm của chai có nắp trải từ 2 đến 103. Nắp trắng cho điểm cao, nhưng nắp đỏ và xanh có độ xám gần nền, và khi ánh sáng xưởng thay đổi thì có lúc gần như trùng nền. Khoảng hở giữa hai nhóm chỉ còn 0,3 mức xám: không tồn tại ngưỡng an toàn. Ngưỡng cài bằng nắp trắng làm 656/1000 chai tốt bị báo thiếu nắp. Hạ ngưỡng xuống thì một chút nhiễu hay vệt chói sẽ làm chai thiếu nắp lọt qua.
• Đèn nền: mọi nắp đều thành bóng đen, điểm từ 183 đến 210; chai thiếu nắp dưới 9. Khoảng hở gần 175 mức xám, ngưỡng đặt ở đâu trong khoảng đó cũng đúng. Màu nắp, ánh sáng xưởng, vệt chói đều không còn ảnh hưởng.

Mở hai ảnh nap_truoc.png và nap_nen.png để nhìn tận mắt. Bài học quan trọng nhất: đừng sửa bằng phần mềm thứ mà chiếu sáng sửa được. Thay vì thêm tiền xử lý, cân bằng sáng, học máy cho trường hợp đèn phía trước, đổi sang đèn nền là xong. Thước đo bạn vừa dùng, khoảng hở giữa hai nhóm điểm, là cách định lượng "ảnh tốt" mà bạn sẽ dùng lại khi chọn đèn ở chặng 6 và khi đặt ngưỡng OK/NG ở chặng 5.

Vài cặp "bài toán → kiểu đèn" bạn sẽ gặp lại liên tục:

5. Khối xử lý và khối I/O: những gì cần biết ngay bây giờ

Phần cứng xử lý có ba dạng chính:

• PC công nghiệp + camera rời: linh hoạt nhất, chạy được OpenCV, Halcon, deep learning, nhiều camera. Cần tủ điện, quạt, phần mềm tự viết hoặc mua.
• Smart camera: camera có bộ xử lý và phần mềm cấu hình bên trong, nối thẳng I/O với PLC. Gọn, nhanh triển khai cho bài toán đơn giản.
• Máy nhúng (ARM, máy có GPU nhúng): rẻ, nhỏ, hợp sản phẩm số lượng lớn hoặc cần AI tại chỗ; đòi hỏi kỹ năng phần mềm cao hơn.

Cách chọn giữa chúng là nội dung bài 3 của chặng này.

I/O và truyền thông với PLC thường gồm hai lớp:

• I/O số 24 V: dây tín hiệu riêng cho những thứ cần nhanh và chắc chắn: Trigger vào, Ready/Busy ra, OK/NG ra. Phải khớp kiểu PNP/NPN giữa hai bên.
• Mạng công nghiệp: PROFINET, EtherNet/IP, Modbus TCP, CC-Link IE, hoặc TCP socket thuần, dùng để gửi dữ liệu nhiều hơn: số đo, mã đọc được, tọa độ, mã lỗi, tên công thức sản phẩm.

Hai bên trao đổi theo cơ chế bắt tay (handshake): PLC chỉ gửi trigger khi camera báo Ready, camera chỉ đặt kết quả khi đã xử lý xong và báo bằng một tín hiệu "dữ liệu hợp lệ". Chi tiết ở chặng 9.

6. Sai lầm thường gặp của người mới

• Chọn camera trước, nghĩ tới đèn sau. Thứ tự đúng: xác định đặc điểm cần thấy → thử chiếu sáng trên mẫu thật → tính độ phân giải và FOV → chọn camera, ống kính.
• Thử trên vài mẫu đẹp ở văn phòng. Mẫu thật trên dây chuyền có bụi, giọt nước, lệch vị trí, nhiều màu nắp, nhiều lô vật liệu. Hãy xin ít nhất vài chục mẫu OK và mọi loại mẫu lỗi có thể.
• Quên ánh sáng môi trường. Trạm chạy đúng ca sáng, sai ca chiều vì nắng chiếu qua cửa sổ. Che chắn và đèn đủ mạnh là bắt buộc.
• Quên khối loại hàng. Phát hiện đúng mà thổi nhầm chai thì vẫn là trạm hỏng. Khoảng cách tới van, theo dõi sản phẩm, xác nhận đã loại phải được thiết kế ngay từ đầu.
• Không lưu ảnh. Khi khách hàng báo "hôm qua lọt chai thiếu nắp", không có ảnh thì không thể chứng minh hay sửa.

7. Bài tập

chai_phut, pitch_mm, van_mm, xu_ly_ms = 600, 80, 900, 30
chu_ky_ms = 60_000 / chai_phut
toc_do = chai_phut / 60 * pitch_mm               # mm/s
print(f"chu kỳ {chu_ky_ms:.0f} ms, băng tải {toc_do:.0f} mm/s, "
      f"{van_mm / pitch_mm:.2f} chai giữa camera và van, tới van sau {van_mm / toc_do * 1000:.0f} ms")
print("kịp" if xu_ly_ms < chu_ky_ms else "không kịp", "| còn dư", chu_ky_ms - xu_ly_ms, "ms")

chu kỳ 100 ms, băng tải 800 mm/s, 11.25 chai giữa camera và van, tới van sau 1125 ms
kịp | còn dư 70.0 ms

Tóm tắt

• Machine Vision là ngành kỹ thuật ứng dụng thị giác máy vào sản xuất: điều kiện chụp kiểm soát được, đầu ra là tín hiệu cho PLC/robot, thời gian và độ tin cậy là yêu cầu cứng.
• Một trạm gồm: kích hoạt, chiếu sáng, quang học, camera, xử lý, I/O, cơ cấu loại hàng, HMI và lưu trữ. Một khối hỏng là cả trạm hỏng.
• Với mỗi trạm, tính ngay chu kỳ sản phẩm và số sản phẩm nằm giữa camera và điểm loại; PLC phải theo dõi từng sản phẩm.
• Chiếu sáng quyết định tương phản; phần mềm không tạo ra thông tin không có trong ảnh. Đo chất lượng ảnh bằng khoảng hở giữa điểm của nhóm OK và nhóm NG.
• Thứ tự thiết kế: đặc điểm cần thấy → chiếu sáng → độ phân giải, FOV → camera, ống kính → xử lý → I/O.

Bài tiếp theo: 5 nhóm bài toán Machine Vision và cách giải, nơi bạn học cách nhận diện một yêu cầu thuộc nhóm nào và ước lượng độ khó của nó.