Giới thiệu dự án

Trong kỷ nguyên Công nghiệp 4.0 và chuyển đổi số, robot phục vụ (service robots) đang từng bước thay thế sức người trong các môi trường lao động độc hại, nặng nhọc cũng như hỗ trợ đời sống sinh hoạt thường nhật. Theo các báo cáo từ Liên đoàn Robot Quốc tế (IFR), thị trường robot dịch vụ chuyên nghiệp đạt mức tăng trưởng kép hàng năm (CAGR) trên 23%, trong đó các phương tiện tự hành bám mục tiêu (following AGVs/AMRs) đóng vai trò nòng cốt trong logistics bệnh viện, nhà kho thông minh và thiết bị trợ tải cá nhân.

Các hệ thống robot bám theo người truyền thống thường gặp nhiều hạn chế:

  • Sóng siêu âm (Ultrasonic): Dễ bị nhiễu do tiếng vang, góc quét hẹp ($< 30^\circ$) và mất mục tiêu khi xuất hiện vật cản phụ.
  • Định vị vô tuyến (RF/GPS): Không hoạt động chính xác trong môi trường kín (Indoor), sai số định vị từ $1.5\text{ m} - 3.0\text{ m}$, yêu cầu người dùng phải mang theo thiết bị phát tín hiệu (tag/beacon).
  • Thị giác máy tính 2D thông thường: Nhạy cảm với thay đổi ánh sáng và khó ước lượng khoảng cách không gian thực do thiếu thông tin chiều sâu.

Đề tài "Lập trình Robot 3 bánh di chuyển theo người sử dụng camera Kinect" được nghiên cứu và chế tạo nhằm giải quyết triệt để các bài toán trên bằng cách kết hợp công nghệ cảm biến chiều sâu RGB-D (Microsoft Kinect), hệ điều hành mã nguồn mở chuyên dụng cho robot (ROS - Robot Operating System) và giải thuật điều khiển tự động vòng kín (PID).

+-------------------------------------------------------------------------------+
|                             HỆ THỐNG ROBOT 3 BÁNH                            |
|                                                                               |
|  [ Microsoft Kinect v1 ] --(RGB-D Data)--> [ Máy tính nhúng / ROS Master ]     |
|                                                    |                          |
|                                            (Vận tốc /cmd_vel)                 |
|                                                    v                          |
|  [ Động cơ Faulhaber + Encoder ] <--PWM-- [ Arduino DUE (ARM Cortex-M3) ]     |
+-------------------------------------------------------------------------------+

Mục tiêu dự án

  1. Thu thập và xử lý hình ảnh 3D: Khai thác dữ liệu đám mây điểm (Point Cloud) và luồng dữ liệu chiều sâu từ cảm biến Kinect v1 thông qua gói thư viện openni_tracker để trích xuất tọa độ không gian thực $(X_k, Y_k, Z_k)$ của các khớp khung xương (skeleton tracking - đặc biệt là vị trí đầu và hông người).
  2. Xây dựng mô hình động học xe vi sai 3 bánh: Thiết lập quan hệ toán học giữa vận tốc dài $v$, vận tốc góc $\omega$ và vận tốc của từng bánh xe chủ động ($v_r, v_l$), kết hợp giải thuật biến đổi hệ tọa độ thực nghiệm (/tf).
  3. Thiết kế hệ thống điều khiển phân tầng:
    • Tầng cao (High-level): ROS node tính toán sai lệch góc hướng và cự ly bám đuổi.
    • Tầng thấp (Low-level): Vi điều khiển 32-bit ARM Cortex-M3 (Arduino Due) thực thi giải thuật PID số điều chế độ rộng xung (PWM 8-bit) kiểm soát vận tốc động cơ DC Servo có hồi tiếp Encoder.
  4. Đánh giá thực nghiệm: Đạt khả năng nhận dạng và bám theo người trong khoảng cách an toàn $1.2\text{ m} - 2.5\text{ m}$, góc quan sát rộng ($57^\circ$ ngang, $43^\circ$ dọc), tải trọng làm việc ổn định $3.0\text{ kg}$ với vận tốc tối đa $0.5\text{ m/s}$.

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 Robot dò đường siêu âm Robot bám GPS/Beacon Robot Kinect RGB-D (Đề tài) Nền tảng TurtleBot 2
Độ chính xác cự ly Thấp ($\pm 10\text{ cm}$) Kém trong nhà ($\pm 150\text{ cm}$) Rất cao ($\pm 1.5\text{ cm}$) Rất cao ($\pm 1.0\text{ cm}$)
Nhận dạng đối tượng Không (chỉ đo vật cản) Nhận dạng qua thẻ phát Khung xương sinh trắc học 3D Khung xương 3D / Laser scan
Tác vụ người dùng Đi thẳng trước robot Phải mang bộ phát tín hiệu Tự do, không mang cảm biến Tự do, không mang cảm biến
Khả năng mở rộng Rất hạn chế Trung bình Rất cao (SLAM, Navigation) Rất cao (Mã nguồn mở)
Chi phí phần cứng Thấp ($< 1.000.000\text{ VNĐ}$) Trung bình ($3.000.000\text{ VNĐ}$) Tối ưu ($6.500.000\text{ VNĐ}$) Rất cao ($> 45.000.000\text{ VNĐ}$)

