net_telemetry.h

Go to the documentation of this file.

// Copyright 2023-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <satcat5/eth_socket.h>
#include <satcat5/io_cbor.h>
#include <satcat5/list.h>
#include <satcat5/polling.h>
#include <satcat5/types.h>
#include <satcat5/udp_socket.h>
 
// Enable this feature? (See types.h)
#if SATCAT5_CBOR_ENABLE
 
namespace satcat5 {
    namespace net {
        class TelemetryCbor final
            : public satcat5::cbor::MapWriter<s64>
            , public satcat5::cbor::MapWriter<const char*>
        {
        public:
            // Import specific functions to resolve ambiguous name issues.
            // (Explicitly include both variants, unless they're equivalent.)
            using satcat5::cbor::MapWriter<s64>::add_bool;
            using satcat5::cbor::MapWriter<s64>::add_item;
            using satcat5::cbor::MapWriter<s64>::add_array;
            using satcat5::cbor::MapWriter<s64>::add_bytes;
            using satcat5::cbor::MapWriter<s64>::add_string;
            using satcat5::cbor::MapWriter<s64>::add_null;
            using satcat5::cbor::MapWriter<s64>::close_list;
            using satcat5::cbor::MapWriter<s64>::close_map;
            using satcat5::cbor::MapWriter<s64>::open_list;
            using satcat5::cbor::MapWriter<s64>::open_map;
            using satcat5::cbor::MapWriter<const char*>::add_bool;
            using satcat5::cbor::MapWriter<const char*>::add_item;
            using satcat5::cbor::MapWriter<const char*>::add_array;
            using satcat5::cbor::MapWriter<const char*>::add_bytes;
            using satcat5::cbor::MapWriter<const char*>::add_string;
            using satcat5::cbor::MapWriter<const char*>::add_null;
            using satcat5::cbor::MapWriter<const char*>::open_list;
            using satcat5::cbor::MapWriter<const char*>::open_map;
 
            TelemetryCbor()
                : CborWriter(nullptr, &m_cbor, m_raw, SATCAT5_QCBOR_BUFFER, true) {}
 
        private:
            QCBOREncodeContext m_cbor;
            u8 m_raw[SATCAT5_QCBOR_BUFFER];
        };
 
        class TelemetrySink {
        public:
            virtual void telem_ready(
                u32 tier_id, unsigned nbytes, const void* data) = 0;
 
        protected:
            explicit TelemetrySink(satcat5::net::TelemetryAggregator* tlm);
            ~TelemetrySink() SATCAT5_OPTIONAL_DTOR;
 
            satcat5::net::TelemetryAggregator* const m_tlm;
 
        private:
            // Linked list of other TelemetrySink objects.
            friend satcat5::util::ListCore;
            satcat5::net::TelemetrySink* m_next;
        };
 
        class TelemetrySource {
        public:
            virtual void telem_event(
                u32 tier_id, satcat5::net::TelemetryCbor& cbor) = 0;
        };
 
        class TelemetryTier final {
        public:
            TelemetryTier(
                satcat5::net::TelemetryAggregator* tlm,
                satcat5::net::TelemetrySource* src,
                u32 tier_id, unsigned interval_msec = 0);
            ~TelemetryTier() SATCAT5_OPTIONAL_DTOR;
 
            void send_now();
 
            void set_interval(unsigned interval_msec);
 
            const u32 m_tier_id;
 
        private:
            // Event notifications from the TelemetryAggregator.
            friend satcat5::net::TelemetryAggregator;
            void telem_poll(satcat5::net::TelemetryCbor& cbor);
 
            // Linked list of other TelemetryTier objects.
            friend satcat5::util::ListCore;
            satcat5::net::TelemetryTier* m_next;
 
            // Internal state for this tier.
            satcat5::net::TelemetryAggregator* const m_tlm;
            satcat5::net::TelemetrySource* const m_src;
            unsigned m_time_interval;
            unsigned m_time_count;
        };
 
        class TelemetryAggregator : protected satcat5::poll::Timer {
        public:
            explicit TelemetryAggregator(bool concat_tiers);
 
            inline void telem_concat(bool concat_tiers)
                { m_tlm_concat = concat_tiers; }
 
            void telem_send(TelemetryCbor& cbor, u32 tier_id);
 
            inline unsigned timer_interval() const
                { return satcat5::poll::Timer::timer_interval(); }
 
        protected:
            // Timer event handler is called every N msec.
            void timer_event() override;
 
            // Set per-tier or concatenated mode for this aggregator.
            bool m_tlm_concat;
 
            // Linked-list of associated TelemetrySink objects.
            friend satcat5::net::TelemetrySink;
            satcat5::util::List<satcat5::net::TelemetrySink> m_sinks;
 
            // Linked-list of associated TelemetryTier objects.
            friend satcat5::net::TelemetryTier;
            satcat5::util::List<satcat5::net::TelemetryTier> m_tiers;
 
            // Statically allocated working buffer.
            u8 m_buff[SATCAT5_QCBOR_BUFFER];
        };
 
        class TelemetryWatcher {
        public:
            virtual void telem_rcvd(
                u32 key, const QCBORItem& item,
                QCBORDecodeContext* cbor) = 0;
 
