SVHControllerFeedback.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 SVH 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 2014 SCHUNK Mobile Greifsysteme GmbH, Lauffen/Neckar Germany
// © Copyright 2014 FZI Forschungszentrum Informatik, Karlsruhe, Germany
//
// -- END LICENSE BLOCK ------------------------------------------------

//----------------------------------------------------------------------
//----------------------------------------------------------------------
#ifndef SVHCONTROLLERFEEDBACK_H
#define SVHCONTROLLERFEEDBACK_H

#include <icl_comm/ByteOrderConversion.h>

namespace driver_svh {

struct SVHControllerFeedback
{
  int32_t position;
  int16_t current;

  SVHControllerFeedback(const int32_t& _position = 0,const int16_t& _current = 0):
    position(_position),
    current(_current)
  {}

  bool operator == (const SVHControllerFeedback& other) const
  {
    return (position == other.position && current == other.current);
  }
};

struct SVHControllerFeedbackAllChannels
{
  std::vector<SVHControllerFeedback> feedbacks;

  SVHControllerFeedbackAllChannels(const SVHControllerFeedback& _feedback0,const SVHControllerFeedback& _feedback1,
                                    const SVHControllerFeedback& _feedback2,const SVHControllerFeedback& _feedback3,
                                    const SVHControllerFeedback& _feedback4,const SVHControllerFeedback& _feedback5,
                                    const SVHControllerFeedback& _feedback6,const SVHControllerFeedback& _feedback7,
                                    const SVHControllerFeedback& _feedback8)
  {
    feedbacks.push_back(_feedback0);
    feedbacks.push_back(_feedback1);
    feedbacks.push_back(_feedback2);
    feedbacks.push_back(_feedback3);
    feedbacks.push_back(_feedback4);
    feedbacks.push_back(_feedback5);
    feedbacks.push_back(_feedback6);
    feedbacks.push_back(_feedback7);
    feedbacks.push_back(_feedback8);
  }

  SVHControllerFeedbackAllChannels(std::vector<SVHControllerFeedback> _feedbacks)
  {
    feedbacks.insert(feedbacks.begin(),_feedbacks.begin(),_feedbacks.end());
  }

  SVHControllerFeedbackAllChannels():
    feedbacks(9)
  { }


  bool operator == (const SVHControllerFeedbackAllChannels& other) const
  {
    return (feedbacks == other.feedbacks);
  }
};

inline icl_comm::ArrayBuilder& operator << (icl_comm::ArrayBuilder& ab,const SVHControllerFeedback& data)
{
  ab << data.position
     << data.current;
  return ab;
}


inline icl_comm::ArrayBuilder& operator >> (icl_comm::ArrayBuilder& ab, SVHControllerFeedback& data)
{
  ab >> data.position
     >> data.current;
  return ab;
}

inline std::ostream& operator << (std::ostream& o, const SVHControllerFeedback& cf)
{
  o << "Pos: " << cf.position << " Cur: " << cf.current << std::endl;
  return o;
}


inline icl_comm::ArrayBuilder& operator << (icl_comm::ArrayBuilder& ab,SVHControllerFeedbackAllChannels& data)
{
  // The Data is transmitted not channel by channel but rather position first, Currents afterwards for all channels
  for (std::vector<SVHControllerFeedback>::iterator it = data.feedbacks.begin() ; it != data.feedbacks.end(); ++it)
  {
    ab << it->position;
  }

  for (std::vector<SVHControllerFeedback>::iterator it = data.feedbacks.begin() ; it != data.feedbacks.end(); ++it)
  {
    ab << it->current;
  }
  return ab;
}


inline icl_comm::ArrayBuilder& operator >> (icl_comm::ArrayBuilder& ab, SVHControllerFeedbackAllChannels& data)
{
  // The Data is transmitted not channel by channel but rather position first, Currents afterwards for all channels
  for (std::vector<SVHControllerFeedback>::iterator it = data.feedbacks.begin() ; it != data.feedbacks.end(); ++it)
  {
    ab >> it->position;
  }

  for (std::vector<SVHControllerFeedback>::iterator it = data.feedbacks.begin() ; it != data.feedbacks.end(); ++it)
  {
    ab >> it->current;
  }
  return ab;
}

inline std::ostream& operator << (std::ostream& o, const SVHControllerFeedbackAllChannels& cf)
{
  o << "Feedbacks: " ;
  unsigned int i = 0;
  for (std::vector<SVHControllerFeedback>::const_iterator it = cf.feedbacks.begin() ; it != cf.feedbacks.end(); ++it,++i)
  {
    o << "Chan " << i << " : "<< *it;
  }
  o << std::endl;
  return o;
}

}

#endif // SVHCONTROLLERFEEDBACK_H