⭐ Vision Engineer · Chặng 9Bài 5/5Dự án~150 phút

Dự án: đo độ đồng phẳng chân linh kiện bằng laser 3D

Trạm đo coplanarity SOIC-16: bản đồ chiều cao, tìm chân không mất chân lỗi, mặt ngồi theo JEDEC so với mặt hồi quy, độ lặp lại qua 10 lần đặt lại.

Dự án: đo độ đồng phẳng chân linh kiện bằng laser 3D

Học xong bài này, bạn sẽ

  • Tìm đủ chân kể cả chân lỗi, đo chiều cao bền nhiễu
  • Dựng mặt ngồi theo JEDEC, phán OK/NG
  • Đánh giá độ lặp lại qua 10 lần đặt lại

Nên học trước: Đám mây điểm với Open3D: RANSAC, DBSCAN, ICP

Nội dung bài viết
  1. 1. Bài toán
  2. 2. Yêu cầu
  3. 3. Kiến thức sử dụng
  4. 4. Dữ liệu: trạm mô phỏng
  5. 5. Gợi ý thiết kế
  6. 6. Lời giải
  7. 7. Tự đánh giá
  8. 8. Mở rộng
  9. Tóm tắt

Độ khó: ★★★☆ (khó) · Cần học trước: chặng 9: 3D Vision · Thời lượng: khoảng 2,5 giờ

Đây là dự án tổng kết chặng 3D Vision. Bạn sẽ xây phần mềm cho một trạm đo độ đồng phẳng chân linh kiện (lead coplanarity), một trong những phép đo 3D kinh điển của ngành điện tử: một chân linh kiện dán bề mặt bị vênh lên vài chục micromet là không chạm pad khi hàn, gây mối hàn hở mà kiểm tra điện có thể không phát hiện ngay. Dự án dùng lại profiler laser của bài laser tam giác (tìm tâm vạch bằng trọng tâm, bản đồ chiều cao), cách đo so với mặt chuẩn, và cách đánh giá hệ đo của bài MSA và Gage R&R.

Mục tiêu dự án(1) Từ bản đồ chiều cao, tìm tự động đủ 16 chân và đo chiều cao từng chân bền nhiễu. (2) Dựng mặt ngồi (seating plane) theo định nghĩa JEDEC, tính độ đồng phẳng, phán OK/NG. (3) Chứng minh bằng số rằng phương pháp tính (mặt ngồi hay mặt phẳng hồi quy) có thể đổi kết luận. (4) Đánh giá độ lặp lại qua 10 lần đặt lại linh kiện. Thời lượng dự kiến: khoảng 2,5 giờ.

1. Bài toán

Một nhà máy lắp ráp nhận linh kiện SOIC-16 (16 chân dạng cánh chim, bước 1,27 mm, thân 10 × 4 mm) từ nhà cung cấp và muốn kiểm tra mẫu mỗi lô trước khi đưa lên dây chuyền SMT. Linh kiện được đặt lật ngửa (chân hướng lên) vào khay đo; một profiler laser nhìn nghiêng 30° quét qua khi khay chạy, độ phân giải 0,015 mm theo vạch, bước quét 0,03 mm. Khay có thể hơi nghiêng vài µm/mm và linh kiện đặt lệch vị trí tới ±0,15 mm.

Đại lượngYêu cầu
Độ đồng phẳng (coplanarity): khoảng cách lớn nhất từ mặt tiếp xúc của một chân tới mặt ngồi≤ 0,100 mm
Phương phápMặt ngồi qua 3 chân đỡ linh kiện, tam giác 3 chân chứa hình chiếu trọng tâm (theo JEDEC JESD22-B108)
Kết quả báo cáoOK/NG, độ đồng phẳng, chân tệ nhất, chiều cao từng chân

