Giới thiệu dự án

Sự bùng nổ của cuộc Cách mạng Công nghiệp 4.0 đã thúc đẩy mạnh mẽ các công nghệ tự hành (Autonomous Systems) và trí tuệ nhân tạo (AI). Theo các báo cáo phân tích thị trường ô tô toàn cầu (Emerging Technologies: Autonomous Cars — Not If, But When), doanh số xe tự hành dự báo đạt 250.000 chiếc trong ngắn hạn và sẽ vượt mốc 21 triệu phương tiện lưu thông trên toàn cầu trong vòng hai thập kỷ tới. Tại Việt Nam, nghiên cứu và ứng dụng phương tiện tự hành theo tiêu chuẩn của Hiệp hội Kỹ sư Ô tô Mỹ (SAE - Society of Automotive Engineers) từ cấp độ 3 (Level 3 - Tự động hóa có điều kiện) đến cấp độ 5 (Level 5 - Tự động hóa hoàn toàn) đang trở thành trọng tâm phát triển của các doanh nghiệp công nghệ và viện nghiên cứu.

[Camera Module V2] ---> [NVIDIA Jetson Nano] ---> [PCA9685 PWM Driver] ---> [Servo / DC Motor]
(Thu nhận 600x400)      (OpenCV Pipeline)         (Giao tiếp I2C)          (Góc lái 50°-130°)

Tuy nhiên, các hệ thống xe tự hành thương mại hiện nay phụ thuộc nhiều vào hệ thống cảm biến đắt đỏ như LiDAR (Light Detection and Ranging), Radar và GPS vi sai độ chính xác cao. Điều này tạo ra rào cản chi phí lớn khi triển khai vào các bài toán thực tế như xe tự hành vận chuyển hàng hóa trong nhà xưởng (AGV - Automated Guided Vehicle) hay thiết bị dẫn đường thông minh.

  • Problem Statement: Thiết kế và hiện thực hóa hệ thống điều hướng tự động thời gian thực cho xe tự hành mô hình tỷ lệ 1/18 hoạt động trên sa hình thực nghiệm, giải quyết triệt để 3 bài toán: bám làn đường (lane keeping), nhận diện biển báo giao thông và phát hiện tránh chướng ngại vật chỉ bằng thị giác máy tính đơn camera (Monocular Computer Vision), loại bỏ sự phụ thuộc vào cảm biến khoảng cách tầm xa đắt tiền.
  • Mục tiêu cụ thể của dự án:
    1. Xây dựng nền tảng phần cứng hoàn chỉnh tích hợp máy tính nhúng NVIDIA Jetson Nano Developer Kit, Camera Raspberry Pi V2 8MP, mạch mở rộng băm xung PWM PCA9685 và khung gầm RC Car A595-B.
    2. Phát triển thuật toán xử lý ảnh số thời gian thực (Real-time Computer Vision) trên thư viện OpenCV: kết hợp phát hiện cạnh Canny và biến đổi xác suất Hough (Probabilistic Hough Transform) để trích xuất vạch kẻ đường và tính toán góc lái servo.
    3. Xây dựng bộ tiền xử lý không gian màu HSV và phân tích hình thái học (Morphological Operations) để phân loại 3 biển báo giao thông: Rẽ trái, Rẽ phải và Dừng lại (Stop).
    4. Thiết lập thuật toán nhận diện và ước lượng vùng chướng ngại vật dựa trên trích xuất đường viền (Find Contours), từ đó kích hoạt chế độ lái né vật cản an toàn.
  • Solution Approach: Tiếp cận theo hướng tính toán biên (Edge Computing) cục bộ trên nền tảng Jetson Nano (GPU 128 lõi kiến trúc Maxwell), kết hợp giữa thuật toán xử lý ảnh hình học cổ điển (Classical CV) để giảm thiểu độ trễ xử lý (Latency < 40ms) và tối ưu hóa tài nguyên phần cứng so với các mạng nơ-ron tích chập (CNN) nặng nề.
  • Kết quả kỳ vọng (Expected Outcomes):
    • Xe vận hành ổn định trên sa hình khép kín với vận tốc thực nghiệm đạt 6 – 7 km/h.
    • Tần số lấy mẫu và xử lý khung hình đạt 25 – 30 FPS ở độ phân giải $600 \times 400$ pixel.
    • Góc đánh lái của động cơ servo biến thiên mượt mà trong dải giới hạn cơ khí từ $50^\circ$ đến $130^\circ$ (trung vị $90^\circ$).
  • Phạm vi và giới hạn (Scope & Limitations): Hệ thống thử nghiệm trên mô hình RC Car 1/18 ngoài trời và phòng lab; bộ nhận diện giới hạn ở 3 loại biển báo tiêu chuẩn và các vật cản có độ tương phản màu sắc rõ rệt so với nền đường.

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Các phương pháp định vị và điều hướng xe tự hành hiện nay được chia thành ba nhóm giải pháp chính với các ưu nhược điểm rõ rệt:

Tiêu chí Cảm biến vật lý (IR / Ultrasonic / LiDAR) Deep Learning End-to-End (CNN / YOLO) Thị giác máy tính biên (OpenCV / Jetson Nano)
Chi phí phần cứng Rất cao (LiDAR) hoặc độ chính xác thấp (Siêu âm) Rất cao (Yêu cầu GPU mạnh, bộ nhớ lớn) Tối ưu, phù hợp hệ thống nhúng
Tốc độ xử lý (FPS) Cao (> 50 FPS) nhưng dữ liệu nghèo nàn Trung bình (10 - 15 FPS trên Jetson Nano) Cao (25 - 30 FPS thời gian thực)
Độ trễ hệ thống Thấp (< 15ms) Khá cao (> 80ms nếu không tối ưu TensorRT) Rất thấp (30 - 40ms)
Khả năng bám làn Kém (chỉ bám theo vạch từ hoặc tia hồng ngoại) Tốt nhưng phụ thuộc tập dữ liệu huấn luyện Xuất sắc, linh hoạt theo hình học đường kẻ
Tính khả thi nhúng Cao nhưng giới hạn tính năng Khó đạt chuẩn Real-time trên kit giá rẻ Tối ưu hóa hoàn hảo trên kit Jetson Nano
  • Đặc tả yêu cầu hệ thống theo mô hình MoSCoW:
    • Must have (Bắt buộc): Nhận diện vạch làn đường liên tục, điều khiển góc lái Servo theo thời gian thực qua giao tiếp $I^2C$, dừng xe an toàn khi phát hiện biển Stop hoặc vật cản trực diện.
    • Should have (Nên có): Phân loại chính xác biển báo rẽ trái/phải để chuyển làn sa hình vòng số 8; bộ lọc làm mờ Gaussian $5 \times 5$ triệt tiêu nhiễu môi trường.
    • Could have (Có thể có): Thuật toán tự động giảm tốc độ khi vào cua gắt; thích ứng dải sáng động.
    • Won't have (Chưa thực hiện): Định vị toàn cầu GPS vi sai, bản đồ số độ nét cao (HD Map), mạng Deep Learning nhận diện hàng trăm vật thể.

Thiết kế hệ thống

Kiến trúc hệ thống xe tự hành được module hóa thành 4 tầng chức năng khép kín:

+-------------------------------------------------------------------------+
|                              SENSORY LAYER                              |
|          Raspberry Pi Camera V2 8MP (Sony IMX219, CSI Interface)        |
+------------------------------------+------------------------------------+
                                     | (Video Stream: 600x400 @ 30 FPS)
                                     v
+-------------------------------------------------------------------------+
|                         PROCESSING & LOGIC LAYER                        |
|       NVIDIA Jetson Nano (4x ARM Cortex-A57 @ 1.43GHz, 128 Maxwell GPU) |
|  - Preprocessing: BGR -> Gray/HSV, Gaussian Blur, Canny Edge Detection  |
|  - Feature Extraction: Probabilistic Hough Transform, Find Contours     |
|  - Motion Planning: Error Calculation, Steering Angle Mapping           |
+------------------------------------+------------------------------------+
                                     | (Control Signals via I2C Bus)
                                     v
