isobus_speed_distance_messages.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
#ifndef ISOBUS_SPEED_MESSAGES_HPP
#define ISOBUS_SPEED_MESSAGES_HPP
 
#include "isobus/isobus/can_internal_control_function.hpp"
#include "isobus/utility/event_dispatcher.hpp"
#include "isobus/utility/processing_flags.hpp"
 
#include <cstdint>
#include <memory>
#include <vector>
 
namespace isobus
{
    class SpeedMessagesInterface
    {
    public:
        SpeedMessagesInterface(std::shared_ptr<InternalControlFunction> source,
                               bool enableSendingGroundBasedSpeedPeriodically = false,
                               bool enableSendingWheelBasedSpeedPeriodically = false,
                               bool enableSendingMachineSelectedSpeedPeriodically = false,
                               bool enableSendingMachineSelectedSpeedCommandPeriodically = false);
 
        ~SpeedMessagesInterface();
 
        enum class MachineDirection : std::uint8_t
        {
            Forward = 0,
            Reverse = 1,
            Error = 2,
            NotAvailable = 3
        };
 
        class WheelBasedMachineSpeedData
        {
        public:
            enum class KeySwitchState : std::uint8_t
            {
                Off = 0, 
                NotOff = 1, 
                Error = 2,
                NotAvailable = 3
            };
 
            enum class ImplementStartStopOperations : std::uint8_t
            {
                StopDisableImplementOperations = 0,
                StartEnableImplementOperations = 1,
                Error = 2,
                NotAvailable = 3
            };
 
            enum class OperatorDirectionReversed : std::uint8_t
            {
                NotReversed = 0,
                Reversed = 1,
                Error = 2,
                NotAvailable = 3
            };
 
            explicit WheelBasedMachineSpeedData(std::shared_ptr<ControlFunction> sender);
 
            std::uint32_t get_machine_distance() const;
 
            bool set_machine_distance(std::uint32_t distance);
 
            std::uint16_t get_machine_speed() const;
 
            bool set_machine_speed(std::uint16_t speed);
 
            std::uint8_t get_maximum_time_of_tractor_power() const;
 
            bool set_maximum_time_of_tractor_power(std::uint8_t maxTime);
 
            MachineDirection get_machine_direction_of_travel() const;
 
            bool set_machine_direction_of_travel(MachineDirection direction);
 
            KeySwitchState get_key_switch_state() const;
 
            bool set_key_switch_state(KeySwitchState state);
 
            ImplementStartStopOperations get_implement_start_stop_operations_state() const;
 
            bool set_implement_start_stop_operations_state(ImplementStartStopOperations state);
 
            OperatorDirectionReversed get_operator_direction_reversed_state() const;
 
            bool set_operator_direction_reversed_state(OperatorDirectionReversed reverseState);
 
            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; 
            std::uint32_t timestamp_ms = 0; 
            std::uint32_t wheelBasedMachineDistance_mm = 0; 
            std::uint16_t wheelBasedMachineSpeed_mm_per_sec = 0; 
            std::uint8_t maximumTimeOfTractorPower_min = 0; 
            MachineDirection machineDirectionState = MachineDirection::NotAvailable; 
            KeySwitchState keySwitchState = KeySwitchState::NotAvailable; 
            ImplementStartStopOperations implementStartStopOperationsState = ImplementStartStopOperations::NotAvailable; 
            OperatorDirectionReversed operatorDirectionReversedState = OperatorDirectionReversed::NotAvailable; 
        };
 
        class MachineSelectedSpeedData
        {
        public:
            enum class ExitReasonCode : std::uint8_t
            {
                NoReasonAllClear = 0,
                RequiredLevelOfOperatorPresenceAwarenessNotDetected = 1,
                ImplementReleasedControlOfFunction = 2,
                OperatorOverrideOfFunction = 3,
                OperatorControlNotInValidPosition = 4,
                RemoteCommandTimeout = 5,
                RemoteCommandOutOfRangeInvalid = 6,
                FunctionNotCalibrated = 7,
                OperatorControlFault = 8,
                FunctionFault = 9,
                VehicleTransmissionGearDoesNotAllowRemoteCommands = 22,
                Error = 62,
                NotAvailable = 63
            };
 
