🎓 Danh sách khóa học Thầy Lê Chí Tuyền

"""Tính lỗ khoan và pad cho linh kiện CHÂN XUYÊN (THT) – theo khuyến nghị IPC-2222 / IPC-7251
   Lỗ khoan  = đường kính chân lớn nhất + khe hở (0.2 mm mức B; 0.25 mm mức A)
   Pad       = lỗ khoan + 2 x vành khuyên (annular ring, tối thiểu ~0.15–0.25 mm, nên >= 0.3 mm khi hàn tay)
   Chân hình chữ nhật: dùng đường chéo sqrt(a² + b²) làm "đường kính chân"
Chạy: python 02-lo-khoan-pad-cham-xuyen.py"""
import math

KHE_HO = 0.20           # mm
VANH_KHUYEN = 0.30      # mm – thoải mái cho hàn tay / xưởng giá rẻ
LO_CHUAN = [0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.5, 1.6, 2.0, 3.2]   # mũi khoan xưởng hay có (mm)


def tinh(ten, chan_mm=None, chan_cn=None):
    d = chan_mm if chan_mm else math.hypot(*chan_cn)
    lo_toi_thieu = d + KHE_HO
    lo = next(x for x in LO_CHUAN if x >= lo_toi_thieu - 1e-9)        # làm tròn lên mũi khoan có sẵn
    pad = lo + 2 * VANH_KHUYEN
    return ten, d, lo, pad


ds = [
    tinh("Điện trở 1/4W", chan_mm=0.6),
    tinh("LED 5 mm", chan_cn=(0.5, 0.5)),
    tinh("Header 2.54 mm", chan_cn=(0.64, 0.64)),
    tinh("IC DIP-8 (NE555)", chan_cn=(0.53, 0.25)),
    tinh("Tụ hoá 10x16", chan_mm=0.6),
    tinh("Diode 1N5408 (3A)", chan_mm=1.3),
    tinh("Transistor TO-220", chan_cn=(0.9, 0.5)),
    tinh("Domino KF301 (5.0)", chan_cn=(1.0, 0.8)),
]
print(f"{'Linh kiện':<22}| {'chân (mm)':>9} | {'lỗ khoan':>8} | {'pad':>5}")
print("-" * 54)
for ten, d, lo, pad in ds:
    print(f"{ten:<22}| {d:>9.2f} | {lo:>8.2f} | {pad:>5.2f}")

print("\nKiểm tra khoảng hở giữa 2 pad header 2.54 mm:")
pad_header = ds[2][3]
khe = 2.54 - pad_header
print(f"  pad {pad_header:.2f} mm -> khe giữa 2 pad = {khe:.2f} mm "
      f"({'đi được 1 đường 0.25 mm + 2 khe 0.2 mm' if khe >= 0.65 else 'KHÔNG đủ chỗ đi dây giữa 2 chân'})")

"""Tính land pattern (pad) cho điện trở / tụ dán (chip) – theo ý tưởng IPC-7351 (rút gọn, dùng kích thước danh định)
   S (khe giữa 2 đầu cực) = L − 2·T
   Z (mép ngoài 2 pad) = L + 2·Jt + Cz        Jt: mối hàn mũi (toe)
   G (mép trong 2 pad) = S − 2·Jh − Cg        Jh: mối hàn gót (heel)
   X (rộng pad)        = W + 2·Js + Cx        Js: mối hàn cạnh (side)
   Mức B (nominal) cho chip >= 0603: Jt = 0.35, Jh = −0.05, Js = 0.00 (mm)
   Cz, Cg, Cx: tổng dung sai = sqrt(dung_sai_linh_kien² + F² + P²), F = sai số chế tạo 0.05, P = sai số gắp đặt 0.05
Chạy: python 03-footprint-chip-smd.py"""
import math

JT, JH, JS = 0.35, -0.05, 0.00
F, P = 0.05, 0.05

