can_extended_transport_protocol.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
 
#ifndef CAN_EXTENDED_TRANSPORT_PROTOCOL_HPP
#define CAN_EXTENDED_TRANSPORT_PROTOCOL_HPP
 
#include "isobus/isobus/can_message_frame.hpp"
#include "isobus/isobus/can_network_configuration.hpp"
#include "isobus/isobus/can_transport_protocol_base.hpp"
 
namespace isobus
{
    class ExtendedTransportProtocolManager
    {
    public:
        enum class StateMachineState
        {
            None, 
            SendRequestToSend, 
            WaitForClearToSend, 
            SendClearToSend, 
            WaitForDataPacketOffset, 
            SendDataPacketOffset, 
            WaitForDataTransferPacket, 
            SendDataTransferPackets, 
            WaitForEndOfMessageAcknowledge, 
        };
 
        enum class ConnectionAbortReason : std::uint8_t
        {
            Reserved = 0, 
            AlreadyInCMSession = 1, 
            SystemResourcesNeeded = 2, 
            Timeout = 3, 
            ClearToSendReceivedWhileTransferInProgress = 4, 
            MaximumRetransmitRequestLimitReached = 5, 
            UnexpectedDataTransferPacketReceived = 6, 
            BadSequenceNumber = 7, 
            DuplicateSequenceNumber = 8, 
            UnexpectedDataPacketOffsetReceived = 9, // Received a data packet offset outside the proper state
            UnexpectedDataPacketOffsetPGN = 10, 
            DataPacketOffsetExceedsClearToSend = 11, 
            BadDataPacketOffset = 12, 
            UnexpectedClearToSendPGN = 14, 
            NumberOfClearToSendPacketsExceedsMessage = 15, 
            AnyOtherError = 250 
        };
 
        class ExtendedTransportProtocolSession : public TransportProtocolSessionBase
        {
        public:
            using TransportProtocolSessionBase::TransportProtocolSessionBase; 
 
            StateMachineState get_state() const;
 
            std::uint32_t get_total_bytes_transferred() const override;
 
        protected:
            friend class ExtendedTransportProtocolManager; 
 
            void set_state(StateMachineState value);
 
            std::uint8_t get_dpo_number_of_packets_remaining() const;
 
            void set_dpo_number_of_packets(std::uint8_t value);
 
            std::uint8_t get_dpo_number_of_packets() const;
 
            std::uint8_t get_cts_number_of_packet_limit() const;
 
            void set_cts_number_of_packet_limit(std::uint8_t value);
 
            std::uint8_t get_last_sequence_number() const;
 
            std::uint32_t get_last_packet_number() const;
 
            void set_sequence_number_offset(std::uint32_t value);
 
            void set_last_sequency_number(std::uint8_t value);
 
            void set_acknowledged_packet_number(std::uint32_t value);
 
            std::uint32_t get_last_acknowledged_packet_number() const;
 
            std::uint32_t get_number_of_remaining_packets() const;
 
            std::uint32_t get_total_number_of_packets() const;
 
        private:
            StateMachineState state = StateMachineState::None; 
 
            std::uint32_t lastAcknowledgedPacketNumber = 0; 
            std::uint32_t sequenceNumberOffset = 0; 
            std::uint8_t lastSequenceNumber = 0; 
            std::uint8_t dataPacketOffsetPacketCount = 0; 
            std::uint8_t clearToSendPacketCountLimit = 0xFF; 
        };
 
        static constexpr std::uint32_t REQUEST_TO_SEND_MULTIPLEXOR = 0x14; 
        static constexpr std::uint32_t CLEAR_TO_SEND_MULTIPLEXOR = 0x15; 
        static constexpr std::uint32_t DATA_PACKET_OFFSET_MULTIPLXOR = 0x16; 
        static constexpr std::uint32_t END_OF_MESSAGE_ACKNOWLEDGE_MULTIPLEXOR = 0x17; 
        static constexpr std::uint32_t CONNECTION_ABORT_MULTIPLEXOR = 0xFF; 
        static constexpr std::uint32_t MAX_PROTOCOL_DATA_LENGTH = 117440505; 
        static constexpr std::uint16_t T1_TIMEOUT_MS = 750; 
        static constexpr std::uint16_t T2_T3_TIMEOUT_MS = 1250; 
        static constexpr std::uint16_t T4_TIMEOUT_MS = 1050; 
        static constexpr std::uint8_t TR_TIMEOUT_MS = 200; 
        static constexpr std::uint8_t SEQUENCE_NUMBER_DATA_INDEX = 0; 
        static constexpr std::uint8_t PROTOCOL_BYTES_PER_FRAME = 7; 
 
