isobus_functionalities.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
#ifndef ISOBUS_FUNCTIONALITIES_HPP
#define ISOBUS_FUNCTIONALITIES_HPP
 
#include "isobus/isobus/can_internal_control_function.hpp"
#include "isobus/isobus/can_parameter_group_number_request_protocol.hpp"
#include "isobus/utility/processing_flags.hpp"
#include "isobus/utility/thread_synchronization.hpp"
 
#include <list>
#include <vector>
 
namespace isobus
{
    class DiagnosticProtocol; // Forward declaration
 
    class ControlFunctionFunctionalities
    {
    public:
        enum class Functionalities : std::uint8_t
        {
            MinimumControlFunction = 0,
            UniversalTerminalServer = 1,
            UniversalTerminalWorkingSet = 2,
            AuxOInputs = 3,
            AuxOFunctions = 4,
            AuxNInputs = 5,
            AuxNFunctions = 6,
            TaskControllerBasicServer = 7,
            TaskControllerBasicClient = 8,
            TaskControllerGeoServer = 9,
            TaskControllerGeoClient = 10,
            TaskControllerSectionControlServer = 11,
            TaskControllerSectionControlClient = 12,
            BasicTractorECUServer = 13,
            BasicTractorECUImplementClient = 14,
            TractorImplementManagementServer = 15,
            TractorImplementManagementClient = 16,
            FileServer = 17,
            FileServerClient = 18,
 
            ReservedRangeBegin = 19,
            MaxFunctionalityReserved = 255
        };
 
        enum class MinimumControlFunctionOptions : std::uint8_t
        {
            NoOptions = 0x00,
            Type1ECUInternalWeakTermination = 0x01,
            Type2ECUInternalEndPointTermination = 0x02,
            SupportOfHeartbeatProducer = 0x04,
            SupportOfHeartbeatConsumer = 0x08,
 
            Reserved = 0xF0
        };
 
        enum class AuxOOptions : std::uint8_t
        {
            NoOptions = 0x00,
            SupportsType0Function = 0x01,
            SupportsType1Function = 0x02,
            SupportsType2Function = 0x04,
 
            Reserved = 0xF8
        };
 
        enum class AuxNOptions : std::uint16_t
        {
            NoOptions = 0x00,
            SupportsType0Function = 0x01,
            SupportsType1Function = 0x02,
            SupportsType2Function = 0x04,
            SupportsType3Function = 0x08,
            SupportsType4Function = 0x10,
            SupportsType5Function = 0x20,
            SupportsType6Function = 0x40,
            SupportsType7Function = 0x80,
            SupportsType8Function = 0x100,
            SupportsType9Function = 0x200,
            SupportsType10Function = 0x400,
            SupportsType11Function = 0x800,
            SupportsType12Function = 0x1000,
            SupportsType13Function = 0x2000,
            SupportsType14Function = 0x4000,
 
            Reserved = 0x8000
        };
 
        enum class TaskControllerGeoServerOptions : std::uint8_t
        {
            NoOptions = 0x00,
            PolygonBasedPrescriptionMapsAreSupported = 0x01,
 
            Reserved = 0xFE
        };
 
        enum class BasicTractorECUOptions : std::uint8_t
        {
            TECUNotMeetingCompleteClass1Requirements = 0x00,
            Class1NoOptions = 0x01,
            Class2NoOptions = 0x02,
            ClassRequiredLighting = 0x04,
            NavigationOption = 0x08,
            FrontHitchOption = 0x10,
            GuidanceOption = 0x20,
            Reserved = 0xC0
        };
 
        enum class TractorImplementManagementOptions
        {
            NoOptions = 0,
            FrontPTODisengagementIsSupported,
            FrontPTOEngagementCCWIsSupported,
            FrontPTOengagementCWIsSupported,
            FrontPTOspeedCCWIsSupported,
            FrontPTOspeedCWIsSupported,
            RearPTODisengagementIsSupported,
            RearPTOEngagementCCWIsSupported,
            RearPTOEngagementCWIsSupported,
            RearPTOSpeedCCWIsSupported,
            RearPTOSpeedCWIsSupported,
            FrontHitchMotionIsSupported,
            FrontHitchPositionIsSupported,
            RearHitchMotionIsSupported,
            RearHitchPositionIsSupported,
            VehicleSpeedInForwardDirectionIsSupported,
            VehicleSpeedInReverseDirectionIsSupported,
            VehicleSpeedStartMotionIsSupported,
            VehicleSpeedStopMotionIsSupported,
            VehicleSpeedForwardSetByServerIsSupported,
            VehicleSpeedReverseSetByServerIsSupported,
            VehicleSpeedChangeDirectionIsSupported,
            GuidanceCurvatureIsSupported
        };
 
        explicit ControlFunctionFunctionalities(std::shared_ptr<InternalControlFunction> sourceControlFunction);
 
        ~ControlFunctionFunctionalities();
 
        void set_functionality_is_supported(Functionalities functionality, std::uint8_t functionalityGeneration, bool isSupported);
 
        bool get_functionality_is_supported(Functionalities functionality);
 
        std::uint8_t get_functionality_generation(Functionalities functionality);
 
        void set_minimum_control_function_option_state(MinimumControlFunctionOptions option, bool optionState);
 
