Giới thiệu

Trong lĩnh vực điều khiển chuyển động nhúng, Odrive nổi bật là một nền tảng điều khiển động cơ mạnh mẽ nhờ kiến trúc phần cứng mã nguồn mở và thiết kế phần mềm linh hoạt. Bài viết này sẽ đi sâu vào hai mô hình đồng thời cốt lõi trong firmware của Odrive: vòng lặp luồng máy chủ CAN (thường được triển khai trong CanBusHandler::serviceLoop()) và chuỗi tác vụ máy trạng thái của từng trục động cơ (ví dụ, MotorAxis::processState()). Qua việc phân tích cấu trúc mã nguồn, chúng ta sẽ khám phá những nguyên tắc thiết kế hệ thống thời gian thực và máy trạng thái trong môi trường công nghiệp.

Kiến Trúc Luồng Thời Gian Thực Của Odrive

Kiến trúc firmware của Odrive được xây dựng trên một mô hình luồng phân lớp, nơi sau khi khởi tạo hệ điều hành thời gian thực (RTOS), nhiều luồng quan trọng sẽ được kích hoạt để quản lý các tác vụ khác nhau. Quy trình khởi tạo cơ bản có thể được hình dung như sau:

// Trình tự khởi tạo luồng chính (minh họa)
sys_comms_init();       // Thiết lập các kênh giao tiếp (CAN, UART)
start_motor_pwm_adc();  // Kích hoạt PWM và lấy mẫu ADC
start_sensor_monitor(); // Khởi tạo luồng giám sát cảm biến
for (int i = 0; i < NUM_AXES; ++i) {
    axis_controllers[i].spawn_worker_thread(); // Tạo luồng cho mỗi trục điều khiển
}

Mỗi luồng được gán một mức độ ưu tiên cẩn thận để đảm bảo các tác vụ yêu cầu thời gian thực cao nhất được xử lý ưu tiên. Dưới đây là ví dụ về phân bổ ưu tiên luồng:

Lưu ý: Trong môi trường RTOS, việc thiết lập ưu tiên luồng có ảnh hưởng trực tiếp đến tốc độ phản hồi của hệ thống. Odrive ưu tiên luồng giao tiếp để đảm bảo tính thời gian thực.

Phân Tích Sâu Luồng Máy Chủ CAN Bus

Luồng máy chủ CAN, thường được gọi là CanBusHandler::serviceLoop(), là kênh chính để Odrive tương tác với các thiết bị bên ngoài. Thiết kế của nó phản ánh các cân nhắc về độ tin cậy cần thiết trong truyền thông công nghiệp:

void CanBusHandler::serviceLoop() {
    CanProtocolType current_protocol = config_.active_protocol;
    if (current_protocol & CanProtocolType::SIMPLE_CAN) {
        simple_can_module_.initialize(); // Thiết lập ngăn xếp giao thức CAN
    }

    while (true) {
        uint32_t bus_error_status = can_driver_.get_bus_error();
        if (bus_error_status == CanErrorStatus::NONE) {
            uint32_t next_scheduled_event_ms = UINT32_MAX;
            if (current_protocol & CanProtocolType::SIMPLE_CAN) {
                next_scheduled_event_ms = std::min(simple_can_module_.process_incoming_frames(), next_scheduled_event_ms);
            }
            
            // Xử lý các khung tin nhận được từ các FIFO
            can_driver_.process_receive_fifo(CAN_RX_FIFO_A);
            can_driver_.process_receive_fifo(CAN_RX_FIFO_B);
            
            can_driver_.enable_interrupts(
                CAN_IT_RX_MSG_PENDING_FIFO0 |
                CAN_IT_RX_MSG_PENDING_FIFO1 |
                CAN_IT_TX_MAILBOX_EMPTY
            );
            
            osSemaphoreAcquire(can_access_semaphore_, std::max(next_scheduled_event_ms, 1UL));
        } else if (bus_error_status == CanErrorStatus::TIMEOUT_DETECTED) {
            can_driver_.clear_error_flags();
            if (can_driver_.start_interface() == InterfaceStatus::OK) {
                can_driver_.enable_interrupts(
                    CAN_IT_RX_MSG_PENDING_FIFO0 |
                    CAN_IT_TX_MAILBOX_EMPTY
                );
            }
        }
    }
}

Những điểm nổi bật trong thiết kế:

• Xử lý FIFO kép: Đồng thời giám sát hai bộ đệm nhận (FIFO) để tối ưu hóa việc sử dụng băng thông bus.
• Cơ chế khôi phục lỗi: Tự động phát hiện và phục hồi từ các lỗi phát sinh trên bus CAN.
• Lập lịch thích ứng: Sử dụng next_scheduled_event_ms để điều chỉnh thời gian chờ, tối ưu hóa phản hồi hệ thống.
• Bảo vệ truy cập: Sử dụng can_access_semaphore_ để quản lý quyền truy cập bus và tránh xung đột.

Trong thực tế gỡ lỗi, khi tải bus CAN vượt quá 70%, việc điều chỉnh hợp lý thời gian chờ của osSemaphoreAcquire có thể giảm đáng kể tỷ lệ mất thông điệp.