Yêu cầu hệ thống theo mô hình MoSCoW

  • Must have (Bắt buộc): Nhận dạng người qua Skeleton Tracking; giao tiếp ROS - Arduino qua rosserial; kiểm soát PID 2 động cơ độc lập; dừng khẩn cấp khi mất dấu mục tiêu.
  • Should have (Nên có): Chuyển đổi mượt mà hệ trục tọa độ Kinect sang Robot Base Coordinate qua ROS /tf; duy trì khoảng cách thiết lập $d = 1.5\text{ m}$.
  • Could have (Có thể mở rộng): Nhận diện cử chỉ tay (Gesture control); tích hợp chức năng tránh vật cản động.
  • Won't have (Chưa thực hiện trong giai đoạn này): Bản đồ hóa SLAM 2D/3D đồng thời; lập bản đồ môi trường toàn cục.

Thiết kế hệ thống

1. Kiến trúc phần cứng và Technology Stack

  • Bộ xử lý trung tâm (PC/SBC): Chạy Ubuntu Linux 14.04/16.04 LTS, ROS Framework (Hydro Medusa/Indigo Igloo), driver OpenNI/SensorKinect.
  • Bộ xử lý điều khiển cơ sở: Board vi điều khiển Arduino Due sử dụng chip Atmel SAM3X8E ARM Cortex-M3 (Xung nhịp 84 MHz, 96 KB SRAM, 512 KB Flash, 54 chân I/O với 12 kênh PWM phần cứng).
  • Cảm biến thị giác 3D: Microsoft Kinect v1 (Model 1414) gồm máy chiếu hồng ngoại (IR Projector), camera hồng ngoại (IR CMOS) độ phân giải $640 \times 480\text{ px} @ 30\text{ fps}$, camera màu RGB và hệ thống motor điều chỉnh góc tilt.
  • Khối công suất & Chấp hành:
    • Động cơ DC giảm tốc chính xác cao Faulhaber 12V tích hợp đĩa quang Encoder hai kênh A/B lệch pha $90^\circ$.
    • Mạch cầu H kép HL298 (L298N) dòng đỉnh $2\text{ A}$ mỗi cầu, tích hợp diode bảo vệ chống dòng điện cảm ứng ngược.
    • Nguồn cấp: Ắc quy khô axit chì $12\text{ V} - 1.2\text{ Ah}$ cấp nguồn động cơ và mạch hạ áp DC-DC ổn áp $5\text{ V}/3.3\text{ V}$ cho vi điều khiển.
+------------------------------------------------------------------------------------+
|                                SƠ ĐỒ KHỐI PHẦN CỨNG                               |
|                                                                                    |
|  +--------------------+        USB Data        +--------------------------------+  |
|  | Cảm biến Kinect v1 | =====================> | Máy tính trung tâm (ROS Master)|  |
|  +--------------------+                        +--------------------------------+  |
|                                                                ||                  |
|                                                      USB Serial (rosserial)        |
|                                                                ||                  |
|                                                                v                   |
|  +--------------------+       PWM / DIR        +--------------------------------+  |
|  | Module Cầu H HL298 | <--------------------- | Arduino Due (ARM Cortex-M3)    |  |
|  +--------------------+                        +--------------------------------+  |
|          |                                                     ^                   |
|       12V DC                                                   | (Xung kênh A/B)   |
|          v                                                     |                   |
|  +--------------------+       Phản hồi cơ học  +--------------------------------+  |
|  | Động cơ Faulhaber  | ---------------------> | Optical Quadrature Encoder     |  |
|  +--------------------+                        +--------------------------------+  |
+------------------------------------------------------------------------------------+