+-------------------------------------------------------------------------+
|                            ACTUATION LAYER                              |
|  - PCA9685 PWM Driver (Address 0x40) -> Metal Gear Servo Emax (Steering)|
|  - DC Motor Driver + Step-Down XL4016E1 (8A) -> JGA-25 DC Motor (Drive) |
+-------------------------------------------------------------------------+
  • Technology Stack & Specifications:
    • Hệ điều hành: Linux Ubuntu 18.04 LTS (NVIDIA JetPack 4.4 SDK).
    • Nền tảng xử lý: Python 3.6.9, thư viện OpenCV 4.1.1 (hỗ trợ CUDA backend), NumPy.
    • Chuẩn giao tiếp ngoại vi: $I^2C$ (Inter-Integrated Circuit) tần số chuẩn 100 kHz (Standard-mode) và 400 kHz (Fast-mode). Chế độ Master-Slave: Jetson Nano (Master) giao tiếp với IC tạo xung PCA9685 (Slave) qua 2 dây tín hiệu SDA (Serial Data) và SCL (Serial Clock).
    • Phần cứng truyền động: Động cơ servo Emax nhông kim loại (Metal Gear), động cơ DC giảm tốc JGA-25, mạch hạ áp DC-DC XL4016E1 (hạ áp từ pin LiPo 3S 11.1V/12V xuống 5V/8A cấp nguồn ổn định).

Methodology

Quy trình phát triển dự án tuân theo mô hình kỹ thuật vòng lặp (Iterative Engineering Methodology):

+----------------+      +-------------------+      +------------------+
| Phase 1: R&D   | ---> | Phase 2: System   | ---> | Phase 3: Field   |
| Hardware Setup |      | Algorithm & CV    |      | Testing & Tuning |
| (Weeks 1 - 6)  |      | (Weeks 7 - 16)    |      | (Weeks 17 - 24)  |
+----------------+      +-------------------+      +------------------+
  • Đánh giá rủi ro và giải pháp khắc phục (Risk Assessment):
    • Sụt áp khi tải nặng: Dòng khởi động của động cơ DC và servo gây sập nguồn Jetson Nano. Giải pháp: Tách riêng nguồn động lực qua IC hạ áp chuyên dụng XL4016E1 8A và pin LiPo 3S dòng xả cao.
    • Nhiễu ánh sáng môi trường: Ánh sáng thay đổi làm sai lệch ngưỡng nhị phân. Giải pháp: Chuyển đổi sang không gian màu HSV để tách biệt kênh cường độ sáng $V$ (Value) khỏi kênh màu $H$ (Hue) và $S$ (Saturation).

Implementation và kết quả

Development process

Quá trình hiện thực hóa giải thuật tập trung vào chuỗi xử lý ảnh số hóa tối ưu cho tính toán biên:

  1. Khử nhiễu & Phát hiện biên Canny: Ảnh đầu vào $f(x, y)$ kích thước $600 \times 400$ được áp dụng bộ lọc Gaussian $5 \times 5$ với độ lệch chuẩn $\sigma$: $$G(x, y) = \frac{1}{2\pi\sigma^2} e^{-\frac{x^2+y^2}{2\sigma^2}}$$ Sau đó, tính toán độ dốc (Gradient) mức xám bằng hai bộ lọc Sobel $3 \times 3$ theo trục ngang $G_x$ và trục dọc $G_y$: $$|G| = \sqrt{G_x^2 + G_y^2}, \quad \theta = \arctan\left(\frac{G_y}{G_x}\right)$$ Tiếp tục áp dụng triệt tiêu không cực đại (Non-maximum Suppression) và lọc ngưỡng Hysteresis kép (Low Threshold = 50, High Threshold = 150) để thu được mặt nạ cạnh nhị phân sắc nét.

  2. Trích xuất vạch làn bằng biến đổi xác suất Hough (Probabilistic Hough Transform): Biến đổi các điểm biên từ không gian ảnh $(x, y)$ sang không gian tham số cực $(r, \theta)$ theo phương trình: $$r = x\cos\theta + y\sin\theta$$ Giải thuật cv2.HoughLinesP trích xuất các đoạn thẳng của làn đường, loại bỏ các đường có góc dốc bất thường và xác định giao điểm trung tâm để tính toán độ lệch góc lái.

