ccsds_spp.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/io_buffer.h>
#include <satcat5/net_core.h>
#include <satcat5/pkt_buffer.h>
 
namespace satcat5 {
    namespace ccsds_spp {
        // Constants and conversion functions for specific fields.
        // (Refer to 133.0-B-2 Section 4.1 for details.)
        constexpr u32 VERSION_MASK  = 0xE0000000u;  // Packet version number
        constexpr u32 TYPE_MASK     = 0x10000000u;  // Packet type (cmd/tlm)
        constexpr u32 SEC_HDR_FLAG  = 0x08000000u;  // Secondary header flag
        constexpr u32 APID_MASK     = 0x07FF0000u;  // APID field
        constexpr u32 SEQF_MASK     = 0x0000C000u;  // Sequence flags
        constexpr u32 SEQC_MASK     = 0x00003FFFu;  // Sequence count
        constexpr u32 VERSION_1     = (0 << 29);
        constexpr u32 TYPE_CMD      = (1 << 28);
        constexpr u32 TYPE_TLM      = (0 << 28);
        constexpr u32 SEQF_CONTINUE = (0 << 14);
        constexpr u32 SEQF_FIRST    = (1 << 14);
        constexpr u32 SEQF_LAST     = (2 << 14);
        constexpr u32 SEQF_UNSEG    = (3 << 14);
 
        // Reserved APID values:
        constexpr u16 APID_IDLE     = 0x7FF;        // Idle Packets
 
        struct Header {
            u32 value;              // All fields concatenated.
 
            Header() = default;
            Header(const Header& t) = default;
            Header& operator=(const Header& t) = default;
 
            static constexpr u32 pack_apid(u16 apid)
                { return (u32(apid) << 16) & APID_MASK; }
            static constexpr u32 pack_seqc(u16 seqc)
                { return u32(seqc) & SEQC_MASK; }
 
            // Convenience accessors.
            u32 version() const     
                { return value & VERSION_MASK; }
            bool type_cmd() const   
                { return (value & TYPE_MASK) == TYPE_CMD; }
            bool type_tlm() const   
                { return (value & TYPE_MASK) == TYPE_TLM; }
            bool sec_hdr() const    
                { return !!(value & SEC_HDR_FLAG); }
            u16 apid() const        
                { return u16((value & APID_MASK) >> 16); }
            u32 seqf() const        
                { return value & SEQF_MASK; }
            u16 seqc() const        
                { return u16(value & SEQC_MASK); }
 
            void set(bool cmd, u16 apid, u16 seq);
 
            Header& operator++();
        };
 
        class Packetizer
            : public satcat5::io::ReadableRedirect
            , public satcat5::io::Writeable
            , public satcat5::poll::Timer {
        public:
            inline satcat5::io::Writeable* bypass()
                { return &m_buff; }
 
            inline satcat5::io::Writeable* packet()
                { return this; }
 
            inline satcat5::io::EventListener* listen()
                { return &m_copy; }
 
            inline satcat5::io::Counter& counter()
                { return m_buff; }
 
            void flush();
 
            void reset();
 
            void set_timeout(unsigned timeout_msec)
                { m_timeout = timeout_msec; }
 
            // Required methods from the Writeable API.
            unsigned get_write_space() const override;
 
        protected:
            Packetizer(
                u8* buff, unsigned rxbytes, unsigned rxpkt,
                satcat5::io::Readable* src = nullptr);
 
            // Required event handlers.
            void timer_event() override;
            void write_next(u8 data) override;
 
            // Internal state:
            satcat5::io::BufferedCopy m_copy;   
            satcat5::io::PacketBuffer m_buff;   
            unsigned m_rem;         
            unsigned m_timeout;     
            u8 m_wridx;             
            u16 m_sreg;             
        };
 
        template<unsigned SIZE=1600>
        class PacketizerStatic : public satcat5::ccsds_spp::Packetizer {
        public:
            explicit PacketizerStatic(satcat5::io::Readable* src = nullptr)
                : Packetizer(m_raw, SIZE, 32, src), m_raw{} {}
        private:
            u8 m_raw[SIZE];
        };
 
        class Address : public satcat5::net::Address {
        public:
            explicit constexpr Address(satcat5::ccsds_spp::Dispatch* iface)
                : m_iface(iface), m_dst{0} {}
 
            inline void connect(bool cmd, u16 apid)
                { m_dst.set(cmd, apid, 0); }
 
            // Implement the required net::Address API.
            satcat5::net::Dispatch* iface() const override;
            satcat5::io::Writeable* open_write(unsigned len) override;
            void close() override;
            bool ready() const override;
            bool is_multicast() const override {return false;}
            bool matches_reply_address() const override;
            bool reply_is_multicast() const override {return false;}
            void save_reply_address() override;
 
        protected:
            satcat5::ccsds_spp::Dispatch* const m_iface;
            satcat5::ccsds_spp::Header m_dst;
        };
 
        class Dispatch final
            : public satcat5::io::EventListener
            , public satcat5::net::Dispatch {
        public:
            Dispatch(
                satcat5::io::Readable* src,
                satcat5::io::Writeable* dst);
            ~Dispatch() SATCAT5_OPTIONAL_DTOR;
 
            satcat5::io::Writeable* open_reply(
                const satcat5::net::Type& type, unsigned len) override;
 
            satcat5::io::Writeable* open_write(
                const satcat5::ccsds_spp::Header& hdr, unsigned len);
 
            inline const satcat5::ccsds_spp::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;
 
            // Sink and source objects for the parent interface.
            satcat5::io::Readable* m_src;
            satcat5::io::Writeable* const m_dst;
 
            // Store most recent received header parameters.
            satcat5::ccsds_spp::Header m_rcvd_hdr;
        };
 
        class Protocol : public satcat5::net::Protocol {
        protected:
            Protocol(satcat5::ccsds_spp::Dispatch* iface, u16 apid);
            ~Protocol() SATCAT5_OPTIONAL_DTOR;
 
            // Child class must define the frame_rcvd() method.
            // void frame_rcvd(satcat5::io::LimitedRead& src) override;
 
            satcat5::ccsds_spp::Dispatch* const m_iface;
        };
 
        class BytesToSpp {
        public:
            BytesToSpp(
                satcat5::io::Readable* src,
                satcat5::ccsds_spp::Dispatch* dst,
                bool cmd, u16 apid, unsigned max_chunk = 256);
 
            inline satcat5::io::BufferedStream* strm()
                { return &m_strm; }
 
        protected:
            satcat5::ccsds_spp::Address m_dst;
            satcat5::io::BufferedStream m_strm;
        };
 
        class SppToBytes : public satcat5::ccsds_spp::Protocol {
        public:
            SppToBytes(
                satcat5::ccsds_spp::Dispatch* src,
                satcat5::io::Writeable* dst, u16 apid);
 
            void frame_rcvd(satcat5::io::LimitedRead& src) override;
 
        protected:
            satcat5::io::Writeable* const m_dst;
        };
    }
}