ThrusterConversionFcn.hh

Go to the documentation of this file.

// Copyright (c) 2016 The UUV Simulator Authors.
// All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.


#ifndef __UUV_GAZEBO_PLUGINS_CONVERSION_FUNCTION_HH__
#define __UUV_GAZEBO_PLUGINS_CONVERSION_FUNCTION_HH__

#include <map>
#include <string>
#include <vector>

#include <sdf/sdf.hh>

namespace gazebo
{
class ConversionFunction
{
  protected: ConversionFunction() {}

  public: virtual ~ConversionFunction() {}

  public: virtual std::string GetType() = 0;

  public: virtual bool GetParam(std::string _tag,
    double& _output) = 0;

  public: virtual std::map<double, double> GetTable()
    { return std::map<double, double>(); };

  public: virtual double convert(double _cmd) = 0;
};

typedef ConversionFunction* (*ConversionFunctionCreator)(sdf::ElementPtr);

class ConversionFunctionFactory
{
  public: ConversionFunction* CreateConversionFunction(sdf::ElementPtr _sdf);

  public: static ConversionFunctionFactory& GetInstance();

  public: bool RegisterCreator(const std::string& _identifier,
                               ConversionFunctionCreator _creator);

  private: ConversionFunctionFactory() {}

  private: std::map<std::string, ConversionFunctionCreator> creators_;
};

#define REGISTER_CONVERSIONFUNCTION(type) \
  static const bool registeredWithFactory

#define REGISTER_CONVERSIONFUNCTION_CREATOR(type, creator) \
  const bool type::registeredWithFactory = \
  ConversionFunctionFactory::GetInstance().RegisterCreator( \
  type::IDENTIFIER, creator);


class ConversionFunctionBasic : public ConversionFunction
{
  public: static ConversionFunction* create(sdf::ElementPtr _sdf);

  public: virtual std::string GetType() { return IDENTIFIER; }

  public: virtual bool GetParam(std::string _tag, double& _output);

  public: virtual double convert(double _cmd);

  private: REGISTER_CONVERSIONFUNCTION(ConversionFunctionBasic);

  private: static const std::string IDENTIFIER;

  private: ConversionFunctionBasic(double _rotorConstant);
  private: double rotorConstant;
};

class ConversionFunctionBessa : public ConversionFunction
{
  public: static ConversionFunction* create(sdf::ElementPtr _sdf);

  public: virtual std::string GetType() { return IDENTIFIER; }

  public: virtual bool GetParam(std::string _tag, double& _output);

  public: virtual double convert(double _cmd);

  private: REGISTER_CONVERSIONFUNCTION(ConversionFunctionBessa);

  private: static const std::string IDENTIFIER;

  private: ConversionFunctionBessa(double _rotorConstantL,
                                   double _rotorConstantR,
                                   double _deltaL, double _deltaR);

  private: double rotorConstantL;

  private: double rotorConstantR;

  private: double deltaL;

  private: double deltaR;
};

class ConversionFunctionLinearInterp: public ConversionFunction
{
  public: static ConversionFunction* create(sdf::ElementPtr _sdf);

  public: virtual std::string GetType() { return IDENTIFIER; }

  public: virtual bool GetParam(std::string _tag, double& _output);

  public: virtual std::map<double, double> GetTable();

  public: virtual double convert(double _cmd);

  private: REGISTER_CONVERSIONFUNCTION(ConversionFunctionLinearInterp);

  private: static const std::string IDENTIFIER;

  private: ConversionFunctionLinearInterp(const std::vector<double> &_input,
                                          const std::vector<double> &_output);

  private: std::map<double, double> lookupTable;
};
}

#endif