DS301Node.h

Go to the documentation of this file.

// this is for emacs file handling -*- mode: c++; indent-tabs-mode: nil -*-

// -- BEGIN LICENSE BLOCK ----------------------------------------------
// This file is part of the SCHUNK Canopen Driver suite.
//
// This program is free software licensed under the LGPL
// (GNU LESSER GENERAL PUBLIC LICENSE Version 3).
// You can find a copy of this license in LICENSE folder in the top
// directory of the source code.
//
// © Copyright 2016 SCHUNK GmbH, Lauffen/Neckar Germany
// © Copyright 2016 FZI Forschungszentrum Informatik, Karlsruhe, Germany
// -- END LICENSE BLOCK ------------------------------------------------

//----------------------------------------------------------------------
//----------------------------------------------------------------------

#ifndef DS301NODE_H
#define DS301NODE_H

// CANOPEN inlcudes
#include "NMT.h"
#include "RPDO.h"
#include "TPDO.h"
#include "SDO.h"
#include "EMCY.h"
#include "HeartBeatMonitor.h"

#include "helper.h"
#include "Logging.h"
#include "exceptions.h"

#include <boost/unordered_map.hpp>

#ifdef _IC_BUILDER_ICL_COMM_WEBSOCKET_
// Schunk Diagnostics addon
#include <icl_comm_websocket/WsBroadcaster.h>
#else
// Forward Deklaration of the WsBroadcaster
// This is not needed for normal driver operation
// but might be added later. To keep the interface the same
// a forward declaration becomes necessary
namespace icl_comm{
namespace websocket{
  class WsBroadcaster;
}}// NS end
#endif // _IC_BUILDER_ICL_COMM_WEBSOCKET_


namespace icl_hardware {
namespace canopen_schunk {

class DS301Node
{
public:
  struct PDOMapEntry
  {
    uint16_t pdo_nr;
    uint8_t pdo_mapping_index;
  };

  enum ePDO_TYPE
  {
    RECEIVE_PDO,
    TRANSMIT_PDO
  };

  typedef boost::shared_ptr<DS301Node> Ptr;
  typedef boost::shared_ptr<const DS301Node> ConstPtr;

  DS301Node(const uint8_t node_id, const CanDevPtr& can_device, HeartBeatMonitor::Ptr heartbeat_monitor);

  uint8_t getNodeId() const {return m_node_id;}


  virtual void initNode();

  virtual void registerWSBroadcaster(boost::shared_ptr<icl_comm::websocket::WsBroadcaster> broadcaster);

  virtual void startHeartbeat();

  virtual void initPDOMappingSingle (const PDO::MappingConfigurationList& config,
                                     const uint16_t pdo_nr,
                                     const PDO::eTransmissionType& transmission_type,
                                     const ePDO_TYPE& pdo_type,
                                     const bool dummy_mapping = false,
                                     const uint8_t cyclic_timeout_cycles = 0);

  virtual void appendPDOMappingSingle (const PDO::MappingConfigurationList& config,
                                      const uint16_t pdo_nr,
                                      const PDO::eTransmissionType& transmission_type,
                                      const ePDO_TYPE& pdo_type,
                                      const bool dummy_mapping = false,
                                      const uint8_t cyclic_timeout_cycles = 0);

  template <typename T>
  T getRPDOValue (const std::string& identifier)
  {
    // find pdo with this identifier
    if (m_rpdo_mapping.find(identifier) == m_rpdo_mapping.end())
    {
      std::stringstream ss;
      ss << "Could not find RPDO entry identifier string " << identifier << ". Aborting action now. ";
      throw PDOException(ss.str());
    }
    const PDOMapEntry& entry = m_rpdo_mapping[identifier];

    const PDO::Mapping& mapping = m_rpdos[entry.pdo_nr]->m_mapping_list[entry.pdo_mapping_index];
    // check if it is castable to the requested value

    return convertFromCharVector<T>(mapping.data);
  }

  template <typename T>
  T getTPDOValue (const std::string& identifier)
  {
    // find pdo with this identifier
    if (m_tpdo_mapping.find(identifier) == m_tpdo_mapping.end())
    {
      std::stringstream ss;
      ss << "Could not find TPDO entry identifier string " << identifier << ". Aborting action now. ";
      throw PDOException(ss.str());
    }
    const PDOMapEntry& entry = m_tpdo_mapping[identifier];

    const PDO::Mapping& mapping = m_tpdos[entry.pdo_nr]->m_mapping_list[entry.pdo_mapping_index];
    // check if it is castable to the requested value

    return convertFromCharVector<T>(mapping.data);
  }

  template <typename T>
  bool setRPDOValue (const std::string& identifier, const T value)
  {
    // find pdo with this identifier
    if (m_rpdo_mapping.find(identifier) == m_rpdo_mapping.end())
    {
      std::stringstream ss;
      ss << "Could not find RPDO entry identifier string " << identifier << ". Aborting action now. ";
      throw PDOException(ss.str());
    }
    const PDOMapEntry& entry = m_rpdo_mapping[identifier];
    PDO::Mapping& mapping = m_rpdos[entry.pdo_nr]->m_mapping_list[entry.pdo_mapping_index];

    if (sizeof(T) == mapping.data.size())
    {
      std::memcpy(&(mapping.data[0]), &value, sizeof(T));
    }

    LOGGING_TRACE (CanOpen, "Setting " << identifier << " for node " << m_node_id << " to " << value << endl);

    return true;
  }

  template <typename T>
  bool setTPDOValue (const std::string& identifier, const T value)
  {
    // find pdo with this identifier
    if (m_tpdo_mapping.find(identifier) == m_tpdo_mapping.end())
    {
      std::stringstream ss;
      ss << "Could not find TPDO entry identifier string " << identifier << ". Aborting action now. ";
      throw PDOException(ss.str());
    }
    const PDOMapEntry& entry = m_tpdo_mapping[identifier];
    PDO::Mapping& mapping = m_tpdos[entry.pdo_nr]->m_mapping_list[entry.pdo_mapping_index];

    if (sizeof(T) == mapping.data.size())
    {
      std::memcpy(&(mapping.data[0]), &value, sizeof(T));
    }

    LOGGING_TRACE (CanOpen, "Setting " << identifier << " for node " << m_node_id << " to " << value << endl);

    return true;
  }

  void uploadPDOs ();

  void downloadPDOs ();

  void printPDOMapping();

  void registerPDONotifyCallback (const std::string& identifier, const boost::function<void ()>& f );

  virtual void stopNode();

  NMT m_nmt;
  SDO m_sdo;
  RPDO::PtrList m_rpdos;
  TPDO::PtrList m_tpdos;
  EMCY::Ptr m_emcy;

protected:
  uint8_t m_node_id;

  CanDevPtr m_can_dev;

  boost::unordered_map<std::string, PDOMapEntry> m_rpdo_mapping;

  boost::unordered_map<std::string, PDOMapEntry> m_tpdo_mapping;

  HeartBeatMonitor::Ptr m_heartbeat_monitor;

  uint16_t m_heartbeat_cycle_time_ms;

  boost::shared_ptr<icl_comm::websocket::WsBroadcaster> m_ws_broadcaster;

};

}}// end of NS

#endif // DS301NODE_H