        ExtendedTransportProtocolManager(const CANMessageFrameCallback &sendCANFrameCallback,
                                         const CANMessageCallback &canMessageReceivedCallback,
                                         const CANNetworkConfiguration *configuration);
 
        void update();
 
        bool has_session(std::shared_ptr<ControlFunction> source, std::shared_ptr<ControlFunction> destination);
 
        const std::vector<std::shared_ptr<ExtendedTransportProtocolSession>> &get_sessions() const;
 
        void process_message(const CANMessage &message);
 
        bool protocol_transmit_message(std::uint32_t parameterGroupNumber,
                                       std::unique_ptr<CANMessageData> &data,
                                       std::shared_ptr<ControlFunction> source,
                                       std::shared_ptr<ControlFunction> destination,
                                       TransmitCompleteCallback sessionCompleteCallback,
                                       void *parentPointer);
 
    private:
        bool abort_session(std::shared_ptr<ExtendedTransportProtocolSession> &session, ConnectionAbortReason reason);
 
        bool send_abort(std::shared_ptr<InternalControlFunction> sender,
                        std::shared_ptr<ControlFunction> receiver,
                        std::uint32_t parameterGroupNumber,
                        ConnectionAbortReason reason) const;
 
        void close_session(std::shared_ptr<ExtendedTransportProtocolSession> &session, bool successful);
 
        bool send_request_to_send(std::shared_ptr<ExtendedTransportProtocolSession> &session) const;
 
        bool send_clear_to_send(std::shared_ptr<ExtendedTransportProtocolSession> &session) const;
 
        bool send_data_packet_offset(std::shared_ptr<ExtendedTransportProtocolSession> &session) const;
 
        bool send_end_of_session_acknowledgement(std::shared_ptr<ExtendedTransportProtocolSession> &session) const;
 
        void send_data_transfer_packets(std::shared_ptr<ExtendedTransportProtocolSession> &session) const;
 
        void process_request_to_send(const std::shared_ptr<ControlFunction> source, const std::shared_ptr<ControlFunction> destination, std::uint32_t parameterGroupNumber, std::uint32_t totalMessageSize);
 
        void process_clear_to_send(const std::shared_ptr<ControlFunction> source, const std::shared_ptr<ControlFunction> destination, std::uint32_t parameterGroupNumber, std::uint8_t packetsToBeSent, std::uint32_t nextPacketNumber);
 
        void process_data_packet_offset(const std::shared_ptr<ControlFunction> source, const std::shared_ptr<ControlFunction> destination, std::uint32_t parameterGroupNumber, std::uint8_t numberOfPackets, std::uint32_t packetOffset);
 
        void process_end_of_session_acknowledgement(const std::shared_ptr<ControlFunction> source, const std::shared_ptr<ControlFunction> destination, std::uint32_t parameterGroupNumber, std::uint32_t numberOfBytesTransferred);
 
        void process_abort(const std::shared_ptr<ControlFunction> source, const std::shared_ptr<ControlFunction> destination, std::uint32_t parameterGroupNumber, ExtendedTransportProtocolManager::ConnectionAbortReason reason);
 
        void process_connection_management_message(const CANMessage &message);
 
        void process_data_transfer_message(const CANMessage &message);
 
        std::shared_ptr<ExtendedTransportProtocolSession> get_session(std::shared_ptr<ControlFunction> source, std::shared_ptr<ControlFunction> destination);
 
        void update_state_machine(std::shared_ptr<ExtendedTransportProtocolSession> &session);
 
        std::vector<std::shared_ptr<ExtendedTransportProtocolSession>> activeSessions; 
        const CANMessageFrameCallback sendCANFrameCallback; 
        const CANMessageCallback canMessageReceivedCallback; 
        const CANNetworkConfiguration *configuration; 
    };
 
} // namespace isobus
 
#endif // CAN_EXTENDED_TRANSPORT_PROTOCOL_HPP