G-code là gì: các lệnh G0, G1, G2, G3, M3, M5 cơ bản và cách đọc một file G-code

G-code là gì, các lệnh G0 G1 G2 G3 G90 G91 M3 M5 F S dùng nhiều nhất trên máy CNC, máy laser chạy GRBL, cung tròn I J, gốc phôi, kèm chương trình Python tự sinh G-code.

G-code là ngôn ngữ lệnh mà máy CNC, máy khắc laser và máy in 3D hiểu được. Mỗi dòng là một lệnh ngắn kiểu "đi thẳng tới X = 40, Y = 10 với tốc độ 600 mm/phút" hay "bật spindle 10 000 vòng/phút". Phần mềm CAM và phần mềm khắc laser tự tạo ra G-code, nhưng người dùng biết đọc G-code sẽ hiểu máy sắp làm gì, sửa nhanh một con số, và tìm ra lỗi khi máy chạy sai.

Bài này giải thích các lệnh G-code dùng nhiều nhất trên máy chạy firmware GRBL, cách hiểu tọa độ tuyệt đối và tương đối, cung tròn G2, G3, gốc máy và gốc phôi, kèm một chương trình Python nhỏ tự sinh G-code để phay một miếng chữ nhật bo góc có lỗ tròn.

1. G-code là gì

G-code ra đời cùng máy điều khiển số, sau được chuẩn hóa (ví dụ tiêu chuẩn ISO 6983, RS-274). Mỗi hãng máy và mỗi firmware dùng một "phương ngữ" hơi khác nhau. GRBL, firmware phổ biến nhất cho máy CNC mini và máy laser diode, hỗ trợ một tập lệnh cơ bản đủ cho hầu hết công việc phay, khắc 2D và 2,5D.

Một dòng G-code gồm các từ, mỗi từ là một chữ cái và một số:

G1 X40 Y10 F600   ; đi thẳng tới (40, 10), tốc độ 600 mm/phút

• G… lệnh chuyển động và chế độ; M… lệnh phụ (spindle, laser, kết thúc chương trình).
• X, Y, Z tọa độ; I, J tâm cung tròn; F tốc độ chạy; S tốc độ spindle hoặc công suất laser; P thời gian chờ.
• Phần trong ngoặc tròn ( … ) hoặc sau dấu chấm phẩy ; là chú thích, máy bỏ qua.

Phần lớn lệnh là lệnh duy trì (modal): sau G1 các dòng tiếp theo chỉ cần ghi tọa độ, máy vẫn hiểu là G1 cho tới khi gặp G0, G2 hay G3. F và S cũng giữ nguyên cho tới khi đổi.

2. Các lệnh dùng nhiều nhất

• G0 chạy nhanh nhất có thể để di chuyển, không dùng để cắt. Luôn nhấc dao lên độ cao an toàn trước khi G0 ngang.
• G1 đi thẳng với tốc độ F (mm/phút). Dòng G1 đầu tiên phải có F; GRBL báo error:22 nếu chưa có tốc độ.
• G21 chọn milimét. Một file vô tình dùng G20 (inch) sẽ cho hình to gấp 25,4 lần.
• M3 S… bật spindle (hoặc laser công suất cố định), M5 tắt. Với máy laser chạy GRBL ở chế độ laser, M4 tự giảm công suất khi máy chạy chậm lại ở góc (bài 12 của loạt).
• M30 kết thúc chương trình.

3. Tọa độ tuyệt đối G90 và tương đối G91

• G90 (tuyệt đối): X, Y là tọa độ đích tính từ gốc. Phần mềm CAM gần như luôn xuất G90.
• G91 (tương đối): X, Y là quãng đường đi thêm từ vị trí hiện tại. Hay dùng khi đẩy tay (jog) từng bước.
• Lỗi hay gặp: chuyển sang G91 để jog rồi quên chuyển lại G90, chương trình sau đó chạy lệch hoàn toàn. Đầu mỗi file nên có G90.

4. Cung tròn G2, G3 và tham số I, J

• G2 đi cung theo chiều kim đồng hồ, G3 ngược chiều kim đồng hồ, khi nhìn từ trên xuống.
• X, Y là điểm cuối của cung; điểm đầu là vị trí hiện tại.
• I, J là khoảng cách từ điểm đầu tới tâm theo trục X và Y. Đây là cách hiểu mặc định của GRBL.
• Điểm cuối trùng điểm đầu thì máy chạy trọn một vòng tròn, như lệnh G3 X22 Y20 I8 J0 trong chương trình mẫu bên dưới.
• Tâm tính ra phải cách điểm đầu và điểm cuối một khoảng bằng nhau (sai lệch rất nhỏ); nếu không GRBL báo lỗi cung tròn và dừng.