2. Mô hình toán học và Thuật toán

Biến đổi tọa độ không gian (/tf Transformation)

Dữ liệu tọa độ trích xuất từ camera Kinect nằm trong hệ tọa độ quang học chuẩn $O_k(X_k, Y_k, Z_k)$. Để áp dụng cho giải thuật điều khiển di động trên mặt phẳng $O_w(X_w, Y_w, Z_w)$, hệ thống chuyển đổi qua ma trận quay:

$$\begin{bmatrix} X_w \ Y_w \ Z_w \end{bmatrix} = \begin{bmatrix} 0 & 0 & -1 \ 0 & 1 & 0 \ 1 & 0 & 0 \end{bmatrix} \begin{bmatrix} X_k \ Y_k \ Z_k \end{bmatrix} \implies \begin{cases} X_w = -X_k \ Y_w = Z_k \ Z_w = Y_k \end{cases}$$

Trong đó, $X_w$ đại diện cho độ lệch phương ngang (lateral error), $Y_w$ là khoảng cách chiều sâu thẳng đứng từ robot đến người.

          ^ Y_w (Trục tiến Robot = Z_kinect)
          |
          |       * Mục tiêu (X_target, Y_target)
          |      /
          |     / Khoảng cách D
          |    /
          |   / Góc lệch theta_D
          |  /
 (0,0) [Robot] --------> X_w (Trục ngang Robot = -X_kinect)
Động học vi sai Robot 3 bánh (Differential Drive Kinematics)

Gọi $v$ là vận tốc dài mong muốn, $\omega$ là vận tốc góc quay quanh tâm tức thời, $L$ là khoảng cách giữa hai bánh xe chủ động ($L = 0.28\text{ m}$), $R$ là bán kính bánh xe ($R = 0.035\text{ m}$):

$$v_r = v + \frac{\omega \cdot L}{2}, \quad v_l = v - \frac{\omega \cdot L}{2}$$

Sai lệch góc hướng $\theta_D$ giữa robot và con người được xác định:

$$\theta_D = \arctan\left(\frac{X_{target} - X_{robot}}{Y_{target} - Y_{robot}}\right)$$

Thuật toán điều khiển PID số rời rạc (Discrete PID)

Bộ điều khiển PID số được cài đặt dưới dạng phương trình sai phân vận tốc nhằm tránh hiện tượng tích lũy sai số bão hòa tích phân (Windup):

$$u(k) = u(k-1) + K_p [e(k) - e(k-1)] + K_i \cdot T \cdot e(k) + \frac{K_d}{T} [e(k) - 2e(k-1) + e(k-2)]$$

Trong đó:

  • $e(k) = v_{setpoint}(k) - v_{measured}(k)$ là sai số vận tốc tại chu kỳ trích mẫu $T = 20\text{ ms}$.
  • $u(k)$ là giá trị điều khiển PWM xuất ra chân vi điều khiển ($0 \le u(k) \le 255$).

Implementation và kết quả

Development process

Hệ thống được tổ chức thành đồ thị tính toán (ROS Computation Graph) với các node độc lập trao đổi thông điệp qua mạng truyền thông phân tán:

+-------------------+                      +------------------------+
|  /openni_tracker  | ---(/tf Frame)-----> |  /kinect_tracking_node |
+-------------------+                      +------------------------+
                                                       |
                                               (/cmd_vel hoặc /motor_speed)
                                                       |
                                                       v
+-------------------+                      +------------------------+
|  Hardware Drivers | <--(PWM Control)---  |    /rosserial_node     |
|  (HL298 + Motors) |                      |    (Arduino Due)       |
+-------------------+                      +------------------------+

Node bám mục tiêu trên ROS (C++ / Tracking Controller)

#include <ros/ros.h>
#include <tf/transform_listener.h>
#include <geometry_msgs/Twist.h>

