SVHHomeSettings.h

Go to the documentation of this file.

//
// © Copyright 2022 SCHUNK Mobile Greifsysteme GmbH, Lauffen/Neckar Germany
// © Copyright 2022 FZI Forschungszentrum Informatik, Karlsruhe, Germany
//
// This file is part of the Schunk SVH Library.
//
// The Schunk SVH Library is free software: you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or (at your
// option) any later version.
//
// The Schunk SVH Library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
// Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// the Schunk SVH Library. If not, see <https://www.gnu.org/licenses/>.
//
 
//----------------------------------------------------------------------
//----------------------------------------------------------------------
 
#ifndef SVHHOMESETTINGS_H
#define SVHHOMESETTINGS_H
 
#include <ostream>
#include <vector>
 
namespace driver_svh {
 
struct SVHHomeSettings
{
  int direction;
  float minimum_offset;
  float maximum_offset;
  float idle_position;
  float range_rad;
  float reset_current_factor;
 
  SVHHomeSettings()
    : direction(+1)
    , minimum_offset(0.0)
    , maximum_offset(0.0)
    , idle_position(0.0)
    , range_rad(0.0)
    , reset_current_factor(0.5)
  {
  }
 
  SVHHomeSettings(const int& direction,
                  const float& minimum_offset,
                  const float& maximum_offset,
                  const float& idle_position,
                  const float& range_rad,
                  const float& reset_current_factor)
    : minimum_offset(minimum_offset)
    , maximum_offset(maximum_offset)
    , idle_position(idle_position)
    , range_rad(range_rad)
    , reset_current_factor(reset_current_factor)
  {
    // Limit the direction to just contain a factor rather than any multipliers
    this->direction = direction < 0 ? -1 : +1;
    // Limit the resetCurrentFactor to allowed bounds
    this->reset_current_factor = std::max(std::min(reset_current_factor, 1.0f), 0.0f);
  }
 
  SVHHomeSettings(const std::vector<float>& home_settings)
  {
    // maybe not the most beautifull way but it works.
    size_t size          = home_settings.size();
    float temp_direction = 0.0;
 
    temp_direction = (size > 0) ? home_settings[0] : 0.0f;
    direction      = temp_direction < 0.0 ? -1 : +1;
 
    minimum_offset       = (size > 1) ? home_settings[1] : 0.0f;
    maximum_offset       = (size > 2) ? home_settings[2] : 0.0f;
    idle_position        = (size > 3) ? home_settings[3] : 0.0f;
    range_rad            = (size > 4) ? home_settings[4] : 0.0f;
    reset_current_factor = (size > 5) ? home_settings[5] : 0.5f;
 
    // Limit the resetCurrentFactor to allowed bounds
    reset_current_factor = std::max(std::min(reset_current_factor, 1.0f), 0.0f);
  }
};
 
 
inline std::ostream& operator<<(std::ostream& o, const SVHHomeSettings& hs)
{
  o << "Direction " << hs.direction << " "
    << "Min offset " << hs.minimum_offset << " "
    << "Max offset " << hs.maximum_offset << " "
    << "idle pos " << hs.idle_position << " "
    << "Range Rad " << hs.range_rad << " "
    << "Reset Curr Factor " << hs.reset_current_factor << " " << std::endl;
  return o;
}
 
 
} // namespace driver_svh
 
 
#endif // SVHHOMESETTINGS_H