5. Gốc máy và gốc phôi

• Gốc máy (MPos): máy biết sau khi chạy về gốc (homing) bằng công tắc hành trình. Máy không có công tắc thì gốc máy là chỗ dao đứng lúc bật máy.
• Gốc phôi (WPos): điểm người dùng chọn trên phôi, thường là góc trái dưới và mặt trên của phôi. G-code do phần mềm CAM xuất ra tính từ gốc này.
• Đặt gốc phôi: đưa dao tới đúng góc phôi, hạ chạm mặt phôi rồi gửi G10 L20 P1 X0 Y0 Z0. Nút "Zero" trong phần mềm gửi G-code làm đúng việc này. GRBL lưu độ lệch vào hệ tọa độ G54.

6. Ví dụ: tự sinh G-code bằng Python

Chương trình dưới đây tạo G-code phay một lỗ tròn bán kính 8 mm và viền chữ nhật 60 × 40 mm bo bốn góc R5, mỗi đường cắt ăn 3 lớp, mỗi lớp 1 mm. Viết chương trình kiểu này giúp hiểu G-code hơn là đọc lý thuyết, và hữu ích khi cần các hình lặp lại (lưới lỗ, chữ nhật nhiều cỡ).

• Cài Python 3 trên máy tính, lưu file sinh_gcode.py.
• Chạy python sinh_gcode.py > mieng_mau.nc để ghi G-code ra file.
• Mở file bằng phần mềm xem trước G-code (có trong hầu hết phần mềm gửi G-code) và kiểm tra đường đi trước khi cắt thật.

# PYWORLD.VN - Sinh G-code phay một miếng chữ nhật bo góc có lỗ tròn ở giữa (máy CNC mini chạy GRBL)
# Đơn vị mm. Gốc phôi: góc trái dưới của miếng, mặt trên phôi là Z = 0. Dao đi ngược chiều kim đồng hồ.
# Chạy: python sinh_gcode.py > mieng_mau.nc   rồi xem thử bằng phần mềm mô phỏng G-code trước khi cắt thật.

Z_AN_TOAN = 5.0       # độ cao chạy nhanh G0, cao hơn mọi kẹp phôi
TOC_CAT = 600         # F khi cắt ngang (mm/phút)
TOC_XUONG = 200       # F khi ăn xuống theo Z (mm/phút)
VONG_QUAY = 10000     # S: tốc độ spindle (vòng/phút)


def so(v):
    """Số gọn: 30.0 -> 30, 2.50 -> 2.5"""
    return f"{v:.3f}".rstrip("0").rstrip(".")


def cac_lop(sau, buoc):
    """Các độ sâu cắt lần lượt, ví dụ sâu 3 bước 1 -> [-1, -2, -3]"""
    z, lop = 0.0, []
    while z > -sau + 1e-9:
        z = max(z - buoc, -sau)
        lop.append(z)
    return lop


def lo_tron(cx, cy, r, sau, buoc):
    """Đường tròn tâm (cx, cy) bán kính r, cắt nhiều lớp. Dao bắt đầu ở điểm bên trái đường tròn."""
    dong = [f"(lo tron tam X{so(cx)} Y{so(cy)} ban kinh {so(r)})",
            f"G0 X{so(cx - r)} Y{so(cy)}"]
    for z in cac_lop(sau, buoc):
        dong.append(f"G1 Z{so(z)} F{TOC_XUONG}")
        dong.append(f"G3 X{so(cx - r)} Y{so(cy)} I{so(r)} J0 F{TOC_CAT}")   # cả vòng tròn, tâm cách điểm đầu I = r
    dong.append(f"G0 Z{so(Z_AN_TOAN)}")
    return dong