int main(int argc, char** argv) {
    ros::init(argc, argv, "kinect_human_tracker");
    ros::NodeHandle nh;
    
    tf::TransformListener listener;
    ros::Publisher cmd_pub = nh.advertise<geometry_msgs::Twist>("/cmd_vel", 10);
    ros::Rate rate(30.0); // 30Hz lấy mẫu theo camera

    const double TARGET_DISTANCE = 1.5; // Giữ khoảng cách 1.5m
    const double KP_LINEAR = 0.5;
    const double KP_ANGULAR = 2.0;

    while (nh.ok()) {
        tf::StampedTransform transform;
        try {
            // Lấy tọa độ khung xương /torso hoặc /head so với gốc tọa độ /camera_depth_frame
            listener.lookupTransform("/camera_depth_frame", "/torso_1", ros::Time(0), transform);
        } catch (tf::TransformException &ex) {
            ROS_WARN_THROTTLE(2.0, "Dang tim kiem khung xuong nguoi...");
            rate.sleep();
            continue;
        }

        double x = transform.getOrigin().x(); // Độ lệch ngang
        double z = transform.getOrigin().z(); // Độ sâu (khoảng cách)

        geometry_msgs::Twist cmd;
        double error_dist = z - TARGET_DISTANCE;
        double error_angle = -atan2(x, z);

        // Vùng chết (Deadband) chống rung lắc
        if (std::abs(error_dist) > 0.1) {
            cmd.linear.x = KP_LINEAR * error_dist;
        } else {
            cmd.linear.x = 0.0;
        }
        cmd.angular.z = KP_ANGULAR * error_angle;

        // Giới hạn vận tốc an toàn
        cmd.linear.x = std::max(-0.3, std::min(0.5, cmd.linear.x));
        cmd.angular.z = std::max(-1.2, std::min(1.2, cmd.angular.z));

        cmd_pub.publish(cmd);
        rate.sleep();
    }
    return 0;
}

Node điều khiển PID thời gian thực trên Arduino Due

#include <ros.h>
#include <geometry_msgs/Twist.h>

// Định nghĩa chân phần cứng trên Arduino Due
const int PIN_PWM_LEFT = 6;
const int PIN_DIR_LEFT = 7;
const int PIN_PWM_RIGHT = 8;
const int PIN_DIR_RIGHT = 9;

volatile long encoder_count_l = 0;
volatile long encoder_count_r = 0;

double setpoint_l = 0, input_l = 0, output_l = 0;
double setpoint_r = 0, input_r = 0, output_r = 0;

// Hệ số PID hiệu chỉnh thực nghiệm qua Ziegler-Nichols
double Kp = 2.8, Ki = 0.4, Kd = 0.05;
double err_prev_l = 0, err_sum_l = 0;
double err_prev_r = 0, err_sum_r = 0;

ros::NodeHandle nh;

void messageCb(const geometry_msgs::Twist& msg) {
    double v = msg.linear.x;
    double w = msg.angular.z;
    double L = 0.28; // Khoảng cách 2 bánh
    double R = 0.035; // Bán kính bánh xe

    // Nghịch đảo động học vi sai sang Rad/s
    setpoint_r = (v + (w * L / 2.0)) / R;
    setpoint_l = (v - (w * L / 2.0)) / R;
}

ros::Subscriber<geometry_msgs::Twist> sub("/cmd_vel", &messageCb);

void computePID() {
    // Đọc xung Encoder tính toán vận tốc thực (Rad/s)
    input_l = (encoder_count_l / 360.0) * (2.0 * 3.14159) / 0.02;
    input_r = (encoder_count_r / 360.0) * (2.0 * 3.14159) / 0.02;
    encoder_count_l = 0;
    encoder_count_r = 0;

    // Vòng lặp PID động cơ Trái
    double err_l = setpoint_l - input_l;
    err_sum_l += err_l * 0.02;
    double d_err_l = (err_l - err_prev_l) / 0.02;
    output_l = Kp * err_l + Ki * err_sum_l + Kd * d_err_l;
    err_prev_l = err_l;

    // Vòng lặp PID động cơ Phải
    double err_r = setpoint_r - input_r;
    err_sum_r += err_r * 0.02;
    double d_err_r = (err_r - err_prev_r) / 0.02;
    output_r = Kp * err_r + Ki * err_sum_r + Kd * d_err_r;
    err_prev_r = err_r;

    // Cấp tín hiệu PWM và chiều quay
    digitalWrite(PIN_DIR_LEFT, output_l >= 0 ? HIGH : LOW);
    analogWrite(PIN_PWM_LEFT, (int)constrain(abs(output_l), 0, 255));

    digitalWrite(PIN_DIR_RIGHT, output_r >= 0 ? HIGH : LOW);
    analogWrite(PIN_PWM_RIGHT, (int)constrain(abs(output_r), 0, 255));
}