# Kích thước linh kiện theo datasheet điện trở chip (mm): (L, ±L, W, ±W, T đầu cực, ±T)
LINH_KIEN = {
    "0402 (1005)": (1.00, 0.05, 0.50, 0.05, 0.25, 0.10),
    "0603 (1608)": (1.60, 0.10, 0.80, 0.10, 0.30, 0.20),
    "0805 (2012)": (2.00, 0.10, 1.25, 0.10, 0.40, 0.20),
    "1206 (3216)": (3.20, 0.10, 1.60, 0.10, 0.50, 0.25),
}


def land_pattern(L, dL, W, dW, T, dT):
    S = L - 2 * T
    Cz = math.sqrt(dL ** 2 + F ** 2 + P ** 2)
    Cg = math.sqrt(dL ** 2 + (2 * dT) ** 2 + F ** 2 + P ** 2) / 2
    Cx = math.sqrt(dW ** 2 + F ** 2 + P ** 2)
    Z = L + 2 * JT + Cz
    G = S - 2 * JH - Cg
    X = W + 2 * JS + Cx
    return Z, G, X, (Z - G) / 2, (Z + G) / 2


print(f"{'Gói':<12}| {'Z':>5} | {'G':>5} | {'pad dài x rộng':>15} | {'tâm–tâm':>7}")
print("-" * 56)
for ten, kt in LINH_KIEN.items():
    Z, G, X, l, c = land_pattern(*kt)
    print(f"{ten:<12}| {Z:>5.2f} | {G:>5.2f} | {l:>6.2f} x {X:<6.2f} | {c:>7.2f}")

print("\nGhi chú: làm tròn tới 0.05 mm khi nhập vào Altium; courtyard = Z và X cộng thêm 0.25 mm mỗi phía.")
Z, G, X, l, c = land_pattern(*LINH_KIEN["0603 (1608)"])
print(f"Ví dụ 0603 nhập vào Altium: 2 pad {round(l / .05) * .05:.2f} x {round(X / .05) * .05:.2f} mm, "
      f"tâm pad tại x = ±{c / 2:.3f} mm, courtyard {Z + 0.5:.2f} x {X + 0.5:.2f} mm")

"""Tính trở kháng đặc tính của đường microstrip (đường trên lớp ngoài, có mặt GND ngay lớp dưới)
   Công thức IPC-2141:  Z0 = 87 / sqrt(εr + 1.41) · ln( 5.98·h / (0.8·w + t) )      (hợp lệ khi 0.1 < w/h < 2)
   Cặp vi sai (gần đúng): Zdiff ≈ 2·Z0·(1 − 0.48·e^(−0.96·s/h))
   Stack-up mẫu: mạch 4 lớp 1.6 mm, lớp prepreg 7628 dày h = 0.21 mm, εr ≈ 4.4, đồng ngoài 1 oz (t = 0.035 mm)
Chạy: python 04-tro-khang-microstrip.py"""
import math

H, ER, T = 0.21, 4.4, 0.035


def z0(w, h=H, er=ER, t=T):
    return 87 / math.sqrt(er + 1.41) * math.log(5.98 * h / (0.8 * w + t))


def zdiff(w, s, h=H):
    return 2 * z0(w, h) * (1 - 0.48 * math.exp(-0.96 * s / h))


def tim_be_rong(muc_tieu, h=H):
    lo, hi = 0.02, 3 * h                     # Z0 giảm khi w tăng -> chia đôi
    for _ in range(60):
        mid = (lo + hi) / 2
        if z0(mid, h) > muc_tieu: lo = mid
        else: hi = mid
    return (lo + hi) / 2


print("Z0 theo bề rộng đường (h = 0.21 mm, εr = 4.4):")
for w in [0.15, 0.20, 0.30, 0.40, 0.50]:
    print(f"  w = {w:.2f} mm -> Z0 = {z0(w):5.1f} Ω")