def chu_nhat_bo_goc(rong, cao, r, sau, buoc):
    """Viền chữ nhật rong x cao, bốn góc bo bán kính r, góc trái dưới tại (0, 0)."""
    dong = [f"(vien chu nhat {so(rong)} x {so(cao)} bo goc R{so(r)})",
            f"G0 X{so(r)} Y0"]
    for z in cac_lop(sau, buoc):
        dong += [f"G1 Z{so(z)} F{TOC_XUONG}",
                 f"G1 X{so(rong - r)} Y0 F{TOC_CAT}",
                 f"G3 X{so(rong)} Y{so(r)} I0 J{so(r)}",
                 f"G1 X{so(rong)} Y{so(cao - r)}",
                 f"G3 X{so(rong - r)} Y{so(cao)} I{so(-r)} J0",
                 f"G1 X{so(r)} Y{so(cao)}",
                 f"G3 X0 Y{so(cao - r)} I0 J{so(-r)}",
                 f"G1 X0 Y{so(r)}",
                 f"G3 X{so(r)} Y0 I{so(r)} J0"]
    dong.append(f"G0 Z{so(Z_AN_TOAN)}")
    return dong


def chuong_trinh():
    dong = ["(PYWORLD.VN - mieng mau, duong tam dao)",
            "G21 G90 G17      (mm, toa do tuyet doi, mat phang XY)",
            f"G0 Z{so(Z_AN_TOAN)}",
            f"M3 S{VONG_QUAY}",
            "G4 P2            (cho spindle quay du toc do 2 giay)"]
    dong += lo_tron(30, 20, 8, 3, 1)               # cắt chi tiết bên trong trước
    dong += chu_nhat_bo_goc(60, 40, 5, 3, 1)       # viền ngoài cắt sau cùng
    dong += ["M5", "G0 X0 Y0", "M30"]
    return "\n".join(dong)


if __name__ == "__main__":
    print(chuong_trinh())

Kết quả chạy chương trình (47 dòng):

(PYWORLD.VN - mieng mau, duong tam dao)
G21 G90 G17      (mm, toa do tuyet doi, mat phang XY)
G0 Z5
M3 S10000
G4 P2            (cho spindle quay du toc do 2 giay)
(lo tron tam X30 Y20 ban kinh 8)
G0 X22 Y20
G1 Z-1 F200
G3 X22 Y20 I8 J0 F600
G1 Z-2 F200
G3 X22 Y20 I8 J0 F600
G1 Z-3 F200
G3 X22 Y20 I8 J0 F600
G0 Z5
(vien chu nhat 60 x 40 bo goc R5)
G0 X5 Y0
G1 Z-1 F200
G1 X55 Y0 F600
G3 X60 Y5 I0 J5
G1 X60 Y35
G3 X55 Y40 I-5 J0
G1 X5 Y40
G3 X0 Y35 I0 J-5
G1 X0 Y5
G3 X5 Y0 I5 J0
G1 Z-2 F200
G1 X55 Y0 F600
G3 X60 Y5 I0 J5
G1 X60 Y35
G3 X55 Y40 I-5 J0
G1 X5 Y40
G3 X0 Y35 I0 J-5
G1 X0 Y5
G3 X5 Y0 I5 J0
G1 Z-3 F200
G1 X55 Y0 F600
G3 X60 Y5 I0 J5
G1 X60 Y35
G3 X55 Y40 I-5 J0
G1 X5 Y40
G3 X0 Y35 I0 J-5
G1 X0 Y5
G3 X5 Y0 I5 J0
G0 Z5
M5
G0 X0 Y0
M30

Vài điểm cần để ý trong chương trình:

• Tọa độ là đường đi của tâm dao. Với mũi phay đường kính 3 mm, lỗ thật rộng 16 + 3 = 19 mm, còn miếng cắt ra nhỏ hơn viền 3 mm mỗi chiều (57 × 37 mm). Phần mềm CAM tự dời đường dao ra ngoài hay vào trong nửa đường kính dao, gọi là bù bán kính dao.
• Cắt phần bên trong trước, viền ngoài sau cùng. Nếu cắt viền ngoài trước, miếng phôi đã rời ra và có thể xê dịch khi cắt lỗ.
• Ăn từng lớp. Máy mini không đủ khỏe để cắt hết chiều sâu một lần; mỗi lớp 1 mm với mũi 3 mm trong gỗ là mức an toàn để bắt đầu.
• Z an toàn 5 mm trước mọi lệnh G0 ngang, phải cao hơn kẹp phôi.

7. Lỗi thường gặp khi đọc, chạy G-code

8. Xem thêm

• Bài trước trong loạt: Cấu tạo máy CNC mini và máy khắc laser. Bài sau: Động cơ bước cho máy CNC.
• Bài 11 và 12 của loạt: GRBL là gì và cấu hình GRBL. Bài 16: tự viết bộ đọc G-code trên ESP32 cho máy vẽ.
• ESP32 điều khiển động cơ bước NEMA 17 với A4988.
• ESP32 DevKit V1 tại PYWORLD.