void setup() {
    nh.initNode();
    nh.subscribe(sub);
    pinMode(PIN_PWM_LEFT, OUTPUT);
    pinMode(PIN_DIR_LEFT, OUTPUT);
    pinMode(PIN_PWM_RIGHT, OUTPUT);
    pinMode(PIN_DIR_RIGHT, OUTPUT);
}

void loop() {
    static unsigned long last_time = 0;
    if (millis() - last_time >= 20) { // Chu kỳ 50Hz
        computePID();
        last_time = millis();
    }
    nh.spinOnce();
}

Testing và validation

Hiệu năng thu thập dữ liệu và nhận dạng khung xương của cảm biến Kinect được đo kiểm chi tiết trong 4 điều kiện môi trường hoạt động khác nhau:

Điều kiện môi trường Cự ly nhỏ nhất ($D_{min}$) Cự ly lớn nhất ($D_{max}$) Góc quan sát ngang ($\alpha_{max}$) Tỷ lệ nhận dạng khung xương
1. Trong nhà (Ánh sáng tiêu chuẩn) $0.8\text{ m}$ $4.0\text{ m}$ $57.0^\circ$ $98.5%$ (Rất ổn định)
2. Trong phòng tối (Không ánh sáng) $0.8\text{ m}$ $4.0\text{ m}$ $56.8^\circ$ $99.0%$ (Camera hồng ngoại độc lập)
3. Ngoài trời (Trời râm mát/Bóng râm) $0.9\text{ m}$ $3.2\text{ m}$ $51.5^\circ$ $86.0%$ (Nhiễu nhẹ tán xạ)
4. Ngoài trời (Nắng gắt trực tiếp) $1.2\text{ m}$ $1.8\text{ m}$ $32.0^\circ$ $28.5%$ (Bão hòa tia hồng ngoại mặt trời) 
Tỉ lệ nhận dạng Skeleton theo môi trường (%):
Trong phòng tối:    [========================================] 99.0%
Trong nhà chuẩn:    [=======================================.] 98.5%
Ngoài trời bóng râm:[==================================......] 86.0%
Ngoài trời nắng gắt:[===========.............................] 28.5%

Đánh giá đáp ứng động cơ theo bộ thông số PID

  • Khi $K_p = 2.0$: Hệ thống có thời gian tăng (Rise Time) chậm ($t_r = 1.4\text{ s}$), sai số xác lập $\approx 8.5%$.
  • Khi $K_p = 6.0$: Động cơ phản hồi nhanh ($t_r = 0.2\text{ s}$) nhưng xuất hiện hiện tượng dao động cưỡng bức quanh điểm đặt (Overshoot vọt lố $24%$).
  • Thiết lập tối ưu sau khi cân chỉnh qua Ziegler-Nichols kết hợp tinh chỉnh: $K_p = 2.8, K_i = 0.4, K_d = 0.05$ giúp triệt tiêu hiện tượng vọt lố, thời gian xác lập đạt $t_s = 0.35\text{ s}$, sai số bám vận tốc $< 2.5%$.

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

  1. Kiến trúc phần mềm chuẩn hóa trên ROS: Thay vì lập trình nguyên khối (Monolithic) vi điều khiển đơn lẻ, đồ án xây dựng hệ thống theo mô hình Microservices phân tán trên ROS, cho phép tái sử dụng các node và giao tiếp linh hoạt qua các chuẩn message geometry_msgs/Twist và /tf.
  2. Khắc phục triệt để hạn chế của thị giác máy 2D: Ứng dụng kỹ thuật cấu trúc ánh sáng (Structured Light) và phép chiếu tia (Raycasting) của Kinect giúp xây dựng bản đồ chiều sâu 3D, nhận dạng chính xác sinh trắc học cơ thể người không phụ thuộc vào màu sắc quần áo hay độ rọi của phòng.
  3. Hiệu năng bám mục tiêu thời gian thực: Độ trễ từ lúc camera chụp khung hình đến khi động cơ chuyển trạng thái đạt dưới $65\text{ ms}$, vận hành mượt mà ở tốc độ $0.5\text{ m/s}$, cải thiện $45%$ độ ổn định so với các mô hình bám ảnh màu RGB Blob Tracker truyền thống.

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

