ccsds_aos.h

Go to the documentation of this file.

// Copyright 2024-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <satcat5/crc16_checksum.h>
#include <satcat5/net_core.h>
#include <satcat5/pkt_buffer.h>
 
namespace satcat5 {
    namespace ccsds_aos {
        // Constants and conversion functions for specific fields.
        // (Refer to 732.0-B-4 Section 4.1 for details.)
        constexpr u16 VERSION_MASK  = 0xC000;   // Transfer Frame Version Number
        constexpr u16 SCID_MASK     = 0x3FC0;   // Spacecraft Identifier (SCID)
        constexpr u16 VCID_MASK     = 0x003F;   // Virtual Channel ID (VCID)
        constexpr u8 REPLAY_MASK    = 0x80;     // Replay flag
        constexpr u8 FRCT_EXT_MASK  = 0x40;     // Extended frame-count enable?
        constexpr u8 RSVD_MASK      = 0x30;     // Reserved (zeros)
        constexpr u8 FRCT_VAL_MASK  = 0x0F;     // Extended frame-count value
        constexpr u16 VERSION_2     = (1 << 14);
 
        constexpr u32 TM_SYNC_WORD  = 0x1ACFFC1D;
        constexpr u8 TM_SYNC_BYTES[] = {0x1A, 0xCF, 0xFC, 0x1D};
 
        // Special IDs for virtual channels:
        constexpr u16 VCID_DEFAULT  = 0x0000;   // Default channel
        constexpr u16 VCID_IDLE     = 0x003F;   // Virtual channel: Only idle data (OID)
 
        struct Header {
            u16 id;                 
            u8  signal;             
            u32 count;              
 
            constexpr Header()
                : id(0), signal(0), count(0) {}
            Header(const Header& t) = default;
            Header& operator=(const Header& t) = default;
            constexpr Header(u8 scid, u8 vcid)
                : id(VERSION_2 | pack_scid(scid) | pack_vcid(vcid))
                , signal(FRCT_EXT_MASK), count(0) {}
 
            static constexpr u32 pack_scid(u8 scid)
                { return (u16(scid) << 6) & SCID_MASK; }
            static constexpr u32 pack_vcid(u8 vcid)
                { return u16(vcid) & VCID_MASK; }
 
            // Convenience accessors.
            u16 version() const     
                { return id & VERSION_MASK; }
            u8 scid() const         
                { return u8((id & SCID_MASK) >> 6); }
            u8 vcid() const         
                { return u8(id & VCID_MASK); }
            bool replay() const     
                { return !!(signal & REPLAY_MASK); }
 
            void write_to(satcat5::io::Writeable* wr) const;
            bool read_from(satcat5::io::Readable* rd);
            Header& operator++();
        };
 
        class Channel final
            : public satcat5::io::EventListener
            , public satcat5::net::Protocol {
        public:
            Channel(
                satcat5::ccsds_aos::Dispatch* iface,    // Parent interface
                satcat5::io::Readable* src,             // Outgoing data buffer
                satcat5::io::Writeable* dst,            // Incoming data buffer
                u8 scid, u8 vcid, bool pkt);            // ID and mode-select
            ~Channel() SATCAT5_OPTIONAL_DTOR;
 
            void desync();
 
            void frame_rcvd(satcat5::io::LimitedRead& src) override;
 
            void set_wildcard();
 
        protected:
            // Required event handlers.
            void data_rcvd(satcat5::io::Readable* src) override;
            void data_unlink(satcat5::io::Readable* src) override;
            u8 idle_filler(satcat5::io::Writeable* dst, unsigned req);
            bool read_header(satcat5::io::Readable* src);
 
            // Internal state.
            enum class State {RAW, RESYNC, HEADER, DATA, SKIP};
            satcat5::ccsds_aos::Dispatch* const m_iface;
            satcat5::io::Readable* m_src;
            satcat5::io::Writeable* const m_dst;
            satcat5::io::ArrayWrite m_rx_spp;
            satcat5::ccsds_aos::Header m_rx_next;
            satcat5::ccsds_aos::Header m_tx_next;
            satcat5::ccsds_aos::Channel::State m_rx_state;
            unsigned m_rx_rem;
            u8  m_tx_busy;
            u8  m_tx_irem;
            u16 m_tx_iseq;
            u8  m_rx_tmp[6];
        };
 
        class Dispatch
            : public satcat5::io::EventListener
            , public satcat5::net::Dispatch {
        public:
            Dispatch(
                satcat5::io::Readable* src,     // Receive interface
                satcat5::io::Writeable* dst,    // Transmit interface
                u8* buff, unsigned dsize,       // Rx working buffer
                bool insert_sync = false);      // Insert TM sync word?
            ~Dispatch() SATCAT5_OPTIONAL_DTOR;
 
            satcat5::io::Writeable* open_write(
                const satcat5::ccsds_aos::Header& hdr);
 
            inline satcat5::io::TrafficStats stats()
                { return satcat5::io::TrafficStats::query(m_crc_rx, m_crc_tx); }
 
            // Other accessors.
            inline unsigned dsize() const   
                { return m_dsize; }
            inline void error_incr()        
                { m_crc_rx.error_incr(); }
            inline unsigned tsize() const   
                { return m_dsize + 6;}
            inline const satcat5::ccsds_aos::Header& rcvd_hdr() const
                { return m_rcvd_hdr; }      
 
        protected:
            // Required event handlers.
            void data_rcvd(satcat5::io::Readable* src) override;
            void data_unlink(satcat5::io::Readable* src) override;
            bool read_sync(satcat5::io::Readable* src);
            bool read_data(satcat5::io::Readable* src);
 
            // Stub required for the Dispatch API (not supported).
            satcat5::io::Writeable* open_reply(
                const satcat5::net::Type& type, unsigned len) override;
 
            // Synchronization and parser state.
            const unsigned m_dsize;
            const bool m_insert;
            u8 m_sync_state;
 
            // Sink and source objects for the parent interface.
            satcat5::io::Readable* m_src;
            satcat5::io::Writeable* const m_dst;
            satcat5::io::ArrayWrite m_work;
            satcat5::crc16::XmodemRx m_crc_rx;
            satcat5::crc16::XmodemTx m_crc_tx;
 
            // Store most recent received header parameters.
            satcat5::ccsds_aos::Header m_rcvd_hdr;
        };
 
        template<unsigned DSIZE=251>
        class DispatchStatic : public satcat5::ccsds_aos::Dispatch {
        public:
            DispatchStatic(
                satcat5::io::Readable* src,     // Input interface
                satcat5::io::Writeable* dst,    // Output interface
                bool insert_sync = false)       // Already packetized?
                : Dispatch(src, dst, m_raw, DSIZE, insert_sync), m_raw{} {}
        private:
            u8 m_raw[DSIZE+6];                  // Working buffer
        };
 
    }
}