        protected:
            explicit TelemetryWatcher(satcat5::net::TelemetryRx* rx);
            ~TelemetryWatcher() SATCAT5_OPTIONAL_DTOR;
 
            satcat5::net::TelemetryRx* const m_rx;
 
        private:
            // Linked list for the net::TelemetryRx class.
            friend satcat5::util::ListCore;
            satcat5::net::TelemetryWatcher* m_next;
        };
 
        struct TelemetryKey {
            explicit TelemetryKey(const char* label);
            TelemetryKey(const TelemetryKey& t) = default;
            TelemetryKey& operator=(const TelemetryKey& t) = default;
 
            const char* key;    
            const u32 hash;     
        };
 
        class TelemetryLogger : public satcat5::net::TelemetryWatcher {
        public:
            explicit TelemetryLogger(
                satcat5::net::TelemetryRx* rx, const char* kstr = nullptr);
            explicit TelemetryLogger(
                satcat5::net::TelemetryRx* rx, u32 key);
 
        protected:
            void telem_rcvd(
                u32 key, const QCBORItem& item,
                QCBORDecodeContext* cbor) override;
            satcat5::util::optional<u32> m_filter;
        };
 
        class TelemetryRx {
        public:
            inline void add_watcher(TelemetryWatcher* callback)
                { m_watchers.add(callback); }
            inline void remove_watcher(TelemetryWatcher* callback)
                { m_watchers.remove(callback); }
 
            void telem_packet(satcat5::io::LimitedRead& src);
 
        protected:
            TelemetryRx() {}
            ~TelemetryRx() {}
 
        private:
            void telem_item(QCBORDecodeContext* cbor, const QCBORItem& item);
 
            satcat5::util::List<satcat5::net::TelemetryWatcher> m_watchers;
        };
 
        class TelemetryLoopback : public satcat5::net::TelemetrySink {
        public:
            TelemetryLoopback(
                satcat5::net::TelemetryAggregator* src,
                satcat5::net::TelemetryRx* dst);
 
            void telem_ready(
                u32 tier_id, unsigned nbytes, const void* data) override;
 
        protected:
            satcat5::net::TelemetryRx* const m_dst;
        };
    }
 
    namespace eth {
        class Telemetry final
            : public satcat5::eth::AddressContainer
            , public satcat5::net::TelemetryAggregator
            , public satcat5::net::TelemetrySink
        {
        public:
            Telemetry(
                satcat5::eth::Dispatch* eth,        // Ethernet interface
                bool concat_tiers = true);          // Concatenate mode?
            ~Telemetry() {}
 
            inline void connect(
                const satcat5::eth::MacAddr& addr,
                const satcat5::eth::MacType& type,
                const satcat5::eth::VlanTag& vtag = satcat5::eth::VTAG_NONE)
                { m_addr.connect(addr, type, vtag); }
 
            inline void close()
                { m_addr.close(); }
 
        protected:
            // Event handler for the TelemetrySink API.
            void telem_ready(
                u32 tier_id, unsigned nbytes, const void* data) override
                { m_addr.write_packet(nbytes, data); }
        };
 
        class TelemetryRx final
            : public satcat5::net::Protocol
            , public satcat5::net::TelemetryRx
        {
        public:
            TelemetryRx(
                satcat5::eth::Dispatch* iface,
                const satcat5::eth::MacType& type);
            ~TelemetryRx() SATCAT5_OPTIONAL_DTOR;
 
        protected:
            // Required callback from net::Protocol.
            void frame_rcvd(satcat5::io::LimitedRead& src);
 
            satcat5::eth::Dispatch* const m_iface;
        };
    }
 
    namespace udp {
        class Telemetry final
            : public satcat5::udp::AddressContainer
            , public satcat5::net::TelemetryAggregator
            , public satcat5::net::TelemetrySink
        {
        public:
            Telemetry(
                satcat5::udp::Dispatch* udp,        // UDP interface
                bool concat_tiers = true);          // Concatenate mode?
            ~Telemetry() {}
 
            inline void connect(
                const satcat5::udp::Addr& dstaddr,
                const satcat5::udp::Port& dstport = satcat5::udp::PORT_CBOR_TLM,
                const satcat5::eth::VlanTag& vtag = satcat5::eth::VTAG_NONE)
                { m_addr.connect(dstaddr, dstport, satcat5::udp::PORT_NONE, vtag);}
 
            inline void close()
                { m_addr.close(); }
 
        protected:
            // Event handler for the TelemetrySink API.
            void telem_ready(
                u32 tier_id, unsigned nbytes, const void* data) override
                { m_addr.write_packet(nbytes, data); }
        };
 
        class TelemetryRx final
            : public satcat5::net::Protocol
            , public satcat5::net::TelemetryRx
        {
        public:
            explicit TelemetryRx(
                satcat5::udp::Dispatch* iface,
                const satcat5::udp::Port& port = satcat5::udp::PORT_CBOR_TLM);
            ~TelemetryRx() SATCAT5_OPTIONAL_DTOR;
 
        protected:
            // Required callback from net::Protocol.
            void frame_rcvd(satcat5::io::LimitedRead& src);
 
            satcat5::udp::Dispatch* const m_iface;
        };
    }
}
 
#endif // SATCAT5_CBOR_ENABLE