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 "Os/Mutex.hpp"
#include "Svc/TlmPacketizer/TlmPacketizerComponentAc.hpp"
#include "Svc/TlmPacketizer/TlmPacketizerTypes.hpp"
#include "TlmPacketizerCfg.hpp"

namespace Svc {

class TlmPacketizer final : public TlmPacketizerComponentBase {
  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(void);

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

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

    void Run_handler(const FwIndexType portNum, 
                     U32 context                    
    );

    void pingIn_handler(const FwIndexType portNum, 
                        U32 key                        
    );

    void SET_LEVEL_cmdHandler(const FwOpcodeType opCode, 
                              const U32 cmdSeq,          
                              U32 level                  
    );

    void SEND_PKT_cmdHandler(const FwOpcodeType opCode, 
                             const U32 cmdSeq,          
                             U32 id                     
    );

    // 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;            
        bool requested;          
    };

    // buffers for filling with telemetry
    BufferEntry m_fillBuffers[MAX_PACKETIZER_PACKETS];
    // buffers for sending - will be copied from fill buffers
    BufferEntry m_sendBuffers[MAX_PACKETIZER_PACKETS];

    struct TlmEntry {
        FwChanIdType id;  
        // Offsets into packet buffers.
        // -1 means that channel is not in that packet
        FwSignedSizeType packetOffset[MAX_PACKETIZER_PACKETS];
        TlmEntry* next;             
        bool used;                  
        bool ignored;               
        FwChanIdType bucketNo;  
    };

    struct TlmSet {
        TlmEntry* slots[TLMPACKETIZER_NUM_TLM_HASH_SLOTS];  
        TlmEntry buckets[TLMPACKETIZER_HASH_BUCKETS];       
        FwChanIdType free;                              
    } m_tlmEntries;

    // hash function for looking up telemetry channel
    FwChanIdType doHash(FwChanIdType id);

    Os::Mutex m_lock;  

    bool m_configured;  

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

    void missingChannel(FwChanIdType id);  

    TlmEntry* findBucket(FwChanIdType id);

    FwChanIdType m_startLevel;  
    FwChanIdType m_maxLevel;    
};

}  // end namespace Svc

#endif