NavigateRelativeSkill.h

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <future>
#include <optional>
#include <string>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/util/StringHelpers.h>
 
#include <RobotAPI/libraries/skills/core/Skill.h>
#include <RobotAPI/libraries/skills/core/SkillDescription.h>
#include <RobotAPI/libraries/skills/core/SkillStatusUpdate.h>
#include <RobotAPI/libraries/skills/provider/SimpleSpecializedSkill.h>
 
#include <armarx/navigation/client.h>
#include <armarx/navigation/client/services/IceNavigatorFactory.h>
#include <armarx/navigation/client/services/MemorySubscriber.h>
#include <armarx/navigation/core/types.h>
#include <armarx/navigation/global_planning/Point2Point.h>
#include <armarx/navigation/skills/NavigatingSkillHelper.h>
#include <armarx/navigation/trajectory_control/local/TrajectoryFollowingController.h>
 
namespace armarx::navigation::skills
{
 
    // abstract base class of a relative movement skill
    template <class AronT>
    class NavigateRelativeSkill : public armarx::skills::SimpleSpecializedSkill<AronT>
    {
 
    public:
        using Base = armarx::skills::SimpleSpecializedSkill<AronT>;
 
        NavigateRelativeSkill() = delete;
 
        NavigateRelativeSkill(const NavigatingSkillHelper::Properties& properties,
                              const NavigatingSkillHelper::Services& srv,
                              const armarx::skills::SkillDescription& desc) :
            Base(desc), helper(properties, srv)
        {
        }
 
        virtual ~NavigateRelativeSkill() = default;
 
    private:
        // implemented by children returning the relative movement to execute
        virtual Eigen::Isometry3f relativeTarget(const typename Base::SpecializedMainInput& in) = 0;
 
        armarx::skills::Skill::InitResult
        init(const typename Base::SpecializedInitInput& in) override
        {
            helper.init(in.parameters.navigatingSkillParams, Base::getSkillId().skillName);
 
            return ::armarx::skills::Skill::InitResult{
                .status = ::armarx::skills::TerminatedSkillStatus::Succeeded};
        }
 
        armarx::skills::Skill::MainResult
        main(const typename Base::SpecializedMainInput& in) override
        {
            const Eigen::Isometry3f relativeTarget = this->relativeTarget(in);
 
            ARMARX_INFO << "Moving to relative target " << VAROUT(relativeTarget.matrix());
 
            // excecute
            ARMARX_INFO << "Sending navigation request";
            // Wait until goal is reached, re-planning while the retry budget lasts. The
            // relative target stays valid across retries: a planning failure leaves the robot
            // in place.
            auto se = helper.moveAndWaitForStop(
                [&]
                {
                    helper.getNavigator()->moveTo(relativeTarget,
                                                  core::NavigationFrame::Relative);
                },
                [this] { return Base::shouldSkillTerminate(); });
            if (se)
            {
                ARMARX_INFO << "Goal " << QUOTED(relativeTarget.matrix())  << "reached.";
            }
            else
            {
                if (se.isSafetyStopTriggeredEvent())
                {
                    ARMARX_ERROR << "Safety stop was triggered!";
 
                    return armarx::skills::Skill::MainResult{
                        .status = armarx::skills::TerminatedSkillStatus::Failed};
                }
                if (se.isUserAbortTriggeredEvent())
                {
                    ARMARX_ERROR << "Aborted by user!";
 
                    return armarx::skills::Skill::MainResult{
                        .status = armarx::skills::TerminatedSkillStatus::Failed};
                }
                if (se.isInternalErrorEvent())
                {
                    ARMARX_ERROR << "Unknown internal error occured! "
                                 << se.toInternalErrorEvent().message;
 
                    return armarx::skills::Skill::MainResult{
                        .status = armarx::skills::TerminatedSkillStatus::Failed};
                }
                if (se.isGlobalPlanningFailedEvent())
                {
                    ARMARX_ERROR << "Global planning failed! "
                                 << se.toGlobalPlanningFailedEvent().message;
 
                    return ::armarx::skills::Skill::MainResult{
                        .status = ::armarx::skills::TerminatedSkillStatus::Failed};
                }
 
                ARMARX_ERROR << "Unknown event!";
                return ::armarx::skills::Skill::MainResult{
                    .status = ::armarx::skills::TerminatedSkillStatus::Failed};
            }
 
            return armarx::skills::Skill::MainResult{
                .status = armarx::skills::TerminatedSkillStatus::Succeeded};
        }
 
        void
        onStopRequested() override
        {
            if (helper.getNavigator().has_value())
            {
                ARMARX_CHECK(helper.getNavigator().has_value());
                helper.getNavigator()->stop();
            }
        }
 
 
    private:
        NavigatingSkillHelper helper;
    };
 
} // namespace armarx::navigation::skills