node.hpp

Go to the documentation of this file.

#ifndef LELY_COAPP_NODE_HPP_
#define LELY_COAPP_NODE_HPP_

#include <lely/coapp/device.hpp>
#include <lely/coapp/io_context.hpp>

namespace lely {

// The CANopen NMT node service from <lely/co/nmt.hpp>.
class CONMT;

namespace canopen {

enum class NmtCommand {
  START = 0x01,
  STOP = 0x02,
  ENTER_PREOP = 0x80,
  RESET_NODE = 0x81,
  RESET_COMM = 0x82
};

enum class NmtState {
  BOOTUP = 0x00,
  STOP = 0x04,
  START = 0x05,
  RESET_NODE = 0x06,
  RESET_COMM = 0x07,
  PREOP = 0x7f,
  TOGGLE = 0x80
};

constexpr NmtState operator&(NmtState lhs, NmtState rhs) {
  return static_cast<NmtState>(static_cast<int>(lhs) & static_cast<int>(rhs));
}

constexpr NmtState
operator|(NmtState lhs, NmtState rhs) {
  return static_cast<NmtState>(static_cast<int>(lhs) | static_cast<int>(rhs));
}

constexpr NmtState
operator^(NmtState lhs, NmtState rhs) {
  return static_cast<NmtState>(static_cast<int>(lhs) ^ static_cast<int>(rhs));
}

constexpr NmtState
operator~(NmtState lhs) {
  return static_cast<NmtState>(~static_cast<int>(lhs));
}

inline NmtState&
operator&=(NmtState& lhs, NmtState rhs) noexcept {
  return lhs = lhs & rhs;
}

inline NmtState&
operator|=(NmtState& lhs, NmtState rhs) noexcept {
  return lhs = lhs | rhs;
}

inline NmtState&
operator^=(NmtState& lhs, NmtState rhs) noexcept {
  return lhs = lhs ^ rhs;
}

class Node : protected BasicLockable, public IoContext, public Device {
 public:
  using time_point = ::std::chrono::steady_clock::time_point;

  Node(aio::TimerBase& timer, aio::CanBusBase& bus,
       const ::std::string& dcf_txt, const ::std::string& dcf_bin = "",
       uint8_t id = 0xff);

  Node(const Node&) = delete;
  Node& operator=(const Node&) = delete;

  virtual ~Node();

  void Reset();

 protected:
  virtual void lock() final override;
  virtual void unlock() final override;

  void OnCanState(CanState new_state, CanState old_state) noexcept override;

  CONMT* nmt() const noexcept;

  /*
   * Generates an EMCY error and triggers the error handling behavior according
   * to object 1029:01 (Error behavior object) in case of a communication error
   * (emergency error code 0x81xx).
   *
   * @param eec  the emergency error code.
   * @param er   the error register.
   * @param msef the manufacturer-specific error code.
   */
  void Error(uint16_t eec, uint8_t er, const uint8_t msef[5] = nullptr);

  void RpdoRtr(int num = 0);

  void TpdoEvent(int num = 0);

#ifndef DOXYGEN_SHOULD_SKIP_THIS
 private:
#endif

  virtual void
  OnCommand(NmtCommand cs) noexcept {
    (void)cs;
  }

  virtual void
  OnHeartbeat(uint8_t id, bool occurred) noexcept {
    (void)id;
    (void)occurred;
  }

  virtual void
  OnState(uint8_t id, NmtState st) noexcept {
    (void)id;
    (void)st;
  }

  virtual void
  OnRpdo(int num, ::std::error_code ec, const void* p,
         ::std::size_t n) noexcept {
    (void)num;
    (void)ec;
    (void)p;
    (void)n;
  }

  virtual void
  OnRpdoError(int num, uint16_t eec, uint8_t er) noexcept {
    (void)num;
    Error(eec, er);
  }

  virtual void
  OnTpdo(int num, ::std::error_code ec, const void* p,
         ::std::size_t n) noexcept {
    (void)num;
    (void)ec;
    (void)p;
    (void)n;
  }

  virtual void
  OnSync(uint8_t cnt, const time_point& t) noexcept {
    (void)cnt;
    (void)t;
  }

  virtual void
  OnSyncError(uint16_t eec, uint8_t er) noexcept {
    Error(eec, er);
  }

  virtual void
  OnTime(const ::std::chrono::system_clock::time_point& abs_time) noexcept {
    (void)abs_time;
  }

  virtual void
  OnEmcy(uint8_t id, uint16_t eec, uint8_t er, uint8_t msef[5]) noexcept {
    (void)id;
    (void)eec;
    (void)er;
    (void)msef;
  }

 private:
  struct Impl_;
  ::std::unique_ptr<Impl_> impl_;
};

}  // namespace canopen

}  // namespace lely

#endif  // LELY_COAPP_NODE_HPP_