isobus_guidance_interface.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
#ifndef ISOBUS_GUIDANCE_INTERFACE_HPP
#define ISOBUS_GUIDANCE_INTERFACE_HPP
 
#include "isobus/isobus/can_internal_control_function.hpp"
#include "isobus/utility/event_dispatcher.hpp"
#include "isobus/utility/processing_flags.hpp"
 
#include <memory>
#include <vector>
 
namespace isobus
{
    class AgriculturalGuidanceInterface
    {
    public:
        AgriculturalGuidanceInterface(std::shared_ptr<InternalControlFunction> source,
                                      std::shared_ptr<ControlFunction> destination,
                                      bool enableSendingSystemCommandPeriodically = false,
                                      bool enableSendingMachineInfoPeriodically = false);
 
        ~AgriculturalGuidanceInterface();
 
        class GuidanceSystemCommand
        {
        public:
            enum class CurvatureCommandStatus : std::uint8_t
            {
                NotIntendedToSteer = 0, 
                IntendedToSteer = 1, 
                Error = 2,
                NotAvailable = 3
            };
 
            explicit GuidanceSystemCommand(std::shared_ptr<ControlFunction> sender);
 
            bool set_status(CurvatureCommandStatus newStatus);
 
            CurvatureCommandStatus get_status() const;
 
            bool set_curvature(float curvature);
 
            float get_curvature() const;
 
            std::shared_ptr<ControlFunction> get_sender_control_function() const;
 
            void set_timestamp_ms(std::uint32_t timestamp);
 
            std::uint32_t get_timestamp_ms() const;
 
        private:
            std::shared_ptr<ControlFunction> const controlFunction; 
            float commandedCurvature = 0.0f; 
            std::uint32_t timestamp_ms = 0; 
            CurvatureCommandStatus commandedStatus = CurvatureCommandStatus::NotAvailable; 
        };
 
        class GuidanceMachineInfo
        {
        public:
            enum class MechanicalSystemLockout : std::uint8_t
            {
                NotActive = 0,
                Active = 1,
                Error = 2,
                NotAvailable = 3
            };
 
            enum class RequestResetCommandStatus : std::uint8_t
            {
                ResetNotRequired = 0,
                ResetRequired = 1,
                Error = 2,
                NotAvailable = 3
            };
 
            enum class GenericSAEbs02SlotValue : std::uint8_t
            {
                DisabledOffPassive = 0,
                EnabledOnActive = 1,
                ErrorIndication = 2,
                NotAvailableTakeNoAction = 3
            };
 
            enum class GuidanceLimitStatus : std::uint8_t
            {
                NotLimited = 0, 
                OperatorLimitedControlled = 1, 
                LimitedHigh = 2, 
                LimitedLow = 3, 
                Reserved_1 = 4, 
                Reserved_2 = 5, 
                NonRecoverableFault = 6, 
                NotAvailable = 7 
            };
 
            enum class GuidanceSystemCommandExitReasonCode
            {
                NoReasonAllClear = 0,
                RequiredLevelOfOperatorPresenceAwarenessNotDetected = 1,
                ImplementReleasedControlOfFunction = 2,
                OperatorOverrideOfFunction = 3,
                OperatorControlNotInValidPosition = 4,
                RemoteCommandTimeout = 5,
                RemoteCommandOutOfRangeInvalid = 6,
                FunctionNotCalibrated = 7,
                OperatorControlFault = 8,
                FunctionFault = 9,
                HydraulicOilLevelTooLow = 20,
                HydraulicOilTemperatureTooLow = 21,
                VehicleTransmissionGearDoesNotAllowRemoteCommands = 22, 
                VehicleSpeedTooLow = 23,
                VehicleSpeedTooHigh = 24,
                AlternateGuidanceSystemActive = 25,
                ControlUnitInDiagnosticMode = 26,
                Error = 62,
                NotAvailable = 63 
            };
 
            explicit GuidanceMachineInfo(std::shared_ptr<ControlFunction> sender);
 
            bool set_estimated_curvature(float curvature);
 
            float get_estimated_curvature() const;
 
            bool set_mechanical_system_lockout_state(MechanicalSystemLockout state);
 
            MechanicalSystemLockout get_mechanical_system_lockout() const;
 
            bool set_guidance_steering_system_readiness_state(GenericSAEbs02SlotValue state);
 
            GenericSAEbs02SlotValue get_guidance_steering_system_readiness_state() const;
 
            bool set_guidance_steering_input_position_status(GenericSAEbs02SlotValue state);
 
            GenericSAEbs02SlotValue get_guidance_steering_input_position_status() const;
 
            bool set_request_reset_command_status(RequestResetCommandStatus state);
 
            RequestResetCommandStatus get_request_reset_command_status() const;
 