2. Yêu cầu

  • Bù độ nghiêng của khay bằng fit mặt phẳng, không dùng "Z = 0" của cảm biến.
  • Tìm chân không dựa vào chiều cao danh định: chân lỗi chính là chân có chiều cao bất thường.
  • Chiều cao mỗi chân là một con số bền với nhiễu, điểm thiếu, mép.
  • Thiếu chân (tìm được khác 16) thì trạm báo lỗi đo, không phán OK.
  • Đo 10 lần (mỗi lần nhấc ra đặt lại) một linh kiện lỗi và một linh kiện tốt; báo cáo trung bình, độ lệch chuẩn, 6σ so với dung sai.

3. Kiến thức sử dụng

  • Laser tam giác: mô phỏng ảnh vạch laser, tìm tâm bằng trọng tâm, vùng khuất, bản đồ chiều cao, fit mặt chuẩn.
  • Blob analysis: connectedComponentsWithStats trên mặt nạ chiều cao.
  • Morphology: erode để bỏ mép vùng trước khi lấy trung vị.
  • MSA: độ lặp lại so với dung sai.
  • Hình học: mặt phẳng qua 3 điểm (tích có hướng), điểm trong tam giác.

4. Dữ liệu: trạm mô phỏng

Đoạn code này đóng vai "trạm thật": mô tả hình học khay, đáy thân và 16 mặt tiếp xúc chân (bỏ qua phần vai chân nối với thân để gọn), rồi quét bằng đúng profiler laser của bài laser tam giác (speckle, vùng khuất, tìm tâm trọng tâm). Linh kiện thử có 16 chân cao lệch nhau vài µm và chân số 6 bị vênh, thấp hơn 0,12 mm (linh kiện lật ngửa nên chân vênh lên khỏi PCB trông thấp hơn các chân khác). Lời giải không được dùng CAO_THAT, trừ khi để chấm điểm.

import itertools

import cv2
import numpy as np

SX, DY = 0.015, 0.03                 # 0,015 mm/pixel dọc vạch laser; bước quét 0,03 mm
ALPHA = np.radians(30)
RONG, CAO_ANH, HANG_0 = 800, 160, 150  # vạch laser phủ 12 mm
THAN = (6.0, 3.6, 10.0, 4.0)         # tâm x, tâm y, dài, rộng của thân linh kiện (mm) trên khay
DAY_THAN, CHAN_DN = 1.50, 1.65       # đáy thân cao 1,50 mm so với khay; mặt tiếp xúc chân danh định 1,65 mm


def vi_tri_chan(dx=0.0, dy=0.0):
    """16 chân SOIC: chân 1–8 một bên (trái → phải), 9–16 bên kia (phải → trái), bước 1,27 mm."""
    cx, cy = THAN[0] + dx, THAN[1] + dy
    x = cx + (np.arange(8) - 3.5) * 1.27
    return np.r_[np.c_[x, np.full(8, cy - 2.6)], np.c_[x[::-1], np.full(8, cy + 2.6)]]


def be_mat(x, y, cao_chan, dx=0.0, dy=0.0, nghieng=(0.004, -0.003)):
    """Khay (nghiêng nhẹ), đáy thân linh kiện, 16 mặt tiếp xúc chân 0,40 × 0,80 mm."""
    z = np.zeros(np.broadcast(x, y).shape)
    cx, cy, dai, rong = THAN
    z = np.where((np.abs(x - cx - dx) <= dai / 2) & (np.abs(y - cy - dy) <= rong / 2), DAY_THAN, z)
    for (px, py), h in zip(vi_tri_chan(dx, dy), cao_chan):
        z = np.where((np.abs(x - px) <= 0.20) & (np.abs(y - py) <= 0.40), h, z)
    return z + nghieng[0] * x + nghieng[1] * y