import cv2
import numpy as np
import math

def calculate_steering_angle(frame, lane_lines):
    """
    Tính toán góc bẻ lái Servo dựa trên các đoạn thẳng làn đường phát hiện được.
    Input: Khung hình 600x400, danh sách đoạn thẳng từ HoughLinesP
    Output: Góc lái trong dải [50, 130] độ (90 độ là chính diện)
    """
    height, width, _ = frame.shape
    if lane_lines is None or len(lane_lines) == 0:
        return 90  # Giữ thẳng nếu mất dấu làn tạm thời
    
    left_x, right_x = [], []
    for line in lane_lines:
        for x1, y1, x2, y2 in line:
            slope = (y2 - y1) / (x2 - x1 + 1e-6)
            if abs(slope) < 0.2:  # Bỏ qua đường gần như nằm ngang
                continue
            if slope < 0:
                left_x.extend([x1, x2])
            else:
                right_x.extend([x1, x2])
                
    mid_screen = width // 2
    lane_center = mid_screen
    
    if left_x and right_x:
        left_avg = np.mean(left_x)
        right_avg = np.mean(right_x)
        lane_center = (left_avg + right_avg) / 2.0
    elif left_x:
        lane_center = np.mean(left_x) + 150
    elif right_x:
        lane_center = np.mean(right_x) - 150
        
    error_x = lane_center - mid_screen
    # Chuẩn hóa độ lệch sang góc lái 50 - 130 độ
    steering_angle = int(90 + (error_x / (width / 2.0)) * 40)
    return max(50, min(130, steering_angle))
  1. Nhận diện biển báo & Phát hiện vật cản:
    • Không gian màu HSV lọc dải màu xanh lam và đỏ của biển báo.
    • Toán tử hình thái học: Giãn nở ảnh (Dilation $\oplus$) lấp đầy vùng khuyết và Co ảnh (Erosion $\ominus$) loại bỏ nhiễu hạt nhỏ.
    • Hàm cv2.findContours tìm kiếm đường bao của biển báo và vật cản; phân tích tỷ lệ khung bao (Aspect Ratio) và hướng mũi tên để đưa ra quyết định rẽ trái/phải hoặc dừng xe.
+-------------------+      +--------------------+      +----------------------+
| Raw Frame 600x400 | ---> | HSV Threshold Mask | ---> | Morphology (Dil/Ero) |
+-------------------+      +--------------------+      +----------------------+
                                                                   |
                                                                   v
+-------------------+      +--------------------+      +----------------------+
| PWM Servo Command | <--- | Steering Calc Mode | <--- | cv2.findContours ROI |
+-------------------+      +--------------------+      +----------------------+

Testing và validation

Hệ thống được kiểm thử thực tế qua hơn 100 lượt chạy trên 3 kịch bản sa hình: Sa hình tròn bám làn, Sa hình số 8 có biển báo điều hướng, và Sa hình có chướng ngại vật ngẫu nhiên.

+-----------------------------------------------------------------------+
|                 SYSTEM LATENCY BREAKDOWN (Total: 34ms)                 |
| [Camera Capture: 8ms] [Preprocessing: 11ms] [Hough: 9ms] [I2C/PWM: 6ms] |
+-----------------------------------------------------------------------+
Kịch bản kiểm thử Số lần thử Tỷ lệ thành công (%) Tốc độ trung bình (km/h) Độ trễ xử lý trung bình (ms)
Bám làn đường liên tục 40 97.5% (39/40) 6.8 km/h 28 ms
Nhận diện biển rẽ Trái/Phải 30 93.3% (28/30) 6.2 km/h 34 ms
Nhận diện biển báo Dừng (Stop) 20 100% (20/20) 6.0 km/h 31 ms
Phát hiện & Né tránh vật cản 30 90.0% (27/30) 5.5 km/h 36 ms