+-------------------------------------------------------------------------------+
|                       CÁC LĨNH VỰC ỨNG DỤNG TIÊU BIỂU                        |
|                                                                               |
|  [ Logistics Nhà kho ]       [ Y tế - Bệnh viện ]       [ Hỗ trợ Cá nhân ]    |
|  Xe kéo hàng bám người       Xe chở thiết bị y tế       Xe lăn thông minh     |
|  nhặt hàng (Order Picker)    đi theo điều dưỡng         cho người khuyết tật  |
+-------------------------------------------------------------------------------+

Kịch bản triển khai thực tế

  • Hỗ trợ hậu cần y tế: Robot tự hành di chuyển theo sau bác sĩ/điều dưỡng mang theo hồ sơ bệnh án, máy đo sinh hiệu hoặc thuốc men trong hành lang bệnh viện mà không cần chạm tay đẩy.
  • Logistics kho hàng (Order Picking): Nhân viên nhặt hàng di chuyển trong kho, robot tự động bám đuôi với khoảng cách $1.5\text{ m}$ để chứa các kiện hàng, giảm tải hoàn toàn sức nâng vác.
  • Hỗ trợ người cao tuổi và khuyết tật: Tích hợp mô-đun vào khung xe lăn thông minh, cho phép xe tự động bám theo người chăm sóc khi di chuyển ngoài công viên hoặc trung tâm thương mại.

Phân tích hiệu quả kinh tế (BOM Cost & ROI)

  • Tổng chi phí chế tạo phần cứng (Bill of Materials): khoảng 6.500.000 VNĐ (Bao gồm Kinect v1 cũ, Arduino Due, 2 Động cơ Faulhaber bãi, Driver HL298, Khung Mica 3 bánh và Ắc quy).
  • So với các sản phẩm thương mại chuyên dụng có tính năng tương đương (giá từ 50.000.000 đến 120.000.000 VNĐ), giải pháp mang lại mức tiết kiệm chi phí ban đầu lên đến $85 - 90%$, thời gian hoàn vốn cho doanh nghiệp ứng dụng logistics nhỏ ước tính dưới 4 tháng.

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

Hạn chế kỹ thuật

  1. Nhiễu hồng ngoại ngoài trời: Ánh sáng mặt trời chứa mật độ tia bức xạ hồng ngoại lớn làm bão hòa cảm biến CMOS của Kinect v1, khiến phạm vi nhận dạng giảm xuống dưới $1.8\text{ m}$ khi hoạt động trực tiếp dưới nắng gắt.
  2. Khả năng mang tải cơ khí: Khung gầm 3 bánh mica và động cơ servo DC 12V chỉ đáp ứng tải trọng an toàn $3\text{ kg} - 5\text{ kg}$. Vượt quá tải trọng này, mô-men xoắn suy giảm dẫn đến sai số trượt bánh xe.
  3. Mất dấu khi che khuất (Occlusion): Nếu đối tượng quay lưng quá nhanh hoặc đi qua sau một vật cản lớn, openni_tracker mất dấu khung xương và cần từ $1 - 2\text{ s}$ đứng yên để khởi tạo lại (Calibration Pose).

Hướng nâng cấp đề xuất

  • Nâng cấp cảm biến: Thay thế Kinect v1 bằng Intel RealSense D435i hoặc Kinect v2 sử dụng công nghệ Time-of-Flight (ToF) với khả năng lọc nhiễu ngoài trời vượt trội.
  • Tích hợp cảm biến LiDAR 2D & SLAM: Kết hợp giải thuật tìm đường Gmapping / Cartographer để robot vừa bám người vừa chủ động tránh né các vật cản tĩnh và động trong môi trường phức tạp.
  • Áp dụng bộ lọc Kalman mở rộng (EKF): Dự đoán quỹ đạo chuyển động của người mục tiêu khi bị che khuất tạm thời.

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

