Robot học: dạy máy cảm nhận, quyết định và hành động trong thế giới thật
Robot học cho người học khoa học máy tính: vòng cảm nhận – hành động, động học, lọc Kalman, RRT, PID, an toàn khi làm cạnh người — và học từ đâu.
Ban biên tập OpenER
Cập nhật 18/11/2026 · 19 phút đọc · CC BY 4.0
Năm 1997, một chiếc máy tính thắng nhà vô địch cờ vua thế giới. Gần ba mươi năm sau, hãy thử nhờ một cánh tay robot làm việc mà cô bán xôi đầu ngõ làm mỗi sáng: xới một nắm xôi vừa đủ, gói vào lá chuối, buộc dây, đưa cho khách — giữa lúc người chen nhau, xe máy lướt sát bên. Không bước nào cần phép tính khó, vậy mà với robot, nó khó hơn đánh cờ nhiều.
Bài Nhập môn trí tuệ nhân tạo coi robot hút bụi là một tác tử biết chọn hành động. Bài này hỏi tiếp: bánh trượt trên sàn gạch thì làm sao nó biết mình đang ở đâu, đi đường nào để khỏi kẹt dưới gầm giường, quẹo bao nhiêu để bám đúng đường? Robot học (robotics) là ngành làm ra những cỗ máy cảm nhận thế giới qua cảm biến, quyết định nên làm gì, rồi hành động bằng động cơ, bánh xe, cánh tay — ngoài đời thật, nơi sàn trơn, pin yếu dần, cảm biến đo sai và con người đi lại xung quanh. Ở đây không có nút "hoàn tác": một lỗi phần mềm có thể làm vỡ cái cốc, hoặc làm người bị thương.
Trước khi có robot
Nhà máy có máy móc từ lâu, nhưng mỗi máy chỉ làm đúng một việc đã chế tạo sẵn, như trục cam trong máy giặt đời cũ ở bài Hệ thống nhúng — tự động hóa cứng (fixed automation): đổi sản phẩm là phải chế lại máy. Còn việc nặng, nóng và độc vẫn do người làm.
Robot ra đời từng bước:
- Chữ "robot" — năm 1920. Vở kịch R.U.R. (Rossum's Universal Robots) của nhà văn Séc Karel Čapek, công diễn chính thức ở Praha tháng 1/1921, kể về những người nhân tạo làm việc thay người rồi nổi dậy. Chữ này lấy từ tiếng Séc robota — lao dịch; theo Čapek, người nghĩ ra nó là anh trai ông, Josef.
- Robot công nghiệp đầu tiên — năm 1961. Từ bằng sáng chế George Devol nộp năm 1954, ông và Joseph Engelberger làm ra Unimate; chiếc đầu tiên vào một nhà máy của General Motors năm 1961, gắp chi tiết còn nóng từ máy đúc. Nó lập trình lại được — đổi việc thì đổi chương trình — nhưng không nhìn thấy gì: chi tiết lệch vài phân là nó gắp vào khoảng không.
- Robot biết nghĩ trước khi đi — 1966–1972. Shakey ở Viện nghiên cứu Stanford (SRI) có camera, máy đo khoảng cách, cảm biến va chạm. Nhận lệnh kiểu "đẩy khối hộp tới cửa", nó dựng bản đồ, lập kế hoạch rồi mới đi; thuật toán A* (1968) mà bài Nhập môn trí tuệ nhân tạo dùng cho trò 8 ô ra đời để tìm đường cho nó. Nhưng nghĩ thì chậm: năm 1979, xe Stanford Cart của Hans Moravec tự băng qua một căn phòng đầy ghế mất khoảng năm tiếng, cứ nhích một mét lại dừng 10–15 phút để xử lý ảnh.
- Ra khỏi phòng thí nghiệm — 1997. Xe tự hành Sojourner, cỡ chiếc lò vi sóng, đáp xuống sao Hỏa ngày 4/7/1997 cùng tàu Mars Pathfinder (bài Hệ điều hành kể chuyện máy tính của tàu). Tín hiệu đi giữa hai hành tinh mất nhiều phút, nên kỹ sư chỉ chọn điểm đến; Sojourner tự chiếu vệt laser xuống đất, nhìn qua camera để thấy đá và đi vòng.
- Xe tự lái băng sa mạc — 2004, 2005. Cơ quan nghiên cứu quốc phòng Mỹ (DARPA) treo giải cho xe tự chạy hết hơn 200 km đường sa mạc. Năm 2004 không xe nào về đích; xe xa nhất đi được chưa tới 12 km. Năm 2005, năm xe về đích trên chặng 212 km; xe Stanley của Đại học Stanford, nhóm do Sebastian Thrun dẫn, về nhất sau khoảng 6 giờ 54 phút — nhờ phần mềm biết ước lượng bằng xác suất và học từ dữ liệu.
- Vào kho hàng và xưởng — từ cuối thập niên 2000. Robot của Kiva Systems chui dưới gầm kệ, chở cả kệ hàng tới chỗ người nhặt hàng; năm 2012 Amazon mua Kiva với giá 775 triệu USD. Robot cộng tác (collaborative robot — cobot) như UR5 (2008) làm ngay cạnh công nhân, thường không cần lồng chắn.
Đặt cạnh nhau:
Không có robot | Có robot | |
|---|---|---|
Việc nặng, nóng, độc: đúc, hàn, phun sơn | Người làm, chịu bỏng, hít khói | Robot làm; người lập trình và giám sát |
Đổi sang sản phẩm khác | Chế lại máy, có khi cả dây chuyền | Nạp chương trình mới, thay đồ gá |
Nơi người không tới được: sao Hỏa, đáy biển | Không ai tới | Robot tới, tự xử lý việc không kịp chờ lệnh |
Kho hàng lớn | Người đi bộ tới từng kệ | Kệ tự đi tới người |
Ngày nay vẫn còn nhiều việc "chưa có robot". Cà phê ở Tây Nguyên, thanh long ở Bình Thuận phần lớn vẫn hái bằng tay. Quả mềm, nấp sau lá, chín không đều: robot phải nhìn ra quả, đoán độ chín, luồn tay qua cành, cầm đủ chặt mà không làm dập — những việc người hái làm không cần nghĩ.
Môn này trả lời câu hỏi gì
Môn Robot học trả lời: làm sao để một cỗ máy cảm nhận, quyết định và hành động đáng tin cậy trong một thế giới vật lý mà nó chỉ thấy một phần, đo sai một chút, và không bao giờ đứng yên chờ nó tính xong?
Hãy nghĩ tới lúc bạn chạy xe máy giờ tan tầm: mắt thấy một khoảng trống, đầu quyết định lách trái, tay xoay ghi-đông — lặp lại nhiều lần mỗi giây. Đó là vòng cảm nhận – lập kế hoạch – hành động (sense–plan–act) của mọi robot. Nhưng bạn không nghĩ để giữ thăng bằng: phần đó chạy như phản xạ. Shakey nhìn hết, nghĩ hết rồi mới đi, nên rất chậm; năm 1986, Rodney Brooks ở MIT đề xuất ngược lại — nhiều tầng phản xạ đơn giản nối thẳng cảm biến với động cơ. Robot ngày nay kết hợp cả hai: vòng điều khiển động cơ ở dưới chạy hàng trăm tới hàng nghìn lần mỗi giây, phần lập kế hoạch ở trên chậm hơn.
Vì sao những việc "dễ" lại khó? Năm 1988, chính Moravec nhận xét: cho máy tính đạt trình độ người lớn trong bài kiểm tra trí tuệ hay ván cờ đam tương đối dễ, còn cho nó khả năng nhìn và đi lại của đứa trẻ một tuổi thì khó, có khi không làm nổi — nghịch lý Moravec (Moravec's paradox). Tiến hóa đã mài giũa việc nhìn, cầm, đi suốt hàng trăm triệu năm, nên với ta chúng dễ tới mức vô hình.
Người học khoa học máy tính cần môn này vì phần lớn công việc trong robot hiện đại là phần mềm — nơi đại số tuyến tính, xác suất, thuật toán và hệ thống nhúng phải cùng đúng một lúc.
Năm ý tưởng cốt lõi
1. Động học: từ góc khớp tới bàn tay
Cánh tay robot công nghiệp là chuỗi thanh cứng nối bằng các khớp quay, mỗi khớp có động cơ và bộ đo góc (encoder). Biết góc từng khớp, tính ra bàn tay ở đâu — động học thuận (forward kinematics), chỉ cần lượng giác. Thứ robot cần hằng ngày là chiều ngược lại: muốn bàn tay tới đúng con ốc kia, xoay các khớp bao nhiêu? Đó là động học nghịch (inverse kinematics), khó hơn hẳn: có thể có hai đáp án, vô số, hoặc không có — như vai và khuỷu tay bạn có nhiều cách phối hợp để cùng chạm ngón tay vào mũi.
Với một cánh tay phẳng hai khớp, vai và khuỷu, cả hai chiều đều có công thức:
import math
L1, L2 = 0.30, 0.25 # cánh tay trên và cẳng tay của robot (mét)
def dong_hoc_thuan(vai, khuyu):
"""Góc vai, góc khuỷu (độ) -> vị trí bàn tay (x, y), gốc tọa độ ở vai."""
a, b = math.radians(vai), math.radians(vai + khuyu)
return (round(L1 * math.cos(a) + L2 * math.cos(b), 3),
round(L1 * math.sin(a) + L2 * math.sin(b), 3))
def dong_hoc_nghich(x, y):
"""Vị trí bàn tay muốn tới -> mọi cặp (vai, khuỷu) đưa tay tới đó."""
c = (x * x + y * y - L1 * L1 - L2 * L2) / (2 * L1 * L2) # định lý cosin
if abs(c) > 1:
return [] # ngoài tầm với
nghiem = []
for khuyu in (math.acos(c), -math.acos(c)): # khuỷu gập về hai phía
vai = math.atan2(y, x) - math.atan2(L2 * math.sin(khuyu), L1 + L2 * math.cos(khuyu))
nghiem.append((round(math.degrees(vai), 1), round(math.degrees(khuyu), 1)))
return nghiem
print(dong_hoc_thuan(30, 45))
for vai, khuyu in dong_hoc_nghich(0.40, 0.10):
print((vai, khuyu), "->", dong_hoc_thuan(vai, khuyu))
print(dong_hoc_nghich(0.60, 0.0))(0.325, 0.391)
(-23.0, 83.3) -> (0.4, 0.1)
(51.1, -83.3) -> (0.4, 0.1)
[]Vai 30°, khuỷu 45° đưa bàn tay tới (0,325; 0,391). Điểm (0,4; 0,1) có hai cách gập tay, khuỷu cong về hai phía — robot phải tự chọn một, chẳng hạn cách không đụng mặt bàn. Điểm cách vai 0,6 m thì vô nghiệm: hai đoạn tay cộng lại chỉ dài 0,55 m.
Sai số cũng bị khuếch đại: ở tư thế đầu, bộ đo góc ở vai lệch 1° là bàn tay lệch gần 1 cm. Cánh tay thật thường có sáu, bảy khớp trong không gian ba chiều; mỗi khớp là một phép xoay — một ma trận như trong bài Đại số tuyến tính — và vị trí bàn tay là tích các ma trận ấy. Động học nghịch khi đó nhiều khi phải giải dần từng bước nhờ ma trận Jacobian (Jacobian): bảng đạo hàm cho biết nhích mỗi khớp một chút thì bàn tay dịch đi đâu (bài Giải tích). Bộ góc (vai, khuỷu) gọi là cấu hình (configuration); tập mọi cấu hình là không gian cấu hình (configuration space) — hai chiều ở đây, bảy chiều với cánh tay bảy khớp.
2. Bất định: robot không bao giờ biết chắc mình ở đâu
Một robot chở thuốc chạy dọc hành lang bệnh viện có hai cách biết mình ở đâu, cách nào cũng có tật. Đếm vòng bánh xe (odometry) cho số liệu mượt, nhưng bánh trượt một chút mỗi mét và sai số cứ dồn lại. Một cảm biến định vị — chẳng hạn đo sóng vô tuyến từ các trạm phát, như điện thoại định vị trong nhà ở bài Tính toán di động và cảm biến — không dồn sai số, nhưng mỗi lần đọc nhảy lệch vài chục phân.
Như đi trong nhà lúc mất điện: vừa đếm bước, vừa sờ khung cửa. Bộ lọc Kalman (Kalman filter) do Rudolf Kálmán công bố năm 1960 trộn hai nguồn đó bằng hai bước lặp lại: dự đoán — đi theo lệnh, và bớt chắc chắn đi một chút; cập nhật — kéo ước lượng về phía số đo nhiều hay ít, tùy bên nào đáng tin hơn.
import random
random.seed(4)
Q, R = 0.1 ** 2, 0.5 ** 2 # mỗi mét bánh trượt lệch ~0,1 m; cảm biến đo lệch ~0,5 m
that = 0.0 # robot thật sự đang ở đâu trên hành lang (m) — robot không biết
dem_banh = 0.0 # cách 1: chỉ đếm vòng bánh xe
uoc, P = 0.0, 0.0 # cách 3: ước lượng của bộ lọc Kalman và độ bất định của nó
tong = {"đếm bánh xe": 0.0, "chỉ cảm biến": 0.0, "Kalman": 0.0}
for buoc in range(1, 101):
that += 1.0 + random.gauss(0, 0.1) # ra lệnh đi 1 m; bánh trượt nên đi hơn hoặc kém một chút
do = that + random.gauss(0, 0.5) # cách 2: cảm biến đọc vị trí, có nhiễu
dem_banh += 1.0
uoc, P = uoc + 1.0, P + Q # Kalman, bước dự đoán: đi theo lệnh, bớt chắc chắn
K = P / (P + R) # bước cập nhật: tin số đo nhiều hay ít
uoc, P = uoc + K * (do - uoc), (1 - K) * P
for ten, gt in (("đếm bánh xe", dem_banh), ("chỉ cảm biến", do), ("Kalman", uoc)):
tong[ten] += abs(gt - that)
if buoc in (1, 10, 100):
print(f"bước {buoc:3d}: thật {that:6.2f} | đếm bánh {dem_banh:6.2f}"
f" | cảm biến {do:6.2f} | Kalman {uoc:6.2f} (K = {K:.2f})")
for ten, t in tong.items():
print(f"{ten:13s} sai trung bình {t / 100:.2f} m")bước 1: thật 1.00 | đếm bánh 1.00 | cảm biến 1.24 | Kalman 1.01 (K = 0.04)
bước 10: thật 10.31 | đếm bánh 10.00 | cảm biến 10.00 | Kalman 10.11 (K = 0.18)
bước 100: thật 102.22 | đếm bánh 100.00 | cảm biến 101.70 | Kalman 101.86 (K = 0.18)
đếm bánh xe sai trung bình 0.86 m
chỉ cảm biến sai trung bình 0.39 m
Kalman sai trung bình 0.19 mĐếm bánh xe đúng ở mét đầu, nhưng tới mét thứ 100 đã lệch hơn 2 m. Cảm biến không trôi, nhưng mỗi lần đọc lệch trung bình 0,4 m. Bộ lọc Kalman tốt hơn cả hai, sai trung bình chưa tới 0,2 m. Hệ số K cho thấy cách nó cân nhắc: lúc xuất phát, robot biết chắc mình ở đầu hành lang nên gần như bỏ qua cảm biến (K = 0,04); càng đi càng bớt chắc, K tăng rồi đứng ở 0,18. Mỗi bước chỉ cần nhớ hai con số; bộ lọc này có mặt từ máy tính dẫn đường tàu Apollo tới bộ thu GPS.
Về bản chất, đây là định lý Bayes trong bài Xác suất và thống kê, áp cho một đại lượng liên tục có độ bất định hình chuông; Bayes trên nhiều biến là việc của bài Mô hình đồ thị xác suất. Khi robot phải giữ cùng lúc nhiều giả thuyết — bật lên trong tòa nhà có hai hành lang giống hệt nhau — người ta dùng bộ lọc hạt (particle filter): rải hàng nghìn phỏng đoán, bỏ dần những cái không khớp cảm biến. Khó hơn nữa là vừa vẽ bản đồ vừa định vị trên chính bản đồ đó — SLAM (simultaneous localization and mapping), việc nhiều robot hút bụi đời mới làm trong những vòng chạy đầu.
3. Lập kế hoạch chuyển động: tìm đường trong không gian cấu hình
Robot chạy trên sàn có thể kẻ ô bản đồ rồi chạy A* như bài Nhập môn trí tuệ nhân tạo. Còn với cánh tay bảy khớp, đường đi nằm trong không gian cấu hình bảy chiều: chia mỗi chiều 100 ô là có 100⁷ = 10¹⁴ ô, không bộ nhớ nào chứa nổi.
Lối thoát là lập kế hoạch dựa trên lấy mẫu (sampling-based planning): không vẽ không gian cấu hình, chỉ cần một hàm trả lời "cấu hình này có va chạm không?" rồi thử những điểm ngẫu nhiên. Thuật toán tiêu biểu là RRT (rapidly-exploring random tree) của Steven LaValle (1998): mọc một cái cây từ điểm xuất phát; mỗi vòng chọn một điểm ngẫu nhiên, từ điểm gần nó nhất trên cây nhích về phía nó một bước, không va thì thêm vào cây; thỉnh thoảng nhắm thẳng vào đích. Ví dụ chạy trong căn phòng hai chiều cho dễ in, nhưng code không quan tâm số chiều.
import math, random
random.seed(1)
VAT_CAN = [(3, 0, 4, 7), (6, 3, 7, 10)] # hai bức tường (x1, y1, x2, y2) trong phòng 10 m × 10 m
DAU, DICH, BUOC = (1, 1), (9, 9), 0.5
def trong_tuong(x, y):
return any(x1 <= x <= x2 and y1 <= y <= y2 for x1, y1, x2, y2 in VAT_CAN)
def va_cham(p, q): # đoạn p → q có chạm tường không? (kiểm 21 điểm dọc đoạn)
return any(trong_tuong(p[0] + (q[0] - p[0]) * k / 20, p[1] + (q[1] - p[1]) * k / 20)
for k in range(21))
cha = {DAU: None} # cây: mỗi điểm nhớ điểm cha của nó
while True:
ngau_nhien = DICH if random.random() < 0.1 else (random.uniform(0, 10), random.uniform(0, 10))
gan = min(cha, key=lambda p: math.dist(p, ngau_nhien)) # điểm gần nhất trên cây
d = math.dist(gan, ngau_nhien)
if d == 0:
continue
t = min(1, BUOC / d) # nhích từ điểm gần nhất về phía điểm ngẫu nhiên
moi = (gan[0] + (ngau_nhien[0] - gan[0]) * t, gan[1] + (ngau_nhien[1] - gan[1]) * t)
if va_cham(gan, moi):
continue
cha[moi] = gan
if math.dist(moi, DICH) < BUOC and not va_cham(moi, DICH):
cha[DICH] = moi
break
duong, p = [], DICH # lần ngược từ đích về điểm đầu
while p:
duong.append(p)
p = cha[p]
dai = sum(math.dist(a, b) for a, b in zip(duong, duong[1:]))
print(f"cây có {len(cha)} điểm; đường đi qua {len(duong)} điểm, dài {dai:.1f} m")
def o(x, y): # ô của bản đồ chữ: rộng 0,5 m, cao 1 m
return int(x * 2), int(y)
ky_hieu = {o(*p): "*" for p in duong} | {o(*DAU): "S", o(*DICH): "G"}
for hang in range(9, -1, -1):
print("".join("#" if trong_tuong(c / 2 + 0.25, hang + 0.5) else ky_hieu.get((c, hang), ".")
for c in range(20)))cây có 234 điểm; đường đi qua 56 điểm, dài 27.0 m
............##....G.
............##....*.
.....******.##....*.
....**##..**##...**.
.....*##..**##...*..
....*.##..**##...*..
....**##..**##..**..
.....*##...******...
..S***##......*.....
......##............Cây chỉ cần 234 điểm để vòng qua hai bức tường, từ S tới G. Đường tìm được ngoằn ngoèo, dài 27 m, trong khi đường ngắn nhất (sát các góc tường) dài khoảng 19 m: RRT tìm một đường đi được rất nhanh, không phải đường ngắn nhất. Thực tế người ta làm mượt đường sau khi tìm, hoặc dùng biến thể RRT*, càng chạy lâu càng tiến về đường ngắn nhất.
Một ý tưởng cũ hơn là trường thế (potential field) của Oussama Khatib, giữa thập niên 1980: đích như cái hố hút robot về, vật cản như ngọn đồi đẩy ra. Nhanh, gọn, nhưng gặp vật cản hình chữ U thì robot lăn vào lòng chữ U rồi đứng đó — một cực tiểu địa phương (local minimum), như hòn bi lọt ổ gà; bài Tối ưu hóa gặp cái bẫy này ở dạng khác.
4. Điều khiển phản hồi: đo sai, sửa, lặp lại
Có kế hoạch rồi, robot vẫn phải bám theo nó khi bánh trượt, tải lúc nặng lúc nhẹ. Cách làm là điều khiển phản hồi (feedback control): đo xem đang lệch bao nhiêu, sửa, rồi đo lại — hàng trăm lần mỗi giây. Ý tưởng này cũ hơn robot nhiều: năm 1922, Nicolas Minorsky phân tích cách lái tàu thủy tự động và viết ra công thức nay gọi là PID:
- P — tỷ lệ (proportional): lệch càng nhiều, sửa càng mạnh.
- I — tích phân (integral): cộng dồn sai số đã qua, để một độ lệch nhỏ mà dai dẳng cũng được sửa.
- D — đạo hàm (derivative): sai số đang giảm nhanh thì bớt tay trước, để khỏi quá đà.
Bài Giải tích nhắc PID trong một dòng; ở đây ta chạy nó trên robot dò line, bài thi quen thuộc của các câu lạc bộ robot sinh viên: dãy cảm biến hồng ngoại dưới gầm đo xe lệch khỏi vạch bao nhiêu, và một bánh hơi mòn làm xe tự quẹo.
import math
def do_line(Kp, Ki, Kd, giay=10, dt=0.01):
v = 0.5 # robot chạy 0,5 m/s
lech, huong = 0.05, 0.0 # xuất phát lệch 5 cm khỏi vạch, đầu xe song song với vạch
banh_mon = 0.2 # một bánh hơi mòn: xe tự quẹo 0,2 rad/s dù không ai lái
tich_luy, sai_truoc, ghi = 0.0, lech, []
for _ in range(int(giay / dt)):
sai = lech # dãy cảm biến dưới gầm đo độ lệch
tich_luy += sai * dt # I: cộng dồn sai số đã qua
doi = (sai - sai_truoc) / dt # D: sai số đang đổi nhanh tới đâu
sai_truoc = sai
lai = -(Kp * sai + Ki * tich_luy + Kd * doi) # lệnh quẹo (rad/s)
huong += (lai + banh_mon) * dt
lech += v * math.sin(huong) * dt
ghi.append(lech * 100) # đổi ra cm
cuoi = ghi[-200:] # 2 giây cuối
return min(cuoi), max(cuoi)
for ten, k in (("P", (20, 0, 0)), ("PD", (20, 0, 6)), ("PID", (20, 10, 6))):
thap, cao = do_line(*k)
print(f"{ten:4s} 2 giây cuối, độ lệch dao động từ {thap:+.1f} cm đến {cao:+.1f} cm")P 2 giây cuối, độ lệch dao động từ -3.0 cm đến +5.0 cm
PD 2 giây cuối, độ lệch dao động từ +1.0 cm đến +1.0 cm
PID 2 giây cuối, độ lệch dao động từ +0.0 cm đến +0.0 cmChỉ có P, xe lắc quanh vạch mãi không dứt, như chiếc lò xo không ma sát trong bài Vật lý: về tới vạch, đầu xe vẫn đang chĩa chéo nên lao sang bên kia. Thêm D, xe "phanh" sớm và êm lại — nhưng đứng yên ở chỗ lệch 1 cm, vì bánh mòn đẩy đều về một phía, và phải lệch một chút thì P mới có lực cân lại. Thêm I, độ lệch nhỏ ấy dồn dần cho tới khi được sửa hết.
Hệ số nào cũng có giá. Tăng Kp thì độ lệch đứng yên nhỏ đi nhưng xe dễ lắc hơn. D làm êm, nhưng tính trên độ thay đổi của số đo nên cũng khuếch đại nhiễu cảm biến. Tăng Ki từ 10 lên 40 thì xe lắc qua lắc lại cả chục giây; khi động cơ đã chạy hết sức mà sai số vẫn dồn, phần I phình to gây vọt lố — tích phân bão hòa (integral windup). Xa hơn PID là điều khiển dựa trên mô hình, và cách để robot tự học điều khiển bằng thử và sai — bài Học tăng cường.
5. An toàn: làm việc bên cạnh con người
Ba định luật robot mà nhà văn Isaac Asimov viết năm 1942 chỉ có trong truyện; ngoài đời, an toàn là chuyện đo, tính và kiểm chứng. Năm 1979, Robert Williams, công nhân một nhà máy đúc của Ford ở Michigan, bị cánh tay robot đánh trúng — người đầu tiên được ghi nhận thiệt mạng vì robot công nghiệp. Suốt nhiều thập kỷ, cách giải quyết chính là tách người khỏi robot: robot làm trong lồng có rào ánh sáng, người bước vào là robot dừng.
Robot cộng tác làm ngay bên cạnh người, nên cần cách khác. Bộ tiêu chuẩn ISO 10218 về an toàn robot công nghiệp, sửa đổi lớn năm 2025, mô tả những cách để người và robot chung chỗ làm. Hai cách tiêu biểu: giới hạn công suất và lực (power and force limiting) — robot nhẹ, bo tròn, lỡ va chạm thì lực ép lên từng vùng cơ thể không vượt ngưỡng cho phép; và giám sát tốc độ và khoảng cách (speed and separation monitoring) — người càng tới gần, robot càng chậm, đủ để kịp dừng hẳn trước khi chạm. Cách thứ hai là một phép tính:
V_NGUOI = 1.6 # người bước về phía robot (m/s)
T_THAY = 0.1 # từ lúc người xuất hiện tới lúc robot nhận lệnh phanh (giây)
T_PHANH = 0.3 # thời gian tay robot phanh tới đứng yên (giây)
DU_PHONG = 0.1 # khoảng dư cho sai số cảm biến (m)
V_MAX = 1.5 # tốc độ tối đa của tay robot (m/s)
def toc_do_cho_phep(d):
"""Người đang cách d mét: tay robot được chạy nhanh tới đâu mà vẫn kịp dừng trước khi chạm?"""
con_lai = d - V_NGUOI * (T_THAY + T_PHANH) - DU_PHONG # trừ quãng người đi thêm trong lúc chờ
v = con_lai / (T_THAY + T_PHANH / 2) # robot chạy đều trong T_THAY, rồi chậm dần đều trong T_PHANH
return max(0.0, min(V_MAX, v))
for d in (2.0, 1.1, 1.0, 0.9, 0.8, 0.7):
print(f"người cách {d} m -> tay robot chạy tối đa {toc_do_cho_phep(d):.2f} m/s")người cách 2.0 m -> tay robot chạy tối đa 1.50 m/s
người cách 1.1 m -> tay robot chạy tối đa 1.44 m/s
người cách 1.0 m -> tay robot chạy tối đa 1.04 m/s
người cách 0.9 m -> tay robot chạy tối đa 0.64 m/s
người cách 0.8 m -> tay robot chạy tối đa 0.24 m/s
người cách 0.7 m -> tay robot chạy tối đa 0.00 m/sNgười còn cách hai mét, robot chạy hết tốc độ; từ 0,7 m trở vào, nó phải đứng yên. Đây là phép tính rút gọn với số tự đặt; công thức trong tiêu chuẩn có thêm nhiều thành phần, và cả chuỗi cảm biến – phần mềm – phanh phải được chứng minh là đáng tin, như bài Hệ thống nhúng đã kể. Robot làm cạnh người còn cần báo trước ý định bằng đèn, âm thanh, cách di chuyển dễ đoán — chỗ robot học gặp bài Tương tác người – máy.
Robot học nằm ở đâu trong chồng tầng
Giống hệ thống nhúng, robot học cắt dọc qua cả chồng tầng của bài Từ electron đến ứng dụng, và vươn cao hơn:
- Dưới cùng: động cơ, bộ đo góc, vi điều khiển chạy vòng PID — thế giới của bài Hệ thống nhúng.
- Ở giữa: ước lượng vị trí, động học, lập kế hoạch — thuật toán và toán.
- Trên cùng: nhiệm vụ kiểu "lấy cái cốc trên bàn" — cần thị giác máy tính để thấy cốc, AI để chia việc thành từng bước.
Các phần ấy thường là những chương trình riêng nhắn tin cho nhau qua ROS (Robot Operating System) — thực ra không phải hệ điều hành mà là phần mềm trung gian (middleware). Bên dưới tất cả là thế giới vật lý, với ma sát, quán tính và con người.
Đưa lên
Một cỗ máy nhận nhiệm vụ kiểu "mang cái này tới kia" rồi tự lo phần còn lại — biết mình ở đâu, tìm đường, bám đường, chậm lại khi có người tới gần.
Giấu đi
Hàng nghìn lần đo và sửa mỗi giây, những phép xoay ma trận, những phỏng đoán xác suất về vị trí.
Học trước và học sau
· 7 mônĐại số tuyến tính
Linear Algebra
Phép xoay và ma trận biến đổi dọc một cánh tay. Nên học trước.
Giải tích
Calculus
Vận tốc, ma trận Jacobian, hai trong ba chữ của PID. Nên học trước.
Xác suất và thống kê
Probability and Statistics
Định lý Bayes và phân phối chuẩn — nền của bộ lọc Kalman, bộ lọc hạt, SLAM. Nên học trước hoặc song song.
Hệ thống nhúng
Embedded Systems
Tầng dưới cùng của mọi robot: vi điều khiển, cảm biến, thời gian thực, an toàn khi hỏng.
Nhập môn trí tuệ nhân tạo
Introduction to Artificial Intelligence
Tác tử, tìm kiếm, ra quyết định khi không chắc chắn — phần "nghĩ" của robot.
Xem chủ đề trên OpenER: Introduction to Artificial Intelligence
Thị giác máy tính
Computer Vision
Đôi mắt của robot: nhận ra vật, đo độ sâu, dựng lại không gian ba chiều.
Học tăng cường
Reinforcement Learning
Học cách điều khiển bằng thử và sai, thường trong mô phỏng trước.
Ứng dụng thật và nghề nghiệp
- Nhà máy: robot hàn, phun sơn, lắp ráp, gắp đặt linh kiện trong các nhà máy điện tử và ô tô lớn ở Việt Nam; nghề lập trình robot, tích hợp hệ thống tự động hóa.
- Kho vận, giao thông: robot chở kệ, xe nâng tự lái, xe tự lái, drone.
- Nông nghiệp: drone phun thuốc ngày càng quen trên đồng ruộng; robot hái quả, làm cỏ còn thử nghiệm.
- Y tế: robot phẫu thuật nội soi do bác sĩ điều khiển, robot hỗ trợ phục hồi chức năng.
- Nghề phần mềm: kỹ sư phần mềm robot (ROS, C++, Python), nhận thức (camera, lidar), điều khiển, mô phỏng, an toàn chức năng.
Học xong làm được gì, bắt đầu từ đâu
Sau môn này bạn có thể:
- tính động học thuận và nghịch cho một cánh tay vài khớp bằng ma trận;
- viết bộ lọc Kalman, bộ lọc hạt để định vị robot từ cảm biến nhiễu;
- cài đặt RRT, biết khi nào nên kẻ lưới, khi nào nên lấy mẫu;
- viết và chỉnh một bộ PID, giải thích được vì sao xe lắc, vì sao lệch.
Nên biết trước: ma trận và phép xoay, đạo hàm, xác suất có điều kiện, phân phối chuẩn, và Python.
Bắt đầu trên OpenER: trang chủ đề Robotics có các khóa học đã chọn lọc, và hướng dẫn học đi qua sáu bước, từ không gian cấu hình tới định vị xác suất và SLAM. Khóa chính là bộ học liệu Modern Robotics của Đại học Northwestern (Kevin Lynch): sách miễn phí, video theo chương, nhiều bài tập. Khóa thay thế: CS223A của Stanford do Oussama Khatib (người đề xuất trường thế) giảng; Robotics của IIT Kharagpur trên NPTEL, góc nhìn cơ khí; khóa tiếng Việt Người máy học trên OpenER để ôn nhanh trước. Bước tiếp theo là Underactuated Robotics của Russ Tedrake (MIT); phần định vị đọc thêm Probabilistic Robotics.
Lời khuyên: mô phỏng trước, phần cứng sau — nhưng đừng sau quá lâu. Chạy năm đoạn code trên, đổi các con số xem chuyện gì xảy ra; rồi lắp một chiếc xe dò line với bo Arduino và viết lại vòng PID bằng C — khoảng cách giữa mô phỏng và mặt bàn thật là bài học lớn nhất của môn này. Nếu có đội, Robocon Việt Nam — cuộc thi VTV tổ chức từ năm 2002 để chọn đội dự ABU Robocon — là nơi học nhanh nhất.
Tài liệu tham khảo
- Kevin M. Lynch, Frank C. Park — Modern Robotics: Mechanics, Planning, and Control, Cambridge University Press 2017; bản PDF miễn phí, video và bài tập trên trang của Đại học Northwestern.
- Sebastian Thrun, Wolfram Burgard, Dieter Fox — Probabilistic Robotics, MIT Press 2005.
- Steven M. LaValle — Planning Algorithms, Cambridge University Press 2006; tác giả cho đọc miễn phí trên trang của mình.
- Stanford CS223A Introduction to Robotics (Oussama Khatib) — Stanford Engineering Everywhere.
- MIT 6.832 Underactuated Robotics (Russ Tedrake) — MIT OpenCourseWare.
- NPTEL — Robotics, IIT Kharagpur (D. K. Pratihar).
- ISO 10218-1 và ISO 10218-2:2025 — Robotics — Safety requirements, Tổ chức Tiêu chuẩn hóa Quốc tế.