io_checksum.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_counter.h>
#include <satcat5/io_writeable.h>
#include <satcat5/utils.h>
 
namespace satcat5 {
    namespace io {
        class ChecksumTxCommon
            : public satcat5::io::CounterSimple
            , public satcat5::io::Writeable {
        public:
            // Implement the Writeable API:
            void write_abort() override;
 
        protected:
            constexpr explicit ChecksumTxCommon(satcat5::io::Writeable* dst)
                : m_dst(dst), m_ovr(false) {}
 
            bool chk_finalize();
 
            virtual void chk_reset() = 0;
 
            // Implement required API from Writeable:
            void write_overflow() override;
 
            // Internal state:
            satcat5::io::Writeable* const m_dst;    
            bool m_ovr;                             
        };
 
        template <class T, unsigned N>
        class ChecksumTx : public satcat5::io::ChecksumTxCommon {
        public:
            // Implement required API from Writeable:
            unsigned get_write_space() const override {
                // Reserve enough space to append FCS.
                unsigned nbytes = m_dst->get_write_space();
                return (m_ovr || nbytes < N) ? (0) : (nbytes - N);
            }
 
        protected:
            ChecksumTx(satcat5::io::Writeable* dst, T init)
                : ChecksumTxCommon(dst), m_chk(init), m_init(init)
            {
                // Nothing else to initialize
            }
 
            void chk_reset() override
                { m_chk = m_init; }
 
            // Templated internal state:
            T m_chk;                                
            const T m_init;                         
        };
 
        class ChecksumRxCommon
            : public satcat5::io::CounterSimple
            , public satcat5::io::Writeable {
        public:
            inline void error_incr()
                { ++m_err_ct; }
 
            // Implement required API from Writeable:
            unsigned get_write_space() const override;
            void write_abort() override;
 
        protected:
            constexpr explicit ChecksumRxCommon(satcat5::io::Writeable* dst)
                : m_dst(dst) {}
 
            // Reset the checksum calculation to its initial state.
            // Child MUST implement this method, since data type is unknown.
            virtual void chk_reset() = 0;
 
            // Internal state:
            satcat5::io::Writeable* const m_dst;    
        };
 
        template <class T, unsigned N>
        class ChecksumRx : public satcat5::io::ChecksumRxCommon {
        protected:
            ChecksumRx(satcat5::io::Writeable* dst, T init)
                : ChecksumRxCommon(dst), m_chk(init), m_init(init)
            {
                // Nothing else to initialize.
            }
 
            void chk_reset() override
                { m_chk = m_init; }
 
            inline bool sreg_match(T fcs) {
                // Does the calculated FCS match the last N bytes in SREG?
                constexpr T MASK = satcat5::util::mask_lower<T>(8*N);
                bool ok = (m_frm_len >= N) && ((fcs & MASK) == (m_sreg & MASK));
                // Reset internal state.
                unsigned len = m_frm_len - N;
                m_chk = m_init;
                m_frm_len = 0;
                // Call write_finalize() or write_abort().
                if (ok && m_dst->write_finalize()) {
                    m_byte_ct += len;
                    ++m_frm_ct;
                    return true;
                } else {
                    ++m_err_ct;
                    if (!ok) m_dst->write_abort();
                    return false;
                }
            }
 
            inline bool sreg_push(u8& data) {
                // FCS is in the last N bytes, but we can't predict end-of-frame.
                // Instead, buffer previous N bytes of input in a shift register.
                constexpr unsigned SHIFT = 8 * (N - 1);
                T tmp = static_cast<T>(data);       // Copy input...
                data = (u8)(m_sreg >> SHIFT);       // Pop oldest data
                m_sreg = (m_sreg << 8) | tmp;       // Push new data
                // Is the shift register currently full?
                if (m_frm_len++ < N) {
                    return false;                   // No update to CRC
                } else {
                    m_dst->write_u8(data);          // Forward popped data
                    return true;                    // Request CRC update
                }
            }
 
            // Templated internal state:
            T m_chk;                                
            const T m_init;                         
            T m_sreg;                               
        };
    }
}