CCSDSHeader.h

Go to the documentation of this file.

#ifndef CCSDS_HEADER_H
#define CCSDS_HEADER_H
 
#include <CCSDSResult.h>
#include <cstdint>
#include <vector>
 
namespace CCSDS {
  enum ESequenceFlag : std::uint8_t {
    CONTINUING_SEGMENT, 
    FIRST_SEGMENT,      
    LAST_SEGMENT,       
    UNSEGMENTED         
  };
 
  struct PrimaryHeader {
    // version and packet identification 16 bit 4 hex
    std::uint8_t versionNumber{};              
    std::uint8_t type{};                       
    std::uint8_t dataFieldHeaderFlag{};        
    std::uint16_t APID{};                      
 
    //packet sequence control 16 bit 4 hex
    std::uint8_t sequenceFlags{};              
    std::uint16_t sequenceCount{};             
 
    // data packet length
    std::uint16_t dataLength{};                
 
    PrimaryHeader(const std::uint8_t versionNumber_value, const std::uint8_t type_value, const std::uint8_t dataFieldHeaderFlag_value,
                  const std::uint16_t APID_value, const std::uint8_t sequenceFlag_value, const std::uint16_t sequenceCount_value,
                  const std::uint16_t dataLength_value) : versionNumber(versionNumber_value), type(type_value),
                                                     dataFieldHeaderFlag(dataFieldHeaderFlag_value),
                                                     APID(APID_value), sequenceFlags(sequenceFlag_value),
                                                     sequenceCount(sequenceCount_value),
                                                     dataLength(dataLength_value) {
    }
  };
 
  class Header {
  public:
    Header() = default;
 
    [[nodiscard]] std::uint8_t getVersionNumber()       const { return m_versionNumber;       } 
    [[nodiscard]] std::uint8_t getType()                const { return m_type;                } 
    [[nodiscard]] std::uint8_t getDataFieldHeaderFlag() const { return m_dataFieldHeaderFlag; } 
    [[nodiscard]] std::uint16_t getAPID()               const { return m_APID;                } 
    [[nodiscard]] std::uint8_t getSequenceFlags()       const { return m_sequenceFlags;       } 
    [[nodiscard]] std::uint16_t getSequenceCount()      const { return m_sequenceCount;       } 
    [[nodiscard]] std::uint16_t getDataLength()         const { return m_dataLength;          } 
 
    std::vector<std::uint8_t> serialize();
 
    std::uint64_t getFullHeader() {
      m_packetSequenceControl = (m_sequenceFlags << 14) | m_sequenceCount;
      m_packetIdentificationAndVersion = (m_versionNumber << 13) | (m_type << 12) | (m_dataFieldHeaderFlag << 11) |
                                         m_APID;
      return (static_cast<std::uint64_t>(m_packetIdentificationAndVersion) << 32) | (
               static_cast<std::uint32_t>(m_packetSequenceControl) << 16) | m_dataLength;
    }
 
    void setVersionNumber      ( const  std::uint8_t &value ) {       m_versionNumber = value & 0x0007; } 
    void setType               ( const  std::uint8_t &value ) {                m_type = value & 0x0001; } 
    void setDataFieldHeaderFlag( const  std::uint8_t &value ) { m_dataFieldHeaderFlag = value & 0x0001; } 
    void setAPID               ( const std::uint16_t &value ) {                m_APID = value & 0x07FF; } 
    void setSequenceFlags      ( const  std::uint8_t &value ) {       m_sequenceFlags = value & 0x0003; } 
    void setSequenceCount      ( const std::uint16_t &value ) {       m_sequenceCount = value & 0x3FFF; } 
    void setDataLength         ( const std::uint16_t &value ) {          m_dataLength = value;          } 
 
    [[nodiscard]] ResultBool setData(const std::uint64_t &data);
 
    [[nodiscard]] ResultBool deserialize(const std::vector<std::uint8_t> &data);
 
 
    void setData(const PrimaryHeader &data);
 
  private:
    // version and packet identification 16 bit 4 hex
    std::uint8_t m_versionNumber{};                    
 
    // packet identification 4 hex
    std::uint8_t m_type{};                             
    std::uint8_t m_dataFieldHeaderFlag{};              
    std::uint16_t m_APID{};                            
 
    // packet sequence control 16 bit 4 hex
    std::uint8_t m_sequenceFlags{UNSEGMENTED};         
    std::uint16_t m_sequenceCount{};                   
 
    // full packet size 48 bit fixed 6 byes
    std::uint16_t m_packetIdentificationAndVersion{};  
    std::uint16_t m_packetSequenceControl{};           
    std::uint16_t m_dataLength{};                      
  };
}
#endif // CCSDS_HEADER_H