simulatedMotor.h

Go to the documentation of this file.

/*
 * Copyright 2017 Fraunhofer Institute for Manufacturing Engineering and Automation (IPA)
 *
 * 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 _SIMULATED_MOTOR_H_
#define _SIMULATED_MOTOR_H_
 
#include <schunk_powercube_chain/moveCommand.h>
#include <string>
 
class simulatedMotor
{
public:
  simulatedMotor(double lowLimit, double upLimit, double maxAcc, double maxVel);
  ~simulatedMotor() {;}
 
  virtual bool init()
  {
    return true;
  }
 
  virtual std::string getErrorMessage()
  {
    return std::string("No Errors.");
  }
 
  // virtual void setDebugOutput(ostream* os) { deb = os; }
 
  // Zunächst die Steuerungs-Funktionen: //
 
  virtual void moveRamp(double targetAngle, double vmax, double amax);
 
  virtual void moveVel(double vel);
 
  virtual void movePos(double pos);
 
  virtual void stop();
 
  // Funktionen zum setzen und auslesen von Parametern: //
 
  virtual void setMaxVelocity(double radpersec)
  {
    m_vmax = radpersec;
  }
  virtual double getMaxVelocity()
  {
    return m_vmax;
  }
 
  virtual void setMaxAcceleration(double radPerSecSquared)
  {
    m_amax = radPerSecSquared;
  }
  virtual double getMaxAcceleration()
  {
    return m_amax;
  }
 
  virtual void setLimits(double lowerLimit, double upperLimit)
  {
    m_ul = upperLimit;
    m_ll = lowerLimit;
  }
  virtual double getUpperLimit()
  {
    return m_ul;
  }
  virtual double getLowerLimit()
  {
    return m_ll;
  }
 
  virtual void setTimeConstant(double T)
  {
    T0 = T;
  }
  virtual double getTimeConstant() const
  {
    return T0;
  }
 
  // hier die Funktionen zur Statusabfrage: //
 
  virtual RampCommand getRampMove(double targetAngle, double v, double a);
 
  virtual RampCommand getRampMove(double targetAngle)
  {
    return getRampMove(targetAngle, m_vmax, m_amax);
  }
 
  virtual double getAngle()
  {
    return m_lastMove.getPos();
  }
 
  virtual double getVelocity()
  {
    return m_lastMove.getVel();
  }
 
  virtual bool statusMoving()
  {
    return m_lastMove.isActive();
  }
 
  virtual bool statusDec()
  {
    return m_lastMove.inPhase3();
  }
 
  virtual bool statusAcc()
  {
    return m_lastMove.inPhase1();
  }
 
private:
  RampCommand m_lastMove;
 
  double m_ul, m_ll;      // upper limit and lower limit
  double m_amax, m_vmax;  // Never mover faster than this!
 
  double T0;  // Zeitkonstante für Annäherung der Sprungantwort durch Rampe
 
  // ostream * deb;
};
 
#endif