slave_device.h

Go to the documentation of this file.

/*      File: slave_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/device.h>
#include <ethercatcpp/coe_utilities.h>
 
#include <string>
#include <vector>
#include <functional>
#include <memory>
 
namespace ethercatcpp {
 
class SlaveDevice : public Device {
public:
    enum syncmanager_buffer_t {
        ASYNCHROS_OUT =
            1, 
        ASYNCHROS_IN =
            2, 
        SYNCHROS_OUT =
            3,          
        SYNCHROS_IN = 4 
    };
 
    SlaveDevice();
    virtual ~SlaveDevice();
 
    void set_serial_number(uint32_t serial_number);
 
    uint32_t eep_manufacturer() const;
 
    uint32_t eep_device() const;
 
    uint32_t serial_number() const;
 
protected:
    friend class coe::PDOMapping;
    friend class coe::PDOBuffer;
 
    template <typename T, typename... U>
    void define_physical_buffer(syncmanager_buffer_t type, uint16_t start_addr,
                                uint32_t flags) {
        if constexpr (sizeof...(U) == 0) {
            define_physical_buffer(type, start_addr, flags,
                                   static_cast<uint16_t>(sizeof(T)));
        } else {
            define_physical_buffer(
                type, start_addr, flags,
                static_cast<uint16_t>(sizeof(T) + (sizeof(U) + ...)));
        }
    }
 
    void define_physical_buffer(syncmanager_buffer_t type, uint16_t start_addr,
                                uint32_t flags, uint16_t length);
 
    template <typename T>
    T* input_buffer(uint16_t start_addr) {
        return reinterpret_cast<T*>(input_buffer(start_addr));
    }
 
    template <typename T, typename U, typename... Other>
    std::tuple<T*, U*, Other*...> input_buffer(uint16_t start_addr) {
        return input_buffer_tuple<T, U, Other...>(start_addr, 0);
    }
 
    uint8_t* input_buffer(uint16_t start_addr);
 
    template <typename T>
    T* output_buffer(uint16_t start_addr) {
        return reinterpret_cast<T*>(output_buffer(start_addr));
    }
 
    template <typename T, typename U, typename... Other>
    std::tuple<T*, U*, Other*...> output_buffer(uint16_t start_addr) {
        return output_buffer_tuple<T, U, Other...>(start_addr, 0);
    }
 
    uint8_t* output_buffer(uint16_t start_addr);
 
    void add_run_step(std::function<void()>&& pre,
                      std::function<void()>&& post);
 
    void add_init_step(std::function<void()>&& pre,
                       std::function<void()>&& post);
 
    void add_end_step(std::function<void()>&& pre,
                      std::function<void()>&& post);
 
    void set_id(const std::string& name, uint32_t manufacturer, uint32_t model);
 
    void define_distributed_clock(bool have_dc);
 
    void define_period_for_non_cyclic_steps(int period);
 
    void configure_at_init(std::function<void()>&& func);
 
    void configure_at_end(std::function<void()>&& func);
 
 
    int write_sdo(uint16_t index, uint8_t sub_index, int buffer_size,
                  void* buffer) const;
 
    int read_sdo(uint16_t index, uint8_t sub_index, int buffer_size,
                 void* buffer) const;
 
    template <typename T>
    int write_sdo(uint16_t index, uint8_t sub_index, T& value) const {
        return write_sdo(index, sub_index, static_cast<int>(sizeof(T)),
                         reinterpret_cast<void*>(&value));
    }
 
    template <typename T>
    int read_sdo(uint16_t index, uint8_t sub_index, T& value) const {
        return read_sdo(index, sub_index, static_cast<int>(sizeof(T)),
                        reinterpret_cast<void*>(&value));
    }
 
    template <typename T>
    bool start_command_pdo_mapping() {
        // Have to desactivate buffer to change it
        T val = 0;
        set_command_mappings(0);
        return write_sdo(coe::coe_rx_pdo_assign, 0x00, val) != 0;
    }
 
    template <typename T>
    bool add_command_pdo_mapping(uint16_t pdo_address) {
        T val = 0;
        // Check if buffer is desactivate
        int wkc = read_sdo(coe::coe_rx_pdo_assign, 0x00, val);
        if (val != 0) { // not in config PDO mode
            return false;
        }
        // Send new PDO address mapping
        set_command_mappings(get_command_mappings() + 1);
        wkc += write_sdo(coe::coe_rx_pdo_assign, get_command_mappings(),
                         pdo_address);
        return (wkc == 2);
    }
 
    template <typename T>
    bool end_command_pdo_mapping() {
        T val = static_cast<T>(get_command_mappings());
        // Have to reactivate buffer with map number to valid it
        return write_sdo(coe::coe_rx_pdo_assign, 0x00, val) != 0;
    }
 
    template <typename T>
    bool start_status_pdo_mapping() {
        // Have to desactivate buffer to change it
        T val = 0;
        set_status_mappings(0);
        return write_sdo(coe::coe_tx_pdo_assign, 0x00, val) != 0;
    }
 
    template <typename T>
    bool add_status_pdo_mapping(uint16_t pdo_address) {
        T val = 0;
        // Check if buffer is desactivate
        int wkc = read_sdo(coe::coe_tx_pdo_assign, 0x00, val);
        if (val != 0) { // no in config PDO mode
            return false;
        }
        // Send new PDO address mapping
        set_status_mappings(get_status_mappings() + 1);
        // increment number of Status pdo mapping to
        // write in good index
        wkc += write_sdo(coe::coe_tx_pdo_assign, get_status_mappings(),
                         pdo_address);
        return (wkc == 2);
    }
 
    template <typename T>
    bool end_status_pdo_mapping() {
        int wkc = 0;
        T val = get_status_mappings();
        // Have to reactivate buffer with map number to valid it
        wkc += write_sdo(coe::coe_tx_pdo_assign, 0x00, val);
        return wkc > 0;
    }
 
 
    void configure_dc_sync0(uint32_t cycle_time_0, int32_t cycle_shift) const;
 
    void configure_dc_sync0_1(uint32_t cycle_time_0, uint32_t cycle_time_1,
                              int32_t cycle_shift) const; // time in ns
 
 
    int32_t read_file(std::string_view filename, uint32_t password,
                      int32_t size, uint8_t* buffer) const;
    bool write_file(std::string_view filename, uint32_t password, int32_t size,
                    uint8_t* buffer) const;
 
 
    bool read_sercos(uint8_t drive, uint8_t flags, uint16_t idn, int32_t size,
                     uint8_t* buffer) const;
    bool write_sercos(uint8_t drive, uint8_t flags, uint16_t idn, int32_t size,
                      uint8_t* buffer) const;
 
#ifdef EOE_AVAILABLE
    struct EthernetConfiguration {
        std::string ip;
        std::string mask;
        std::string mac;
        std::string gateway;
        std::string dns;
    };
 
    bool detect_ethernet_configuration(uint8_t port,
                                       EthernetConfiguration& config);
    bool configure_ethernet(uint8_t port, const EthernetConfiguration& config);
 
    int32_t read_ethernet(uint8_t port, int32_t size, uint8_t* buffer);
    bool write_ethernet(uint8_t port, int32_t size, uint8_t* buffer);
#endif
private:
    friend class Master;
    friend class SlaveInfo;
 
    void print_slave_info() const;
    uint8_t run_steps() const;
 
    void pre_run_step(uint8_t step);
    void post_run_step(uint8_t step);
 
    uint8_t init_steps() const;
 
    void pre_init_step(uint8_t step);
 
    void post_init_step(uint8_t step);
 
    /***
     * @brief Get the number of end steps for the device
     *
     * @return number of end steps
     */
    uint8_t end_steps() const;
 
    void pre_end_step(uint8_t step);
 
    void post_end_step(uint8_t step);
 
    void update_buffers();
 
    void launch_init_configuration();
 
    void launch_end_configuration();
 
    void set_command_mappings(uint8_t mappings);
    uint8_t get_command_mappings() const;
    void set_status_mappings(uint8_t mappings);
    uint8_t get_status_mappings() const;
 
    std::vector<Device*> device_vector() final;
 
    SlaveInfo* slave_address() final;
 
    class Impl;
    std::unique_ptr<Impl> impl_;
 
    // Auxiliary template functions
    template <typename T>
    std::tuple<T*> input_buffer_tuple(uint16_t start_addr,
                                      size_t ptr_increment) {
        return std::make_tuple(
            reinterpret_cast<T*>(input_buffer(start_addr) + ptr_increment));
    }
 
    template <typename T, typename U, typename... Other>
    std::tuple<T*, U*, Other*...> input_buffer_tuple(uint16_t start_addr,
                                                     size_t ptr_increment) {
        return std::tuple_cat(input_buffer_tuple<T>(start_addr, ptr_increment),
                              input_buffer_tuple<U, Other...>(
                                  start_addr, ptr_increment + sizeof(T)));
    }
 
    template <typename T>
    std::tuple<T*> output_buffer_tuple(uint16_t start_addr,
                                       size_t ptr_increment) {
        return std::make_tuple(
            reinterpret_cast<T*>(output_buffer(start_addr) + ptr_increment));
    }
 
    template <typename T, typename U, typename... Other>
    std::tuple<T*, U*, Other*...> output_buffer_tuple(uint16_t start_addr,
                                                      size_t ptr_increment) {
        return std::tuple_cat(output_buffer_tuple<T>(start_addr, ptr_increment),
                              output_buffer_tuple<U, Other...>(
                                  start_addr, ptr_increment + sizeof(T)));
    }
};
} // namespace ethercatcpp