def quet(rng, cao_chan, dx=0.0, dy=0.0, nghieng=(0.004, -0.003)):
    """Mô phỏng profiler laser (như bài Laser tam giác): trả về bản đồ chiều cao (mm), NaN là điểm thiếu."""
    x = np.arange(RONG) * SX
    r = np.arange(CAO_ANH)[:, None]
    ban_do = []
    for yq in np.arange(0.0, 7.2, DY):
        z = be_mat(x, yq, cao_chan, dx, dy, nghieng)
        khuat = np.zeros(RONG, bool)
        for buoc in np.arange(DY, 1.0, DY):
            khuat |= be_mat(x, yq + buoc, cao_chan, dx, dy, nghieng) > z + buoc / np.tan(ALPHA) + 1e-6
        anh = 230 * np.exp(-((r - (HANG_0 - z * np.sin(ALPHA) / SX)[None, :]) ** 2) / (2 * 1.6 ** 2))
        anh = anh * rng.gamma(8.0, 1 / 8.0, anh.shape)
        anh[:, khuat] = 0
        anh = np.clip(np.round(anh + rng.normal(8, 3, anh.shape)), 0, 255)
        i_max = anh.argmax(axis=0)                                   # tìm tâm vạch bằng trọng tâm (bài Laser tam giác)
        hang = np.clip(np.arange(-4, 5)[:, None] + i_max[None, :], 0, CAO_ANH - 1)
        w = np.clip(anh[hang, np.arange(RONG)] - 20, 0, None)
        tam = (w * hang).sum(0) / np.maximum(w.sum(0), 1e-9)
        ban_do.append(np.where(anh.max(0) >= 40, (HANG_0 - tam) * SX / np.sin(ALPHA), np.nan))
    return np.array(ban_do)


# linh kiện thử: chiều cao 16 chân lệch nhau vài µm; chân 6 bị vênh, thấp hơn 0,12 mm (không chạm PCB)
rng = np.random.default_rng(2)
CAO_THAT = CHAN_DN + rng.normal(0, 0.006, 16)
CAO_THAT[5] -= 0.12
ban_do = quet(rng, CAO_THAT)
print("bản đồ chiều cao:", ban_do.shape, f"| điểm thiếu {100 * np.isnan(ban_do).mean():.1f}%",
      f"| cao nhất {np.nanmax(ban_do):.3f} mm")
bản đồ chiều cao: (241, 800) | điểm thiếu 10.3% | cao nhất 1.711 mm

5. Gợi ý thiết kế

  1. Fit mặt khay từ các điểm thấp, đổi bản đồ sang chiều cao so với khay.
  2. Phân ngưỡng thấp (chỉ tách khỏi khay), gom vùng, giữ vùng có diện tích cỡ một chân (loại thân linh kiện rất lớn và các đốm nhỏ), đánh số theo quy ước SOIC.
  3. Chiều cao chân = trung vị phần lõi vùng (đã erode).
  4. Thử mọi bộ 3 chân: mặt phẳng qua 3 chân là mặt ngồi nếu không chân nào vượt lên trên nó và tam giác chứa trọng tâm. Độ đồng phẳng = khoảng cách lớn nhất từ các chân tới mặt ngồi.
  5. Gói toàn bộ thành một hàm, chạy 10 lần với linh kiện đặt lại.

6. Lời giải

Bước 1. Mặt khay

def cao_so_voi_khay(bd):
    """Fit mặt khay (điểm thấp hơn 0,5 mm) bằng mặt phẳng, trả về chiều cao so với khay và lưới tọa độ."""
    yy, xx = np.mgrid[0:bd.shape[0], 0:bd.shape[1]]
    X, Y = xx * SX, yy * DY
    m = bd < 0.5                                                   # NaN so sánh luôn False: tự bị loại
    A = np.c_[X[m], Y[m], np.ones(m.sum())]
    he_so, *_ = np.linalg.lstsq(A, bd[m], rcond=None)
    return bd - (he_so[0] * X + he_so[1] * Y + he_so[2]), X, Y, he_so


h, X, Y, khay = cao_so_voi_khay(ban_do)
print(f"mặt khay: nghiêng {1000 * khay[0]:+.2f} µm/mm theo x, {1000 * khay[1]:+.2f} µm/mm theo y")
mặt khay: nghiêng +4.00 µm/mm theo x, -3.00 µm/mm theo y

