Giới thiệu dự án

Công nghệ xe tự hành (Autonomous Vehicles - AV) đang định hình lại tương lai của ngành công nghiệp ô tô toàn cầu. Theo các báo cáo từ Hiệp hội Kỹ sư Ô tô (SAE International), các hệ thống hỗ trợ lái xe nâng cao (ADAS) đạt chuẩn Tự động hóa Cấp độ 2 (SAE Level 2) đang trở thành tiêu chuẩn bắt buộc trên các dòng xe thương mại hiện đại nhằm giảm thiểu hơn 90% các vụ tai nạn giao thông xuất phát từ lỗi con người. Tại Việt Nam, xu hướng nghiên cứu và làm chủ công nghệ điều khiển tự động bám làn đường đang được thúc đẩy mạnh mẽ từ các viện nghiên cứu, trường đại học kỹ thuật cho đến các doanh nghiệp công nghệ lớn.

Đề tài tốt nghiệp "Nghiên cứu, thiết kế mô hình xe tự hành" thuộc ngành Công nghệ Kỹ thuật Ô tô - Trường Đại học Sư phạm Kỹ thuật TP.HCM (HCMUTE), dưới sự hướng dẫn của TS. Lê Thanh Phúc và thực hiện bởi sinh viên Nguyễn Hồng Phúc, Dương Quốc Việt, tập trung giải quyết bài toán cốt lõi: tối ưu hóa thuật toán thị giác máy tính phát hiện làn đường và điều khiển bám làn thời gian thực trên nền tảng phần cứng nhúng chi phí thấp.

Vấn đề kỹ thuật (Problem Statement)

Các mô hình xe tự hành quy mô phòng thí nghiệm thường gặp phải các hạn chế nghiêm trọng:

  • Hiện tượng rung lắc, mất ổn định quỹ đạo (steering oscillation) khi xe đi vào các khúc cua gắt hoặc đoạn đường bị đứt gãy vạch kẻ.
  • Độ trễ tính toán (computational latency) cao khi xử lý luồng video độ phân giải cao trên các bộ điều khiển khả trình cấp thấp.
  • Xung đột tài nguyên phần cứng khi một vi xử lý đơn lẻ vừa phải đảm nhiệm tác vụ xử lý ảnh phức tạp vừa điều chế xung PWM tần số cao để điều khiển góc lái servo và tốc độ động cơ DC.

Mục tiêu dự án

  1. Thiết kế cơ khí và điện tử: Xây dựng mô hình xe tự hành hoàn chỉnh dựa trên khung gầm RC Buggy, tích hợp vi xử lý máy tính nhúng Raspberry Pi 4 Model B và vi điều khiển Arduino Nano ATmega328P.
  2. Phát triển thuật toán thị giác: Xây dựng pipeline xử lý ảnh thời gian thực bằng Python và OpenCV bao gồm: Biến đổi phối cảnh (Perspective Transformation), lọc nhiễu Gaussian Blur, tách biên Canny Edge Detection và thuật toán dò tìm điểm biên làn đường.
  3. Thiết kế hệ thống điều khiển bám làn: Xây dựng giải thuật điều khiển tỉ lệ - tích phân - vi phân (PID Controller) nhằm hiệu chỉnh góc bẻ lái mượt mà dựa trên độ lệch tâm (offset/cross-track error).
  4. Đồng bộ giao tiếp Master-Slave: Thiết lập chuẩn truyền thông SPI (Serial Peripheral Interface) tốc độ cao giữa Raspberry Pi và Arduino Nano, đảm bảo thời gian đáp ứng điều khiển dưới 20ms.
+-------------------------------------------------------------------------+
|                        HỆ THỐNG XE TỰ HÀNH RC BUGGY                     |
|                                                                         |
|  [ Camera Module ] ---> [ Raspberry Pi 4 (Vision & PID) ]               |
|                                     | (SPI Bus)                         |
|                                     v                                   |
|                             [ Arduino Nano ]                            |
|                               /          \                              |
|                              v            v                             |
|                    [ Servo MG996R ]    [ DC775 Motor Driver ]           |
|                    (Góc lái hướng)     (Điều khiển tốc độ)              |
+-------------------------------------------------------------------------+

