ec_master.hpp

Go to the documentation of this file.

// Copyright 2022 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.
 
#ifndef ETHERCAT_INTERFACE__EC_MASTER_HPP_
#define ETHERCAT_INTERFACE__EC_MASTER_HPP_
 
#include <ecrt.h>
 
#include <time.h>
#include <string>
#include <vector>
#include <map>
#include <chrono>
#include "ethercat_interface/ec_slave.hpp"
 
 
namespace ethercat_interface
{
 
class EcMaster
{
public:
  explicit EcMaster(const int master = 0);
  virtual ~EcMaster();
 
  void addSlave(uint16_t alias, uint16_t position, EcSlave * slave);
 
  int configSlaveSdo(uint16_t slave_position, SdoConfigEntry sdo_config, uint32_t * abort_code);
 
  bool activate();
 
  virtual void update(uint32_t domain = 0);
 
  typedef void (* SIMPLECAT_CONTRL_CALLBACK)(void);
  virtual void run(SIMPLECAT_CONTRL_CALLBACK user_callback);
 
  virtual void stop() {running_ = false;}
 
  virtual double elapsedTime();
 
  virtual uint64_t elapsedCycles();
 
  typedef void (* SIMPLECAT_EXIT_CALLBACK)(int);
  static void setCtrlCHandler(SIMPLECAT_EXIT_CALLBACK user_callback = NULL);
 
  static void setThreadHighPriority();
 
  static void setThreadRealTime();
 
  void setCtrlFrequency(double frequency)
  {
    interval_ = 1000000000.0 / frequency;
  }
 
  uint32_t getInterval() {return interval_;}
 
  void readData(uint32_t domain = 0);
  void writeData(uint32_t domain = 0);
 
private:
  volatile bool running_ = false;
 
  std::chrono::time_point<std::chrono::system_clock> start_t_, curr_t_;
 
  // EtherCAT Control
 
  struct DomainInfo;
  void registerPDOInDomain(
    uint16_t alias, uint16_t position,
    std::vector<uint32_t> & channel_indices,
    DomainInfo * domain_info,
    EcSlave * slave);
 
  void checkDomainState(uint32_t domain);
 
  void checkMasterState();
 
  void checkSlaveStates();
 
  static void printWarning(const std::string & message);
 
  ec_master_t * master_ = NULL;
  ec_master_state_t master_state_ = {};
 
  struct DomainInfo
  {
    explicit DomainInfo(ec_master_t * master);
    ~DomainInfo();
 
    ec_domain_t * domain = NULL;
    ec_domain_state_t domain_state = {};
    uint8_t * domain_pd = NULL;
 
    std::vector<ec_pdo_entry_reg_t> domain_regs;
 
    struct Entry
    {
      EcSlave * slave = NULL;
      int num_pdos = 0;
      uint32_t * offset = NULL;
      uint32_t * bit_position = NULL;
    };
 
    std::vector<Entry> entries;
  };
 
  std::map<uint32_t, DomainInfo *> domain_info_;
 
  struct SlaveInfo
  {
    EcSlave * slave = NULL;
    ec_slave_config_t * config = NULL;
    ec_slave_config_state_t config_state = {0};
  };
 
  std::vector<SlaveInfo> slave_info_;
 
  uint64_t update_counter_ = 0;
 
  uint32_t check_state_frequency_ = 10;
 
  uint32_t interval_;
};
 
}  // namespace ethercat_interface
 
#endif  // ETHERCAT_INTERFACE__EC_MASTER_HPP_