Độ nghiêng tìm được đúng giá trị đã cài (+4 và −3 µm/mm). Trên 10 mm thân linh kiện, nghiêng 4 µm/mm là 40 µm, gần một nửa dung sai: không bù là hỏng phép đo.

Bước 2. Tìm chân và đo chiều cao từng chân

def tim_chan(h, X, Y, nguong=0.8, dien_tich=(200, 5000)):
    """Tách mọi thứ cao hơn khay (ngưỡng thấp), giữ vùng có diện tích cỡ một chân (loại thân linh kiện, nhiễu),
    đo chiều cao bền nhiễu bằng trung vị phần lõi của vùng."""
    mn = np.nan_to_num(h, nan=-1.0) > nguong                       # NaN thành −1: không bao giờ là chân
    so, nhan, st, _ = cv2.connectedComponentsWithStats(mn.astype(np.uint8))
    chan = []
    for k in range(1, so):
        if not dien_tich[0] <= st[k, cv2.CC_STAT_AREA] <= dien_tich[1]:
            continue
        vung = cv2.erode((nhan == k).astype(np.uint8), np.ones((5, 5), np.uint8)).astype(bool)   # bỏ mép 2 px
        gt = h[vung]
        gt = gt[~np.isnan(gt)]
        chan.append((X[vung].mean(), Y[vung].mean(), np.median(gt), len(gt)))
    chan = np.array(chan)
    # đánh số như SOIC: hàng y nhỏ trái → phải là 1–8, hàng y lớn phải → trái là 9–16
    duoi = chan[chan[:, 1] < np.median(chan[:, 1])]
    tren = chan[chan[:, 1] >= np.median(chan[:, 1])]
    return np.r_[duoi[np.argsort(duoi[:, 0])], tren[np.argsort(-tren[:, 0])]]


print("ngưỡng sát danh định (1,56 mm):", len(tim_chan(h, X, Y, nguong=DAY_THAN + 0.06)), "chân")
chan = tim_chan(h, X, Y)
print(f"ngưỡng thấp + lọc diện tích: {len(chan)} chân; số điểm đo mỗi chân {int(chan[:, 3].min())}–{int(chan[:, 3].max())}")
for i in (0, 4, 5, 6, 15):
    print(f"  chân {i + 1:2d}: tâm ({chan[i, 0]:.2f}, {chan[i, 1]:.2f}) mm, cao {chan[i, 2]:.4f} mm")
print(f"sai số chiều cao chân so với thật: lớn nhất {1000 * np.abs(chan[:, 2] - CAO_THAT).max():.1f} µm")
ngưỡng sát danh định (1,56 mm): 15 chân
ngưỡng thấp + lọc diện tích: 16 chân; số điểm đo mỗi chân 506–529
  chân  1: tâm (1.55, 0.99) mm, cao 1.6508 mm
  chân  5: tâm (6.64, 0.99) mm, cao 1.6607 mm
  chân  6: tâm (7.91, 0.99) mm, cao 1.5366 mm
  chân  7: tâm (9.18, 0.99) mm, cao 1.6480 mm
  chân 16: tâm (1.55, 6.21) mm, cao 1.6492 mm
sai số chiều cao chân so với thật: lớn nhất 0.8 µm

Dòng đầu là cái bẫy chính của dự án: phân ngưỡng sát chiều cao danh định (1,56 mm, "chỉ lấy những gì cao hơn đáy thân") chỉ tìm được 15 chân, vì chân 6 bị vênh xuống còn khoảng 1,53 mm. Chân lỗi biến mất khỏi phép đo, và nếu phần mềm không kiểm tra số chân, linh kiện có thể được phán OK dựa trên 15 chân tốt. Ngưỡng thấp kèm lọc theo diện tích tìm đủ 16 chân; chiều cao từng chân (trung vị của khoảng 500 điểm) sai dưới 1 µm so với giá trị thật.

