nmea2000_message_definitions.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
#ifndef NMEA2000_MESSAGE_DEFINITIONS_HPP
#define NMEA2000_MESSAGE_DEFINITIONS_HPP
 
#include "isobus/isobus/can_internal_control_function.hpp"
 
#include <string>
 
namespace isobus
{
    namespace NMEA2000Messages
    {
        constexpr std::uint8_t MAX_SEQUENCE_ID = 252; 
 
        class VesselHeading
        {
        public:
            enum class HeadingSensorReference : std::uint8_t
            {
                True = 0, 
                Magnetic = 1, 
                Error = 2,
                NotApplicableOrNull = 3
            };
 
            explicit VesselHeading(std::shared_ptr<ControlFunction> source);
 
            std::shared_ptr<ControlFunction> get_control_function() const;
 
            std::uint32_t get_timestamp() const;
 
            bool set_timestamp(std::uint32_t timestamp);
 
            std::uint16_t get_raw_heading() const;
 
            float get_heading() const;
 
            bool set_heading(std::uint16_t heading);
 
            std::int16_t get_raw_magnetic_deviation() const;
 
            float get_magnetic_deviation() const;
 
            bool set_magnetic_deviation(std::int16_t deviation);
 
            std::int16_t get_raw_magnetic_variation() const;
 
            float get_magnetic_variation() const;
 
            bool set_magnetic_variation(std::int16_t variation);
 
            std::uint8_t get_sequence_id() const;
 
            bool set_sequence_id(std::uint8_t sequenceNumber);
 
            HeadingSensorReference get_sensor_reference() const;
 
            bool set_sensor_reference(HeadingSensorReference reference);
 
            void serialize(std::vector<std::uint8_t> &buffer) const;
 
            bool deserialize(const CANMessage &receivedMessage);
 
            static std::uint32_t get_timeout();
 
        private:
            static constexpr std::uint32_t CYCLIC_MESSAGE_RATE_MS = 100; 
 
            std::shared_ptr<ControlFunction> senderControlFunction; 
            std::uint32_t messageTimestamp_ms = 0; 
            std::uint16_t headingReading = 0; 
            std::int16_t magneticDeviation = 0; 
            std::int16_t magneticVariation = 0; 
            std::uint8_t sequenceID = 0; 
            HeadingSensorReference sensorReference = HeadingSensorReference::NotApplicableOrNull; 
        };
 
        class RateOfTurn
        {
        public:
            explicit RateOfTurn(std::shared_ptr<ControlFunction> source);
 
            std::shared_ptr<ControlFunction> get_control_function() const;
 
            std::uint32_t get_timestamp() const;
 
            bool set_timestamp(std::uint32_t timestamp);
 
            std::int32_t get_raw_rate_of_turn() const;
 
            double get_rate_of_turn() const;
 
            bool set_rate_of_turn(std::int32_t turnRate);
 
            std::uint8_t get_sequence_id() const;
 
            bool set_sequence_id(std::uint8_t sequenceNumber);
 
            void serialize(std::vector<std::uint8_t> &buffer) const;
 
            bool deserialize(const CANMessage &receivedMessage);
 
            static std::uint32_t get_timeout();
 
        private:
            static constexpr std::uint32_t CYCLIC_MESSAGE_RATE_MS = 100; 
 
            std::shared_ptr<ControlFunction> senderControlFunction; 
            std::uint32_t messageTimestamp_ms = 0; 
            std::int32_t rateOfTurn = 0; 
            std::uint8_t sequenceID = 0; 
        };
 
        class PositionRapidUpdate
        {
        public:
            explicit PositionRapidUpdate(std::shared_ptr<ControlFunction> source);
 
            static constexpr std::int32_t NOT_AVAILABLE = 0x7FFFFFFF; 
 
            std::shared_ptr<ControlFunction> get_control_function() const;
 
            std::uint32_t get_timestamp() const;
 
            bool set_timestamp(std::uint32_t timestamp);
 