w50 = tim_be_rong(50)
print(f"\nĐường 50 Ω (anten 2.4 GHz, RF): w ≈ {w50:.3f} mm")

print("\nCặp vi sai USB 2.0 (mục tiêu 90 Ω ± 10%):")
for w, s in [(0.15, 0.15), (0.20, 0.15), (0.25, 0.15), (0.25, 0.20)]:
    z = zdiff(w, s)
    print(f"  w = {w:.2f}, s = {s:.2f} mm -> Zdiff ≈ {z:5.1f} Ω {'✓' if 81 <= z <= 99 else ''}")

print("\nNếu là mạch 2 lớp 1.6 mm (h = 1.5 mm), đường 50 Ω phải rộng:",
      f"{tim_be_rong(50, 1.5):.2f} mm -> quá to, vì vậy RF/high-speed nên dùng mạch 4 lớp.")

"""Tính bề rộng đường mạch theo dòng điện – công thức IPC-2221
   I = k · ΔT^0.44 · A^0.725      (A: tiết diện, đơn vị mil²)
   k = 0.048 với lớp NGOÀI (top/bottom), 0.024 với lớp TRONG (khó toả nhiệt hơn)
Chạy: python 01-be-rong-duong-mach.py"""
import math

MIL = 0.0254            # 1 mil = 0.0254 mm
OZ_TO_MIL = 1.378       # 1 oz/ft² đồng ≈ 1.378 mil ≈ 35 µm
RHO_CU = 1.72e-8        # điện trở suất đồng (Ω·m) ở 20°C


def be_rong_mm(dong_A, tang_nhiet=10, oz=1.0, lop_ngoai=True):
    k = 0.048 if lop_ngoai else 0.024
    tiet_dien_mil2 = (dong_A / (k * tang_nhiet ** 0.44)) ** (1 / 0.725)
    return tiet_dien_mil2 / (oz * OZ_TO_MIL) * MIL


def sut_ap(dong_A, rong_mm, dai_mm, oz=1.0):
    day_m = oz * 35e-6
    R = RHO_CU * (dai_mm / 1000) / ((rong_mm / 1000) * day_m)
    return R, dong_A * R, dong_A ** 2 * R


print("Bề rộng tối thiểu (mm) cho phép tăng nhiệt ΔT = 10°C")
print(f"{'Dòng (A)':>9} | {'ngoài 1oz':>10} | {'ngoài 2oz':>10} | {'trong 1oz':>10}")
print("-" * 49)
for I in [0.3, 0.5, 1, 2, 3, 5, 10]:
    print(f"{I:>9} | {be_rong_mm(I):>10.2f} | {be_rong_mm(I, oz=2):>10.2f} | {be_rong_mm(I, lop_ngoai=False):>10.2f}")

print("\nẢnh hưởng của mức tăng nhiệt cho phép (2 A, lớp ngoài, 1 oz):")
for dT in [5, 10, 20, 30]:
    print(f"  ΔT = {dT:>2}°C -> {be_rong_mm(2, dT):.2f} mm")

print("\nSụt áp & công suất toả nhiệt trên đường dài 50 mm, 1 oz:")
for I, w in [(0.5, 0.25), (2, 0.8), (5, 2.5)]:
    R, V, P = sut_ap(I, w, 50)
    print(f"  {I} A, rộng {w} mm: R = {R * 1000:.1f} mΩ, sụt áp = {V * 1000:.0f} mV, P = {P * 1000:.0f} mW")

"""Via chịu được bao nhiêu dòng? – coi thân via mạ đồng như một đường mạch lớp TRONG (IPC-2221, k = 0.024)
   Tiết diện thành via = π · (d_lỗ + t) · t       t: độ dày lớp mạ (thường 20–25 µm)
Chạy: python 05-via-dong-dien.py"""
import math

MIL = 0.0254