Bước 3. Mặt ngồi và độ đồng phẳng

Khi đặt lên PCB, linh kiện nằm trên ba chân "nhô xa nhất" sao cho trọng tâm rơi vào trong tam giác của ba chân đó, nếu không nó sẽ lật sang ba chân khác. Đó chính là định nghĩa mặt ngồi (seating plane) của JEDEC; độ đồng phẳng của từng chân là khoảng cách từ nó tới mặt ngồi, của linh kiện là giá trị lớn nhất. Với 16 chân chỉ có 560 bộ ba, thử hết là đủ nhanh.

def trong_tam_giac(p, a, b, c):
    """Điểm p (2D) có nằm trong tam giác abc không (kể cả trên cạnh)?"""
    def cheo(o, u, v):
        return (u[0] - o[0]) * (v[1] - o[1]) - (u[1] - o[1]) * (v[0] - o[0])
    d1, d2, d3 = cheo(a, b, p), cheo(b, c, p), cheo(c, a, p)
    return not ((min(d1, d2, d3) < 0) and (max(d1, d2, d3) > 0))


def mat_ngoi(chan, trong_tam, sai_so=1e-4):
    """Mặt phẳng đỡ (seating plane): đi qua 3 chân, mọi chân khác không vượt quá nó (linh kiện lật ngửa nên
    'vượt' là cao hơn), tam giác 3 chân chứa hình chiếu trọng tâm. Trả về (3 chỉ số chân, khoảng cách từng chân)."""
    P = chan[:, :3]
    for bo in itertools.combinations(range(len(P)), 3):
        a, b, c = P[list(bo)]
        n = np.cross(b - a, c - a)
        if abs(n[2]) < 1e-12:
            continue
        n = n / np.linalg.norm(n) * np.sign(n[2])                 # pháp tuyến hướng lên
        kc = (a - P) @ n                                          # ≥ 0: chân nằm dưới mặt phẳng
        if kc.min() >= -sai_so and trong_tam_giac(trong_tam, a[:2], b[:2], c[:2]):
            return bo, kc
    return None, None


than = (np.nan_to_num(h, nan=-1) > 1.3) & (np.nan_to_num(h, nan=-1) < 1.58)      # đáy thân: lấy trọng tâm hình chiếu
trong_tam = (X[than].mean(), Y[than].mean())
bo3, kc = mat_ngoi(chan, trong_tam)
print(f"trọng tâm thân ({trong_tam[0]:.2f}, {trong_tam[1]:.2f}) mm; mặt ngồi đi qua chân {[i + 1 for i in bo3]}")
print("khoảng cách từng chân tới mặt ngồi (µm):", np.round(1000 * kc).astype(int).tolist())
DUNG_SAI_DP = 0.100
dong_phang = kc.max()
print(f"độ đồng phẳng = {1000 * dong_phang:.1f} µm (chân {kc.argmax() + 1}) → "
      f"{'OK' if dong_phang <= DUNG_SAI_DP else 'NG'} (yêu cầu ≤ {1000 * DUNG_SAI_DP:.0f} µm)")

# so sánh: mặt phẳng hồi quy (bình phương tối thiểu qua 16 chân)
A = np.c_[chan[:, 0], chan[:, 1], np.ones(len(chan))]
hs, *_ = np.linalg.lstsq(A, chan[:, 2], rcond=None)
du = chan[:, 2] - A @ hs
print(f"mặt phẳng hồi quy: chân lệch xa nhất {1000 * np.abs(du).max():.1f} µm (chân {np.abs(du).argmax() + 1}), "
      f"chênh cao nhất − thấp nhất {1000 * (du.max() - du.min()):.1f} µm")