Phạm vi và giới hạn nghiên cứu

  • Phạm vi: Thử nghiệm trên sa hình mô phỏng làn đường tiêu chuẩn với các phân đoạn đường thẳng, cua trái $90^\circ$, cua phải $90^\circ$ và điều kiện ánh sáng trong phòng thí nghiệm ổn định.
  • Giới hạn: Hệ thống tập trung vào bài toán bám làn đường (Lane Keeping Assist System - LKAS); chưa tích hợp module nhận diện biển báo giao thông bằng Deep Learning hoặc cảm biến LiDAR định vị bản đồ 2D/3D (SLAM).

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

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

Tiêu chí so sánh Hệ thống Line Follower truyền thống Nền tảng Deep Learning cao cấp (NVIDIA Jetson) Giải pháp Đề tài (Raspberry Pi 4 + Arduino Nano)
Cảm biến đầu vào Mảng LED quang trở / Hồng ngoại Camera Stereo + LiDAR 3D + Radar Camera CMOS góc rộng (Wide FOV)
Khả năng xử lý Đọc tín hiệu số/analog thô Mạng nơ-ron CNN/YOLO phức tạp Pipeline thị giác máy tính OpenCV + PID
Độ linh hoạt làn đường Rất thấp (chỉ bám vạch đen cố định) Rất cao (thích ứng mọi điều kiện) Cao (xử lý phối cảnh, bù đứt gãy làn)
Chi phí phần cứng Rất thấp (< 1.000.000 VNĐ) Rất cao (> 15.000.000 VNĐ) Tối ưu (~ 3.500.000 - 4.500.000 VNĐ)
Độ trễ điều khiển Cực thấp (< 5ms) Trung bình (30 - 60ms) Thấp (< 15ms qua chuẩn giao tiếp SPI)

Hệ thống phân loại yêu cầu kỹ thuật theo mô hình MoSCoW:

  • Must have: Thu nhận hình ảnh $\ge 30\text{ FPS}$, phát hiện 2 vạch kẻ làn, tính toán sai số $\Delta e$, điều khiển góc lái servo qua PWM, truyền dữ liệu qua SPI.
  • Should have: Giao diện cân chỉnh vùng quan tâm (ROI) bằng thanh trượt Trackbar, cơ chế tự động giữ góc lái dự đoán khi mất vạch kẻ.
  • Could have: Hiển thị thông số thời gian thực lên màn hình LCD FPC7005001, tính năng phanh tái sinh qua mạch MOSFET H-bridge.
  • Won't have: Xử lý tránh chướng ngại vật động và định vị toàn cầu GPS thời gian thực.

Thiết kế hệ thống

Kiến trúc phần cứng được phân tầng rõ rệt nhằm phân tách trách nhiệm giữa tác vụ tính toán nặng và tác vụ chấp hành thời gian thực:

