isobus_task_controller_client.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
#ifndef ISOBUS_TASK_CONTROLLER_CLIENT_HPP
#define ISOBUS_TASK_CONTROLLER_CLIENT_HPP
 
#include "isobus/isobus/can_internal_control_function.hpp"
#include "isobus/isobus/can_partnered_control_function.hpp"
#include "isobus/isobus/isobus_device_descriptor_object_pool.hpp"
#include "isobus/isobus/isobus_language_command_interface.hpp"
#include "isobus/utility/processing_flags.hpp"
 
#include <list>
#if !defined CAN_STACK_DISABLE_THREADS && !defined ARDUINO
#include <thread>
#endif
 
namespace isobus
{
    class TaskControllerClient
    {
    public:
        enum class StateMachineState
        {
            Disconnected, 
            WaitForStartUpDelay, 
            WaitForServerStatusMessage, 
            SendWorkingSetMaster, 
            SendStatusMessage, 
            RequestVersion, 
            WaitForRequestVersionResponse, 
            WaitForRequestVersionFromServer, 
            SendRequestVersionResponse, 
            RequestLanguage, 
            WaitForLanguageResponse, 
            ProcessDDOP, 
            RequestStructureLabel, 
            WaitForStructureLabelResponse, 
            RequestLocalizationLabel, 
            WaitForLocalizationLabelResponse, 
            SendDeleteObjectPool, 
            WaitForDeleteObjectPoolResponse, 
            SendRequestTransferObjectPool, 
            WaitForRequestTransferObjectPoolResponse, 
            BeginTransferDDOP, 
            WaitForDDOPTransfer, 
            WaitForObjectPoolTransferResponse, 
            SendObjectPoolActivate, 
            WaitForObjectPoolActivateResponse, 
            Connected, 
            DeactivateObjectPool, 
            WaitForObjectPoolDeactivateResponse 
        };
 
        enum class Version : std::uint8_t
        {
            DraftInternationalStandard = 0, 
            FinalDraftInternationalStandardFirstEdition = 1, 
            FirstPublishedEdition = 2, 
            SecondEditionDraft = 3, 
            SecondPublishedEdition = 4, 
            Unknown = 0xFF
        };
 
        enum class ServerOptions : std::uint8_t
        {
            SupportsDocumentation = 0x01,
            SupportsTCGEOWithoutPositionBasedControl = 0x02,
            SupportsTCGEOWithPositionBasedControl = 0x04,
            SupportsPeerControlAssignment = 0x08,
            SupportsImplementSectionControlFunctionality = 0x10,
            ReservedOption1 = 0x20,
            ReservedOption2 = 0x40,
            ReservedOption3 = 0x80
        };
 
        using RequestValueCommandCallback = bool (*)(std::uint16_t elementNumber,
                                                     std::uint16_t DDI,
                                                     std::int32_t &processVariableValue,
                                                     void *parentPointer);
 
        using ValueCommandCallback = bool (*)(std::uint16_t elementNumber,
                                              std::uint16_t DDI,
                                              std::int32_t processVariableValue,
                                              void *parentPointer);
 
        TaskControllerClient(std::shared_ptr<PartneredControlFunction> partner, std::shared_ptr<InternalControlFunction> clientSource, std::shared_ptr<PartneredControlFunction> primaryVT);
 
        ~TaskControllerClient();
 
        // Setup Functions
        void initialize(bool spawnThread);
 
        void add_request_value_callback(RequestValueCommandCallback callback, void *parentPointer);
 
        void add_value_command_callback(ValueCommandCallback callback, void *parentPointer);
 
        void remove_request_value_callback(RequestValueCommandCallback callback, void *parentPointer);
 
        void remove_value_command_callback(ValueCommandCallback callback, void *parentPointer);
 
        void configure(std::shared_ptr<DeviceDescriptorObjectPool> DDOP,
                       std::uint8_t maxNumberBoomsSupported,
                       std::uint8_t maxNumberSectionsSupported,
                       std::uint8_t maxNumberChannelsSupportedForPositionBasedControl,
                       bool reportToTCSupportsDocumentation,
                       bool reportToTCSupportsTCGEOWithoutPositionBasedControl,
                       bool reportToTCSupportsTCGEOWithPositionBasedControl,
                       bool reportToTCSupportsPeerControlAssignment,
                       bool reportToTCSupportsImplementSectionControl);
 
