CanOpenController.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 CANOPENCONTROLLER_H
#define CANOPENCONTROLLER_H

#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <icl_hardware_can/tCanDevice.h>

#include "helper.h"
#include "CanOpenReceiveThread.h"
#include "DS301Group.h"
#include "HeartBeatMonitor.h"

#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 CanOpenController : protected virtual boost::noncopyable
{
public:
  typedef boost::shared_ptr<CanOpenController> Ptr;
  typedef boost::shared_ptr<const CanOpenController> ConstPtr;

  CanOpenController(const std::string can_device_identifier = "/dev/pcanusb0",
                    const uint32_t baud_rate = 500,
                    const std::string& resource_folder_location = "");

  ~CanOpenController ();

  void initNodes(const int16_t node_id = -1);

  void processCanMsgCallback (const icl_hardware::can::tCanMessage& msg);

  void reconnectCanDevice(const std::string& can_identifier, const uint32_t baud_rate);

  template <typename GroupT>
  void addGroup(const std::string& identifier);

  template <typename GroupT>
  boost::shared_ptr<GroupT> getGroup (const std::string& index = "default");

  void deleteGroup(const std::string& identifier);


  template <typename NodeT>
  void addNode(const uint8_t node_id, const std::string& group_name = "default");

  void deleteNode (const uint8_t node_id);

  CanDevPtr getCanDevice () const { return m_can_device; }

  void syncAll();

  template <typename NodeT>
  boost::shared_ptr<NodeT> getNode (const uint8_t node_id);

  void stopAll();

  std::vector<uint8_t> getNodeList ();

  void enablePPMotion(const int16_t node_id = -1);

private:
  void init();

  void getResources();

  DS301Node::Ptr getNodeById (const uint8_t node_id);

  CanOpenReceiveThreadPtr m_receive_thread;

  CanDevPtr m_can_device;



  std::string m_can_device_name;
  int32_t m_can_device_flags;
  unsigned char m_can_device_acceptance_code;
  unsigned char m_can_device_acceptance_mask;
  uint32_t m_can_device_send_fifo_size;
  uint32_t m_can_device_receive_fifo_size;
  uint32_t m_can_device_baud_rate;
  HeartBeatMonitor::Ptr m_heartbeat_monitor;

  uint32_t m_polling_period_ms;

  std::map<std::string, DS301Group::Ptr> m_groups;
  std::map<uint8_t, DS301Node::Ptr> m_nodes;

  std::string m_resource_folder_location;

  boost::shared_ptr<icl_comm::websocket::WsBroadcaster> m_ws_broadcaster;
  size_t m_ws_broadcast_counter; 
  size_t m_ws_broadcast_rate; 

};


}// End of NS
}

// include template implementations
#include "CanOpenController.hpp"

#endif // CANOPENCONTROLLER_H