+-----------------------------------------------------------------------------+
|                             KIẾN TRÚC HỆ THỐNG                              |
+-----------------------------------------------------------------------------+
| [TẦNG CẢM BIẾN]      Camera Module CMOS (640x480 @ 30fps)                   |
|                                  | (CSI / USB Interface)                    |
|                                  v                                          |
| [TẦNG XỬ LÝ ẢNH]     Raspberry Pi 4 Model B (Broadcom BCM2711, 4GB RAM)     |
|                      - Perspective Transform (Bird's Eye View)              |
|                      - Gray Scale -> Gaussian Blur -> Canny Edge            |
|                      - Two-Point Search & Lateral Error Delta(e)            |
|                      - PID Controller -> Target Angle                       |
|                                  |                                          |
|                                  | SPI Protocol (MOSI, MISO, SCK, SS)       |
|                                  v                                          |
| [TẦNG ĐIỀU KHIỂN]    Arduino Nano (ATmega328P @ 16MHz)                      |
|                      - SPI Interrupt Handler                                |
|                      - Timer PWM Generation (Pins D9, D10)                  |
|                                  |                                          |
|                 +----------------+----------------+                         |
|                 |                                 |                         |
|                 v                                 v                         |
| [TẦNG CHẤP HÀNH] Servo MG996R (Góc lái)    Mạch Công suất DC775             |
|                  - Đánh lái trục trước     - Opto PC817 cách ly quang       |
|                  - Tần số xung 50Hz        - MOSFET IRF3205 H-Bridge        |
|                                            - Động cơ DC775 + Bộ vi sai sau  |
+-----------------------------------------------------------------------------+
  • Khối nguồn và bảo vệ: Sử dụng khối pin nguồn chuyên dụng kết hợp mạch hạ áp Buck LM2596 để chuyển đổi điện áp nguồn xuống $5\text{V}-3\text{A}$ ổn định cho Raspberry Pi 4 và Arduino. Tích hợp cầu chì ống bảo vệ quá dòng và diode Schottky chống phân cực ngược.
  • Mạch cách ly và công suất: Tín hiệu PWM từ Arduino được cách ly qua mạch Optocoupler PC817 nhằm triệt tiêu hoàn toàn xung điện áp phản kháng (Back-EMF) từ động cơ DC775 công suất lớn, dẫn động qua tầng công suất MOSFET kênh N IRF3205 ($V_{DSS} = 55\text{V}, I_D = 110\text{A}, R_{DS(on)} = 8.0\text{ m}\Omega$).

Methodology

Quy trình phát triển áp dụng mô hình lai V-Model kết hợp Agile Sprints:

  • Giai đoạn 1 (Tuần 1 - 3): Phân tích cơ sở lý thuyết, mô hình hóa động học xe 4 bánh lái trước (Ackermann Steering Geometry), khảo sát thư viện OpenCV và chuẩn giao tiếp ngoại vi.
  • Giai đoạn 2 (Tuần 4 - 8): Thiết kế mạch in, gia công cơ khí khung gầm RC Buggy, bố trí gá đỡ camera có thể tùy chỉnh góc ngẩng $\theta = 30^\circ - 45^\circ$, hoàn thiện khối truyền động vi sai.
  • Giai đoạn 3 (Tuần 9 - 13): Xây dựng thuật toán xử lý ảnh trên máy tính nhúng, tối ưu hóa tốc độ khung hình (frame rate), lập trình firmware SPI Slave cho Arduino Nano.
  • Giai đoạn 4 (Tuần 14 - 16): Thử nghiệm sa hình thực tế, hiệu chuẩn tham số PID bằng phương pháp Ziegler-Nichols kết hợp tinh chỉnh thực nghiệm, hoàn thiện báo cáo kỹ thuật.

Implementation và kết quả

Development Process

1. Thuật toán phát hiện làn đường thời gian thực (Vision Pipeline)

Thuật toán thị giác máy tính được triển khai bằng ngôn ngữ Python 3.9 và thư viện OpenCV 4.5 trên hệ điều hành Raspberry Pi OS.

Pipeline xử lý qua các giai đoạn tuần tự:

  1. Biến đổi phối cảnh (Perspective Transform): Chuyển đổi góc nhìn phối cảnh (Perspective View) thu được từ camera thành góc nhìn từ trên xuống (Bird's Eye View / Top-Down View). Kỹ thuật này giúp loại bỏ hiệu ứng tụ tiêu cự, đảm bảo hai vạch kẻ song song trên thực tế sẽ xuất hiện song song trong ma trận điểm ảnh.
  2. Tiền xử lý ảnh: Chuyển đổi không gian màu RGB sang Grayscale 8-bit nhằm giảm $66.7%$ dung lượng dữ liệu cần xử lý. Áp dụng bộ lọc Gaussian Blur với kích thước Kernel $5 \times 5$ để loại bỏ nhiễu hạt tần số cao.
  3. Phát hiện biên cạnh (Canny Edge Detection): Tính toán đạo hàm không gian bậc một (Sobel Gradient) để tìm các điểm có biến thiên cường độ sáng lớn nhất:
import cv2
import numpy as np

def process_lane_frame(frame, width=640, height=480):
    # 1. Định nghĩa 4 điểm vùng ROI trên ảnh gốc và ảnh đích
    src_points = np.float32([[80, 300], [560, 300], [10, 460], [630, 460]])
    dst_points = np.float32([[0, 0], [width, 0], [0, height], [width, height]])
    
    # 2. Ma trận biến đổi phối cảnh (Perspective Matrix)
    matrix = cv2.getPerspectiveTransform(src_points, dst_points)
    transformed_frame = cv2.warpPerspective(frame, matrix, (width, height))
    
    # 3. Tiền xử lý GrayScale và Gaussian Blur
    gray = cv2.cvtColor(transformed_frame, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    
    # 4. Trích xuất biên độ sáng bằng Canny Edge
    t_lower, t_upper = 50, 150
    canny_edges = cv2.Canny(blurred, t_lower, t_upper)
    
    return canny_edges

2. Thuật toán dò tìm biên làn và tính toán độ lệch tâm

Sau khi trích xuất ma trận biên cạnh nhị phân, chương trình tiến hành quét các hàng ngang tại vùng quan tâm (ROI) cố định để xác định tọa độ $x_{left}$ và $x_{right}$ của vạch kẻ trái và phải:

$$\text{Center}{\text{lane}} = \frac{x{left} + x_{right}}{2}$$

$$\text{Error } e(t) = \text{Center}{\text{lane}} - \text{Center}{\text{camera}}$$

Trong trường hợp một bên làn đường bị mờ hoặc đứt gãy, hệ thống kích hoạt cơ chế dự đoán điểm (Point Extrapolation) dựa trên độ rộng tiêu chuẩn của làn đường đã được hiệu chuẩn trước ($\text{Lane Width} \approx 320\text{ pixels}$):

  • Mất làn phải: $x_{right} = x_{left} + \text{Lane Width}$
  • Mất làn trái: $x_{left} = x_{right} - \text{Lane Width}$

3. Bộ điều khiển bám làn PID (Proportional-Integral-Derivative)

Tín hiệu sai số $e(t)$ được đưa vào bộ điều khiển PID số để tính toán góc bẻ lái $\theta(t)$:

$$u(t) = K_p \cdot e(t) + K_i \int_{0}^{t} e(\tau) d\tau + K_d \frac{de(t)}{dt}$$

class PIDController:
    def __init__(self, Kp=0.45, Ki=0.01, Kd=0.15, sample_time=0.03):
        self.Kp = Kp
        self.Ki = Ki
        self.Kd = Kd
        self.sample_time = sample_time
        self.prev_error = 0.0
        self.integral = 0.0

    def compute(self, error):
        # Thành phần tỷ lệ
        P = self.Kp * error
        # Thành phần tích phân với Anti-Windup giới hạn biên
        self.integral += error * self.sample_time
        self.integral = np.clip(self.integral, -50, 50)
        I = self.Ki * self.integral
        # Thành phần vi phân
        derivative = (error - self.prev_error) / self.sample_time
        D = self.Kd * derivative
        
        self.prev_error = error
        output = P + I + D
        # Giới hạn góc lái Servo trong dải [45, 135] độ (Tâm 90 độ)
        steering_angle = int(np.clip(90 + output, 45, 135))
        return steering_angle

4. Giao thức truyền thông SPI Master-Slave

Tín hiệu góc lái sau khi tính toán trên Raspberry Pi 4 (Master) được đóng gói thành các khung dữ liệu 1-byte và truyền tức thời xuống Arduino Nano (Slave) qua giao thức SPI ở tốc độ xung nhịp $500\text{ kHz}$:

  • Raspberry Pi (Python - spidev): Ghi giá trị góc lái trực tiếp vào bus SPI thông qua các chân MOSI (GPIO11), SCLK (GPIO9), CE0 (GPIO8).
  • Arduino Nano (C/C++): Sử dụng ngắt ngầm định ISR(SPI_STC_vect) để đọc trực tiếp thanh ghi dữ liệu SPDR (SPI Data Register), giảm thiểu tối đa tải của CPU chính:
#include <SPI.h>
#include <Servo.h>

Servo steeringServo;
volatile byte receivedAngle = 90;

void setup() {
  // Cấu hình chân Slave SPI: MISO là OUTPUT, MOSI/SCK/SS là INPUT
  pinMode(MISO, OUTPUT);
  pinMode(MOSI, INPUT);
  pinMode(SCK, INPUT);
  pinMode(SS, INPUT);
  
  // Bật chế độ SPI Slave thông qua thanh ghi SPCR
  SPCR |= _BV(SPE);
  SPI.attachInterrupt();
  
  steeringServo.attach(9); // Servo lái kết nối chân D9
  steeringServo.write(90); // Khởi tạo góc thẳng
}

// Trình phục vụ ngắt SPI (ISR) thực thi ngay khi nhận đủ 8-bit dữ liệu
ISR(SPI_STC_vect) {
  byte c = SPDR;
  if (c >= 45 && c <= 135) {
    receivedAngle = c;
    steeringServo.write(receivedAngle);
  }
}

void loop() {
  // Luồng chính xử lý điều tốc động cơ DC775 không bị chặn bởi truyền thông
}

Testing và validation

Quá trình kiểm thử thực nghiệm được thực hiện trên sa hình với các tham số đo lường thực tế:

Kịch bản thử nghiệm Số lần chạy Tỉ lệ bám làn thành công Sai số lệch tâm trung bình ($\text{RMSE}$) Thời gian đáp ứng lái
Đoạn đường thẳng ($5\text{m}$) 30 $100%$ $\pm 4.2\text{ mm}$ $< 12\text{ ms}$
Cua cong bán kính $R=0.8\text{m}$ (Trái) 25 $96.0%$ $\pm 8.7\text{ mm}$ $< 15\text{ ms}$
Cua cong bán kính $R=0.8\text{m}$ (Phải) 25 $96.0%$ $\pm 9.1\text{ mm}$ $< 15\text{ ms}$
Đoạn mất vạch kẻ ($20\text{cm}$) 20 $90.0%$ $\pm 14.5\text{ mm}$ $< 18\text{ ms}$
  • Hiệu chuẩn bộ điều khiển PID: Áp dụng phương pháp xác định hệ số tới hạn $K_u = 0.85$ và chu kỳ dao động tới hạn $T_u = 0.42\text{ s}$. Bộ tham số tối ưu đạt được sau tinh chỉnh thực nghiệm: $K_p = 0.45$, $K_i = 0.01$, $K_d = 0.15$.
  • Độ ổn định hệ thống: Raspberry Pi 4 duy trì tốc độ xử lý ổn định ở mức $32 - 35\text{ FPS}$ với độ phân giải đầu vào $640 \times 480$. Nhiệt độ CPU duy trì ở mức $52^\circ\text{C}$ nhờ hệ thống tản nhiệt thụ động kết hợp quạt làm mát mini.

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

  1. Kiến trúc đồng xử lý phân tán (Distributed Dual-Controller Architecture): Tách biệt hoàn toàn tầng thị giác máy tính phức tạp và tầng điều khiển thời gian thực cứng (Hard Real-Time). Cách tiếp cận này giúp Raspberry Pi tập trung $100%$ chu kỳ xử lý cho pipeline OpenCV mà không bị gián đoạn bởi các xung PWM ngắt quãng, đồng thời Arduino Nano đảm bảo tín hiệu điều khiển servo luôn chính xác tuyệt đối không bị trễ khung (jitter-free).
  2. Tối ưu hóa Pipeline biến đổi góc nhìn thích ứng (Adaptive Birds-Eye ROI): Việc kết hợp Biến đổi phối cảnh (Perspective Transformation) với thanh trượt hiệu chỉnh ma trận trực quan (Trackbars) giúp mô hình dễ dàng thích ứng với các độ cao và góc nghiêng camera khác nhau mà không cần hiệu chỉnh lại phần cứng.
  3. Cơ chế suy luận bù trừ làn đứt quãng (Point Extrapolation Mechanism): Giải quyết triệt để hiện tượng xe bị giật lái hoặc dừng đột ngột khi đi qua vùng vạch kẻ bị mòn hoặc ngắt quãng bằng thuật toán dự đoán dựa trên khoảng cách hình học đối xứng của làn đường.

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

Trường hợp sử dụng thực tế (Real-World Use Cases)

  • Robot tự hành trong nhà kho (Intralogistics AGV): Ứng dụng trong các nhà máy sản xuất thông minh để vận chuyển linh kiện, hàng hóa theo các tuyến đường cố định được sơn vạch với chi phí triển khai cực thấp.
  • Mô hình giáo dục và nghiên cứu ADAS: Đóng vai trò là nền tảng thực hành thí nghiệm chi phí thấp cho sinh viên ngành Công nghệ Kỹ thuật Ô tô, Kỹ thuật Cơ điện tử và Tự động hóa tiếp cận công nghệ xe tự lái cấp độ 2.
  • Xe làm sạch tự động trong khuôn viên kín: Ứng dụng trên các phương tiện nhỏ tự hành làm nhiệm vụ quét dọn, khử khuẩn trong bệnh viện, sân bay hoặc khuôn viên trường học.

Hướng dẫn triển khai nhanh (Deployment Instructions)

# 1. Cập nhật hệ thống và cài đặt môi trường trên Raspberry Pi OS
sudo apt-get update && sudo apt-get upgrade -y
sudo apt-get install python3-opencv python3-numpy python3-spidev -y

# 2. Kích hoạt giao tiếp SPI trên Raspberry Pi
sudo raspi-config
# Chọn: Interface Options -> SPI -> Enable -> Finish

# 3. Nạp mã nguồn điều khiển lên Arduino Nano qua Arduino IDE
# Kết nối dây SPI giữa 2 mạch:
# Pi Pin 19 (MOSI) <---> Nano Pin D11
# Pi Pin 21 (MISO) <---> Nano Pin D12
# Pi Pin 23 (SCK)  <---> Nano Pin D13
# Pi Pin 24 (CE0)  <---> Nano Pin D10
# Pi Pin 6  (GND)  <---> Nano Pin GND

# 4. Khởi chạy chương trình bám làn chính
python3 lane_keeping_system.py

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

Hạn chế kỹ thuật

  • Độ nhạy cảm với ánh sáng môi trường: Thuật toán phát hiện cạnh Canny phụ thuộc vào ngưỡng cố định ($T_{lower}, T_{upper}$), do đó có thể suy giảm độ chính xác khi cường độ ánh sáng thay đổi đột ngột hoặc xuất hiện bóng đổ phức tạp trên mặt đường.
  • Thiếu cảm biến bổ trợ: Hệ thống hiện chỉ sử dụng camera đơn sắc (Monocular Vision), chưa có cảm biến đo khoảng cách siêu âm (Ultrasonic) hoặc LiDAR để phát hiện chướng ngại vật phía trước.

Hướng phát triển trong tương lai

  • Tích hợp mạng nơ-ron học sâu (Deep Learning): Nhúng mô hình thị giác nhẹ như MobileNetV3 hoặc YOLOv8-tiny kết hợp bộ tăng tốc AI Google Coral USB TPU để đồng thời phát hiện làn đường, biển báo giao thông và đèn tín hiệu.
  • Hệ điều hành Robot ROS 2 (Robot Operating System): Chuyển đổi kiến trúc phần mềm sang ROS 2 Humble để chuẩn hóa các node giao tiếp, tích hợp thuật toán lọc Kalman mở rộng (EKF) kết hợp dữ liệu cảm biến quán tính (IMU).
  • Nâng cấp mạng truyền thông CAN Bus: Thay thế giao tiếp SPI bằng chuẩn mạng CAN Bus chuẩn ô tô để tăng tính đồng bộ và chuẩn hóa công nghiệp.

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

  • Sinh viên ngành Kỹ thuật Ô tô & Cơ điện tử: Cung cấp tài liệu tham khảo chi tiết từ thiết kế cơ khí, điện tử công suất đến lập trình thuật toán điều khiển nhúng thời gian thực.
  • Kỹ sư phát triển hệ thống nhúng (Embedded Engineers): Nắm vững kỹ thuật ghép nối đa vi xử lý qua SPI tốc độ cao và kỹ thuật lập trình ngắt điều khiển tối ưu hóa tài nguyên.
  • Các doanh nghiệp vừa và nhỏ (SMEs): Cơ sở để phát triển các dòng robot vận chuyển hàng hóa tự động (AGV/AMR) chi phí thấp phục vụ tự động hóa kho bãi.
  • Giảng viên và Nghiên cứu sinh: Nền tảng mở (Open Platform) để phát triển các bài thí nghiệm chuyên sâu về lý thuyết điều khiển tự động và xử lý ảnh ứng dụng.

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

1. Cấu hình phần cứng tối thiểu để triển khai hệ thống là gì?

Hệ thống yêu cầu tối thiểu một vi xử lý máy tính nhúng có xung nhịp từ $1.2\text{ GHz}$, RAM tối thiểu $2\text{GB}$ (khuyến nghị Raspberry Pi 4 Model B), một vi điều khiển 8-bit (như Arduino Nano ATmega328P), camera độ phân giải HD $720\text{p}$, servo lực kéo từ $10\text{ kg}\cdot\text{cm}$ (MG996R) và nguồn cấp pin dòng xả cao tối thiểu $20\text{A}$.

2. Tại sao lại lựa chọn giao thức SPI thay vì UART hay I2C để giao tiếp giữa 2 bộ điều khiển?

Chuẩn giao tiếp SPI là giao thức truyền thông đồng bộ song công toàn phần (Full-Duplex) với tốc độ xung nhịp có thể đạt tới hàng chục MHz (cao hơn nhiều so với tốc độ chuẩn của I2C là $400\text{ kHz}$ và UART thông thường $115200\text{ bps}$). Điều này loại bỏ hoàn toàn hiện tượng nghẽn cổ chai dữ liệu khi truyền lệnh điều khiển góc lái liên tục theo thời gian thực.

3. Làm thế nào để giải quyết hiện tượng xung điện áp ngược làm treo vi điều khiển khi động cơ DC hoạt động?

Mạch điều khiển sử dụng cách ly quang (Optocoupler PC817) để tách rời hoàn toàn đường mass (GND) và nguồn tín hiệu của vi điều khiển với mạch nguồn công suất của động cơ DC775, kết hợp tụ hóa dập xung và diode bảo vệ song song với cuộn dây động cơ.

4. Hệ thống xử lý như thế nào khi xe đi vào khúc cua khuất vạch kẻ một bên?

Khi mất dấu vạch kẻ một bên, module trích xuất biên sẽ kích hoạt thuật toán ước lượng điểm hình học (Point Extrapolation). Dựa vào tọa độ biên còn lại và thông số bề rộng làn đường tiêu chuẩn được lưu trong bộ nhớ đệm, hệ thống tự động suy diễn tọa độ tâm làn giả định để tiếp tục tính toán sai số PID.

5. Chi phí dự toán và thời gian hoàn vốn (ROI) khi ứng dụng mô hình này vào nhà xưởng là bao nhiêu?

Tổng chi phí linh kiện phần cứng cho một mô hình xe hoàn chỉnh dao động từ 3.500.000 đến 5.000.000 VNĐ. Khi ứng dụng vào mô hình AGV chở hàng nhẹ trong các xưởng may mặc hoặc chế tạo nhỏ, thời gian thu hồi vốn ước tính chỉ từ 3 đến 6 tháng so với chi phí thuê nhân công vận chuyển thủ công.

Kết luận

Đồ án tốt nghiệp "Nghiên cứu, thiết kế mô hình xe tự hành" của nhóm sinh viên Nguyễn Hồng Phúc và Dương Quốc Việt dưới sự hướng dẫn của TS. Lê Thanh Phúc tại Trường Đại học Sư phạm Kỹ thuật TP.HCM đã xây dựng thành công một mô hình xe tự hành bám làn đường hoàn chỉnh, ổn định và có tính ứng dụng thực tiễn cao. Bằng cách kết hợp linh hoạt giữa máy tính nhúng Raspberry Pi 4, vi điều khiển Arduino Nano, pipeline thị giác máy tính OpenCV và bộ điều khiển PID, hệ thống đã chứng minh tính khả thi vượt trội của giải pháp xe tự hành chi phí thấp nhưng vẫn đảm bảo độ tin cậy và thời gian đáp ứng thời gian thực.

Nghiên cứu này không chỉ đóng góp một giải pháp kỹ thuật rõ ràng, chi tiết cho cộng đồng nghiên cứu xe tự hành trong nước mà còn mở ra nền tảng vững chắc để tiếp tục tích hợp các công nghệ tự hành nâng cao như trí tuệ nhân tạo nhận diện đối tượng và hệ điều hành robot ROS trong tương lai.