phymarxbot.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 PHYMARXBOT_H
#define PHYMARXBOT_H

#include "worldsimconfig.h"
#include "wvector.h"
#include "wmatrix.h"
#include "world.h"
#include "motorcontrollers.h"
#include "sensorcontrollers.h"
#include "graphicalwobject.h"
#include "phyhinge.h"
#include "phyfixed.h"
#include "phycylinder.h"
#include <QVector>

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

    class FARSA_WSIM_API PhyMarXbot : public WObject {
        Q_OBJECT
    public:
        // Robot dimensions. Measures and masses in MKS

        // --- chassis containing the battery
        static const real basex;
        static const real basey;
        static const real basez;
        static const real basem;

        // --- cylinder body supporting infrared and other modules and turrets
        static const real bodyr;
        static const real bodyh;
        static const real bodym;

        // --- inner part of the continous tracks (where the rubber tracks move on)
        static const real axledistance;
        static const real trackradius;
        static const real trackheight;
        static const real trackm;

        // --- the height of the treads on tracks and wheels
        static const real treaddepth;

        // --- external wheels (the radius is excluding the tread height)
        static const real wheelr;
        static const real wheelh;
        static const real wheelm;

        // --- height of the turret
        static const real turreth;
        static const real turretm;

        // --- dimensions of the attachment device
        static const real attachdevr;
        static const real attachdevx;
        static const real attachdevy;
        static const real attachdevz;
        static const real attachdevm;

    public:
        PhyMarXbot( World* world, QString name, const wMatrix& tm = wMatrix::identity() );
        virtual ~PhyMarXbot();
        WheelMotorController* wheelsController() {
            return wheelsCtrl;
        }
        MarXbotAttachmentDeviceMotorController* attachmentDeviceController() {
            return attachdevCtrl;
        }
        SimulatedIRProximitySensorController* proximityIRSensorController() {
            return proximityIR;
        }
        SimulatedIRGroundSensorController* groundBottomIRSensorController() {
            return groundBottomIR;
        }
        SimulatedIRGroundSensorController* groundAroundIRSensorController() {
            return groundAroundIR;
        }
        TractionSensorController* tractionSensorController() {
            return tractionSensor;
        }
        virtual void preUpdate();
        virtual void postUpdate();
        void setProximityIRSensorsGraphicalProperties(bool drawSensor, bool drawRay = false, bool drawRealRay = false);
        void setGroundBottomIRSensorsGraphicalProperties(bool drawSensor, bool drawRay = false, bool drawRealRay = false);
        void setGroundAroundIRSensorsGraphicalProperties(bool drawSensor, bool drawRay = false, bool drawRealRay = false);

        void setDrawFrontMarker(bool drawMarker);

        bool getDrawFrontMarker() const;

        void enableAttachmentDevice(bool enable);

        bool attachmentDeviceEnabled() const
        {
            return (attachdev != NULL);
        }

        void resetAttachmentDevice();

        PhyObject* base()
        {
            return basev;
        }

        PhyObject* turret()
        {
            return turretv;
        }

        PhyObject* attachmentDevice()
        {
            return attachdev;
        }

        PhyHinge* attachmentDeviceJoint()
        {
            return attachdevjoint;
        }

        void doKinematicSimulation(bool k);

        bool isKinematic() const
        {
            return kinematicSimulation;
        }

        void setLedColors(QList<QColor> c);

        QList<QColor> ledColors() const;

        const QList<PhyCylinder::SegmentColor>& segmentsColor() const;

    public slots:

    protected slots:
        void setLeftWheelDesideredVelocity(real velocity);

        void setRightWheelDesideredVelocity(real velocity);

    protected:
        virtual void changedMatrix();

    private:
        PhyObject* basev;
        QVector<PhyObject*> wheels;
        QVector<wMatrix> wheelstm;
        QVector<PhyJoint*> wheelJoints;
        WheelMotorController* wheelsCtrl;
        PhyCylinder* turretv;
        wMatrix turrettm;
        PhyFixed* forcesensor;
        PhyObject* attachdev;
        wMatrix attachdevtm;
        PhyHinge* attachdevjoint;
        MarXbotAttachmentDeviceMotorController* attachdevCtrl;
        SimulatedIRProximitySensorController* proximityIR;
        SimulatedIRGroundSensorController* groundBottomIR;
        SimulatedIRGroundSensorController* groundAroundIR;
        TractionSensorController* tractionSensor;
        bool kinematicSimulation;
        real leftWheelVelocity;
        real rightWheelVelocity;

        GraphicalWObject* frontMarker;

        QList<QColor> ledColorsv;

        mutable QList<PhyCylinder::SegmentColor> uniformColor;
    };

    namespace previous {
        class FARSA_WSIM_API PhyMarXbot : public WObject {
            Q_OBJECT
        public:
            // Robot dimensions. Measures and masses in MKS

            // --- chassis containing the battery
            static const real basex;
            static const real basey;
            static const real basez;
            static const real basem;

            // --- cylinder body supporting infrared and other modules and turrets
            static const real bodyr;
            static const real bodyh;
            static const real bodym;

            // --- inner part of the continous tracks (where the rubber tracks move on)
            static const real axledistance;
            static const real trackradius;
            static const real trackheight;
            static const real trackm;

            // --- the height of the treads on tracks and wheels
            static const real treaddepth;

            // --- external wheels (the radius is excluding the tread height)
            static const real wheelr;
            static const real wheelh;
            static const real wheelm;

            // --- height of the attachment ring
            static const real attachringh;
            static const real attachringm;

            // --- module with 12 RGB LEDs
            static const real ledsh;
            static const real ledsradius;
            static const real ledsm;

        public:
            PhyMarXbot( World* world, QString name, const wMatrix& tm = wMatrix::identity() );
            virtual ~PhyMarXbot();
            WheelMotorController* wheelsController() {
                return wheelsCtrl;
            };
            IRSensorController* proximityIRSensorController() {
                return proximityIR;
            }
            IRSensorController* groundBottomIRSensorController() {
                return groundBottomIR;
            }
            IRSensorController* groundAroundIRSensorController() {
                return groundAroundIR;
            }
            TractionSensorController* tractionSensorController() {
                return tractionSensor;
            }
            virtual void preUpdate();
            virtual void postUpdate();
            void setProximityIRSensorsGraphicalProperties(bool drawSensor, bool drawRay = false, bool drawRealRay = false);
            void setGroundBottomIRSensorsGraphicalProperties(bool drawSensor, bool drawRay = false, bool drawRealRay = false);
            void setGroundAroundIRSensorsGraphicalProperties(bool drawSensor, bool drawRay = false, bool drawRealRay = false);


            void doKinematicSimulation(bool k);

            bool isKinematic() const
            {
                return kinematicSimulation;
            }
        public slots:

        protected slots:
            void setLeftWheelDesideredVelocity(real velocity);

            void setRightWheelDesideredVelocity(real velocity);

        protected:
            virtual void changedMatrix();

        private:
            PhyObject* base;
            QVector<PhyObject*> wheels;
            QVector<wMatrix> wheelstm;
            QVector<PhyJoint*> wheelJoints;
            WheelMotorController* wheelsCtrl;
            PhyObject* attachring;
            wMatrix attachringtm;
            PhyFixed* forcesensor;
            SimulatedIRProximitySensorController* proximityIR;
            SimulatedIRGroundSensorController* groundBottomIR;
            SimulatedIRGroundSensorController* groundAroundIR;
            TractionSensorController* tractionSensor;
            bool kinematicSimulation;
            real leftWheelVelocity;
            real rightWheelVelocity;
        };
    }
} // end namespace farsa

#endif