ExecutorInterface.h

Go to the documentation of this file.

#pragma once
 
#include <armarx/navigation/core/Trajectory.h>
#include <armarx/navigation/core/types.h>
 
namespace armarx::navigation::server
{
 
    /**
     * @brief An executer the server navigator will use to send its control commands to.
     */
    class ExecutorInterface
    {
 
    public:
        virtual ~ExecutorInterface() = default;
 
        virtual void execute(const core::LocalTrajectory& trajectory,
                             bool activateController = false) = 0;
        virtual void execute(const core::GlobalTrajectory& trajectory,
                             bool activateController = false) = 0;
 
 
        enum class ControllerType
        {
            GlobalTrajectory,
            LocalTrajectory,
            None
        };
 
        virtual void start(ControllerType controllerType) = 0;
        virtual void stop() = 0;
 
        virtual void ensureIsActive(ControllerType controllerType) = 0;
 
        /**
         * @brief Whether the emergency stop has been released since this was last asked.
         *
         * Reports the edge once and clears it. The caller must re-anchor its plan at the robot's
         * current pose before the controller is activated again: the robot stands still where
         * the old profile assigns cruise speed, so resuming on the old trajectory steps the
         * command from zero and the device ramp answers at its own maximum.
         *
         * Defaults to false for executors with no emergency-stop source.
         */
        virtual bool
        consumeEmergencyStopRelease()
        {
            return false;
        }
 
        /**
         * @brief Ask the executor to persist whatever execution diagnostics it has recorded.
         *
         * Called when a navigation request finishes, because finishing does not reliably stop the
         * controller that holds the data: `stop()` only deactivates a controller that reports
         * active. A record that appears only on deactivation is a record that can fail to appear.
         *
         * A no-op unless the executor's controller has diagnostics enabled, and never throws --
         * this must not be able to fail a navigation request.
         */
        virtual void
        dumpDiagnostics()
        {
        }
 
        virtual void updateVelocityLimits(const core::TwistLimits& limits) = 0;
 
        virtual void updateVelocityFactor(float velocityFactor) = 0;
    };
 
} // namespace armarx::navigation::server