nmea2000_fast_packet_protocol.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
 
#ifndef NMEA2000_FAST_PACKET_PROTOCOL_HPP
#define NMEA2000_FAST_PACKET_PROTOCOL_HPP
 
#include "isobus/isobus/can_transport_protocol_base.hpp"
#include "isobus/utility/event_dispatcher.hpp"
#include "isobus/utility/thread_synchronization.hpp"
 
namespace isobus
{
    class FastPacketProtocol
    {
    public:
        class FastPacketProtocolSession : public TransportProtocolSessionBase
        {
        public:
            FastPacketProtocolSession(TransportProtocolSessionBase::Direction direction,
                                      std::unique_ptr<CANMessageData> data,
                                      std::uint32_t parameterGroupNumber,
                                      std::uint16_t totalMessageSize,
                                      std::uint8_t sequenceNumber,
                                      CANIdentifier::CANPriority priority,
                                      std::shared_ptr<ControlFunction> source,
                                      std::shared_ptr<ControlFunction> destination,
                                      TransmitCompleteCallback sessionCompleteCallback,
                                      void *parentPointer);
 
            std::uint8_t get_message_length() const;
 
            std::uint32_t get_total_bytes_transferred() const override;
 
            bool is_broadcast() const;
 
        protected:
            friend class FastPacketProtocol; 
 
            std::uint8_t get_last_packet_number() const;
 
            std::uint8_t get_number_of_remaining_packets() const;
 
            std::uint8_t get_total_number_of_packets() const;
 
            void add_number_of_bytes_transferred(std::uint8_t bytes);
 
        private:
            std::uint8_t numberOfBytesTransferred = 0; 
            std::uint8_t sequenceNumber; 
            CANIdentifier::CANPriority priority; 
        };
 
        struct FastPacketHistory
        {
            NAME isoName; 
            std::uint32_t parameterGroupNumber; 
            std::uint8_t sequenceNumber; 
        };
 
        explicit FastPacketProtocol(const CANMessageFrameCallback &sendCANFrameCallback);
 
        void register_multipacket_message_callback(std::uint32_t parameterGroupNumber, CANLibCallback callback, void *parent, std::shared_ptr<InternalControlFunction> internalControlFunction = nullptr);
 
        // @brief Removes a callback previously added with register_multipacket_message_callback
        void remove_multipacket_message_callback(std::uint32_t parameterGroupNumber, CANLibCallback callback, void *parent, std::shared_ptr<InternalControlFunction> internalControlFunction = nullptr);
 
        bool send_multipacket_message(std::uint32_t parameterGroupNumber,
                                      const std::uint8_t *data,
                                      std::uint8_t messageLength,
                                      std::shared_ptr<InternalControlFunction> source,
                                      std::shared_ptr<ControlFunction> destination,
                                      CANIdentifier::CANPriority priority = CANIdentifier::CANPriority::PriorityDefault6,
                                      TransmitCompleteCallback txCompleteCallback = nullptr,
                                      void *parentPointer = nullptr,
                                      DataChunkCallback frameChunkCallback = nullptr);
 
        void allow_any_control_function(bool allow);
 
        void update();
 
        void process_message(const CANMessage &message);
 
        static std::uint8_t calculate_number_of_frames(std::uint8_t messageLength);
 
    private:
        void add_session_history(const std::shared_ptr<FastPacketProtocolSession> &session);
 
        void close_session(std::shared_ptr<FastPacketProtocolSession> session, bool successful);
 
        std::uint8_t get_new_sequence_number(NAME name, std::uint32_t parameterGroupNumber) const;
 
        std::shared_ptr<FastPacketProtocolSession> get_session(std::uint32_t parameterGroupNumber, std::shared_ptr<ControlFunction> source, std::shared_ptr<ControlFunction> destination);
 
        bool has_session(std::uint32_t parameterGroupNumber, std::shared_ptr<ControlFunction> source, std::shared_ptr<ControlFunction> destination);
 
        void update_session(const std::shared_ptr<FastPacketProtocolSession> &session);
 
        static constexpr std::uint32_t FP_MIN_PARAMETER_GROUP_NUMBER = 0x1F000; 
        static constexpr std::uint32_t FP_MAX_PARAMETER_GROUP_NUMBER = 0x1FFFF; 
        static constexpr std::uint32_t FP_TIMEOUT_MS = 750; 
        static constexpr std::uint8_t MAX_PROTOCOL_MESSAGE_LENGTH = 223; 
        static constexpr std::uint8_t FRAME_COUNTER_BIT_MASK = 0x1F; 
        static constexpr std::uint8_t SEQUENCE_NUMBER_BIT_MASK = 0x07; 
        static constexpr std::uint8_t SEQUENCE_NUMBER_BIT_OFFSET = 5; 
        static constexpr std::uint8_t PROTOCOL_BYTES_PER_FRAME = 7; 
 
        std::vector<std::shared_ptr<FastPacketProtocolSession>> activeSessions; 
        Mutex sessionMutex; 
        std::vector<FastPacketHistory> sessionHistory; 
        std::vector<ParameterGroupNumberCallbackData> parameterGroupNumberCallbacks; 
        bool allowAnyControlFunction = false; 
        const CANMessageFrameCallback sendCANFrameCallback; 
    };
 
} // namespace isobus
 
#endif // NMEA2000_FAST_PACKET_PROTOCOL_HPP