trọng tâm thân (6.02, 3.58) mm; mặt ngồi đi qua chân [5, 11, 15]
khoảng cách từng chân tới mặt ngồi (µm): [7, 12, 11, 25, 0, 125, 14, 8, 6, 10, 0, 7, 7, 8, 0, 3]
độ đồng phẳng = 124.8 µm (chân 6) → NG (yêu cầu ≤ 100 µm)
mặt phẳng hồi quy: chân lệch xa nhất 96.1 µm (chân 6), chênh cao nhất − thấp nhất 122.5 µm
  • Mặt ngồi đi qua ba chân ở cả hai hàng, tam giác của chúng chứa trọng tâm thân; ba chân đó có khoảng cách 0, mọi chân khác dương.
  • Chân 6 cách mặt ngồi khoảng 125 µm, vượt yêu cầu 100 µm: NG, đúng lỗi đã cài.
  • Mặt phẳng hồi quy cho kết luận ngược lại: fit bình phương tối thiểu qua cả 16 chân thì chân vênh kéo mặt phẳng về phía nó, và độ lệch lớn nhất chỉ còn khoảng 96 µm, tức là "OK" với cùng ngưỡng 100 µm. Mặt phẳng hồi quy mô tả hình dạng trung bình của các chân, không mô tả cách linh kiện thực sự nằm trên PCB. Bản sửa đổi JESD22-B108A có thêm phương pháp mặt phẳng hồi quy cho mục đích khác (ước lượng hành vi khi hàn reflow), nên đặc tả phải ghi rõ phương pháp; nếu không, nhà cung cấp và nhà máy sẽ có hai kết luận khác nhau cho cùng một linh kiện.

Bước 4. Độ lặp lại

def do_dong_phang(bd):
    """Cả quy trình cho một lần quét: khay → chân → mặt ngồi → độ đồng phẳng (mm), chân tệ nhất."""
    h_, X_, Y_, _ = cao_so_voi_khay(bd)
    ch = tim_chan(h_, X_, Y_)
    if len(ch) != 16:
        return np.nan, -1                                        # thiếu chân: trạm phải báo lỗi, không phán OK
    th = (np.nan_to_num(h_, nan=-1) > 1.3) & (np.nan_to_num(h_, nan=-1) < 1.58)
    _, k = mat_ngoi(ch, (X_[th].mean(), Y_[th].mean()))
    return k.max(), int(k.argmax()) + 1


rng_l = np.random.default_rng(10)
CAO_TOT = CHAN_DN + rng_l.normal(0, 0.006, 16)                    # một linh kiện tốt để so sánh
for ten, cao in (("linh kiện có chân 6 vênh", CAO_THAT), ("linh kiện tốt", CAO_TOT)):
    kq = []
    for lan in range(10):                                         # 10 lần nhấc ra, đặt lại khay, quét lại
        dx, dy = rng_l.uniform(-0.15, 0.15, 2)
        ng = (rng_l.uniform(0.002, 0.006), rng_l.uniform(-0.005, 0.0))
        kq.append(do_dong_phang(quet(rng_l, cao, dx, dy, ng)))
    dp = np.array([k[0] for k in kq])
    print(f"{ten:25s}: TB {1000 * dp.mean():6.1f} µm, σ {1000 * dp.std(ddof=1):.2f} µm, "
          f"6σ/dung sai {100 * 6 * dp.std(ddof=1) / DUNG_SAI_DP:.1f}%, chân tệ nhất {sorted({k[1] for k in kq})}, "
          f"kết luận {sorted({'OK' if v <= DUNG_SAI_DP else 'NG' for v in dp})}")
linh kiện có chân 6 vênh : TB  124.6 µm, σ 0.57 µm, 6σ/dung sai 3.4%, chân tệ nhất [6], kết luận ['NG']
linh kiện tốt            : TB    7.8 µm, σ 0.48 µm, 6σ/dung sai 2.9%, chân tệ nhất [10, 11], kết luận ['OK']

