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_