        void configure(std::uint8_t const *binaryDDOP,
                       std::uint32_t DDOPSize,
                       std::uint8_t maxNumberBoomsSupported,
                       std::uint8_t maxNumberSectionsSupported,
                       std::uint8_t maxNumberChannelsSupportedForPositionBasedControl,
                       bool reportToTCSupportsDocumentation,
                       bool reportToTCSupportsTCGEOWithoutPositionBasedControl,
                       bool reportToTCSupportsTCGEOWithPositionBasedControl,
                       bool reportToTCSupportsPeerControlAssignment,
                       bool reportToTCSupportsImplementSectionControl);
 
        void configure(std::shared_ptr<std::vector<std::uint8_t>> binaryDDOP,
                       std::uint8_t maxNumberBoomsSupported,
                       std::uint8_t maxNumberSectionsSupported,
                       std::uint8_t maxNumberChannelsSupportedForPositionBasedControl,
                       bool reportToTCSupportsDocumentation,
                       bool reportToTCSupportsTCGEOWithoutPositionBasedControl,
                       bool reportToTCSupportsTCGEOWithPositionBasedControl,
                       bool reportToTCSupportsPeerControlAssignment,
                       bool reportToTCSupportsImplementSectionControl);
 
        void restart();
 
        // Calling this will stop the worker thread if it exists
        void terminate();
 
        std::shared_ptr<InternalControlFunction> get_internal_control_function() const;
 
        std::shared_ptr<PartneredControlFunction> get_partner_control_function() const;
 
        std::uint8_t get_number_booms_supported() const;
 
        std::uint8_t get_number_sections_supported() const;
 
        std::uint8_t get_number_channels_supported_for_position_based_control() const;
 
        bool get_supports_documentation() const;
 
        bool get_supports_tcgeo_without_position_based_control() const;
 
        bool get_supports_tcgeo_with_position_based_control() const;
 
        bool get_supports_peer_control_assignment() const;
 
        bool get_supports_implement_section_control() const;
 
        bool get_is_initialized() const;
 
        bool get_is_connected() const;
 
        bool get_is_task_active() const;
 
        StateMachineState get_state() const;
 
        std::uint8_t get_connected_tc_number_booms_supported() const;
 
        std::uint8_t get_connected_tc_number_sections_supported() const;
 
        std::uint8_t get_connected_tc_number_channels_supported() const;
 
        std::uint8_t get_connected_tc_max_boot_time() const;
 
        bool get_connected_tc_option_supported(ServerOptions option) const;
 
        Version get_connected_tc_version() const;
 
        void on_value_changed_trigger(std::uint16_t elementNumber, std::uint16_t DDI);
 
        bool request_task_controller_identification() const;
 
        bool reupload_device_descriptor_object_pool(std::shared_ptr<std::vector<std::uint8_t>> binaryDDOP);
 
        bool reupload_device_descriptor_object_pool(std::uint8_t const *binaryDDOP, std::uint32_t DDOPSize);
 
        bool reupload_device_descriptor_object_pool(std::shared_ptr<DeviceDescriptorObjectPool> DDOP);
 
        void update();
 
        LanguageCommandInterface languageCommandInterface;
 
    protected:
        enum class ProcessDataCommands : std::uint8_t
        {
            TechnicalCapabilities = 0x00, 
            DeviceDescriptor = 0x01, 
            RequestValue = 0x02, 
            Value = 0x03, 
            MeasurementTimeInterval = 0x04, 
            MeasurementDistanceInterval = 0x05, 
            MeasurementMinimumWithinThreshold = 0x06, 
            MeasurementMaximumWithinThreshold = 0x07, 
            MeasurementChangeThreshold = 0x08, 
            PeerControlAssignment = 0x09, 
            SetValueAndAcknowledge = 0x0A, 
            Reserved1 = 0x0B, 
            Reserved2 = 0x0C, 
            ProcessDataAcknowledge = 0x0D, 
            StatusMessage = 0x0E, 
            ClientTask = 0x0F 
        };
 
