isobus_task_controller_server.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
#ifndef ISOBUS_TASK_CONTROLLER_SERVER_HPP
#define ISOBUS_TASK_CONTROLLER_SERVER_HPP
 
#include "isobus/isobus/can_constants.hpp"
#include "isobus/isobus/isobus_language_command_interface.hpp"
#include "isobus/isobus/isobus_task_controller_server_options.hpp"
 
#include <deque>
 
#include <condition_variable>
 
namespace isobus
{
    class TaskControllerServer
    {
    public:
        enum class ObjectPoolActivationError : std::uint8_t
        {
            NoErrors = 0x00,
            ThereAreErrorsInTheDDOP = 0x01,
            TaskControllerRanOutOfMemoryDuringActivation = 0x02,
            AnyOtherError = 0x04,
            DifferentDDOPExistsWithSameStructureLabel = 0x08
        };
 
        enum class ObjectPoolDeletionErrors : std::uint8_t
        {
            ObjectPoolIsReferencedByTaskData = 0,
            ServerCannotCheckForObjectPoolReferences = 1,
            ErrorDetailsNotAvailable = 0xFF
        };
 
        enum class ObjectPoolErrorCodes : std::uint8_t
        {
            NoErrors = 0x00,
            MethodOrAttributeNotSupported = 0x01,
            UnknownObjectReference = 0x02,
            AnyOtherError = 0x04,
            DDOPWasDeletedFromVolatileMemory = 0x08
        };
 
        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, 
            Reserved = 0x0B, 
            Reserved2 = 0x0C, 
            Acknowledge = 0x0D, 
            Status = 0x0E, 
            ClientTask = 0x0F 
        };
 
        enum class ServerOptions : std::uint8_t
        {
            SupportsDocumentation = 0x01,
            SupportsTCGEOWithoutPositionBasedControl = 0x02,
            SupportsTCGEOWithPositionBasedControl = 0x04,
            SupportsPeerControlAssignment = 0x08,
            SupportsImplementSectionControl = 0x10,
            ReservedOption1 = 0x20,
            ReservedOption2 = 0x40,
            ReservedOption3 = 0x80
        };
 
        enum class ProcessDataAcknowledgeErrorCodes : std::uint8_t
        {
            ProcessDataCommandNotSupported = 0x01,
            InvalidElementNumber = 0x02,
            DDINotSupportedByElement = 0x04,
            TriggerMethodNotSupported = 0x08,
            ProcessDataNotSettable = 0x10,
            InvalidOrUnsupportedIntervalOrThreshold = 0x20,
            ProcessDataValueDoesNotConformToDDIDefinition = 0x40,
            ProcessDataValueIsOutOfOperationalRangeOfThisDevice = 0x80
        };
 
        enum class TaskControllerVersion : std::uint8_t
        {
            DraftInternationalStandard = 0, 
            FinalDraftInternationalStandardFirstEdition = 1, 
            FirstPublishedEdition = 2, 
            SecondEditionDraft = 3, 
            SecondPublishedEdition = 4, 
            Unknown = 0xFF
        };
 
        TaskControllerServer(std::shared_ptr<InternalControlFunction> internalControlFunction,
                             std::uint8_t numberBoomsSupported,
                             std::uint8_t numberSectionsSupported,
                             std::uint8_t numberChannelsSupportedForPositionBasedControl,
                             const TaskControllerOptions &options,
                             TaskControllerVersion versionToReport = TaskControllerVersion::SecondPublishedEdition);
 
        virtual ~TaskControllerServer();
 
        TaskControllerServer(TaskControllerServer &) = delete;
 
        TaskControllerServer &operator=(const TaskControllerServer &) = delete;
 
        // **** Functions to be implemented by the consumer of the library ****
 
        virtual bool activate_object_pool(std::shared_ptr<ControlFunction> clientControlFunction, ObjectPoolActivationError &activationError, ObjectPoolErrorCodes &objectPoolError, std::uint16_t &parentObjectIDOfFaultyObject, std::uint16_t &faultyObjectID) = 0;
 
        virtual bool change_designator(std::shared_ptr<ControlFunction> clientControlFunction, std::uint16_t objectIDToAlter, const std::vector<std::uint8_t> &designator) = 0;
 
        virtual bool deactivate_object_pool(std::shared_ptr<ControlFunction> clientControlFunction) = 0;
 
        virtual bool delete_device_descriptor_object_pool(std::shared_ptr<ControlFunction> clientControlFunction, ObjectPoolDeletionErrors &returnedErrorCode) = 0;
 
        virtual bool get_is_stored_device_descriptor_object_pool_by_structure_label(std::shared_ptr<ControlFunction> clientControlFunction, const std::vector<std::uint8_t> &structureLabel, const std::vector<std::uint8_t> &extendedStructureLabel) = 0;
 
