SDO.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 SDO_H
#define SDO_H
#include <stdint.h>
#include "helper.h"
#include "exceptions.h"

namespace icl_hardware {
namespace canopen_schunk {

class SDO
{
public:
  typedef boost::shared_ptr<SDO> Ptr;
  typedef boost::shared_ptr<const SDO> ConstPtr;


  static uint16_t const SDOTX_ID = 0x580; //             # 1408 -> 1409 ... 1535
  static uint16_t const SDORX_ID = 0x600; //             # 1536 -> 1537 ... 1663

  // download
  static unsigned char const SDO_SEG_REQ_INIT_DOWNLOAD_xBYTE = 0x22;
  static unsigned char const SDO_SEG_REQ_INIT_DOWNLOAD_1BYTE = 0x2F;
  static unsigned char const SDO_SEG_REQ_INIT_DOWNLOAD_2BYTE = 0x2B;
  static unsigned char const SDO_SEG_REQ_INIT_DOWNLOAD_3BYTE = 0x27;
  static unsigned char const SDO_SEG_REQ_INIT_DOWNLOAD_4BYTE = 0x23;
  static unsigned char const SDO_SEG_RES_INIT_DOWNLOAD = 0x60;
  // upload
  static unsigned char const SDO_SEG_REQ_INIT_UPLOAD = 0x40;
  static unsigned char const SDO_SEG_RES_INIT_UPLOAD_nBYTE =  0x41;
  static unsigned char const SDO_SEG_RES_INIT_UPLOAD_xBYTE =  0x42;
  static unsigned char const SDO_SEG_RES_INIT_UPLOAD_1BYTE = 0x4F;
  static unsigned char const SDO_SEG_RES_INIT_UPLOAD_2BYTE = 0x4B;
  static unsigned char const SDO_SEG_RES_INIT_UPLOAD_3BYTE = 0x47;
  static unsigned char const SDO_SEG_RES_INIT_UPLOAD_4BYTE = 0x43;
  static unsigned char const SDO_SEG_REQ_UPLOAD0 = 0x60; // used for segmented upload only
  static unsigned char const SDO_SEG_REQ_UPLOAD1 = 0x70; // used for segmented upload only

  static unsigned char const SDO_SEG_ABORT_TRANSFER =0x80;


  SDO(const uint8_t& node_id, const CanDevPtr& can_device);

  void update(const CanMsg& msg);

  bool download(const bool normal_transfer,
                const uint16_t index,
                const uint8_t subindex,
                const std::vector<uint8_t>& usrdata);

  template <typename T>
  bool download(const bool normal_transfer,
                const uint16_t index,
                const uint8_t subindex,
                const T& usrdata)
  {
    std::vector<uint8_t> data_vector = convertToCharVector(usrdata);
    return download(normal_transfer, index, subindex, data_vector);
  }


  bool upload(const bool normal_transfer,
              const uint16_t index,
              const uint8_t subindex,
              std::vector<uint8_t>& uploaded_data);

  template <typename T>
  bool upload(const bool normal_transfer,
              const uint16_t index,
              const uint8_t subindex,
              T& uploaded_data)
  {
    std::vector<uint8_t> buffer;
    bool ret = upload (false, index, subindex, buffer);

    if (!ret || buffer.size() == 0)
    {
      throw ProtocolException (index, subindex, "Uploaded data was empty");
    }

    uploaded_data = convertFromCharVector<T>(buffer);

    // To be honest, this only can be true right now, otherwise we throw
    return ret;
  }

  static void addErrorMapFromFile(const std::string& filename);

  void setResponseWaitTime(const uint32_t wait_time_ms) {m_response_wait_time_ms = wait_time_ms;}

  uint32_t getResponseWaitTime () const {return m_response_wait_time_ms;}

private:
  static std::string lookupErrorString(const uint32_t error_code);


  uint8_t m_node_id;
  CanDevPtr m_can_device;
  uint32_t m_response_wait_time_ms;

  bool m_data_update_received;
  boost::mutex m_data_buffer_mutex;
  boost::condition_variable m_data_buffer_updated_cond;
  std::vector<uint8_t> m_data_buffer;

  static std::map<uint32_t, std::string> m_error_map;
};

}}//end of NS

#endif // SDO_H