ControllerWrapper.h

Go to the documentation of this file.

/**
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX 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, see <http://www.gnu.org/licenses/>.
 *
 * @author     Fabian Reister ( fabian dot reister at kit dot edu )
 * @date       2022
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#pragma once
 
// #include <optional>
// #include <type_traits>
#include <RobotAPI/libraries/aron/core/codegeneration/cpp/AronGeneratedClass.h>
#include <RobotAPI/libraries/aron/core/codegeneration/cpp/AronGeneratedObject.h>
 
#include <armarx/control/client/ControllerDescription.h>
#include <armarx/control/interface/ConfigurableNJointControllerInterface.h>
#include <armarx/control/memory/config/Writer.h>
 
// #include <armarx/control/common/type.h>
// #include <armarx/control/memory/constants.h>
 
namespace armarx::control::client
{
 
    namespace detail
    {
        /**
     * @brief The base class for the ControllerWrapper which allows the private implementation to be in the .cpp file.
     */
        class ControllerWrapperBase
        {
        public:
            using ControllerPrx = armarx::control::ConfigurableNJointControllerInterfacePrx;
 
            ControllerWrapperBase() = delete;
 
            /**
            * @brief Constructor for the ControllerWrapperBase class.
            * @param controller The controller object.
            * @param controllerName The name of the controller.
            * @param controllerTypeName The type name of the controller.
            * @param configWriter The configuration writer object.
            */
            ControllerWrapperBase(const ControllerPrx& controller,
                                  const std::string& controllerName,
                                  const std::string& controllerTypeName,
                                  const memory::config::Writer& configWriter);
 
            /**
            * @brief Destructor for the ControllerWrapperBase class. When invoked, the controller is deactivated and deleted unless being daemonized.
            */
            ~ControllerWrapperBase();
 
            /**
            * @brief Requests the activation of the controller in the RobotUnit.
            */
            void activate();
 
            /**
            * @brief Check the status of the controller.
            */
            bool isActive();
 
            /**
            * @brief Requests the deactivation of the controller in the RobotUnit.
            */
            void deactivate();
 
            /**
            * @brief Sets whether the controller should be daemonized.
            * @param daemonize Flag indicating whether to daemonize the controller.
            */
            void daemonize(bool daemonize = true);
 
            /**
            * @brief Returns the "raw" controller object.
            * @return The controller object.
            */
            ControllerPrx& ctrl();
 
        protected:
            /**
            * @brief Updates the configuration of the controller.
            *
            * This update is two-fold:
            * 1. The configuration is sent to the controller in the RobotUnit.
            * 2. The configuration is written to the memory (via the the configuration writer).
            *
            * @param config The configuration object.
            */
            void
            updateConfig(const armarx::aron::codegenerator::cpp::AronGeneratedObjectBase& config);
 
 
        private:
            ControllerPrx controller_; ///< The controller object.
            const std::string controllerName_; ///< The name of the controller.
            const std::string controllerTypeName_; ///< The type name of the controller.
            memory::config::Writer configWriter_; ///< The configuration writer object.
            bool daemonized_ = false; ///< Flag indicating whether the controller is daemonized.
        };
 
    } // namespace detail
 
    /**
     * @brief Wrapper class for an NJointController proxy.
     *
     * This class provides a wrapper for a controller, allowing easy access and life-cicle management.
     * It holds the controller configuration which can be modified and updated accordingly.
     *
     * @tparam T The type of the controller description.
     */
    template <auto T>
    class ControllerWrapper : public detail::ControllerWrapperBase
    {
    public:
        using ControllerDescriptionType = ControllerDescription<T>;
        using AronConfigT = typename ControllerDescriptionType::AronDTO;
 
        static_assert(not std::is_void<typename ControllerDescriptionType::AronDTO>::value,
                      "You must provide a ControllerDescription!");
 
        using Base = detail::ControllerWrapperBase;
 
        // The class must be instantiated properly.
        ControllerWrapper() = delete;
 
        ControllerWrapper(const ControllerWrapper&) = delete;
        ControllerWrapper& operator=(ControllerWrapper const&) = delete;
 
        /**
         * @brief Constructor for ControllerWrapper.
         *
         * @param controller The NJointController controller proxy.
         * @param controllerName The name of the controller.
         * @param configWriter The configuration writer used to store the controller configs in the memory.
         * @param config The initial configuration for the controller.
         */
        ControllerWrapper(const ControllerPrx& controller,
                          const std::string& controllerName,
                          const memory::config::Writer& configWriter,
                          AronConfigT config) :
            ControllerWrapperBase(controller,
                                  controllerName,
                                  std::string(ControllerDescriptionType::name),
                                  configWriter),
            config(config)
        {
        }
 
        AronConfigT config;
        static_assert(::armarx::aron::cpp::isAronGeneratedClass<AronConfigT>,
                      "The AronConfigT must be an AronGeneratedClass!");
 
        /**
         * @brief Updates the configuration of the controller.
         */
        void
        updateConfig()
        {
            Base::updateConfig(config);
        }
 
        AronConfigT
        getConfig()
        {
            ARMARX_CHECK_NOT_NULL(ctrl());
            auto cfg = ctrl()->getConfig();
            return AronConfigT::FromAron(cfg);
        }
    };
 
} // namespace armarx::control::client