Đổi mới và đóng góp

  • Tối ưu hóa Pipeline Computer Vision trên phần cứng biên: Thay vì sử dụng các mạng nơ-ron phức tạp tiêu tốn năng lượng và sinh nhiệt cao, đề tài chứng minh giải thuật thị giác máy tính cổ điển tối ưu có thể đạt tần số khung hình $28 - 30$ FPS ổn định trên GPU Maxwell của Jetson Nano với mức tiêu thụ điện năng toàn mạch dưới 15W.
  • Tích hợp phần cứng module hóa cao: Thiết kế thành công mạch điều khiển động cơ DC công suất lớn và phân phối nguồn cách ly, giải quyết triệt để xung nhiễu điện từ từ motor gây reset vi xử lý trung tâm.
Giải pháp so sánh Phương pháp xử lý Tốc độ khung hình (FPS) Tải CPU / GPU (%) Khả năng né vật cản
Raspberry Pi 3B+ (Baseline) OpenCV CPU Only 8 - 11 FPS CPU: 98% (Quá tải) Kém, độ trễ cao gây va chạm
Jetson Nano + Deep Learning (YOLOv4-tiny) Mạng nơ-ron CNN 12 - 15 FPS GPU: 95%, RAM: 85% Tốt nhưng tốc độ phản hồi chậm
Hệ thống đề tài (Jetson + Classical CV) Canny + HoughP + HSV Mask 28 - 30 FPS CPU: 35%, GPU: 40% Nhanh, mượt mà, phản hồi tức thì
  • Đóng góp kỹ thuật: Cung cấp mô hình tham chiếu thực nghiệm hoàn chỉnh (từ thiết kế điện tử, cấu hình I2C, đến giải thuật bám làn và tránh vật thể) phục vụ đào tạo và nghiên cứu phương tiện tự hành cho sinh viên ngành Điều khiển & Tự động hóa.

Ứng dụng thực tế và triển khai

  • Ứng dụng công nghiệp (Smart Factory AGV): Mô hình có thể mở rộng trực tiếp thành xe tự hành vận chuyển linh kiện trong nhà máy, thay thế giải pháp bám băng từ truyền thống vốn tốn kém chi phí bảo trì và kém linh hoạt khi đổi Layout xưởng.
  • Hỗ trợ người khiếm thị: Ứng dụng giải thuật nhận diện biển báo và vật thể vào gậy thông minh hoặc xe lăn điện tự hành dẫn đường trong các khu vực công cộng như sân bay, bệnh viện.
Sa hình thực nghiệm -------------------> Nhà xưởng thông minh
- Khung xe 1/18 RC                       - Xe AGV công nghiệp tải trọng lớn
- Camera Raspberry Pi V2                - Camera công nghiệp chuẩn IP67
- Xung PWM PCA9685                      - PLC / Driver động cơ công suất lớn
  • Quy trình triển khai (Deployment Guide):
    1. Cài đặt hệ điều hành JetPack 4.4 trên thẻ nhớ microSD (tối thiểu 32GB Class 10 U3).
    2. Bật cổng giao tiếp $I^2C$ trên Jetson Nano bằng lệnh sudo usermod -aG i2c $USER.
    3. Quét địa chỉ module PWM PCA9685: sudo i2cdetect -y -r 1 (xác nhận địa chỉ 0x40).
    4. Cân chỉnh vị trí camera ở độ cao 15cm, nghiêng góc $20^\circ$ so với phương ngang để đạt tầm quan sát tối ưu (ROI: 200 pixel dưới cùng của khung hình).
    5. Khởi chạy tiến trình điều khiển: python3 autonomous_drive.py.

Hạn chế và hướng phát triển

  • Hạn chế kỹ thuật hiện tại:
    • Xe chưa tích hợp thuật toán tự động giảm tốc độ khi vào các khúc cua có bán kính cong nhỏ (dưới 0.5m), dễ dẫn đến hiện tượng trượt bánh nếu tăng tốc độ động cơ.
    • Thuật toán phân ngưỡng màu sắc nhạy cảm với sự thay đổi đột ngột của cường độ ánh sáng môi trường hoặc khi vật cản có màu sắc trùng với màu nền đường.
  • Hướng phát triển:
    • Tích hợp bộ điều khiển PID mờ (Fuzzy-PID) để điều tiết vận tốc thích ứng với độ cong của đường kẻ.
    • Triển khai mô hình học sâu rút gọn MobileNet-SSD hoặc YOLOv4-tiny được lượng tử hóa bằng NVIDIA TensorRT để nhận diện đa dạng biển báo và vật thể phức tạp.

