cia402_device.h

Go to the documentation of this file.

/*      File: cia402_device.h
 *       This file is part of the program ethercatcpp-core
 *       Program description : EtherCAT driver libraries for UNIX
 *       Copyright (C) 2017-2024 -  Robin Passama (LIRMM / CNRS) Arnaud Meline
 * (LIRMM / CNRS) Benjamin Navarro (LIRMM / CNRS). All Right reserved.
 *
 *       This software is free software: you can redistribute it and/or modify
 *       it under the terms of the CeCILL-C license as published by
 *       the CEA CNRS INRIA, either version 1
 *       of the License, or (at your option) any later version.
 *       This software is distributed in the hope that it will be useful,
 *       but WITHOUT ANY WARRANTY without even the implied warranty of
 *       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *       CeCILL-C License for more details.
 *
 *       You should have received a copy of the CeCILL-C License
 *       along with this software. If not, it can be found on the official
 * website of the CeCILL licenses family (http://www.cecill.info/index.en.html).
 */
#pragma once
 
#include <ethercatcpp/slave_device.h>
#include <ethercatcpp/coe_utilities.h>
 
namespace ethercatcpp::coe::cia402 {
 
class CIA402ObjectDictionary : public ObjectDictionary {
public:
    CIA402ObjectDictionary();
    explicit CIA402ObjectDictionary(
        std::initializer_list<std::pair<std::string_view, entry>>);
 
    ~CIA402ObjectDictionary() = default;
};
 
using dico_t = CIA402ObjectDictionary;
 
class CIA402Device : public SlaveDevice {
public:
    // cia402 object dictionary default codes
    static constexpr const uint16_t controlword_addr = 0x6040;
    static constexpr const uint16_t statusword_addr = 0x6041;
    static constexpr const uint16_t set_modes_of_operation_addr = 0x6060;
    static constexpr const uint16_t get_modes_of_operation_addr = 0x6061;
 
    // flags to check operation state in statusword
    static constexpr const uint16_t not_ready_to_switch_on_code = 0x0000;
    static constexpr const uint16_t switch_on_disabled_code = 0x0040;
    static constexpr const uint16_t ready_to_switch_on_code = 0x0021;
    static constexpr const uint16_t switched_on_code = 0x0023;
    static constexpr const uint16_t operation_enabled_code = 0x0027;
    static constexpr const uint16_t quick_stop_active_code = 0x0007;
    static constexpr const uint16_t fault_reaction_active_code = 0x000F;
    static constexpr const uint16_t fault_code = 0x0008;
 
    // values for CIA402 standard operation modes
    static constexpr const int8_t monitor_mode = 0;
    static constexpr const int8_t PP_mode = 1;     
    static constexpr const int8_t PV_mode = 3;     
    static constexpr const int8_t PT_mode = 4;     
    static constexpr const int8_t HOMING_mode = 6; 
    static constexpr const int8_t IP_mode = 7;     
    static constexpr const int8_t CSP_mode = 8; 
    static constexpr const int8_t CSV_mode = 9; 
    static constexpr const int8_t CST_mode = 10; 
 
    enum state_t {
        unknown_state,
        not_ready_to_switch_on,
        switch_on_disabled,
        ready_to_switch_on,
        switched_on,
        operation_enabled,
        quick_stop_active,
        fault_reaction_active,
        faulty
    };
 
    enum control_t {
        shutdown,                
        switch_on,               
        switch_on_and_enable_op, 
        disable_voltage, 
        quickstop,       
        disable_op,      
        enable_op,       
        fault_reset_op   
    };
 
    static const std::map<state_t, std::string_view> device_state_decode_;
 
    static void set_control_word(uint16_t& controlword, control_t ctrl);
 
    static state_t operation_state(uint16_t statusword);
 
    CIA402Device(uint16_t& control_word, uint16_t& status_word,
                 int8_t& mode_set, int8_t& mode_read);
 
    virtual bool profile_mode() const;
    virtual bool cyclic_mode() const;
    virtual bool position_mode() const;
    virtual bool velocity_mode() const;
    virtual bool torque_mode() const;
    virtual bool profile_mode_queried() const;
    virtual bool cyclic_mode_queried() const;
    virtual bool position_mode_queried() const;
    virtual bool velocity_mode_queried() const;
    virtual bool torque_mode_queried() const;
 
    CIA402Device();
 
    virtual ~CIA402Device();
 
    state_t operation_state() const;
 
    std::string_view operation_state_str() const;
 
    static std::string_view operation_state_to_str(state_t);
 
    static std::string_view control_mode_to_str(int8_t);
 
    void acknowledge_fault();
 
    void quick_stop();
 
    bool voltage_enabled() const;
 
    bool fault_alert() const;
 
    bool warning_alert() const;
 
    bool is_configurable() const;
 
    bool process_state();
 
    void startup();
 
    void finish();
 
    void pause(bool doit);
 
    bool active() const;
 
    bool paused() const;
 
    // mode specific functions
    bool target_reached() const;
 
    bool manage_new_setpoint();
 
    bool motion_halted() const;
 
    void halt_motion(bool choice);
 
    bool new_setpoint_following() const;
 
    bool internal_limit() const;
 
    void reset_fault();
 
protected:
    void set_operation_state(control_t state);
 
    void set_quick_stop_reaction(std::function<void()> reaction);
 
    void set_leaving_enable_requires_quick_stop(
        std::function<bool()> check_quick_stop);
 
    void set_entering_enable_reaction(std::function<bool()> reaction);
 
    void set_entering_switchon_reaction(std::function<void()> reaction);
 
    void set_entering_disabled_reaction(std::function<void()> reaction);
 
    void initialize_state_variables(uint16_t& control_word,
                                    uint16_t& status_word, int8_t& mode_set,
                                    int8_t& mode_read);
 
    void initialize_state_variables(uint16_t* control_word,
                                    uint16_t* status_word, int8_t* mode_set,
                                    int8_t* mode_read);
 
    void initialize_state_variables(uint8_t* control_word_addr,
                                    uint8_t* status_word_addr,
                                    uint8_t* mode_set_addr,
                                    uint8_t* mode_read_addr);
 
    int8_t current_control_mode() const;
 
    void device_state_termination();
 
    void device_state_initialization();
 
    void managed_set_point();
 
    static const std::map<int8_t, std::string_view> std_control_mode_str;
    static bool profile_mode(int8_t);
    static bool cyclic_mode(int8_t);
    static bool position_mode(int8_t);
    static bool velocity_mode(int8_t);
    static bool torque_mode(int8_t);
 
private:
    bool active_;
    bool paused_;
    bool go_back_to_monitor_mode_;
    enum SetPointCtrl {
        READY_TO_ACCEPT,   // control (bit 4,5=0) status (bit 12=0)
        SET_POINT_SET,     // control (bit 4,5=1) status (bit 12=0)
        ACCEPTED_SET_POINT // control (bit 4,5=1) status (bit 12=1)
    };
    SetPointCtrl setpoint_management_;
    bool set_point_defined_;
    uint16_t* control_word_;
    uint16_t* status_word_;
    int8_t* mode_set_;
    int8_t* mode_read_;
    std::function<void()> quick_stop_reaction_;
    std::function<bool()> leaving_enabled_requires_quick_stop_;
    std::function<bool()> entering_enable_reaction_;
    std::function<void()> entering_switch_on_reaction_;
    std::function<void()> entering_switch_on_disabled_reaction_;
 
    void reset_set_point();
    void follow_set_point();
};
} // namespace ethercatcpp::coe::cia402