        virtual bool get_is_stored_device_descriptor_object_pool_by_localization_label(std::shared_ptr<ControlFunction> clientControlFunction, const std::array<std::uint8_t, 7> &localizationLabel) = 0;
 
        virtual bool get_is_enough_memory_available(std::uint32_t numberBytesRequired) = 0;
 
        virtual void identify_task_controller(std::uint8_t taskControllerNumber) = 0;
 
        virtual void on_client_timeout(std::shared_ptr<ControlFunction> clientControlFunction) = 0;
 
        virtual void on_process_data_acknowledge(std::shared_ptr<ControlFunction> clientControlFunction, std::uint16_t dataDescriptionIndex, std::uint16_t elementNumber, std::uint8_t errorCodesFromClient, ProcessDataCommands processDataCommand) = 0;
 
        virtual bool on_value_command(std::shared_ptr<ControlFunction> clientControlFunction, std::uint16_t dataDescriptionIndex, std::uint16_t elementNumber, std::int32_t processDataValue, std::uint8_t &errorCodes) = 0;
 
        virtual bool store_device_descriptor_object_pool(std::shared_ptr<ControlFunction> clientControlFunction, const std::vector<std::uint8_t> &objectPoolData, bool appendToPool) = 0;
 
        // **** Functions used to communicate with the client ****
 
        bool send_request_value(std::shared_ptr<ControlFunction> clientControlFunction, std::uint16_t dataDescriptionIndex, std::uint16_t elementNumber) const;
 
        bool send_time_interval_measurement_command(std::shared_ptr<ControlFunction> clientControlFunction, std::uint16_t dataDescriptionIndex, std::uint16_t elementNumber, std::uint32_t timeInterval) const;
 
        bool send_distance_interval_measurement_command(std::shared_ptr<ControlFunction> clientControlFunction, std::uint16_t dataDescriptionIndex, std::uint16_t elementNumber, std::uint32_t distanceInterval) const;
 
        bool send_minimum_threshold_measurement_command(std::shared_ptr<ControlFunction> clientControlFunction, std::uint16_t dataDescriptionIndex, std::uint16_t elementNumber, std::uint32_t minimum) const;
 
        bool send_maximum_threshold_measurement_command(std::shared_ptr<ControlFunction> clientControlFunction, std::uint16_t dataDescriptionIndex, std::uint16_t elementNumber, std::uint32_t maximum) const;
 
        bool send_change_threshold_measurement_command(std::shared_ptr<ControlFunction> clientControlFunction, std::uint16_t dataDescriptionIndex, std::uint16_t elementNumber, std::uint32_t threshold) const;
 
        bool send_set_value_and_acknowledge(std::shared_ptr<ControlFunction> clientControlFunction, std::uint16_t dataDescriptionIndex, std::uint16_t elementNumber, std::uint32_t processDataValue) const;
 
        bool send_set_value(std::shared_ptr<ControlFunction> clientControlFunction, std::uint16_t dataDescriptionIndex, std::uint16_t elementNumber, std::uint32_t processDataValue) const;
 
        void set_task_totals_active(bool isTaskActive);
 
        bool get_task_totals_active() const;
 
        LanguageCommandInterface &get_language_command_interface();
 
#if !defined CAN_STACK_DISABLE_THREADS && !defined ARDUINO
        std::condition_variable &get_condition_variable();
#endif
 
        // **** Functions used to initialize and run the server ****
 
        void initialize();
 
        bool get_initialized() const;
 
        void terminate();
 
        void update();
 
    protected:
        enum class ServerStatusBit : std::uint8_t
        {
            TaskTotalsActive = 0x01,
            BusySavingDataToNVM = 0x02,
            BusyReadingDataFromNVM = 0x04,
            BusyExecutingACommand = 0x08,
            OutOfMemory = 0x80,
        };
 
        enum class TechnicalDataCommandParameters : std::uint8_t
        {
            RequestVersion = 0x00, 
            ParameterVersion = 0x01, 
            IdentifyTaskController = 0x02 
        };
 
        enum class DeviceDescriptorCommandParameters : std::uint8_t
        {
            RequestStructureLabel = 0x00, 
            StructureLabel = 0x01, 
            RequestLocalizationLabel = 0x02, 
            LocalizationLabel = 0x03, 
            RequestObjectPoolTransfer = 0x04, 
            RequestObjectPoolTransferResponse = 0x05, 
            ObjectPoolTransfer = 0x06, 
            ObjectPoolTransferResponse = 0x07, 
            ObjectPoolActivateDeactivate = 0x08, 
            ObjectPoolActivateDeactivateResponse = 0x09, 
            DeleteObjectPool = 0x0A, 
            DeleteObjectPoolResponse = 0x0B, 
            ChangeDesignator = 0x0C, 
            ChangeDesignatorResponse = 0x0D 
        };
 
