RokubiminiEthercatSlave.hpp

Go to the documentation of this file.

#pragma once

// soem_interface
#include <rokubimini_ethercat/soem_interface/EthercatBusBase.hpp>
#include <rokubimini_ethercat/soem_interface/EthercatSlaveBase.hpp>

#include <rokubimini/Reading.hpp>
#include <rokubimini/calibration/SensorCalibration.hpp>
#include <rokubimini/configuration/SensorConfiguration.hpp>
#include <rokubimini/configuration/ForceTorqueFilter.hpp>

#include <rokubimini_ethercat/PdoTypeEnum.hpp>
#include <rokubimini_ethercat/RxPdo.hpp>

#define MAX_FILE_SIZE_FIRMWARE (0x100000)

namespace rokubimini
{
namespace ethercat
{
class RokubiminiEthercatSlave : public rokubimini::soem_interface::EthercatSlaveBase
{
public:
  RokubiminiEthercatSlave() = delete;

  RokubiminiEthercatSlave(const std::string& name, rokubimini::soem_interface::EthercatBusBase* bus,
                          const uint32_t address, const PdoTypeEnum pdoTypeEnum);

  ~RokubiminiEthercatSlave() override = default;

  bool startup() override;

  void updateRead() override;

  void updateWrite() override;

  void shutdown() override;

  void setState(const uint16_t state);

  bool waitForState(const uint16_t state);

  PdoInfo getCurrentPdoInfo() const override;

  std::string getName() const override
  {
    return name_;
  }

  PdoTypeEnum getCurrentPdoTypeEnum() const
  {
    return currentPdoTypeEnum_;
  }

  // Methods for all the SDOs

  bool getSerialNumber(unsigned int& serialNumber);

  bool getForceTorqueSamplingRate(int& samplingRate);

  bool setForceTorqueFilter(const configuration::ForceTorqueFilter& filter);

  bool setAccelerationFilter(const unsigned int filter);

  bool setAngularRateFilter(const unsigned int filter);

  bool setAccelerationRange(const unsigned int range);

  bool setAngularRateRange(const unsigned int range);

  bool setForceTorqueOffset(const Eigen::Matrix<double, 6, 1>& forceTorqueOffset);

  bool setSensorConfiguration(const configuration::SensorConfiguration& sensorConfiguration);

  bool setSensorCalibration(const calibration::SensorCalibration& sensorCalibration);

  bool setConfigMode();

  bool setRunMode();

  bool saveConfigParameter();

  void getReading(rokubimini::Reading& reading) const;

  bool firmwareUpdate(const std::string& filePath, const std::string& fileName, const uint32_t& password);

  bool isRunning()
  {
    return isRunning_;
  }

private:
  bool configurePdo(const PdoTypeEnum pdoTypeEnum);

  bool sendCalibrationMatrixEntry(const uint8_t subId, const double entry);

  bool readFileToBuffer(const std::string& filePath);

  using PdoInfos = std::map<PdoTypeEnum, PdoInfo>;

  const std::string name_;

  PdoInfos pdoInfos_;

  std::atomic<PdoTypeEnum> pdoTypeEnum_;

  std::atomic<PdoTypeEnum> currentPdoTypeEnum_;

  Reading reading_;

  int fileSize_;

  char* fileBuffer_;

  std::atomic<bool> isRunning_;
};

using RokubiminiEthercatSlavePtr = std::shared_ptr<RokubiminiEthercatSlave>;

}  // namespace ethercat
}  // namespace rokubimini