            enum class SpeedSource : std::uint8_t
            {
                WheelBasedSpeed = 0, 
                GroundBasedSpeed = 1, 
                NavigationBasedSpeed = 2, 
                Blended = 3, 
                Simulated = 4, 
                Reserved_1 = 5, 
                Reserved_2 = 6, 
                NotAvailable = 7 
            };
 
            enum class LimitStatus : std::uint8_t
            {
                NotLimited = 0,
                OperatorLimitedControlled = 1, 
                LimitedHigh = 2, 
                LimitedLow = 3, 
                Reserved_1 = 4, 
                Reserved_2 = 5, 
                NonRecoverableFault = 6,
                NotAvailable 
            };
 
            explicit MachineSelectedSpeedData(std::shared_ptr<ControlFunction> sender);
 
            std::uint32_t get_machine_distance() const;
 
            bool set_machine_distance(std::uint32_t distance);
 
            std::uint16_t get_machine_speed() const;
 
            bool set_machine_speed(std::uint16_t speed);
 
            std::uint8_t get_exit_reason_code() const;
 
            bool set_exit_reason_code(std::uint8_t exitCode);
 
            SpeedSource get_speed_source() const;
 
            bool set_speed_source(SpeedSource selectedSource);
 
            LimitStatus get_limit_status() const;
 
            bool set_limit_status(LimitStatus statusToSet);
 
            MachineDirection get_machine_direction_of_travel() const;
 
            bool set_machine_direction_of_travel(MachineDirection directionOfTravel);
 
            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; 
            std::uint32_t timestamp_ms = 0; 
            std::uint32_t machineSelectedSpeedDistance_mm = 0; 
            std::uint16_t machineSelectedSpeed_mm_per_sec = 0; 
            std::uint8_t exitReasonCode = static_cast<std::uint8_t>(ExitReasonCode::NotAvailable); 
            SpeedSource source = SpeedSource::NotAvailable; 
            LimitStatus limitStatus = LimitStatus::NotAvailable; 
            MachineDirection machineDirectionState = MachineDirection::NotAvailable; 
        };
 
        class GroundBasedSpeedData
        {
        public:
            explicit GroundBasedSpeedData(std::shared_ptr<ControlFunction> sender);
 
            std::uint32_t get_machine_distance() const;
 
            bool set_machine_distance(std::uint32_t distance);
 
            std::uint16_t get_machine_speed() const;
 
            bool set_machine_speed(std::uint16_t speed);
 
            MachineDirection get_machine_direction_of_travel() const;
 
            bool set_machine_direction_of_travel(MachineDirection directionOfTravel);
 
            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; 
            std::uint32_t timestamp_ms = 0; 
            std::uint32_t groundBasedMachineDistance_mm = 0; 
            std::uint16_t groundBasedMachineSpeed_mm_per_sec = 0; 
            MachineDirection machineDirectionState = MachineDirection::NotAvailable; 
        };
 
        class MachineSelectedSpeedCommandData
        {
        public:
            explicit MachineSelectedSpeedCommandData(std::shared_ptr<ControlFunction> sender);
 
            std::uint16_t get_machine_speed_setpoint_command() const;
 
            bool set_machine_speed_setpoint_command(std::uint16_t speed);
 
            std::uint16_t get_machine_selected_speed_setpoint_limit() const;
 
            bool set_machine_selected_speed_setpoint_limit(std::uint16_t speedLimit);
 
            MachineDirection get_machine_direction_command() const;
 
            bool set_machine_direction_of_travel(MachineDirection commandedDirection);
 
            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; 
            std::uint32_t timestamp_ms = 0; 
            std::uint16_t speedCommandedSetpoint = 0; 
            std::uint16_t speedSetpointLimit = 0; 
            MachineDirection machineDirectionCommand = MachineDirection::NotAvailable; 
        };
 
        void initialize();
 
        bool get_initialized() const;
 
        MachineSelectedSpeedData machineSelectedSpeedTransmitData;
 
        WheelBasedMachineSpeedData wheelBasedSpeedTransmitData;
 
        GroundBasedSpeedData groundBasedSpeedTransmitData;
 
        MachineSelectedSpeedCommandData machineSelectedSpeedCommandTransmitData;
 