        enum class TechnicalDataMessageCommands : std::uint8_t
        {
            ParameterRequestVersion = 0x00, 
            ParameterVersion = 0x01, 
            IdentifyTaskController = 0x02 
        };
 
        enum class DeviceDescriptorCommands : std::uint8_t
        {
            RequestStructureLabel = 0x00, 
            StructureLabel = 0x01, 
            RequestLocalizationLabel = 0x02, 
            LocalizationLabel = 0x03, 
            RequestObjectPoolTransfer = 0x04, 
            RequestObjectPoolTransferResponse = 0x05, 
            ObjectPoolTransfer = 0x06, 
            ObjectPoolTransferResponse = 0x07, 
            ObjectPoolActivateDeactivate = 0x08, 
            ObjectPoolActivateDeactivateResponse = 0x09, 
            ObjectPoolDelete = 0x0A, 
            ObjectPoolDeleteResponse = 0x0B, 
            ChangeDesignator = 0x0C, 
            ChangeDesignatorResponse = 0x0D 
        };
 
        static bool process_internal_object_pool_upload_callback(std::uint32_t callbackIndex,
                                                                 std::uint32_t bytesOffset,
                                                                 std::uint32_t numberOfBytesNeeded,
                                                                 std::uint8_t *chunkBuffer,
                                                                 void *parentPointer);
 
        void clear_queues();
 
        bool get_was_ddop_supplied() const;
 
        void process_labels_from_ddop();
 
        void process_queued_commands();
 
        void process_queued_threshold_commands();
 
        static void process_rx_message(const CANMessage &message, void *parentPointer);
 
        static void process_tx_callback(std::uint32_t parameterGroupNumber,
                                        std::uint32_t dataLength,
                                        std::shared_ptr<InternalControlFunction> sourceControlFunction,
                                        std::shared_ptr<ControlFunction> destinationControlFunction,
                                        bool successful,
                                        void *parentPointer);
 
        bool send_delete_object_pool() const;
 
        bool send_generic_process_data(std::uint8_t multiplexor) const;
 
        bool send_object_pool_activate() const;
 
        bool send_object_pool_deactivate() const;
 
        bool send_pdack(std::uint16_t elementNumber, std::uint16_t ddi) const;
 
        bool send_request_localization_label() const;
 
        bool send_request_object_pool_transfer() const;
 
        bool send_request_structure_label() const;
 
        bool send_request_version_response() const;
 
        bool send_status() const;
 
        bool send_value_command(std::uint16_t elementNumber, std::uint16_t ddi, std::int32_t value) const;
 
        bool send_version_request() const;
 
        bool send_working_set_master() const;
 
        void set_common_config_items(std::uint8_t maxNumberBoomsSupported,
                                     std::uint8_t maxNumberSectionsSupported,
                                     std::uint8_t maxNumberChannelsSupportedForPositionBasedControl,
                                     bool reportToTCSupportsDocumentation,
                                     bool reportToTCSupportsTCGEOWithoutPositionBasedControl,
                                     bool reportToTCSupportsTCGEOWithPositionBasedControl,
                                     bool reportToTCSupportsPeerControlAssignment,
                                     bool reportToTCSupportsImplementSectionControl);
 
        void set_state(StateMachineState newState);
 
        void set_state(StateMachineState newState, std::uint32_t timestamp);
 
        void select_language_command_partner();
 
        void worker_thread_function();
 
        static constexpr std::uint32_t SIX_SECOND_TIMEOUT_MS = 6000; 
        static constexpr std::uint16_t TWO_SECOND_TIMEOUT_MS = 2000; 
 
    private:
        struct ProcessDataCallbackInfo
        {
            bool operator==(const ProcessDataCallbackInfo &obj) const;
            std::int32_t processDataValue; 
            std::int32_t lastValue; 
            std::uint16_t elementNumber; 
            std::uint16_t ddi; 
            bool ackRequested; 
            bool thresholdPassed; 
        };
 