            std::int32_t get_raw_latitude() const;
 
            double get_latitude() const;
 
            bool set_latitude(std::int32_t latitudeToSet);
 
            std::int32_t get_raw_longitude() const;
 
            double get_longitude() const;
 
            bool set_longitude(std::int32_t longitudeToSet);
 
            void serialize(std::vector<std::uint8_t> &buffer) const;
 
            bool deserialize(const CANMessage &receivedMessage);
 
            static std::uint32_t get_timeout();
 
        private:
            static constexpr std::uint32_t CYCLIC_MESSAGE_RATE_MS = 100; 
 
            std::shared_ptr<ControlFunction> senderControlFunction; 
            std::int32_t latitude = NOT_AVAILABLE; 
            std::int32_t longitude = NOT_AVAILABLE; 
            std::uint32_t messageTimestamp_ms = 0; 
        };
 
        class CourseOverGroundSpeedOverGroundRapidUpdate
        {
        public:
            enum class CourseOverGroundReference : std::uint8_t
            {
                True = 0, 
                Magnetic = 1, 
                Error = 2,
                NotApplicableOrNull = 3
            };
 
            explicit CourseOverGroundSpeedOverGroundRapidUpdate(std::shared_ptr<ControlFunction> source);
 
            std::shared_ptr<ControlFunction> get_control_function() const;
 
            std::uint32_t get_timestamp() const;
 
            bool set_timestamp(std::uint32_t timestamp);
 
            std::uint16_t get_raw_course_over_ground() const;
 
            float get_course_over_ground() const;
 
            bool set_course_over_ground(std::uint16_t course);
 
            std::uint16_t get_raw_speed_over_ground() const;
 
            float get_speed_over_ground() const;
 
            bool set_speed_over_ground(std::uint16_t speed);
 
            std::uint8_t get_sequence_id() const;
 
            bool set_sequence_id(std::uint8_t sequenceNumber);
 
            CourseOverGroundReference get_course_over_ground_reference() const;
 
            bool set_course_over_ground_reference(CourseOverGroundReference reference);
 
            void serialize(std::vector<std::uint8_t> &buffer) const;
 
            bool deserialize(const CANMessage &receivedMessage);
 
            static std::uint32_t get_timeout();
 
        private:
            static constexpr std::uint32_t CYCLIC_MESSAGE_RATE_MS = 250; 
 
            std::shared_ptr<ControlFunction> senderControlFunction; 
            std::uint32_t messageTimestamp_ms = 0; 
            std::uint16_t courseOverGround = 0; 
            std::uint16_t speedOverGround = 0; 
            std::uint8_t sequenceID = 0; 
            CourseOverGroundReference cogReference = CourseOverGroundReference::NotApplicableOrNull; 
        };
 
        class PositionDeltaHighPrecisionRapidUpdate
        {
        public:
            explicit PositionDeltaHighPrecisionRapidUpdate(std::shared_ptr<ControlFunction> source);
 
            std::shared_ptr<ControlFunction> get_control_function() const;
 
            std::uint32_t get_timestamp() const;
 
            bool set_timestamp(std::uint32_t timestamp);
 
            std::int32_t get_raw_latitude_delta() const;
 
            double get_latitude_delta() const;
 
            bool set_latitude_delta(std::int32_t delta);
 
            std::int32_t get_raw_longitude_delta() const;
 
            double get_longitude_delta() const;
 
            bool set_longitude_delta(std::int32_t delta);
 
            std::uint8_t get_sequence_id() const;
 
            bool set_sequence_id(std::uint8_t sequenceNumber);
 
            std::uint8_t get_raw_time_delta() const;
 
            double get_time_delta() const;
 
            bool set_time_delta(std::uint8_t delta);
 
            void serialize(std::vector<std::uint8_t> &buffer) const;
 
            bool deserialize(const CANMessage &receivedMessage);
 
            static std::uint32_t get_timeout();
 