        std::size_t get_number_received_wheel_based_speed_sources() const;
 
        std::size_t get_number_received_ground_based_speed_sources() const;
 
        std::size_t get_number_received_machine_selected_speed_sources() const;
 
        std::size_t get_number_received_machine_selected_speed_command_sources() const;
 
        std::shared_ptr<MachineSelectedSpeedData> get_received_machine_selected_speed(std::size_t index);
 
        std::shared_ptr<WheelBasedMachineSpeedData> get_received_wheel_based_speed(std::size_t index);
 
        std::shared_ptr<GroundBasedSpeedData> get_received_ground_based_speed(std::size_t index);
 
        std::shared_ptr<MachineSelectedSpeedCommandData> get_received_machine_selected_speed_command(std::size_t index);
 
        EventDispatcher<const std::shared_ptr<WheelBasedMachineSpeedData>, bool> &get_wheel_based_machine_speed_data_event_publisher();
 
        EventDispatcher<const std::shared_ptr<MachineSelectedSpeedData>, bool> &get_machine_selected_speed_data_event_publisher();
 
        EventDispatcher<const std::shared_ptr<GroundBasedSpeedData>, bool> &get_ground_based_machine_speed_data_event_publisher();
 
        EventDispatcher<const std::shared_ptr<MachineSelectedSpeedCommandData>, bool> &get_machine_selected_speed_command_data_event_publisher();
 
        void update();
 
    protected:
        enum class TransmitFlags : std::uint32_t
        {
            SendWheelBasedSpeed = 0, 
            SendMachineSelectedSpeed, 
            SendGroundBasedSpeed, 
            SendMachineSelectedSpeedCommand, 
 
            NumberOfFlags 
        };
 
        static constexpr std::uint32_t SPEED_DISTANCE_MESSAGE_TX_INTERVAL_MS = 100; 
        static constexpr std::uint32_t SPEED_DISTANCE_MESSAGE_RX_TIMEOUT_MS = 3 * SPEED_DISTANCE_MESSAGE_TX_INTERVAL_MS; 
        static constexpr std::uint32_t SAEds05_MAX_VALUE = 4211081215; 
        static constexpr std::uint16_t SAEvl01_MAX_VALUE = 64255; 
 
        static void process_flags(std::uint32_t flag, void *parentPointer);
 
        static void process_rx_message(const CANMessage &message, void *parentPointer);
 
        bool send_machine_selected_speed() const;
 
        bool send_wheel_based_speed() const;
 
        bool send_ground_based_speed() const;
 
        bool send_machine_selected_speed_command() const;
 
        ProcessingFlags txFlags; 
        EventDispatcher<const std::shared_ptr<WheelBasedMachineSpeedData>, bool> wheelBasedMachineSpeedDataEventPublisher; 
        EventDispatcher<const std::shared_ptr<MachineSelectedSpeedData>, bool> machineSelectedSpeedDataEventPublisher; 
        EventDispatcher<const std::shared_ptr<GroundBasedSpeedData>, bool> groundBasedSpeedDataEventPublisher; 
        EventDispatcher<const std::shared_ptr<MachineSelectedSpeedCommandData>, bool> machineSelectedSpeedCommandDataEventPublisher; 
        std::vector<std::shared_ptr<WheelBasedMachineSpeedData>> receivedWheelBasedSpeedMessages; 
        std::vector<std::shared_ptr<MachineSelectedSpeedData>> receivedMachineSelectedSpeedMessages; 
        std::vector<std::shared_ptr<GroundBasedSpeedData>> receivedGroundBasedSpeedMessages; 
        std::vector<std::shared_ptr<MachineSelectedSpeedCommandData>> receivedMachineSelectedSpeedCommandMessages; 
        std::uint32_t wheelBasedSpeedTransmitTimestamp_ms = 0; 
        std::uint32_t machineSelectedSpeedTransmitTimestamp_ms = 0; 
        std::uint32_t groundBasedSpeedTransmitTimestamp_ms = 0; 
        std::uint32_t machineSelectedSpeedCommandTransmitTimestamp_ms = 0; 
        bool initialized = false; 
    };
} // namespace isobus
 
#endif // ISOBUS_SPEED_MESSAGES_HPP