can_transport_protocol.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
 
#ifndef CAN_TRANSPORT_PROTOCOL_HPP
#define CAN_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 TransportProtocolManager
    {
    public:
        enum class StateMachineState
        {
            None, 
            SendBroadcastAnnounce, 
            SendRequestToSend, 
            WaitForClearToSend, 
            SendClearToSend, 
            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, 
            TotalMessageSizeTooBig = 9, 
            AnyOtherError = 250 
        };
 
        class TransportProtocolSession : public TransportProtocolSessionBase
        {
        public:
            TransportProtocolSession(TransportProtocolSessionBase::Direction direction,
                                     std::unique_ptr<CANMessageData> data,
                                     std::uint32_t parameterGroupNumber,
                                     std::uint16_t totalMessageSize,
                                     std::uint8_t clearToSendPacketMax,
                                     std::shared_ptr<ControlFunction> source,
                                     std::shared_ptr<ControlFunction> destination,
                                     TransmitCompleteCallback sessionCompleteCallback,
                                     void *parentPointer);
 
            StateMachineState get_state() const;
 
            std::uint16_t get_message_length() const;
 
            bool is_broadcast() const;
 
            std::uint32_t get_total_bytes_transferred() const override;
 
        protected:
            friend class TransportProtocolManager; 
 
            void set_state(StateMachineState value);
 
            std::uint8_t get_cts_number_of_packets_remaining() const;
 
            void set_cts_number_of_packets(std::uint8_t value);
 
            std::uint8_t get_cts_number_of_packets() const;
 
            std::uint8_t get_rts_number_of_packet_limit() const;
 
            std::uint8_t get_last_sequence_number() const;
 
            std::uint8_t get_last_packet_number() const;
 
            void set_last_sequency_number(std::uint8_t value);
 
            void set_acknowledged_packet_number(std::uint8_t value);
 
            std::uint8_t get_number_of_remaining_packets() const;
 
            std::uint8_t get_total_number_of_packets() const;
 
        private:
            StateMachineState state = StateMachineState::None; 
 
            std::uint8_t lastSequenceNumber = 0; 
            std::uint8_t lastAcknowledgedPacketNumber = 0; 
            std::uint8_t clearToSendPacketCount = 0; 
            std::uint8_t clearToSendPacketCountMax = 0xFF; 
        };
 
        static constexpr std::uint32_t REQUEST_TO_SEND_MULTIPLEXOR = 0x10; 
        static constexpr std::uint32_t CLEAR_TO_SEND_MULTIPLEXOR = 0x11; 
        static constexpr std::uint32_t END_OF_MESSAGE_ACKNOWLEDGE_MULTIPLEXOR = 0x13; 
        static constexpr std::uint32_t BROADCAST_ANNOUNCE_MESSAGE_MULTIPLEXOR = 0x20; 
        static constexpr std::uint32_t CONNECTION_ABORT_MULTIPLEXOR = 0xFF; 
        static constexpr std::uint32_t MAX_PROTOCOL_DATA_LENGTH = 1785; 
        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 R_TIMEOUT_MS = 200; 
        static constexpr std::uint8_t SEQUENCE_NUMBER_DATA_INDEX = 0; 
        static constexpr std::uint8_t PROTOCOL_BYTES_PER_FRAME = 7; 
 
        TransportProtocolManager(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<TransportProtocolSession>> &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<TransportProtocolSession> &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<TransportProtocolSession> &session, bool successful);
 
        bool send_broadcast_announce_message(std::shared_ptr<TransportProtocolSession> &session) const;
 
        bool send_request_to_send(std::shared_ptr<TransportProtocolSession> &session) const;
 
        bool send_clear_to_send(std::shared_ptr<TransportProtocolSession> &session) const;
 
        bool send_end_of_session_acknowledgement(std::shared_ptr<TransportProtocolSession> &session) const;
 
        void send_data_transfer_packets(std::shared_ptr<TransportProtocolSession> &session);
 
        void process_broadcast_announce_message(const std::shared_ptr<ControlFunction> source, std::uint32_t parameterGroupNumber, std::uint16_t totalMessageSize, std::uint8_t totalNumberOfPackets);
 
        void process_request_to_send(const std::shared_ptr<ControlFunction> source, const std::shared_ptr<ControlFunction> destination, std::uint32_t parameterGroupNumber, std::uint16_t totalMessageSize, std::uint8_t totalNumberOfPackets, std::uint8_t clearToSendPacketMax);
 
        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::uint8_t nextPacketNumber);
 
        void process_end_of_session_acknowledgement(const std::shared_ptr<ControlFunction> source, const std::shared_ptr<ControlFunction> destination, std::uint32_t parameterGroupNumber);
 
        void process_abort(const std::shared_ptr<ControlFunction> source, const std::shared_ptr<ControlFunction> destination, std::uint32_t parameterGroupNumber, TransportProtocolManager::ConnectionAbortReason reason);
 
        void process_connection_management_message(const CANMessage &message);
 
        void process_data_transfer_message(const CANMessage &message);
 
        std::shared_ptr<TransportProtocolSession> get_session(std::shared_ptr<ControlFunction> source, std::shared_ptr<ControlFunction> destination);
 
        void update_state_machine(std::shared_ptr<TransportProtocolSession> &session);
 
        std::vector<std::shared_ptr<TransportProtocolSession>> activeSessions; 
        const CANMessageFrameCallback sendCANFrameCallback; 
        const CANMessageCallback canMessageReceivedCallback; 
        const CANNetworkConfiguration *configuration; 
    };
 
} // namespace isobus
 
#endif // CAN_TRANSPORT_PROTOCOL_HPP