Cả 10 lần, linh kiện lỗi đều NG ở chân 6 và linh kiện tốt đều OK; độ lệch chuẩn của độ đồng phẳng dưới 1 µm, 6σ chỉ khoảng 3% dung sai. Con số này lạc quan: mô phỏng không có nhám bề mặt và lớp mạ của chân, phản xạ gương trên thiếc, rung khay, sai số hiệu chuẩn của profiler. Trên trạm thật, hãy chạy đúng nghiên cứu này với linh kiện thật (cả loại có chân sát giới hạn) trước khi tin vào trạm; độ lặp lại vài µm đến chục µm là mức thường gặp, vẫn đủ cho dung sai 100 µm nếu chiếu sáng và góc laser hợp lý.

7. Tự đánh giá

  • Phần mềm của bạn có báo lỗi (không phải OK) khi chỉ tìm được 15 chân không? Thử bằng cách xóa một chân khỏi bản đồ chiều cao (gán NaN).
  • Đổi chân vênh sang chân 1 (ở góc): mặt ngồi đổi sang bộ ba nào, độ đồng phẳng còn đúng không?
  • Cho chân 6 cao hơn các chân khác 0,12 mm (vênh xuống, linh kiện sẽ bập bênh): kết quả theo mặt ngồi và theo mặt phẳng hồi quy thay đổi thế nào?
  • Tăng nghiêng khay lên 20 µm/mm và đặt linh kiện lệch 0,5 mm: chương trình còn chạy đúng không?

8. Mở rộng

  • Đo thêm: khoảng cách chân (pitch) và độ lệch ngang từng chân từ tâm vùng; chiều dài chân, độ lệch giữa hai hàng (lead span).
  • Hai phía: chân sát thân dễ bị khuất; thêm camera thứ hai nhìn từ phía đối diện và ghép hai bản đồ.
  • Linh kiện BGA: thay chân bằng bi hàn; chiều cao bi đo bằng fit chỏm cầu (như đỉnh chỏm cầu ở bài laser tam giác) thay vì trung vị mặt phẳng.
  • Đưa vào trạm: gói thành hàm trả về kết quả có cấu trúc, ghi SQLite, gửi OK/NG cho PLC như chặng PLC / Robot / MES.

Tóm tắt

  • Bản đồ chiều cao → bù nghiêng bằng mặt khay fit → tách chân bằng ngưỡng thấp + diện tích → chiều cao bền nhiễu bằng trung vị lõi vùng.
  • Không tìm đối tượng lỗi bằng ngưỡng sát giá trị danh định: chính đối tượng lỗi sẽ biến mất. Luôn kiểm tra số đối tượng tìm được.
  • Mặt ngồi JEDEC: ba chân đỡ có tam giác chứa trọng tâm; độ đồng phẳng là khoảng cách lớn nhất tới mặt ngồi. Mặt phẳng hồi quy có thể đổi kết luận sát giới hạn; đặc tả phải ghi phương pháp.
  • Độ lặp lại trong mô phỏng là cận dưới; kiểm chứng lại bằng nghiên cứu MSA trên linh kiện thật.

Chặng tiếp theo: PLC / Robot / MES, bắt đầu với bài I/O số và handshake với PLC, để đưa kết quả của các trạm đo 2D và 3D tới dây chuyền.

Nguồn tham khảo: JEDEC JESD22-B108 / JESD22-B108A, Coplanarity Test for Surface-Mount Semiconductor Devices (định nghĩa mặt ngồi và độ đồng phẳng); US6713311B2 (mô tả phương pháp mặt ngồi theo JEDEC); AT Sensors: Measuring principle (laser triangulation).

Bài tập thực hành

  1. Chạy toàn bộ dự án, rồi chuyển chân vênh sang chân 1 và kiểm tra mặt ngồi đổi thế nào.
  2. So độ đồng phẳng theo mặt ngồi và theo mặt phẳng hồi quy cho linh kiện sát giới hạn.

Làm xong bài tập mới chuyển sang bài tiếp theo: tự viết code là cách duy nhất để nhớ lâu.

Bài tiếp theo
Ban biên tập HocFree

Chúng tôi viết những bài hướng dẫn dễ hiểu, thực tế để ai cũng có thể tự học lập trình và AI, hoàn toàn miễn phí.