        struct RequestValueCommandCallbackInfo
        {
            bool operator==(const RequestValueCommandCallbackInfo &obj) const;
            RequestValueCommandCallback callback; 
            void *parent; 
        };
 
        struct ValueCommandCallbackInfo
        {
            bool operator==(const ValueCommandCallbackInfo &obj) const;
            ValueCommandCallback callback; 
            void *parent; 
        };
 
        enum class DDOPUploadType
        {
            ProgramaticallyGenerated, 
            UserProvidedBinaryPointer, 
            UserProvidedVector 
        };
 
        std::shared_ptr<PartneredControlFunction> partnerControlFunction; 
        std::shared_ptr<InternalControlFunction> myControlFunction; 
        std::shared_ptr<PartneredControlFunction> primaryVirtualTerminal; 
        std::shared_ptr<DeviceDescriptorObjectPool> clientDDOP; 
        std::uint8_t const *userSuppliedBinaryDDOP = nullptr; 
        std::shared_ptr<std::vector<std::uint8_t>> userSuppliedVectorDDOP; 
        std::vector<std::uint8_t> generatedBinaryDDOP; 
        std::vector<RequestValueCommandCallbackInfo> requestValueCallbacks; 
        std::vector<ValueCommandCallbackInfo> valueCommandsCallbacks; 
        std::list<ProcessDataCallbackInfo> queuedValueRequests; 
        std::list<ProcessDataCallbackInfo> queuedValueCommands; 
        std::list<ProcessDataCallbackInfo> measurementTimeIntervalCommands; 
        std::list<ProcessDataCallbackInfo> measurementMinimumThresholdCommands; 
        std::list<ProcessDataCallbackInfo> measurementMaximumThresholdCommands; 
        std::list<ProcessDataCallbackInfo> measurementOnChangeThresholdCommands; 
        Mutex clientMutex; 
#if !defined CAN_STACK_DISABLE_THREADS && !defined ARDUINO
        std::thread *workerThread = nullptr; 
#endif
        std::string ddopStructureLabel; 
        std::string previousStructureLabel; 
        std::array<std::uint8_t, 7> ddopLocalizationLabel = { 0 }; 
        DDOPUploadType ddopUploadMode = DDOPUploadType::ProgramaticallyGenerated; 
        StateMachineState currentState = StateMachineState::Disconnected; 
        std::uint32_t stateMachineTimestamp_ms = 0; 
        std::uint32_t statusMessageTimestamp_ms = 0; 
        std::uint32_t serverStatusMessageTimestamp_ms = 0; 
        std::uint32_t userSuppliedBinaryDDOPSize_bytes = 0; 
        std::uint32_t languageCommandWaitingTimestamp_ms = 0; 
        std::uint8_t numberOfWorkingSetMembers = 1; 
        std::uint8_t tcStatusBitfield = 0; 
        std::uint8_t sourceAddressOfCommandBeingExecuted = 0; 
        std::uint8_t commandBeingExecuted = 0; 
        std::uint8_t serverVersion = 0; 
        std::uint8_t maxServerBootTime_s = 0; 
        std::uint8_t serverOptionsByte1 = 0; 
        std::uint8_t serverOptionsByte2 = 0; 
        std::uint8_t serverNumberOfBoomsForSectionControl = 0; 
        std::uint8_t serverNumberOfSectionsForSectionControl = 0; 
        std::uint8_t serverNumberOfChannelsForPositionBasedControl = 0; 
        std::uint8_t numberBoomsSupported = 0; 
        std::uint8_t numberSectionsSupported = 0; 
        std::uint8_t numberChannelsSupportedForPositionBasedControl = 0; 
        bool initialized = false; 
        bool shouldTerminate = false; 
        bool enableStatusMessage = false; 
        bool supportsDocumentation = false; 
        bool supportsTCGEOWithoutPositionBasedControl = false; 
        bool supportsTCGEOWithPositionBasedControl = false; 
        bool supportsPeerControlAssignment = false; 
        bool supportsImplementSectionControl = false; 
        bool shouldReuploadAfterDDOPDeletion = false; 
    };
} // namespace isobus
 
#endif // ISOBUS_TASK_CONTROLLER_CLIENT_HPP