        private:
            static constexpr std::uint32_t CYCLIC_MESSAGE_RATE_MS = 250; 
 
            std::shared_ptr<ControlFunction> senderControlFunction; 
            std::uint32_t messageTimestamp_ms = 0; 
            std::int32_t latitudeDelta = 0; 
            std::int32_t longitudeDelta = 0; 
            std::uint8_t sequenceID = 0; 
            std::uint8_t timeDelta = 0; 
        };
 
        class GNSSPositionData
        {
        public:
            enum class TypeOfSystem
            {
                GPS = 0x00, 
                GLONASS = 0x01, 
                GPSPlusGLONASS = 0x02, 
                GPSPlusSBAS = 0x03, 
                GPSPlusSBASPlusGLONASS = 0x04, 
                Chayka = 0x05, 
                Integrated = 0x06, 
                Surveyed = 0x07,
                Galileo = 0x08, 
                Null = 0x0F
            };
 
            enum class GNSSMethod
            {
                NoGNSS = 0x00, 
                GNSSFix = 0x01, 
                DGNSSFix = 0x02, 
                PreciseGNSS = 0x03, 
                RTKFixedInteger = 0x04, 
                RTKFloat = 0x05, 
                EstimatedMode = 0x06, 
                ManualInput = 0x07,
                SimulateMode = 0x08,
                Null = 0x0F
            };
 
            enum class Integrity
            {
                NoIntegrityChecking = 0x00,
                Safe = 0x01,
                Caution = 0x02,
                Unsafe = 0x03
            };
 
            explicit GNSSPositionData(std::shared_ptr<ControlFunction> source);
 
            std::shared_ptr<ControlFunction> get_control_function() const;
 
            std::int64_t get_raw_altitude() const;
 
            double get_altitude() const;
 
            bool set_altitude(std::int64_t altitudeToSet);
 
            std::int64_t get_raw_latitude() const;
 
            double get_latitude() const;
 
            bool set_latitude(std::int64_t latitudeToSet);
 
            std::int64_t get_raw_longitude() const;
 
            double get_longitude() const;
 
            bool set_longitude(std::int64_t longitudeToSet);
 
            std::int32_t get_raw_geoidal_separation() const;
 
            float get_geoidal_separation() const;
 
            bool set_geoidal_separation(std::int32_t separation);
 
            std::uint32_t get_timestamp() const;
 
            bool set_timestamp(std::uint32_t timestamp);
 
            std::uint8_t get_sequence_id() const;
 
            bool set_sequence_id(std::uint8_t sequenceNumber);
 
            TypeOfSystem get_type_of_system() const;
 
            bool set_type_of_system(TypeOfSystem type);
 
            GNSSMethod get_gnss_method() const;
 
            bool set_gnss_method(GNSSMethod gnssFixMethod);
 
            Integrity get_integrity() const;
 
            bool set_integrity(Integrity integrity);
 
            std::uint8_t get_number_of_space_vehicles() const;
 
            bool set_number_of_space_vehicles(std::uint8_t numberOfSVs);
 
            std::int16_t get_raw_horizontal_dilution_of_precision() const;
 
            float get_horizontal_dilution_of_precision() const;
 
            bool set_horizontal_dilution_of_precision(std::int16_t hdop);
 
            std::int16_t get_raw_positional_dilution_of_precision() const;
 
            float get_positional_dilution_of_precision() const;
 
            bool set_positional_dilution_of_precision(std::int16_t pdop);
 
            std::uint8_t get_number_of_reference_stations() const;
 
            bool set_number_of_reference_stations(std::uint8_t stations);
 
            std::uint16_t get_reference_station_id(std::size_t index) const;
 
            std::uint16_t get_raw_reference_station_corrections_age(std::size_t index) const;
 
            float get_reference_station_corrections_age(std::size_t index) const;
 
            TypeOfSystem get_reference_station_system_type(std::size_t index) const;
 