            bool set_guidance_limit_status(GuidanceLimitStatus status);
 
            GuidanceLimitStatus get_guidance_limit_status() const;
 
            bool set_guidance_system_command_exit_reason_code(std::uint8_t exitCode);
 
            std::uint8_t get_guidance_system_command_exit_reason_code() const;
 
            bool set_guidance_system_remote_engage_switch_status(GenericSAEbs02SlotValue switchStatus);
 
            GenericSAEbs02SlotValue get_guidance_system_remote_engage_switch_status() const;
 
            std::shared_ptr<ControlFunction> get_sender_control_function() const;
 
            void set_timestamp_ms(std::uint32_t timestamp);
 
            std::uint32_t get_timestamp_ms() const;
 
        private:
            std::shared_ptr<ControlFunction> const controlFunction; 
            float estimatedCurvature = 0.0f; 
            std::uint32_t timestamp_ms = 0; 
            MechanicalSystemLockout mechanicalSystemLockoutState = MechanicalSystemLockout::NotAvailable; 
            GenericSAEbs02SlotValue guidanceSteeringSystemReadinessState = GenericSAEbs02SlotValue::NotAvailableTakeNoAction; 
            GenericSAEbs02SlotValue guidanceSteeringInputPositionStatus = GenericSAEbs02SlotValue::NotAvailableTakeNoAction; 
            GenericSAEbs02SlotValue guidanceSystemRemoteEngageSwitchStatus = GenericSAEbs02SlotValue::NotAvailableTakeNoAction; 
            RequestResetCommandStatus requestResetCommandStatus = RequestResetCommandStatus::NotAvailable; 
            GuidanceLimitStatus guidanceLimitStatus = GuidanceLimitStatus::NotAvailable; 
            std::uint8_t guidanceSystemCommandExitReasonCode = static_cast<std::uint8_t>(GuidanceSystemCommandExitReasonCode::NotAvailable); 
        };
 
        void initialize();
 
        bool get_initialized() const;
 
        GuidanceMachineInfo guidanceMachineInfoTransmitData;
 
        GuidanceSystemCommand guidanceSystemCommandTransmitData;
 
        std::size_t get_number_received_guidance_system_command_sources() const;
 
        std::size_t get_number_received_guidance_machine_info_message_sources() const;
 
        std::shared_ptr<GuidanceMachineInfo> get_received_guidance_machine_info(std::size_t index);
 
        std::shared_ptr<GuidanceSystemCommand> get_received_guidance_system_command(std::size_t index);
 
        EventDispatcher<const std::shared_ptr<GuidanceMachineInfo>, bool> &get_guidance_machine_info_event_publisher();
 
        EventDispatcher<const std::shared_ptr<GuidanceSystemCommand>, bool> &get_guidance_system_command_event_publisher();
 
        void update();
 
    protected:
        enum class TransmitFlags : std::uint32_t
        {
            SendGuidanceSystemCommand = 0, 
            SendGuidanceMachineInfo, 
 
            NumberOfFlags 
        };
 
        static void process_flags(std::uint32_t flag, void *parentPointer);
 
        static void process_rx_message(const CANMessage &message, void *parentPointer);
 
        static constexpr std::uint32_t GUIDANCE_MESSAGE_TX_INTERVAL_MS = 100; 
        static constexpr std::uint32_t GUIDANCE_MESSAGE_TIMEOUT_MS = 150; 
        static constexpr float CURVATURE_COMMAND_OFFSET_INVERSE_KM = 8032.0f; 
        static constexpr float CURVATURE_COMMAND_MAX_INVERSE_KM = 8031.75f; 
        static constexpr float CURVATURE_COMMAND_RESOLUTION_PER_BIT = 0.25f; 
        static constexpr std::uint16_t ZERO_CURVATURE_INVERSE_KM = 32128; 
 
        bool send_guidance_machine_info() const;
 
        bool send_guidance_system_command() const;
 
        ProcessingFlags txFlags; 
        EventDispatcher<const std::shared_ptr<GuidanceMachineInfo>, bool> guidanceMachineInfoEventPublisher; 
        EventDispatcher<const std::shared_ptr<GuidanceSystemCommand>, bool> guidanceSystemCommandEventPublisher; 
        std::shared_ptr<ControlFunction> destinationControlFunction; 
        std::vector<std::shared_ptr<GuidanceMachineInfo>> receivedGuidanceMachineInfoMessages; 
        std::vector<std::shared_ptr<GuidanceSystemCommand>> receivedGuidanceSystemCommandMessages; 
        std::uint32_t guidanceSystemCommandTransmitTimestamp_ms = 0; 
        std::uint32_t guidanceMachineInfoTransmitTimestamp_ms = 0; 
        bool initialized = false; 
    };
} // namespace isobus
 
#endif // ISOBUS_GUIDANCE_HPP