TlmPacketizer.hpp

Go to the documentation of this file.

// ======================================================================
// \title  TlmPacketizerImpl.hpp
// \author tcanham
// \brief  hpp file for TlmPacketizer component implementation class
//
// \copyright
// Copyright 2009-2015, by the California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.

#ifndef TlmPacketizer_HPP
#define TlmPacketizer_HPP

#include "Fw/DataStructures/Array.hpp"
#include "Fw/DataStructures/RedBlackTreeMap.hpp"
#include "Fw/Prm/PrmExternalTypes.hpp"
#include "Fw/Types/EnabledEnumAc.hpp"
#include "Os/Mutex.hpp"
#include "Svc/TlmPacketizer/TlmPacketizerComponentAc.hpp"
#include "Svc/TlmPacketizer/TlmPacketizerTypes.hpp"
#include "Svc/TlmPacketizer/TlmPacketizer_TelemetrySendPortMapArrayAc.hpp"
#include "TlmPacketizerConfig/FppConstantsAc.hpp"
#include "TlmPacketizerConfig/TlmPacketizerCfg.hpp"

namespace Svc {

constexpr Svc::TlmPacketizerPacket IGNORE_OMIT_LIST = {nullptr, 0, 0, 0};

class TlmPacketizer final : public TlmPacketizerComponentBase, public Fw::ParamExternalDelegate {
    friend class TlmPacketizerTester;

  public:
    // ----------------------------------------------------------------------
    // Construction, initialization, and destruction
    // ----------------------------------------------------------------------

    TlmPacketizer(const char* const compName 
    );

    void setPacketList(
        const TlmPacketizerPacketList& packetList,   // channels to packetize
        const Svc::TlmPacketizerPacket& ignoreList,  // channels to ignore (i.e. no warning event if not packetized)
        const FwChanIdType startLevel                // starting level of packets to send
    );

    ~TlmPacketizer();

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

    void TlmRecv_handler(const FwIndexType portNum, 
                         FwChanIdType id,           
                         Fw::Time& timeTag,         
                         Fw::TlmBuffer& val         
                         ) override;

    void configureSectionGroupRate_handler(
        FwIndexType portNum,                   
        const Svc::TelemetrySection& section,  
        FwChanIdType tlmGroup,                 
        const Svc::RateLogic& rateLogic,       
        U32 minDelta,  
        U32 maxDelta   
        ) override;

    void Run_handler(const FwIndexType portNum, 
                     U32 context                
                     ) override;

    void controlIn_handler(FwIndexType portNum,                   
                           const Svc::TelemetrySection& section,  
                           const Fw::Enabled& enabled             
                           ) override;

    void pingIn_handler(const FwIndexType portNum, 
                        U32 key                    
                        ) override;

    Fw::TlmValid TlmGet_handler(FwIndexType portNum,  
                                FwChanIdType id,      
                                Fw::Time& timeTag,    
                                Fw::TlmBuffer& val    
                                ) override;

    void SET_LEVEL_cmdHandler(FwOpcodeType opCode,  
                              U32 cmdSeq,           
                              FwChanIdType level    
                              ) override;

    void SEND_PKT_cmdHandler(FwOpcodeType opCode,                  
                             U32 cmdSeq,                           
                             U32 id,                               
                             const Svc::TelemetrySection& section  
                             ) override;

    void ENABLE_SECTION_cmdHandler(FwOpcodeType opCode,                   
                                   U32 cmdSeq,                            
                                   const Svc::TelemetrySection& section,  
                                   const Fw::Enabled& enable              
                                   ) override;

    void ENABLE_GROUP_cmdHandler(FwOpcodeType opCode,                   
                                 U32 cmdSeq,                            
                                 const Svc::TelemetrySection& section,  
                                 FwChanIdType tlmGroup,                 
                                 const Fw::Enabled& enable              
                                 ) override;

    void FORCE_GROUP_cmdHandler(FwOpcodeType opCode,                   
                                U32 cmdSeq,                            
                                const Svc::TelemetrySection& section,  
                                FwChanIdType tlmGroup,                 
                                const Fw::Enabled& enable              
                                ) override;

    void CONFIGURE_GROUP_RATES_cmdHandler(
        FwOpcodeType opCode,                   
        U32 cmdSeq,                            
        const Svc::TelemetrySection& section,  
        FwChanIdType tlmGroup,                 
        const Svc::RateLogic& rateLogic,       
        U32 minDelta,  
        U32 maxDelta   
        ) override;

    // number of packets to fill
    FwChanIdType m_numPackets;
    // Array of packet buffers to send
    // Double-buffered to fill one while sending one

    struct BufferEntry {
        Fw::ComBuffer buffer;  
        Fw::Time latestTime;   
        FwChanIdType id;       
        FwChanIdType level;    
        bool updated;          
    };

    // buffers for filling with telemetry
    BufferEntry m_fillBuffers[MAX_PACKETIZER_PACKETS];

    static constexpr U16 NOT_IN_PACKET = std::numeric_limits<U16>::max();  

    struct TlmEntry {
        FwChanIdType id;  
        // Offsets into packet buffers.
        // NOT_IN_PACKET means that channel is not in that packet
        U16 packetOffset[MAX_PACKETIZER_PACKETS];
        FwSizeType channelSize;  
        bool ignored;            
        bool hasValue;           
    };

    Os::Mutex m_lock;  

    bool m_configured;  

    struct MissingTlmChan {
        FwChanIdType id;
        bool checked;
    } m_missTlmCheck[TLMPACKETIZER_MAX_MISSING_TLM_CHECK];

    void missingChannel(FwChanIdType id);  

    TlmPacketizer_SectionEnabled m_sectionEnabled{};

    TlmPacketizer_SectionConfigs m_groupConfigs{};

    enum UpdateFlag : U8 {
        NEVER_UPDATED = 0,  
        PAST = 1,           
        NEW = 2,            
        REQUESTED = 3,      
    };

    struct PktSendCounters {
        U32 prevSentCounter = std::numeric_limits<U32>::max();  // Prevent Start up spam
        UpdateFlag updateFlag = UpdateFlag::NEVER_UPDATED;
    } m_packetFlags[TelemetrySection::NUM_SECTIONS][MAX_PACKETIZER_PACKETS]{};

    static const TlmPacketizer_TelemetrySendPortMap TELEMETRY_SEND_PORT_MAP;

  private:
    Fw::SerializeStatus serializeParam(const FwPrmIdType base_id,
                                       const FwPrmIdType local_id,
                                       Fw::SerialBufferBase& buff) const override;

    Fw::SerializeStatus deserializeParam(const FwPrmIdType base_id,
                                         const FwPrmIdType local_id,
                                         const Fw::ParamValid prmStat,
                                         Fw::SerialBufferBase& buff) override;

  private:
    void configureSectionGroupRate(
        const Svc::TelemetrySection& section,  
        FwChanIdType tlmGroup,                 
        const Svc::RateLogic& rateLogic,       
        U32 minDelta,  
        U32 maxDelta   
    );

    static FwIndexType sectionGroupToPort(const FwIndexType section, const FwSizeType group);

  private:
    FwSizeType m_numChannels;  
    Fw::RedBlackTreeMap<FwChanIdType, FwSizeType, MAX_PACKETIZER_CHANNELS> m_channelIndices;
    Fw::Array<TlmEntry, MAX_PACKETIZER_CHANNELS>
        m_channels;  
};

}  // end namespace Svc

#endif