Triển Khai Máy Trạng Thái Với Chuỗi Tác Vụ Động

Hàm MotorAxis::processState() minh họa một cách tiếp cận máy trạng thái mạnh mẽ, điển hình cho các ứng dụng điều khiển công nghiệp:

void MotorAxis::processState() {
    while (true) {
        // Xây dựng chuỗi tác vụ động
        if (requested_operation_ != AxisOperation::NONE) {
            size_t sequence_idx = 0;
            if (requested_operation_ == AxisOperation::STARTUP_INITIALIZATION) {
                if (config_.auto_calibrate_motor)
                    operation_sequence_[sequence_idx++] = AxisOperation::MOTOR_CALIBRATION_PHASE;
                if (config_.auto_encoder_index_search && encoder_.has_index_sensor())
                    operation_sequence_[sequence_idx++] = AxisOperation::ENCODER_INDEX_SEARCH_PHASE;
                // ... Thêm các trạng thái khởi động khác
            }
            operation_sequence_[sequence_idx++] = AxisOperation::NONE; // Đánh dấu kết thúc chuỗi
            requested_operation_ = AxisOperation::NONE;
        }

        // Thực thi trạng thái hiện tại
        bool operation_successful;
        switch (current_op_state_) {
            case AxisOperation::MOTOR_CALIBRATION_PHASE:
                operation_successful = motor_controller_.perform_calibration();
                break;
            case AxisOperation::ENCODER_INDEX_SEARCH_PHASE:
                if (!motor_controller_.is_calibrated()) goto invalid_state_transition;
                operation_successful = encoder_.execute_index_search();
                break;
            // ... Các xử lý trạng thái khác
            default:
                axis_error_flags_ |= AxisError::INVALID_STATE_TRANSITION;
                operation_successful = false;
        }

        // Logic chuyển đổi trạng thái
        if (!operation_successful) {
            std::fill(operation_sequence_.begin(), operation_sequence_.end(), AxisOperation::NONE);
            current_op_state_ = AxisOperation::IDLE_MODE; // Quay về trạng thái chờ
        } else {
            // Di chuyển trạng thái tiếp theo lên đầu chuỗi
            std::rotate(operation_sequence_.begin(), operation_sequence_.begin() + 1, operation_sequence_.end());
            operation_sequence_.back() = AxisOperation::NONE; // Đánh dấu vị trí trống cuối cùng
        }
    }
    invalid_state_transition:; // Nhãn cho lỗi chuyển đổi trạng thái
}

Những điểm tinh tế trong thiết kế máy trạng thái:

1. Khởi tạo chuỗi tác vụ động: Tự động sắp xếp trình tự hiệu chỉnh dựa trên cấu hình.
2. Kiểm tra điều kiện tiên quyết: Đảm bảo các điều kiện như động cơ đã hiệu chỉnh được kiểm tra trước khi thực hiện các tác vụ tiếp theo (ví dụ: tìm kiếm chỉ mục bộ mã hóa).
3. Xử lý lỗi mạnh mẽ: Mọi thất bại trong một trạng thái sẽ dẫn đến việc đặt lại trục về trạng thái chờ (IDLE_MODE).
4. Quản lý chuỗi hiệu quả: Sử dụng std::rotate để dịch chuyển các tác vụ trong chuỗi một cách tối ưu, giữ cho tác vụ tiếp theo luôn ở vị trí đầu tiên.

Ví dụ về một chuỗi tác vụ điển hình:

1. Hiệu chỉnh tham số động cơ (AxisOperation::MOTOR_CALIBRATION_PHASE)
2. Tìm kiếm chỉ mục bộ mã hóa (AxisOperation::ENCODER_INDEX_SEARCH_PHASE)
3. Hiệu chỉnh offset bộ mã hóa (AxisOperation::ENCODER_OFFSET_CALIBRATION_PHASE)
4. Chuyển sang chế độ điều khiển vòng kín (AxisOperation::CLOSED_LOOP_CONTROL_MODE)

Phối Hợp Đa Luồng và An Toàn Dữ Liệu

Sự phối hợp giữa các luồng trong Odrive đặt ra ba thách thức chính:

Bảo vệ tài nguyên chia sẻ:

• Sử dụng các cơ chế khóa (ví dụ: mutex, semaphore) để bảo vệ các biến và cấu trúc dữ liệu chung.
• Truy cập bus CAN được điều phối thông qua một semaphore.
• Các biến trạng thái động cơ có thể được xử lý bằng các hoạt động nguyên tử.

// Ví dụ về vùng bảo vệ (critical section)
std::mutex global_motor_mutex_; // Khởi tạo mutex toàn cục

void emergency_brake_engage() {
    // Sử dụng một đối tượng mutex để bảo vệ quyền truy cập
    std::lock_guard<std::mutex> lock(global_motor_mutex_);
    
    for (size_t i = 0; i < NUM_AXES_TOTAL; ++i) {
        motor_controllers_[i].reset_bus_current(); // Đặt lại dòng điện bus an toàn
    }
    emergency_stop_activated_ = true; // Kích hoạt cờ dừng khẩn cấp
}