Đối tượng hưởng lợi

  • Sinh viên chuyên ngành Tự động hóa / Cơ điện tử / Robotics: Nắm vững nền tảng kết hợp giữa phần cứng nhúng, giao thức truyền thông nối tiếp $I^2C$ và kỹ thuật thị giác máy tính thực chiến.
  • Kỹ sư phát triển Robot (Robotics Developers): Tham khảo kiến trúc phân tầng xử lý và mã nguồn mở tối ưu cho các dòng xe tự hành AGV/AMR tầm thấp.
  • Các doanh nghiệp sản xuất: Tiếp cận giải pháp xe tự hành vận chuyển nội bộ giá rẻ với chi phí vật tư phần cứng dưới 5 triệu VNĐ.

Câu hỏi thường gặp

  1. Yêu cầu phần cứng tối thiểu để triển khai hệ thống là gì?
    Cần máy tính nhúng NVIDIA Jetson Nano Developer Kit (hoặc Raspberry Pi 4 có hỗ trợ tăng tốc), Camera CSI 8MP, mạch mở rộng PCA9685, động cơ servo nhông kim loại, driver động cơ DC và nguồn pin LiPo 3S tối thiểu 2200mAh 25C.

  2. Hệ thống xử lý thế nào khi bị mất dấu vạch kẻ đường tạm thời?
    Thuật toán lưu trữ góc lái của 5 khung hình gần nhất; nếu vạch kẻ bị gián đoạn, hệ thống duy trì góc lái trung vị trước đó và giảm 30% tốc độ động cơ DC cho đến khi phát hiện lại làn đường.

  3. Làm thế nào để tích hợp thêm các biển báo giao thông mới?
    Mở rộng dải phân ngưỡng trong không gian màu HSV và bổ sung các hàm phân tích đặc trưng hình học/đường bao (Contours Matching) hoặc tích hợp mô hình SVM/CNN phân loại ảnh kích thước nhỏ ($32 \times 32$ pixel).

  4. Tại sao sử dụng I2C thay vì trực tiếp băm xung PWM từ GPIO của Jetson Nano?
    Chân GPIO của Jetson Nano không hỗ trợ Hardware PWM đa kênh chuẩn xác; sử dụng IC chuyên dụng PCA9685 qua giao tiếp $I^2C$ giúp giảm tải CPU và tạo ra xung điều khiển servo có độ phân giải 12-bit cực kỳ mịn và không bị giật.

  5. Chi phí ước tính và thời gian hoàn vốn (ROI) khi ứng dụng cho xưởng sản xuất?
    Tổng chi phí chế tạo một mô hình AGV hoàn chỉnh chỉ dao động từ 4 – 6 triệu VNĐ, giảm hơn 80% so với mua thiết bị AGV thương mại bám từ, giúp thu hồi vốn đầu tư chỉ sau 2 – 3 tháng vận hành thực tế.

Kết luận

Đồ án tốt nghiệp "Điều Hướng Xe Tự Hành Tránh Vật Cản Ứng Dụng Thị Giác Máy Tính" đã giải quyết trọn vẹn và chuẩn xác bài toán điều khiển phương tiện tự hành thời gian thực trên phần cứng nhúng NVIDIA Jetson Nano. Bằng việc kết hợp nhuần nhuyễn giữa phát hiện cạnh Canny, biến đổi xác suất Hough và phân tích không gian màu HSV, hệ thống vận hành tự chủ đạt tốc độ 6 – 7 km/h với độ trễ xử lý cực thấp (dưới 35ms). Đây là minh chứng rõ nét cho tính khả thi của việc ứng dụng thị giác máy tính chi phí thấp vào tự động hóa công nghiệp và giao thông thông minh. Các nhà phát triển và sinh viên có thể kế thừa mã nguồn và kiến trúc phần cứng này để tiếp tục phát triển các hệ thống robot tự hành nâng cao trong tương lai.