ComAggregator.hpp

Go to the documentation of this file.

// ======================================================================
// \title  ComAggregator.hpp
// \author lestarch
// \brief  hpp file for ComAggregator component implementation class
// ======================================================================

#ifndef Svc_ComAggregator_HPP
#define Svc_ComAggregator_HPP

#include <algorithm>
#include <atomic>
#include "Fw/Types/MemAllocator.hpp"
#include "Os/Mutex.hpp"
#include "Svc/Ccsds/Types/FppConstantsAc.hpp"
#include "Svc/Ccsds/Types/SpacePacketHeaderSerializableAc.hpp"
#include "Svc/Ccsds/Utils/IdlePacket.hpp"
#include "Svc/ComAggregator/ComAggregatorComponentAc.hpp"

namespace Svc {

class ComAggregator final : public ComAggregatorComponentBase {
    friend class ComAggregatorTester;  // Allow unit test access to private members
  public:
    // ----------------------------------------------------------------------
    // Component construction and destruction
    // ----------------------------------------------------------------------

    ComAggregator(const char* const compName  
    );

    ~ComAggregator();

    void configure(FwSizeType aggregationSize,    
                   bool spanningEnabled,          
                   FwEnumStoreType allocationId,  
                   Fw::MemAllocator& allocator    
    );

    void cleanup();

    void preamble() override;

    static constexpr FwSizeType MIN_NON_SPANNING_AGGREGATION_SIZE =
        std::max(static_cast<FwSizeType>(FW_COM_BUFFER_MAX_SIZE), static_cast<FwSizeType>(FW_FILE_BUFFER_MAX_SIZE)) +
        static_cast<FwSizeType>(Ccsds::SpacePacketHeader::SERIALIZED_SIZE) + Ccsds::Utils::IdlePacket::MIN_SIZE;

  private:
    // ----------------------------------------------------------------------
    // Handler implementations for typed input ports
    // ----------------------------------------------------------------------

    void comStatusIn_handler(FwIndexType portNum,    
                             Fw::Success& condition  
                             ) override;

    void dataIn_handler(FwIndexType portNum,  
                        Fw::Buffer& data,
                        const ComCfg::FrameContext& context) override;

    void dataReturnIn_handler(FwIndexType portNum,  
                              Fw::Buffer& data,
                              const ComCfg::FrameContext& context) override;

    void timeout_handler(FwIndexType portNum,  
                         U32 context           
                         ) override;

  private:
    // ----------------------------------------------------------------------
    // Implementations for internal state machine actions
    // ----------------------------------------------------------------------

    void Svc_AggregationMachine_action_doClear(SmId smId,                             
                                               Svc_AggregationMachine::Signal signal  
                                               ) override;

    void Svc_AggregationMachine_action_doFill(SmId smId,                              
                                              Svc_AggregationMachine::Signal signal,  
                                              const Svc::ComDataContextPair& value    
                                              ) override;

    void Svc_AggregationMachine_action_doSend(SmId smId,                             
                                              Svc_AggregationMachine::Signal signal  
                                              ) override;

    void Svc_AggregationMachine_action_doHold(SmId smId,                              
                                              Svc_AggregationMachine::Signal signal,  
                                              const Svc::ComDataContextPair& value    
                                              ) override;

    void Svc_AggregationMachine_action_doSplitHold(SmId smId,                              
                                                   Svc_AggregationMachine::Signal signal,  
                                                   const Svc::ComDataContextPair& value    
                                                   ) override;

    void Svc_AggregationMachine_action_doNoteFailure(SmId smId,                             
                                                     Svc_AggregationMachine::Signal signal  
                                                     ) override;

    void Svc_AggregationMachine_action_assertNoStatus(SmId smId,                             
                                                      Svc_AggregationMachine::Signal signal  
                                                      ) override;

  private:
    // ----------------------------------------------------------------------
    // Implementations for internal state machine guards
    // ----------------------------------------------------------------------

    bool Svc_AggregationMachine_guard_isFull(SmId smId,                              
                                             Svc_AggregationMachine::Signal signal,  
                                             const Svc::ComDataContextPair& value    
    ) const override;

    bool Svc_AggregationMachine_guard_willFill(SmId smId,                              
                                               Svc_AggregationMachine::Signal signal,  
                                               const Svc::ComDataContextPair& value    
    ) const override;

    bool Svc_AggregationMachine_guard_isNotEmpty(SmId smId,                             
                                                 Svc_AggregationMachine::Signal signal  
    ) const override;

    bool Svc_AggregationMachine_guard_isGood(SmId smId,                              
                                             Svc_AggregationMachine::Signal signal,  
                                             const Fw::Success& value                
    ) const override;

    bool Svc_AggregationMachine_guard_isSpanFull(SmId smId,                             
                                                 Svc_AggregationMachine::Signal signal  
    ) const override;

  private:
    // ----------------------------------------------------------------------
    // Helper functions
    // ----------------------------------------------------------------------

    FwSizeType remainingCapacity() const;

    bool accepts(FwSizeType size) const;

    void markFirstHeaderIfUnset();

    void fillFromHeld();

    void fillResidualWithIdle();

    void returnAndSignalReady(const Svc::ComDataContextPair& pair);

    void dropLostFrameState();

  private:
    static constexpr U16 FHP_UNSET = 0xFFFF;  

    Fw::MemAllocator* m_allocator;   
    FwEnumStoreType m_allocationId;  
    void* m_allocation;              
    std::atomic<Fw::Buffer::OwnershipState> m_bufferState{
        Fw::Buffer::OwnershipState::OWNED};  
    Fw::Buffer m_frameBuffer;
    Fw::ExternalSerializeBufferWithMemberCopy m_frameSerializer;  
    ComCfg::FrameContext m_lastContext;                           

    Svc::ComDataContextPair m_held;     
    std::atomic<bool> m_allow_timeout;  

    bool m_spanning;               
    FwSizeType m_aggregationSize;  
    FwSizeType m_heldOffset;       
    U16 m_fhp;                     
    U8 m_pendingIdle[Ccsds::Utils::IdlePacket::MIN_SIZE] = {};  
    FwSizeType m_pendingIdleCount;                              
    FwSizeType m_leadingIdleCount;  
    bool m_lastFrameLost;           
};

}  // namespace Svc

#endif