DRPlugin.hh

Go to the documentation of this file.

/*
 *  Copyright (C) 2018 João Borrego
 *
 *  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 _DOMAIN_RANDOMIZATION_PLUGIN_HH_
#define _DOMAIN_RANDOMIZATION_PLUGIN_HH_

// Gazebo
#include "gazebo/common/Plugin.hh"
#include <gazebo/msgs/msgs.hh>
#include <gazebo/transport/transport.hh>
#include <gazebo/sensors/sensors.hh>

// Custom messages
#include "dr_request.pb.h"
#include "model_cmd.pb.h"
// Custom gazebo debug utilities
#include "gz_debug.hh"

// Required fields workaround
#include <limits>

namespace gazebo {

    // Message types

    typedef gap::msgs::DRRequest DRRequest;
    typedef const boost::shared_ptr<const gap::msgs::DRRequest>
        DRRequestPtr;
    typedef gap::msgs::ModelCmd ModelCmdMsg;
    typedef const boost::shared_ptr<const gap::msgs::ModelCmd>
        ModelCmdPtr;
    
    // Forward declaration of private data class
    class DRPluginPrivate;

    class DRPlugin : public WorldPlugin
    {
        public: static const char REQUEST_TOPIC[];
        public: static const char RESPONSE_TOPIC[];
        public: static const int POSITION;
        public: static const int VELOCITY;

        // Private attributes

        private: std::unique_ptr<DRPluginPrivate> data_ptr;
        private: event::ConnectionPtr update_connection;

        private: physics::WorldPtr world;
        private: physics::PhysicsEnginePtr physics_engine;

        private: boost::shared_ptr<DRRequest const> msg;

        // Public methods

        public: DRPlugin();

        public: virtual ~DRPlugin();

        public: virtual void Load(
            physics::WorldPtr _world, sdf::ElementPtr _sdf);

        public: void onUpdate();

        public: void onRequest(DRRequestPtr & _msg);

        // Physics 

        private: void processPhysics(const msgs::Physics & msg);

        private: void processModel(const msgs::Model & msg);

        private: void processJoint(
            physics::ModelPtr model,
            const msgs::Joint & msg);

        private: void processLink(
            physics::ModelPtr model,
            const msgs::Link & msg);

        private: void processInertial(
            physics::LinkPtr link,
            const msgs::Inertial & msg);

        private: void processSurface(
            physics::CollisionPtr collision,
            const msgs::Surface & msg);

        private: void processModelCmd(
            const ModelCmdMsg & msg);

        private: void processJointCmd(
            physics::ModelPtr model,
            const msgs::JointCmd & msg);
        
        private: void processPID(
            int type,
            physics::JointControllerPtr controller,
            const std::string & joint,
            const msgs::PID & msg);

    };
}

#endif