messages.hpp

Go to the documentation of this file.

// Copyright 2025 ICUBE Laboratory, University of Strasbourg
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Thibault Poignonec (thibault.poignonec@gmail.fr)
 
#ifndef STAUBLI_ROBOT_DRIVER__COMMUNICATION__MESSAGES_HPP_
#define STAUBLI_ROBOT_DRIVER__COMMUNICATION__MESSAGES_HPP_
 
#include "staubli_robot_driver/communication/protocol.hpp"
 
 
namespace staubli_robot_driver {
 
class RobotStateMessage: public Message {
public:
    RobotStateMessage();
    ~RobotStateMessage() = default;
 
    // Bring the vector-based methods from the base class into scope
    using Message::serialize;
    using Message::deserialize;
 
    bool serialize(uint8_t* buffer, size_t buffer_size) const override;
 
    bool deserialize(uint8_t* buffer, size_t buffer_size) override;
 
    static size_t message_size();
 
    size_t get_serialized_size() const override {
        return message_size();
    }
 
public:
    // Sequence delay
    uint16_t sequence_delay = 0;
 
    // Robot operation mode
    OperationMode operation_mode = OperationMode::UNKNOWN;
 
    // Robot operation mode status (signification depends on mode...)
    uint8_t operation_mode_status = 100;
 
    // Current robot control state
    CommandType control_state = CommandType::INVALID;
 
    // Safety state enum
    SafetyStatus safety_status = SafetyStatus::NO_SAFETY_STOP;
 
    // Robot status flags
    bool power_on = false;
    bool brakes_released = false;
    bool motion_possible = false;
    bool in_motion = false;
    bool error_state = false;
    bool estop_pressed = false;
 
    // Valid fields flags
    bool has_joint_positions = false;
    bool has_joint_velocities = false;
    bool has_joint_torques = false;
    bool has_ft_sensor = false;
    bool has_digital_inputs = false;
    bool has_analog_inputs = false;
 
    // Joint positions in radians
    std::array<double, 6> joint_positions;
 
    // Joint velocities in radians/s
    std::array<double, 6> joint_velocities;
 
    // Joint torques in Nm
    std::array<double, 6> joint_torques;
 
    // F/T sensor readings in N and Nm
    std::array<double, 6> ft_sensor;
 
    // Digital inputs
    std::array<bool, 16> digital_inputs;
 
    // Analog inputs
    std::array<double, 4> analog_inputs;
};
 
class RobotCommandMessage : public Message {
public:
    RobotCommandMessage();
    ~RobotCommandMessage() = default;
 
    // Bring the vector-based methods from the base class into scope
    using Message::serialize;
    using Message::deserialize;
 
    bool serialize(uint8_t* buffer, size_t buffer_size) const override;
 
    bool deserialize(uint8_t* buffer, size_t buffer_size) override;
 
    static size_t message_size();
 
    size_t get_serialized_size() const override {
        return message_size();
    }
 
public:
    // Command type (position, velocity, torque)
    CommandType command_type = CommandType::STOP;
 
    // Controller period in milliseconds
    double controller_period = -1.0;
 
    std::array<double, 6> command_reference;
 
    // Digital outputs
    std::array<bool, 16> digital_outputs;
 
    // Analog outputs
    std::array<double, 4> analog_outputs;
};
 
class DiagnosticDataMessage : public Message {
public:
    DiagnosticDataMessage();
    ~DiagnosticDataMessage() = default;
 
    // Bring the vector-based methods from the base class into scope
    using Message::serialize;
    using Message::deserialize;
 
    bool serialize(uint8_t* buffer, size_t buffer_size) const override;
 
    bool deserialize(uint8_t* buffer, size_t buffer_size) override;
 
    static size_t message_size();
 
    size_t get_serialized_size() const override {
        return message_size();
    }
 
public:
    // Robot controller type
    enum class RobotControllerType : uint8_t {
        UNKNOWN = 0x00,
        CS8 = 0x01,
        CS9 = 0x02,
    };
    RobotControllerType robot_controller_type;
 
    // Robot firmware major version
    struct Version {
        uint8_t major;
        uint8_t minor;
        uint8_t patch;
    };
    Version robot_firmware_version;
 
    // Error log entries, maximum 10 entries
    struct ErrorLogEntry {
        uint32_t timestamp;  
        uint16_t error_code;  
    };
    std::array<ErrorLogEntry, 10> error_log;
 
    // Robot task statuses
    uint16_t control_task_status;
};
 
}  // namespace staubli_robot_driver
 
#endif  // STAUBLI_ROBOT_DRIVER__COMMUNICATION__MESSAGES_HPP_