def dong_qua_via(d_lo_mm, t_ma_mm=0.025, tang_nhiet=10):
    tiet_dien_mm2 = math.pi * (d_lo_mm + t_ma_mm) * t_ma_mm
    tiet_dien_mil2 = tiet_dien_mm2 / (MIL * MIL)
    return 0.024 * tang_nhiet ** 0.44 * tiet_dien_mil2 ** 0.725


print(f"{'Lỗ via (mm)':>11} | {'dòng tối đa (A)':>15}")
print("-" * 30)
for d in [0.2, 0.3, 0.4, 0.5, 0.6]:
    print(f"{d:>11.1f} | {dong_qua_via(d):>15.2f}")

I, d = 5, 0.3
n = math.ceil(I / dong_qua_via(d) * 1.25)           # +25% dự phòng
print(f"\nĐưa {I} A từ lớp TOP xuống lớp POWER bằng via {d} mm cần ít nhất {n} via (đã cộng 25% dự phòng).")
print("Mẹo: đặt các via thành cụm ngay sát pad, thay vì 1 via to ở xa.")

"""Mạch đo dòng (điện trở shunt) và đo áp (cầu phân áp) cho ADC 12 bit của ESP32 (0–3.3 V)
Chạy: python 06-do-dong-do-ap.py"""

ADC_BIT, VREF = 12, 3.3
LSB = VREF / (2 ** ADC_BIT)

print("== ĐO ÁP: pin 24 V qua cầu phân áp R1 (trên) – R2 (dưới) ==")
V_MAX = 25.2                                   # pin 6S đầy 25.2 V
for R1, R2 in [(100e3, 10e3), (100e3, 15e3), (68e3, 10e3)]:
    he_so = R2 / (R1 + R2)
    v_adc = V_MAX * he_so
    dong_tieu_thu = V_MAX / (R1 + R2)
    ok = "VƯỢT 3.3 V – hỏng chân ADC!" if v_adc > VREF else ("sát 3.3 V, không còn dự phòng" if v_adc > 0.9 * VREF else "OK")
    print(f"  R1 = {R1 / 1e3:.0f}k, R2 = {R2 / 1e3:.0f}k: Vadc max = {v_adc:.2f} V ({ok}), "
          f"độ phân giải = {LSB / he_so * 1000:.1f} mV/bước, dòng rò = {dong_tieu_thu * 1e6:.0f} µA")

R_LOC, C_LOC = 10e3, 100e-9
import math
fc = 1 / (2 * math.pi * R_LOC * C_LOC)
print(f"  Lọc RC {R_LOC / 1e3:.0f}k + {C_LOC * 1e9:.0f}nF trước chân ADC: tần số cắt {fc:.0f} Hz")

print("\n== ĐO DÒNG: điện trở shunt + khuếch đại (INA180 gain 50) ==")
I_MAX, V_SHUNT_MAX = 5.0, 0.05                 # muốn sụt áp trên shunt <= 50 mV ở dòng max
R_SHUNT = V_SHUNT_MAX / I_MAX
GAIN = 50
P = I_MAX ** 2 * R_SHUNT
v_ra = I_MAX * R_SHUNT * GAIN
print(f"  R_shunt = {R_SHUNT * 1000:.0f} mΩ, công suất ở {I_MAX} A = {P:.2f} W -> chọn shunt 2512 loại 1 W")
print(f"  Điện áp ra khuếch đại ở {I_MAX} A = {v_ra:.2f} V (<= 3.3 V: OK)")
print(f"  Độ phân giải dòng = {LSB / (R_SHUNT * GAIN) * 1000:.1f} mA/bước ADC")
for I in [0.1, 1.0, 2.5]:
    adc = round(I * R_SHUNT * GAIN / LSB)
    print(f"  I = {I:>4} A -> giá trị ADC ≈ {adc}")
print("\nLayout: nối 2 dây cảm biến của bộ khuếch đại vào shunt theo kiểu KELVIN (4 dây),")
print("đi song song sát nhau tới chân IN+/IN−, không dùng chung đường dòng lớn.")