phykhepera.h

/********************************************************************************
 *  WorldSim -- library for robot simulations                                   *
 *  Copyright (C) 2012-2013                                                     *
 *  Gianluca Massera <emmegian@yahoo.it>                                        *
 *  Fabrizio Papi <erkito87@gmail.com>                                          *
 *                                                                              *
 *  This program 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 2 of the License, or           *
 *  (at your option) any later version.                                         *
 *                                                                              *
 *  This program 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 this program; if not, write to the Free Software                 *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#ifndef PHYKHEPERA_H
#define PHYKHEPERA_H

#include "worldsimconfig.h"
#include "wvector.h"
#include "wmatrix.h"
#include "world.h"
#include "motorcontrollers.h"
#include "sensorcontrollers.h"
#include <QVector>

namespace farsa {
    class PhyObject;
    class PhyJoint;
    class PhyCylinder;

    class FARSA_WSIM_API PhyKhepera : public WObject {
        Q_OBJECT

    public:
        static const real bodydistancefromground;

        static const real bodyr;

        static const real bodyh;

        static const real bodym;

        static const real wheelr;

        static const real wheelh;

        static const real wheelm;

        static const real axletrack;

        static const real passivewheelr;

        static const real passivewheelm;

    public:
//      /**
//       * \brief Creates a khepera II robot
//       *
//       * \param world the world in which the robot lives
//       * \param name the name of the robots
//       * \param transformation the transformation matrix of the robot
//       */
//      PhyKhepera(World* world, QString name, const wMatrix& transformation = wMatrix::identity());
// 
//      /**
//       * \brief Destructor
//       */
//      virtual ~PhyKhepera();
// 
//      /**
//       * \brief Returns the motor controller for the wheels
//       *
//       * \return the motor controller for the wheels
//       */
//      WheelMotorController* wheelsController()
//      {
//          return m_wheelsCtrl;
//      }
// 
//      /**
//       * \brief Pre-updates the robot
//       *
//       * This method is called at each step of the world just before
//       * the physic update
//       */
//      virtual void preUpdate();
// 
//      /**
//       * \brief Post-updates the robot
//       *
//       * This method is called at each step of the world just after
//       * the physic update
//       */
//      virtual void postUpdate();
// 
//      /**
//       * \brief Changes the robot model from dynamic to kinematic and
//       *        vice-versa
//       *
//       * \param k if true switches to the kinematic Kephera II model,
//       *          if false to the dynamic one (at creation the model
//       *          is always dynamic)
//       */
//      void doKinematicSimulation(bool k);
// 
//      /**
//       * \brief Returns true if we are using the kinematic model
//       *
//       * \return true if we are using the kinematic model
//       */
//      bool isKinematic() const
//      {
//          return m_kinematicSimulation;
//      }
// 
//  protected slots:
//      /**
//       * \brief Sets the desidered velocity of the left wheel
//       *
//       * This is used when in kinematic to move the robot. We only use
//       * velocity because robots can only move by setting wheel
//       * velocities
//       * \param velocity the desidered velocity (in radiants per
//       *                 second)
//       */
//      void setLeftWheelDesideredVelocity(real velocity);
// 
//      /**
//       * \brief Sets the desidered velocity of the right wheel
//       *
//       * This is used when in kinematic to move the robot. We only use
//       * velocity because robots can only move by setting wheel
//       * velocities
//       * \param velocity the desidered velocity (in radiants per
//       *                 second)
//       */
//      void setRightWheelDesideredVelocity(real velocity);
// 
//  protected:
//      /**
//       * \brief The function called when the transformation matrix of
//       *        the robot is changed
//       *
//       * This updates the matrix of all sub-objects
//       */
//      virtual void changedMatrix();
// 
//  private:
//      /**
//       * \brief The object representing the robot body
//       */
//      PhyObject* m_body;
// 
//      /**
//       * \brief The transformation matrix of the body relative to the
//       *        robot frame of reference
//       */
//      wMatrix m_bodyTransformation;
// 
//      /**
//       * \brief The inverse transformation matrix of the body relative
//       *        to the robot frame of reference
//       */
//      wMatrix m_bodyInvTransformation;
// 
//      /**
//       * \brief The vector containing the wheels
//       *
//       * The order is: right wheel, left wheel, and 2 passive
//       * spherical wheels
//       */
//      QVector<PhyObject*> m_wheels;
// 
//      /**
//       * \brief The relative matrices of wheels respect to body
//       *
//       * The order is: right wheel, left wheel, and 2 passive
//       * spherical wheels
//       */
//      QVector<wMatrix> m_wheelsTransformation;
// 
//      /**
//       * \brief The vector containing the wheel joints
//       *
//       * The order is: right wheel, left wheel, and 2 passive
//       * spherical wheels
//       */
//      QVector<PhyJoint*> m_wheelJoints;
// 
//      /**
//       * \brief The motor controller for the two motorized wheels
//       *
//       * The wheels order it (right, left)
//       */
//      WheelMotorController* m_wheelsCtrl;
// 
//      /**
//       * \brief True if we are doing a kinematic simulation
//       */
//      bool m_kinematicSimulation;
// 
//      /**
//       * \brief The speed of the left wheel (used when in kinematic)
//       */
//      real m_leftWheelVelocity;
// 
//      /**
//       * \brief The speed of the left wheel (used when in kinematic)
//       */
//      real m_rightWheelVelocity;
    };
} // end namespace farsa

#endif