        bool get_minimum_control_function_option_state(MinimumControlFunctionOptions option);
 
        void set_aux_O_inputs_option_state(AuxOOptions option, bool optionState);
 
        bool get_aux_O_inputs_option_state(AuxOOptions option);
 
        void set_aux_O_functions_option_state(AuxOOptions option, bool optionState);
 
        bool get_aux_O_functions_option_state(AuxOOptions option);
 
        void set_aux_N_inputs_option_state(AuxNOptions option, bool optionState);
 
        bool get_aux_N_inputs_option_state(AuxNOptions option);
 
        void set_aux_N_functions_option_state(AuxNOptions option, bool optionState);
 
        bool get_aux_N_functions_option_state(AuxNOptions option);
 
        void set_task_controller_geo_server_option_state(TaskControllerGeoServerOptions option, bool optionState);
 
        bool get_task_controller_geo_server_option_state(TaskControllerGeoServerOptions option);
 
        void set_task_controller_geo_client_option(std::uint8_t numberOfControlChannels);
 
        std::uint8_t get_task_controller_geo_client_option();
 
        void set_task_controller_section_control_server_option_state(std::uint8_t numberOfSupportedBooms, std::uint8_t numberOfSupportedSections);
 
        std::uint8_t get_task_controller_section_control_server_number_supported_booms();
 
        std::uint8_t get_task_controller_section_control_server_number_supported_sections();
 
        void set_task_controller_section_control_client_option_state(std::uint8_t numberOfSupportedBooms, std::uint8_t numberOfSupportedSections);
 
        std::uint8_t get_task_controller_section_control_client_number_supported_booms();
 
        std::uint8_t get_task_controller_section_control_client_number_supported_sections();
 
        void set_basic_tractor_ECU_server_option_state(BasicTractorECUOptions option, bool optionState);
 
        bool get_basic_tractor_ECU_server_option_state(BasicTractorECUOptions option);
 
        void set_basic_tractor_ECU_implement_client_option_state(BasicTractorECUOptions option, bool optionState);
 
        bool get_basic_tractor_ECU_implement_client_option_state(BasicTractorECUOptions option);
 
        void set_tractor_implement_management_server_option_state(TractorImplementManagementOptions option, bool optionState);
 
        bool get_tractor_implement_management_server_option_state(TractorImplementManagementOptions option);
 
        void set_tractor_implement_management_server_aux_valve_option(std::uint8_t auxValveIndex, bool stateSupported, bool flowSupported);
 
        bool get_tractor_implement_management_server_aux_valve_state_supported(std::uint8_t auxValveIndex);
 
        bool get_tractor_implement_management_server_aux_valve_flow_supported(std::uint8_t auxValveIndex);
 
        void set_tractor_implement_management_client_option_state(TractorImplementManagementOptions option, bool optionState);
 
        bool get_tractor_implement_management_client_option_state(TractorImplementManagementOptions option);
 
        void set_tractor_implement_management_client_aux_valve_option(std::uint8_t auxValveIndex, bool stateSupported, bool flowSupported);
 
        bool get_tractor_implement_management_client_aux_valve_state_supported(std::uint8_t auxValveIndex);
 
        bool get_tractor_implement_management_client_aux_valve_flow_supported(std::uint8_t auxValveIndex);
 
        void update();
 
    protected:
        void get_message_content(std::vector<std::uint8_t> &messageData);
 
    private:
        class FunctionalityData
        {
        public:
            explicit FunctionalityData(Functionalities functionalityToStore);
 
            void configure_default_data();
 
            void set_bit_in_option(std::uint8_t byteIndex, std::uint8_t bit, bool value);
 
            bool get_bit_in_option(std::uint8_t byteIndex, std::uint8_t bit);
 
            Functionalities functionality = Functionalities::MinimumControlFunction; 
            std::vector<std::uint8_t> serializedValue; 
            std::uint8_t generation = 1; 
        };
 
        enum class TransmitFlags : std::uint32_t
        {
            ControlFunctionFunctionalitiesMessage = 0, 
 
            NumberOfFlags 
        };
 
        std::list<FunctionalityData>::iterator get_functionality(Functionalities functionalityToRetrieve);
 
        bool get_functionality_byte_option(Functionalities functionality, std::uint8_t byteIndex, std::uint8_t option);
 
        std::uint8_t get_tim_option_byte_index(TractorImplementManagementOptions option) const;
 
        std::uint8_t get_tim_option_bit_index(TractorImplementManagementOptions option) const;
 
        static bool pgn_request_handler(std::uint32_t parameterGroupNumber,
                                        std::shared_ptr<ControlFunction> requestingControlFunction,
                                        bool &acknowledge,
                                        AcknowledgementType &acknowledgeType,
                                        void *parentPointer);
 
        static void process_flags(std::uint32_t flag, void *parentPointer);
 
        static constexpr std::uint8_t NUMBER_TIM_AUX_VALVES_PER_BYTE = 4; 
        static constexpr std::uint8_t NUMBER_TIM_AUX_VALVES = 32; 
 
        std::shared_ptr<InternalControlFunction> myControlFunction; 
        std::list<FunctionalityData> supportedFunctionalities; 
        ProcessingFlags txFlags; 
        Mutex functionalitiesMutex; 
    };
} // namespace isobus
#endif // ISOBUS_FUNCTIONALITIES_HPP