Đảm bảo tính thời gian thực:

• Luồng CAN thường có ưu tiên cao nhất (osPriorityAboveNormal).
• Luồng máy trạng thái của trục được điều chỉnh ưu tiên tùy thuộc vào số lượng trục và tải tính toán.
• Luồng lấy mẫu ADC sử dụng DMA để giảm gánh nặng CPU.

Cơ chế lan truyền lỗi:

• Hệ thống sử dụng các cờ lỗi ở nhiều cấp độ: cờ lỗi hệ thống toàn cầu (system_status.is_faulted), cờ lỗi cấp trục (axis.fault_code), và cờ lỗi của các module con như động cơ hoặc bộ mã hóa.

Khi phát triển logic điều khiển tùy chỉnh, khuyến nghị tuân thủ các nguyên tắc sau:

1. Đặt các thao tác tốn thời gian vào các luồng ưu tiên thấp.
2. Giữ cho vòng lặp điều khiển thời gian thực có thời gian thực hiện dưới 100μs.
3. Mọi dữ liệu chia sẻ phải được bảo vệ bằng các cơ chế khóa.
4. Xử lý lỗi phải dẫn đến việc chấm dứt ngay lập tức các trạng thái liên quan.

Kỹ Thuật Gỡ Lỗi Nâng Cao và Tối Ưu Hóa Hiệu Suất

Dựa trên kinh nghiệm thực tế, các phương pháp gỡ lỗi và tối ưu hóa sau đây đã được tổng hợp:

Chẩn đoán giao tiếp CAN:

• Sử dụng các hàm can_driver.get_bus_error() để theo dõi trạng thái bus.
• Đếm số lần tràn FIFO để đánh giá tải bus.
• Phân tích thời gian chờ của can_access_semaphore_ để xác định xung đột.

Ví dụ sử dụng công cụ dòng lệnh:

# Kiểm tra trạng thái CAN thông qua công cụ Odrive
odrive_cli can --status

Mẹo gỡ lỗi máy trạng thái:

1. Đặt điểm dừng tại các vị trí operation_sequence_ thay đổi.
2. Theo dõi thời gian thực hiện của current_op_state_.
3. Kiểm tra các cờ điều kiện tiên quyết của từng trạng thái.
4. Sử dụng tính năng ghi log của Odrive để ghi lại các chuyển đổi trạng thái.

Hướng tối ưu hóa hiệu suất:

• Giảm kích thước thread_stack_size_ để tiết kiệm bộ nhớ.
• Điều chỉnh thời gian chờ semaphore để cân bằng giữa phản hồi và tải CPU.
• Tối ưu hóa đường dẫn thực thi của các hàm xử lý trạng thái.
• Thiết lập hợp lý các cờ config_.startup_* để rút ngắn thời gian khởi động.

Một trường hợp tối ưu hóa phổ biến là rút ngắn thời gian cho chuỗi hiệu chỉnh. Phân tích cho thấy hiệu chỉnh động cơ (AxisOperation::MOTOR_CALIBRATION_PHASE) chiếm 70% thời gian khởi động. Các giải pháp bao gồm: lưu trữ các tham số động cơ điển hình, triển khai lưu trữ kết quả hiệu chỉnh, và bổ sung chế độ hiệu chỉnh nhanh.

Ứng Dụng Mở Rộng: Điều Khiển Đa Trục Phối Hợp

Dựa trên mô hình luồng và máy trạng thái của Odrive, có thể phát triển các hệ thống điều khiển đa trục phức tạp:

1. Đồng bộ hóa chủ-tớ: Trục chính phát các lệnh vị trí qua CAN. Các trục tớ thực hiện thuật toán theo dõi trong máy trạng thái của chúng.
2. Bánh răng điện tử: Áp dụng quan hệ tỉ lệ trong hàm run_closed_loop_control_loop. Sử dụng bộ định thời phần cứng để duy trì độ chính xác đồng bộ.
3. Chuyển động phối hợp: Định nghĩa các trạng thái tùy chỉnh (ví dụ: AxisOperation::CUSTOM_MOTION_PHASE) để triển khai các thuật toán nội suy và trao đổi dữ liệu quỹ đạo thông qua bộ nhớ chia sẻ.

Khi triển khai điều khiển đa trục, cần đặc biệt chú ý đến:

• Phân bổ băng thông bus CAN.
• Thiết lập ưu tiên của các luồng máy trạng thái trục.
• Cơ chế đồng bộ hóa trạng thái giữa các trục.
• Phản ứng dây chuyền của việc xử lý lỗi.

Trong một dự án cánh tay robot công nghiệp, chúng tôi đã áp dụng kiến trúc sau: bus CAN được dùng để đồng bộ hóa vị trí thời gian thực (1kHz), máy trạng thái triển khai ba cấp độ "về gốc - sẵn sàng - chuyển động", một chuỗi khôi phục lỗi tùy chỉnh, và điều chỉnh động tần số PWM để cân bằng giữa nhiệt độ và tốc độ phản hồi.