        class ActiveClient
        {
        public:
            explicit ActiveClient(std::shared_ptr<ControlFunction> clientControlFunction);
            std::shared_ptr<ControlFunction> clientControlFunction; 
            std::uint32_t lastStatusMessageTimestamp_ms = 0; 
            std::uint32_t clientDDOPsize_bytes = 0; 
            std::uint32_t statusBitfield = 0; 
            std::uint16_t numberOfObjectPoolSegments = 0; 
            bool isDDOPActive = false; 
        };
 
        static void store_rx_message(const CANMessage &message, void *parentPointer);
 
        void process_rx_messages();
 
        bool send_generic_process_data_default_payload(std::uint8_t multiplexer, std::shared_ptr<ControlFunction> destination) const;
 
        bool send_measurement_command(std::shared_ptr<ControlFunction> clientControlFunction, std::uint8_t commandValue, std::uint16_t dataDescriptionIndex, std::uint16_t elementNumber, std::uint32_t processDataValue) const;
 
        bool send_status_message() const;
 
        bool send_version(std::shared_ptr<ControlFunction> clientControlFunction) const;
 
        std::shared_ptr<ActiveClient> get_active_client(std::shared_ptr<ControlFunction> clientControlFunction) const;
 
        bool nack_process_data_command(std::shared_ptr<ControlFunction> clientControlFunction) const;
 
        bool send_structure_label(std::shared_ptr<ControlFunction> clientControlFunction, std::vector<std::uint8_t> &structureLabel, const std::vector<std::uint8_t> &extendedStructureLabel) const;
 
        bool send_localization_label(std::shared_ptr<ControlFunction> clientControlFunction, const std::array<std::uint8_t, 7> &localizationLabel) const;
 
        bool send_request_object_pool_transfer_response(std::shared_ptr<ControlFunction> clientControlFunction, bool isEnoughMemory) const;
 
        bool send_object_pool_transfer_response(std::shared_ptr<ControlFunction> clientControlFunction, std::uint8_t errorBitfield, std::uint32_t sizeBytes) const;
 
        bool send_object_pool_activate_deactivate_response(std::shared_ptr<ControlFunction> clientControlFunction,
                                                           std::uint8_t activationErrorBitfield,
                                                           std::uint8_t objectPoolErrorBitfield,
                                                           std::uint16_t parentOfFaultingObject,
                                                           std::uint16_t faultingObject) const;
 
        bool send_delete_object_pool_response(std::shared_ptr<ControlFunction> clientControlFunction, bool deletionResult, std::uint8_t errorCode) const;
 
        bool send_change_designator_response(std::shared_ptr<ControlFunction> clientControlFunction, std::uint16_t objectID, std::uint8_t errorCode) const;
 
        bool send_process_data_acknowledge(std::shared_ptr<ControlFunction> clientControlFunction, std::uint16_t dataDescriptionIndex, std::uint16_t elementNumber, std::uint8_t errorBitfield, ProcessDataCommands processDataCommand) const;
 
        bool send_process_data_to_client(std::shared_ptr<ControlFunction> clientControlFunction,
                                         const std::uint8_t *dataBuffer,
                                         std::uint32_t dataLength,
                                         CANIdentifier::CANPriority priority = CANIdentifier::CANPriority::Priority5) const;
 
        static constexpr std::uint32_t STATUS_MESSAGE_RATE_MS = 2000; 
 
        LanguageCommandInterface languageCommandInterface; 
        std::shared_ptr<InternalControlFunction> serverControlFunction; 
        std::deque<CANMessage> rxMessageQueue; 
        std::deque<std::shared_ptr<ActiveClient>> activeClients; 
#if !defined CAN_STACK_DISABLE_THREADS && !defined ARDUINO
        std::condition_variable updateWakeupCondition; 
        std::mutex messagesMutex; 
#endif
        std::uint32_t lastStatusMessageTimestamp_ms = 0; 
        const TaskControllerVersion reportedVersion; 
        const std::uint8_t numberBoomsSupportedToReport; 
        const std::uint8_t numberSectionsSupportedToReport; 
        const std::uint8_t numberChannelsSupportedForPositionBasedControlToReport; 
        const std::uint8_t optionsBitfieldToReport; 
        std::uint8_t currentStatusByte = 0; 
        std::uint8_t currentCommandByte = 0; 
        std::uint8_t currentCommandSourceAddress = NULL_CAN_ADDRESS; 
        bool initialized = false; 
    };
} // namespace isobus
 
#endif // ISOBUS_TASK_CONTROLLER_SERVER_HPP