Channel.hpp

Go to the documentation of this file.

// ======================================================================
// \title  Channel.hpp
// \brief  CFDP Channel operations
//
// This file is a port of channel-specific functions from the following files
// from the NASA Core Flight System (cFS) CFDP (CF) Application, version 3.0.0,
// adapted for use within the F-Prime (F') framework:
// - cf_cfdp.c (channel processing functions)
// - cf_utils.c (channel transaction and resource management)
//
// ======================================================================
//
// NASA Docket No. GSC-18,447-1
//
// Copyright (c) 2019 United States Government as represented by the
// Administrator of the National Aeronautics and Space Administration.
// All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// ======================================================================

#ifndef CFDP_CHANNEL_HPP
#define CFDP_CHANNEL_HPP

#include <Fw/Types/Assert.hpp>
#include <Fw/Types/MemAllocator.hpp>

#include <Svc/Ccsds/CfdpManager/Types/Types.hpp>

namespace Svc {
namespace Ccsds {
namespace Cfdp {

// Forward declarations
class Engine;
class Transaction;

class Channel {
  public:
    // ----------------------------------------------------------------------
    // Construction
    // ----------------------------------------------------------------------

    Channel(Engine* engine, U8 channelId, CfdpManager* cfdpManager, Fw::MemAllocator& allocator, FwEnumStoreType memId);

    ~Channel();

    void cleanup(Fw::MemAllocator& allocator, FwEnumStoreType memId);

    // Disable copy constructor and assignment operator
    // Channel manages dynamic resources and should not be copied
    Channel(const Channel&) = delete;
    Channel& operator=(const Channel&) = delete;

    // ----------------------------------------------------------------------
    // Channel Processing
    // ----------------------------------------------------------------------

    void cycleTx();

    void tickTransactions();

    void processPlaybackDirectories();

    void processPollingDirectories();

    // ----------------------------------------------------------------------
    // Transaction Management
    // ----------------------------------------------------------------------

    Transaction* findUnusedTransaction(Direction direction);

    Transaction* findTransactionBySequenceNumber(TransactionSeq transaction_sequence_number, EntityId src_eid);

    I32 traverseAllTransactions(CfdpTraverseAllTransactionsFunc fn, void* context);

    void resetHistory(History* history);

    // ----------------------------------------------------------------------
    // Channel State Management
    // ----------------------------------------------------------------------

    inline U8 getChannelId() const { return m_channelId; }

    inline U32 getOutgoingCounter() const { return m_outgoingCounter; }

    inline void incrementOutgoingCounter() { ++m_outgoingCounter; }

    inline void resetOutgoingCounter() { m_outgoingCounter = 0; }

    inline U32 getNumCmdTx() const { return m_numCmdTx; }

    inline void incrementCmdTxCounter() { ++m_numCmdTx; }

    void decrementCmdTxCounter();

    void clearCurrentIfMatch(Transaction* txn);

    void setCurrentTxn(const Transaction* txn);

    inline void setFlowState(Flow::T flowState) { m_flowState = flowState; }

    inline Flow::T getFlowState() const { return m_flowState; }

    inline Playback* getPlayback(U32 index) {
        FW_ASSERT(index < MaxCommandedPlaybackDirectoriesPerChan);
        return &m_playback[index];
    }

    inline CfdpPollDir* getPollDir(U32 index) {
        FW_ASSERT(index < MaxPollingDirPerChan);
        return &m_polldir[index];
    }

    Transaction* getTransaction(U32 index);

    History* getHistory(U32 index);

    // ----------------------------------------------------------------------
    // Resource Management
    // ----------------------------------------------------------------------

    CListNode** getChunkListHead(U8 direction);

    CfdpChunkWrapper* findUnusedChunks(Direction dir);

    // ----------------------------------------------------------------------
    // Transaction Management
    // ----------------------------------------------------------------------

    void dequeueTransaction(Transaction* txn);

    void moveTransaction(Transaction* txn, QueueId::T queue);

    void freeTransaction(Transaction* txn);

    void recycleTransaction(Transaction* txn);

    void insertSortPrio(Transaction* txn, QueueId::T queue);

    // ----------------------------------------------------------------------
    // Queue Management
    // ----------------------------------------------------------------------

    inline void removeFromQueue(QueueId::T queueidx, CListNode* node);

    inline void insertAfterInQueue(QueueId::T queueidx, CListNode* start, CListNode* after);

    inline void insertBackInQueue(QueueId::T queueidx, CListNode* node);

    // ----------------------------------------------------------------------
    // Callback methods (public so wrappers can call them)
    // ----------------------------------------------------------------------

    CListTraverseStatus cycleTxFirstActive(CListNode* node, void* context);

    CListTraverseStatus doTick(CListNode* node, void* context);

    // ----------------------------------------------------------------------
    // Static callback wrappers (for function pointer callbacks)
    // ----------------------------------------------------------------------

    static CListTraverseStatus cycleTxFirstActiveWrapper(CListNode* node, void* context);

    static CListTraverseStatus doTickWrapper(CListNode* node, void* context);

    static CListTraverseStatus traverseAllTransactionsWrapper(CListNode* node, void* context);

  private:
    // ----------------------------------------------------------------------
    // Private helper methods
    // ----------------------------------------------------------------------

    void processPlaybackDirectory(Playback* pb);

    void updatePollPbCounted(Playback* pb, I32 up, U8* counter);

  private:
    // ----------------------------------------------------------------------
    // Member variables
    // ----------------------------------------------------------------------

    Engine* m_engine;  

    CListNode* m_qs[QueueId::NUM];                                
    CListNode* m_cs[static_cast<U32>(Direction::DIRECTION_NUM)];  

    U32 m_numCmdTx;  

    Playback m_playback[MaxCommandedPlaybackDirectoriesPerChan];  
    CfdpPollDir m_polldir[MaxPollingDirPerChan];                  

    const Transaction* m_currentTxn;  
    CfdpManager* m_cfdpManager;       

    U8 m_tickType;   
    U8 m_channelId;  

    Flow::T m_flowState;    
    U32 m_outgoingCounter;  

    // Per-channel resource arrays (dynamically allocated, moved from Engine)
    Transaction* m_transactions;  
    History* m_histories;         
    CfdpChunkWrapper* m_chunks;   
    Chunk* m_chunkMem;            

    U32 m_dirMaxChunks[static_cast<U32>(
        Direction::DIRECTION_NUM)];  

    // Friend declarations for testing
    friend class CfdpManagerTester;
};

// ----------------------------------------------------------------------
// Inline function implementations
// ----------------------------------------------------------------------

inline void Channel::removeFromQueue(QueueId::T queueidx, CListNode* node) {
    CfdpCListRemove(&m_qs[queueidx], node);
}

inline void Channel::insertAfterInQueue(QueueId::T queueidx, CListNode* start, CListNode* after) {
    CfdpCListInsertAfter(&m_qs[queueidx], start, after);
}

inline void Channel::insertBackInQueue(QueueId::T queueidx, CListNode* node) {
    CfdpCListInsertBack(&m_qs[queueidx], node);
}

}  // namespace Cfdp
}  // namespace Ccsds
}  // namespace Svc

#endif  // CFDP_CHANNEL_HPP