            bool set_reference_station(std::size_t index, std::uint16_t ID, TypeOfSystem type, std::uint16_t ageOfCorrections);
 
            std::uint16_t get_position_date() const;
 
            bool set_position_date(std::uint16_t dateToSet);
 
            std::uint32_t get_raw_position_time() const;
 
            double get_position_time() const;
 
            bool set_position_time(std::uint32_t timeToSet);
 
            void serialize(std::vector<std::uint8_t> &buffer) const;
 
            bool deserialize(const CANMessage &receivedMessage);
 
            static std::uint32_t get_timeout();
 
        private:
            class ReferenceStationData
            {
            public:
                ReferenceStationData() = default;
 
                ReferenceStationData(std::uint16_t id, TypeOfSystem type, std::uint16_t age);
                std::uint16_t stationID = 0; 
                TypeOfSystem stationType = TypeOfSystem::Null; 
                std::uint16_t ageOfDGNSSCorrections = 0xFFFF; 
            };
 
            static constexpr std::uint32_t CYCLIC_MESSAGE_RATE_MS = 1000; 
            static constexpr std::uint8_t MINIMUM_LENGTH_BYTES = 43; 
 
            std::shared_ptr<ControlFunction> senderControlFunction; 
            std::vector<ReferenceStationData> referenceStations; 
            std::int64_t altitude = 0; 
            std::int64_t latitude = 0; 
            std::int64_t longitude = 0; 
            std::uint32_t messageTimestamp_ms = 0; 
            std::uint32_t positionTime = 0; 
            std::int32_t geoidalSeparation = 0; 
            std::uint16_t positionDate = 0; 
            std::int16_t horizontalDilutionOfPrecision = 0; 
            std::int16_t positionalDilutionOfPrecision = 0; 
            std::uint8_t numberOfSpaceVehicles = 0; 
            std::uint8_t sequenceID = 0; 
            TypeOfSystem systemType = TypeOfSystem::Null; 
            GNSSMethod method = GNSSMethod::NoGNSS; 
            Integrity integrityChecking = Integrity::NoIntegrityChecking; 
        };
 
        class Datum
        {
        public:
            explicit Datum(std::shared_ptr<ControlFunction> source);
 
            std::shared_ptr<ControlFunction> get_control_function() const;
 
            std::string get_local_datum() const;
 
            bool set_local_datum(const std::string &datum);
 
            std::string get_reference_datum() const;
 
            bool set_reference_datum(const std::string &datum);
 
            std::int32_t get_raw_delta_latitude() const;
 
            double get_delta_latitude() const;
 
            bool set_delta_latitude(std::int32_t delta);
 
            std::int32_t get_raw_delta_longitude() const;
 
            double get_delta_longitude() const;
 
            bool set_delta_longitude(std::int32_t delta);
 
            std::int32_t get_raw_delta_altitude() const;
 
            float get_delta_altitude() const;
 
            bool set_delta_altitude(std::int32_t delta);
 
            std::uint32_t get_timestamp() const;
 
            bool set_timestamp(std::uint32_t timestamp);
 
            void serialize(std::vector<std::uint8_t> &buffer) const;
 
            bool deserialize(const CANMessage &receivedMessage);
 
            static std::uint32_t get_timeout();
 
        private:
            static constexpr std::uint32_t CYCLIC_MESSAGE_RATE_MS = 10000; 
            static constexpr std::uint8_t LENGTH_BYTES = 20; 
            static constexpr std::uint8_t DATUM_STRING_LENGTHS = 4; 
 
            std::shared_ptr<ControlFunction> senderControlFunction; 
            std::string localDatum; 
            std::string referenceDatum; 
            std::int32_t deltaLatitude = 0; 
            std::int32_t deltaLongitude = 0; 
            std::int32_t deltaAltitude = 0; 
            std::uint32_t messageTimestamp_ms = 0; 
        };
    } // namespace NMEA2000Messages
} // namespace isobus
#endif // NMEA2000_MESSAGE_DEFINITIONS_HPP