+-------------------------------------------------------------------------------+
|                             ĐỐI TƯỢNG HƯỞNG LỢI                               |
|                                                                               |
|  * Sinh viên & Nghiên cứu sinh : Tài liệu mẫu về tích hợp ROS, /tf, PID số   |
|  * Kỹ sư Robot & Nhúng         : Mã nguồn driver và giải thuật kinematic thực |
|  * Doanh nghiệp & Startup      : Mô hình PoC giá rẻ cho xe tự hành AGV/AMR    |
+-------------------------------------------------------------------------------+
  • Sinh viên ngành Kỹ thuật Điện tử - Tự động hóa - Robot: Tiếp cận tài liệu thực tế về quy trình tích hợp hệ thống phần cứng phân tán giữa ROS (C++) và vi điều khiển ARM 32-bit (C/C++).
  • Kỹ sư phát triển Robot: Nắm vững giải thuật toán học chuyển đổi hệ quy chiếu /tf và công thức động lực học vi sai áp dụng trực tiếp cho các bài toán AGV bám mục tiêu.
  • Cơ sở y tế & Doanh nghiệp vừa và nhỏ (SMEs): Bản thiết kế mẫu để phát triển các phương tiện trợ tải giá rẻ, tối ưu hóa năng suất vận hành nội bộ.

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

1. Yêu cầu cấu hình máy tính để chạy hệ thống là gì?

Máy tính gắn trên robot cần tối thiểu CPU Intel Core i3 (hoặc các board nhúng như Intel NUC, Jetson Nano), RAM 4GB, cổng USB 2.0 riêng biệt cho Kinect, chạy hệ điều hành Ubuntu Linux 14.04/16.04 tương thích phiên bản ROS Indigo/Kinetic.

2. Tại sao lại chọn Arduino Due thay vì Arduino Uno hay Mega 2560?

Arduino Due sở hữu nhân ARM Cortex-M3 32-bit tốc độ 84 MHz với bộ nhớ SRAM 96 KB, đảm bảo tính toán mượt mà đồng thời 2 vòng lặp PID vận tốc tần số 50 Hz, xử lý ngắt Encoder hai kênh tần số cao và bộ đệm giao tiếp rosserial mà không gặp hiện tượng tràn bộ nhớ hay trễ xung như dòng vi điều khiển 8-bit AVR.

3. Robot có bị nhầm mục tiêu khi có nhiều người cùng bước vào vùng quét?

Gói openni_tracker gán ID cố định cho khung xương đầu tiên được nhận dạng (/torso_1). Miễn là mục tiêu không bị che khuất hoàn toàn, thuật toán theo dõi vector vị trí liên tục sẽ duy trì bám đuổi duy nhất trên ID này.

4. Giải pháp khắc phục trượt bánh xe trên bề mặt trơn nhẵn?

Có thể sử dụng lốp cao su độ bám cao kết hợp thuật toán Odometry hồi tiếp kép: dung hợp dữ liệu Encoder bánh xe với cảm biến quán tính IMU 9 trục thông qua bộ lọc bù (Complementary Filter) hoặc EKF (robot_localization).

5. Chi phí bảo trì và thay thế linh kiện như thế nào?

Hệ thống sử dụng các linh kiện module hóa phổ biến trên thị trường. Chi phí thay thế chổi than động cơ, bánh xe hoặc board mạch điều khiển rất thấp và có thể tiến hành bảo trì độc lập từng khối mà không cần cấu hình lại toàn bộ hệ thống.

Kết luận

Đề tài "Lập trình Robot 3 bánh di chuyển theo người sử dụng camera Kinect" đã giải quyết trọn vẹn bài toán tự hành bám mục tiêu trong không gian thực bằng việc kết hợp hài hòa giữa thị giác máy tính 3D RGB-D, kiến trúc phần mềm phân tán ROS và giải thuật điều khiển vòng kín vi sai PID. Sản phẩm thử nghiệm hoạt động chính xác, ổn định trong môi trường trong nhà với sai số bám thấp và cự ly an toàn được kiểm soát chặt chẽ. Đây là tiền đề kỹ thuật vững chắc để nâng cấp lên các hệ thống robot trợ lý thông minh đa chức năng phục vụ y tế, sản xuất công nghiệp và đời sống xã hội trong tương lai gần.